EmbeddedSurfaceNodeManager.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_EMBEDDEDSURFACENODEMANAGER_HPP_
#define GEOS_MESH_EMBEDDEDSURFACENODEMANAGER_HPP_
 
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "ToElementRelation.hpp"
 
namespace geos
{
 
class EdgeManager;
class ElementRegionManager;
 
class EmbeddedSurfaceNodeManager : public ObjectManagerBase
{
public:
  using EdgeMapType = InterObjectRelation< ArrayOfSets< localIndex > >;
 
  using ElemMapType = OrderedVariableToManyElementRelation;
 
  static constexpr localIndex edgeMapOverallocation()
  { return CellBlockManagerABC::edgeMapExtraSpacePerNode(); }
 
  static constexpr localIndex elemMapOverallocation()
  { return 8; }
 
 
 
  EmbeddedSurfaceNodeManager( string const & name,
                              dataRepository::Group * const parent );
 
 
  virtual void resize( localIndex const newsize ) override;
 
 
  static string catalogName()
  { return "EmbeddedSurfaceNodeManager"; }
 
  string getCatalogName() const override final
  { return catalogName(); }
 
 
  void setEdgeMaps( EdgeManager const & edgeManager );
 
 
  void setElementMaps( ElementRegionManager const & elementRegionManager );
 
  void compressRelationMaps();
 
  void appendNode( arraySlice1d< real64 const > const & pointCoord,
                   integer const & pointGhostRank );
 
 
  localIndex packNewNodesGlobalMapsSize( arrayView1d< localIndex const > const & packList ) const;
 
  localIndex packNewNodesGlobalMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList ) const;
 
  virtual localIndex packUpDownMapsSize( arrayView1d< localIndex const > const & packList ) const override;
 
 
  virtual localIndex packUpDownMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList ) const override;
 
  localIndex unpackNewNodesGlobalMaps( buffer_unit_type const * & buffer,
                                       localIndex_array & packList );
 
  virtual localIndex unpackUpDownMaps( buffer_unit_type const * & buffer,
                                       array1d< localIndex > & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;
 
 
 
  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * referencePositionString() { return "referencePosition"; }
 
    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"; }
 
    static constexpr char const * parentEdgeGlobalIndexString() { return "parentEdgeGlobalIndex"; }
 
    dataRepository::ViewKey referencePosition       = { referencePositionString() };
 
    dataRepository::ViewKey edgeList                = { edgeListString() };
 
    dataRepository::ViewKey elementRegionList       = { elementRegionListString() };
 
    dataRepository::ViewKey elementSubRegionList    = { elementSubRegionListString() };
 
    dataRepository::ViewKey elementList             = { elementListString() };
 
    dataRepository::ViewKey parentEdgeGlobalIndex   = { parentEdgeGlobalIndexString() };
  }
  viewKeys;
 
 
 
  EdgeMapType const & edgeList() const { return m_toEdgesRelation; }
 
  EdgeMapType & edgeList() { return m_toEdgesRelation; }
 
  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(); }
 
  array2d< real64, nodes::REFERENCE_POSITION_PERM > & referencePosition() { return m_referencePosition; }
 
  arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > referencePosition() const
  { return m_referencePosition; }
 
  array1d< globalIndex > & getParentEdgeGlobalIndex()
  {
    return m_parentEdgeGlobalIndex;
  }
 
  arrayView1d< globalIndex const > getParentEdgeGlobalIndex() const
  {
    return m_parentEdgeGlobalIndex;
  }
 
 
private:
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  template< bool DO_PACKING >
  localIndex packNewNodesGlobalMapsImpl( buffer_unit_type * & buffer,
                                         arrayView1d< localIndex const > const & packList ) const;
 
  void nodeExistsOnThisRank( real64 const (&nodeCoord)[3],
                             localIndex & nodeIndexOnThisRank ) const;
 
  array2d< real64, nodes::REFERENCE_POSITION_PERM > m_referencePosition;
 
  EdgeMapType m_toEdgesRelation;
 
  ElemMapType m_toElements;
 
  array1d< globalIndex > m_parentEdgeGlobalIndex;
 
};
}
 
#endif // MESH_EMBEDDEDSURFACENODEMANAGER_HPP_