FaceManager.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MESH_FACEMANAGER_HPP_
#define GEOS_MESH_FACEMANAGER_HPP_
 
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "ToElementRelation.hpp"
 
namespace geos
{
 
class NodeManager;
class EdgeManager;
class ElementRegionManager;
class CellElementSubRegion;
 
class FaceManager : public ObjectManagerBase
{
public:
 
  using NodeMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
  using EdgeMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
  using ElemMapType = FixedToManyElementRelation;
 
 
  static string catalogName()
  { return "FaceManager"; }
 
  virtual string getCatalogName() const override
  { return catalogName(); }
 
  static constexpr localIndex nodeMapOverallocation()
  { return CellBlockManagerABC::nodeMapExtraSpacePerFace(); }
 
  static constexpr localIndex edgeMapOverallocation()
  { return CellBlockManagerABC::edgeMapExtraSpacePerFace(); }
 
 
  FaceManager( string const & name, Group * const parent );
 
 
  virtual void reserve( localIndex const newSize ) override;
 
  virtual void resize( localIndex const newsize ) override;
 
  void setGeometricalRelations( CellBlockManagerABC const & cellBlockManager,
                                ElementRegionManager const & elemRegionManager,
                                NodeManager const & nodeManager, bool isBaseMeshLevel );
 
  void setupRelatedObjectsInRelations( NodeManager const & nodeManager,
                                       EdgeManager const & edgeManager,
                                       ElementRegionManager const & elemRegionManager );
 
  void computeGeometry( NodeManager const & nodeManager );
 
  void setDomainBoundaryObjects( ElementRegionManager const & elemRegionManager );
 
  void buildSets( NodeManager const & nodeManager );
 
  void sortAllFaceNodes( NodeManager const & nodeManager,
                         ElementRegionManager const & elemManager );
 
  static void sortFaceNodes( arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X,
                             arraySlice1d< real64 const > const elementCenter,
                             Span< localIndex > const faceNodes );
 
  void setIsExternal();
 
 
  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 compressRelationMaps();
 
  virtual void enforceStateFieldConsistencyPostTopologyChange( std::set< localIndex > const & targetIndices ) override;
 
  void depopulateUpMaps( std::set< localIndex > const & receivedFaces,
                         ElementRegionManager const & elemRegionManager );
 
 
  //void SetGlobalIndexFromCompositionalObject( ObjectManagerBase const * const compositionalObject );
 
  virtual ArrayOfSets< globalIndex >
  extractMapFromObjectForAssignGlobalIndexNumbers( ObjectManagerBase const & nodeManager ) override;
 
 
  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * nodeListString() { return "nodeList"; }
    static constexpr char const * edgeListString() { return "edgeList"; }
    static constexpr char const * elementRegionListString() { return "elemRegionList"; }
    static constexpr char const * elementSubRegionListString() { return "elemSubRegionList"; }
    static constexpr char const * elementListString() { return "elemList"; }
    constexpr static char const * faceAreaString() { return "faceArea"; }
    constexpr static char const * faceCenterString() { return "faceCenter"; }
    constexpr static char const * faceNormalString() { return "faceNormal"; }
 
    dataRepository::ViewKey nodeList              = { nodeListString() };
    dataRepository::ViewKey edgeList              = { edgeListString() };
    dataRepository::ViewKey elementRegionList     = { elementRegionListString() };
    dataRepository::ViewKey elementSubRegionList  = { elementSubRegionListString() };
    dataRepository::ViewKey elementList           = { elementListString() };
  }
  viewKeys;
 
 
 
  array1d< real64 > & faceArea()       { return m_faceArea; }
 
  arrayView1d< real64 const > faceArea() const { return m_faceArea; }
 
  array2d< real64 > & faceCenter() { return m_faceCenter; }
 
 
  arrayView2d< real64 const > faceCenter() const { return m_faceCenter; }
 
  array2d< real64 > & faceNormal() { return m_faceNormal; }
 
  arrayView2d< real64 const > faceNormal() const { return m_faceNormal; }
 
  NodeMapType & nodeList()                    { return m_toNodesRelation; }
 
  NodeMapType const & nodeList() const { return m_toNodesRelation; }
 
  EdgeMapType & edgeList()       { return m_toEdgesRelation; }
 
  EdgeMapType const & edgeList() const { return m_toEdgesRelation; }
 
  array2d< localIndex > & elementRegionList() { return m_toElements.m_toElementRegion; }
 
  arrayView2d< localIndex const > elementRegionList() const { return m_toElements.m_toElementRegion; }
 
  array2d< localIndex > & elementSubRegionList() { return m_toElements.m_toElementSubRegion; }
 
  arrayView2d< localIndex const > elementSubRegionList() const { return m_toElements.m_toElementSubRegion; }
 
  array2d< localIndex > & elementList() { return m_toElements.m_toElementIndex; }
 
  arrayView2d< localIndex const > elementList() const { return m_toElements.m_toElementIndex; }
 
  ElemMapType & toElementRelation()       { return m_toElements; }
 
  ElemMapType const & toElementRelation() const { return m_toElements; }
 
 
  constexpr static int maxFaceNodes() { return MAX_FACE_NODES; }
private:
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  NodeMapType m_toNodesRelation;
 
  EdgeMapType m_toEdgesRelation;
 
  ElemMapType m_toElements;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToNodes;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToEdges;
 
  array1d< real64 > m_faceArea;
 
  array2d< real64 > m_faceCenter;
  array2d< real64 > m_faceNormal;
 
  constexpr static int MAX_FACE_NODES = 16;
 
};
 
}
#endif /* FACEMANAGERT_H_ */