EmbeddedSurfaceSubRegion.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_EMBEDDEDSURFACESUBREGION_HPP_
#define GEOS_MESH_EMBEDDEDSURFACESUBREGION_HPP_
 
#include "SurfaceElementSubRegion.hpp"
#include "InterObjectRelation.hpp"
#include "ToElementRelation.hpp"
#include "EdgeManager.hpp"
#include "EmbeddedSurfaceNodeManager.hpp"
#include "CellElementSubRegion.hpp"
//Do we really need this include Rectangle?
#include "simpleGeometricObjects/Rectangle.hpp"
 
namespace geos
{
 
struct surfaceWithGhostNodes
{
  localIndex surfaceIndex;
  std::vector< globalIndex > parentEdgeIndex;
  localIndex numOfNodes;
 
  surfaceWithGhostNodes():
    surfaceIndex(),
    parentEdgeIndex(),
    numOfNodes( 0 ){}
  void insert ( globalIndex const & edgeIndex );
};
 
class EmbeddedSurfaceSubRegion : public SurfaceElementSubRegion
{
public:
 
  using FaceMapType = FixedOneToManyRelation;
 
 
  static string catalogName()
  { return "EmbeddedSurfaceSubRegion"; }
 
  virtual string getCatalogName() const override
  {
    return catalogName();
  }
 
 
 
  EmbeddedSurfaceSubRegion( string const & name,
                            dataRepository::Group * const parent );
 
 
 
  virtual void calculateElementGeometricQuantities( NodeManager const & nodeManager,
                                                    FaceManager const & facemanager ) override final;
 
  void calculateElementGeometricQuantities( arrayView2d< real64 const > const intersectionPoints,
                                            localIndex k );
  bool addNewEmbeddedSurface( localIndex const cellIndex,
                              localIndex const regionIndex,
                              localIndex const subRegionIndex,
                              NodeManager const & nodeManager,
                              EmbeddedSurfaceNodeManager & embSurfNodeManager,
                              EdgeManager const & edgeManager,
                              FixedOneToManyRelation const & cellToEdges,
                              PlanarGeometricObject const * fracture );
 
  void inheritGhostRank( array1d< array1d< arrayView1d< integer const > > > const & cellGhostRank );
 
  real64 computeHeavisideFunction( ArraySlice< real64 const, 1, nodes::REFERENCE_POSITION_USD - 1 > const nodeCoord,
                                   localIndex const k ) 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;
 
  virtual localIndex unpackUpDownMaps( buffer_unit_type const * & buffer,
                                       array1d< localIndex > & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;
 
 
  struct viewKeyStruct : SurfaceElementSubRegion::viewKeyStruct
  {
    static constexpr char const * connectivityIndexString() { return "connectivityIndex"; }
 
    static constexpr char const * surfaceWithGhostNodesString() { return "surfaceWithGhostNodes"; }
  }
  viewKeys;
 
  virtual void setupRelatedObjectsInRelations( MeshLevel const & mesh ) override;
 
 
  localIndex & numOfJumpEnrichments()       {return m_numOfJumpEnrichments;}
 
  localIndex const & numOfJumpEnrichments() const {return m_numOfJumpEnrichments;}
 
  string const & getFractureName( localIndex k ) const { return m_parentPlaneName[k]; }
 
  arrayView1d< real64 > getConnectivityIndex()   { return m_connectivityIndex.toView();}
 
  arrayView1d< real64 const > getConnectivityIndex() const { return m_connectivityIndex;}
 
  std::vector< struct surfaceWithGhostNodes > surfaceWithGhostNodes() { return m_surfaceWithGhostNodes; }
 
  OrderedVariableToManyElementRelation & getToCellRelation()
  {
    return m_2dElemToElems;
  }
 
  OrderedVariableToManyElementRelation const & getToCellRelation() const
  {
    return m_2dElemToElems;
  }
 
 
private:
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  localIndex m_numOfJumpEnrichments;
 
  array1d< real64 > m_connectivityIndex;
 
  // Indices of geometric objects the element belongs to
  array1d< string > m_parentPlaneName;
 
  std::vector< struct surfaceWithGhostNodes > m_surfaceWithGhostNodes;
 
  OrderedVariableToManyElementRelation m_2dElemToElems;
 
};
 
 
} /* namespace geos */
 
#endif /* GEOS_MESH_EMBEDDEDSURFACESUBREGION_HPP_ */