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 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MESH_NODEMANAGER_HPP_
#define GEOS_MESH_NODEMANAGER_HPP_
 
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "mesh/simpleGeometricObjects/GeometricObjectManager.hpp"
#include "ToElementRelation.hpp"
 
namespace geos
{
 
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
 
  static constexpr localIndex getEdgeMapOverallocation()
  { return CellBlockManagerABC::edgeMapExtraSpacePerNode(); }
 
  static constexpr localIndex getFaceMapOverallocation()
  { return CellBlockManagerABC::faceMapExtraSpacePerNode(); }
 
  static constexpr localIndex getElemMapOverAllocation()
  { return CellBlockManagerABC::elemMapExtraSpacePerNode(); }
 
 
  NodeManager( string const & name,
               dataRepository::Group * const parent );
 
 
  virtual void resize( localIndex const newsize ) override;
 
 
  static string catalogName()
  { return "NodeManager"; }
 
  string getCatalogName() const override final
  { return catalogName(); }
 
 
  void constructGlobalToLocalMap( CellBlockManagerABC const & cellBlockManager );
 
  void buildSets( CellBlockManagerABC const & cellBlockManager,
                  GeometricObjectManager const & geometries );
 
  void buildGeometricSets( GeometricObjectManager const & geometries );
 
 
  void setDomainBoundaryObjects( FaceManager const & faceManager,
                                 EdgeManager const & edgeManager );
 
  void setGeometricalRelations( CellBlockManagerABC const & cellBlockManager,
                                ElementRegionManager const & elemRegionManager,
                                bool isBaseMeshLevel );
 
  void setupRelatedObjectsInRelations( EdgeManager const & edgeManager,
                                       FaceManager const & faceManager,
                                       ElementRegionManager const & elemRegionManager );
 
  void compressRelationMaps();
 
 
  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 char const * referencePositionString() { return "ReferencePosition"; }
 
    static constexpr char const * EmbSurfNodesPositionString() { return "EmbSurfNodesPosition"; }
 
    static constexpr char const * edgeListString() { return "edgeList"; }
 
    static constexpr char const * faceListString() { return "faceList"; }
 
    static constexpr char const * elementRegionListString() { return "elemRegionList"; }
 
    static constexpr char const * elementSubRegionListString() { return "elemSubRegionList"; }
 
    static constexpr char const * elementListString() { return "elemList"; }
 
    dataRepository::ViewKey referencePosition       = { referencePositionString() };
 
    dataRepository::ViewKey edgeList                = { edgeListString() };
 
    dataRepository::ViewKey faceList                = { faceListString() };
 
    dataRepository::ViewKey elementRegionList       = { elementRegionListString() };
 
    dataRepository::ViewKey elementSubRegionList    = { elementSubRegionListString() };
 
    dataRepository::ViewKey elementList             = { elementListString() };
 
  }
  viewKeys;
 
 
  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
 
 
private:
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
 
 
  //START_SPHINX_REFPOS
  array2d< real64, nodes::REFERENCE_POSITION_PERM > m_referencePosition;
  //END_SPHINX_REFPOS
 
  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_