NodeManager.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_MESH_NODEMANAGER_HPP_
#define GEOSX_MESH_NODEMANAGER_HPP_

#include "managers/ObjectManagerBase.hpp"
#include <string.h>
#include "CellBlockManager.hpp"
#include "ToElementRelation.hpp"

class SiloFile;

namespace geosx
{

class CellBlock;
class FaceManager;
class EdgeManager;
class ElementRegionManager;


class NodeManager : public ObjectManagerBase
{
public:

  //START_SPHINX_INCLUDE_01

  using EdgeMapType = InterObjectRelation< ArrayOfSets< localIndex > >;

  using FaceMapType = InterObjectRelation< ArrayOfSets< localIndex > >;

  using ElemMapType = OrderedVariableToManyElementRelation;
  //END_SPHINX_INCLUDE_01

  inline localIndex getEdgeMapOverallocation()
  { return 8; }

  inline localIndex getFaceMapOverallocation()
  { return 8; }

  inline localIndex getElemMapOverAllocation()
  { return 8; }


  NodeManager( std::string const & name,
               dataRepository::Group * const parent );

  ~NodeManager() override;


  NodeManager() = delete;

  NodeManager( const NodeManager & init ) = delete;

  NodeManager & operator=( const NodeManager & ) = delete;


  virtual void resize( localIndex const newsize ) override;


  static string CatalogName()
  { return "NodeManager"; }

  const string getCatalogName() const override final
  { return NodeManager::CatalogName(); }


  void SetEdgeMaps( EdgeManager const * const edgeManager );

  void SetFaceMaps( FaceManager const * const faceManager );

  void SetElementMaps( ElementRegionManager const * const elementRegionManager );

  void CompressRelationMaps();


  virtual void ViewPackingExclusionList( SortedArray< localIndex > & exclusionList ) const override;

  virtual localIndex PackUpDownMapsSize( arrayView1d< localIndex const > const & packList ) const override;

  virtual localIndex PackUpDownMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList ) const override;

  virtual localIndex UnpackUpDownMaps( buffer_unit_type const * & buffer,
                                       localIndex_array & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;

  void FixUpDownMaps( bool const clearIfUnmapped );


  void depopulateUpMaps( std::set< localIndex > const & receivedNodes,
                         array2d< localIndex > const & edgesToNodes,
                         ArrayOfArraysView< localIndex const > const & facesToNodes,
                         ElementRegionManager const & elemRegionManager );


  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr auto referencePositionString       = "ReferencePosition";

    static constexpr auto EmbSurfNodesPositionString = "EmbSurfNodesPosition";

    static constexpr auto totalDisplacementString       = "TotalDisplacement";

    static constexpr auto incrementalDisplacementString = "IncrementalDisplacement";

    static constexpr auto edgeListString                = "edgeList";

    static constexpr auto faceListString                = "faceList";

    static constexpr auto elementRegionListString       = "elemRegionList";

    static constexpr auto elementSubRegionListString    = "elemSubRegionList";

    static constexpr auto elementListString             = "elemList";

    dataRepository::ViewKey referencePosition       = { referencePositionString };

    dataRepository::ViewKey totalDisplacement       = { totalDisplacementString };

    dataRepository::ViewKey incrementalDisplacement = { incrementalDisplacementString };

    dataRepository::ViewKey edgeList                = { edgeListString };

    dataRepository::ViewKey faceList                = { faceListString };

    dataRepository::ViewKey elementRegionList       = { elementRegionListString };

    dataRepository::ViewKey elementSubRegionList    = { elementSubRegionListString };

    dataRepository::ViewKey elementList             = { elementListString };

    dataRepository::ViewKey velocity                = { dataRepository::keys::Velocity };

    dataRepository::ViewKey acceleration            = { dataRepository::keys::Acceleration };
  }
  viewKeys;

  struct groupKeyStruct : ObjectManagerBase::groupKeyStruct
  {}
  groupKeys;


  EdgeMapType const & edgeList() const { return m_toEdgesRelation; }

  EdgeMapType & edgeList() { return m_toEdgesRelation; }

  FaceMapType const & faceList() const { return m_toFacesRelation; }

  FaceMapType & faceList() { return m_toFacesRelation; }

  ElemMapType & toElementRelation() {return m_toElements;}

  ElemMapType const & toElementRelation() const {return m_toElements;}

  ArrayOfArrays< localIndex > & elementRegionList() { return m_toElements.m_toElementRegion; }

  ArrayOfArraysView< localIndex const > elementRegionList() const { return m_toElements.m_toElementRegion.toViewConst(); }

  ArrayOfArrays< localIndex > & elementSubRegionList() { return m_toElements.m_toElementSubRegion; }

  ArrayOfArraysView< localIndex const > elementSubRegionList() const { return m_toElements.m_toElementSubRegion.toViewConst(); }

  ArrayOfArrays< localIndex > & elementList() { return m_toElements.m_toElementIndex; }

  ArrayOfArraysView< localIndex const > elementList() const
  { return m_toElements.m_toElementIndex.toViewConst(); }

  //START_SPHINX_REFPOS_ACCESS
  array2d< real64, nodes::REFERENCE_POSITION_PERM > & referencePosition() { return m_referencePosition; }

  arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > referencePosition() const
  { return m_referencePosition; }
  //END_SPHINX_REFPOS_ACCESS

  array2d< real64, nodes::REFERENCE_POSITION_PERM > & embSurfNodesPosition()
  { return m_embeddedSurfNodesPosition; }

  arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > embSurfNodesPosition() const
  { return m_embeddedSurfNodesPosition; }

  array2d< real64, nodes::TOTAL_DISPLACEMENT_PERM > & totalDisplacement()
  { return getReference< array2d< real64, nodes::TOTAL_DISPLACEMENT_PERM > >( viewKeys.totalDisplacement ); }

  arrayView2d< real64 const, nodes::TOTAL_DISPLACEMENT_USD > totalDisplacement() const
  {return getReference< array2d< real64, nodes::TOTAL_DISPLACEMENT_PERM > >( viewKeys.totalDisplacement ); }

  array2d< real64, nodes::INCR_DISPLACEMENT_PERM > & incrementalDisplacement()
  { return getReference< array2d< real64, nodes::INCR_DISPLACEMENT_PERM > >( viewKeys.incrementalDisplacement ); }

  arrayView2d< real64 const, nodes::INCR_DISPLACEMENT_USD > incrementalDisplacement() const
  { return getReference< array2d< real64, nodes::INCR_DISPLACEMENT_PERM > >( viewKeys.incrementalDisplacement ); }

  array2d< real64, nodes::VELOCITY_PERM > & velocity()
  { return getReference< array2d< real64, nodes::VELOCITY_PERM > >( viewKeys.velocity ); }

  arrayView2d< real64 const, nodes::VELOCITY_USD > velocity() const
  { return getReference< array2d< real64, nodes::VELOCITY_PERM > >( viewKeys.velocity ); }

  array2d< real64, nodes::ACCELERATION_PERM > & acceleration()
  { return getReference< array2d< real64, nodes::ACCELERATION_PERM > >( viewKeys.acceleration ); }

  arrayView2d< real64 const, nodes::ACCELERATION_USD > acceleration() const
  { return getReference< array2d< real64, nodes::ACCELERATION_PERM > >( viewKeys.acceleration ); }


private:

  template< bool DOPACK >
  localIndex PackUpDownMapsPrivate( buffer_unit_type * & buffer,
                                    arrayView1d< localIndex const > const & packList ) const;



  //START_SPHINX_REFPOS
  array2d< real64, nodes::REFERENCE_POSITION_PERM > m_referencePosition;
  //END_SPHINX_REFPOS

  array2d< real64, nodes::REFERENCE_POSITION_PERM > m_embeddedSurfNodesPosition;

  EdgeMapType m_toEdgesRelation;

  FaceMapType m_toFacesRelation;

  ElemMapType m_toElements;

  map< localIndex, SortedArray< globalIndex > > m_unmappedGlobalIndicesInToEdges;

  map< localIndex, SortedArray< globalIndex > > m_unmappedGlobalIndicesInToFaces;

  map< localIndex, array1d< array1d< SortedArray< globalIndex > > > > m_unmappedGlobalIndicesInToElems;

};
}

#endif // MESH_NODEMANAGER_HPP_