SurfaceElementRegion.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_SURFACEELEMENTREGION_HPP_
#define GEOS_MESH_SURFACEELEMENTREGION_HPP_
 
#include "ElementRegionBase.hpp"
#include "common/format/EnumStrings.hpp"
 
namespace geos
{
 
 
class EdgeManager;
 
class SurfaceElementRegion : public ElementRegionBase
{
public:
 
  enum class SurfaceSubRegionType : integer
  {
    faceElement,
    embeddedElement
  };
 
 
  SurfaceElementRegion( string const & name, Group * const parent );
 
  SurfaceElementRegion() = delete;
 
  virtual ~SurfaceElementRegion() override;
 
 
 
  static string catalogName()
  { return "SurfaceElementRegion"; }
 
  virtual string getCatalogName() const override final
  { return catalogName(); }
 
 
 
 
  virtual void generateMesh( Group const & faceBlocks ) override;
 
  localIndex addToSurfaceMesh( FaceManager const * const faceManager,
                               localIndex const faceIndices[2] );
 
  localIndex addToFractureMesh( real64 const time_np1,
                                FaceManager const * const faceManager,
                                ArrayOfArraysView< localIndex const > const & originalFaceToEdges,
                                localIndex const faceIndices[2] );
 
  void updateSets( FaceManager const & faceManager );
 
 
 
 
  real64 getDefaultAperture() const { return m_defaultAperture; }
 
  SurfaceSubRegionType subRegionType() const { return m_subRegionType; }
 
  template< typename SUBREGION_TYPE >
  SUBREGION_TYPE & getUniqueSubRegion()
  {
    return getSubRegion< SUBREGION_TYPE >( getUniqueSubRegionName< SUBREGION_TYPE >() );
  }
 
  template< typename SUBREGION_TYPE >
  SUBREGION_TYPE const & getUniqueSubRegion() const
  {
    return getSubRegion< SUBREGION_TYPE >( getUniqueSubRegionName< SUBREGION_TYPE >() );
  }
 
 
  struct viewKeyStruct : public ElementRegionBase::viewKeyStruct
  {
    static constexpr char const * subRegionTypeString() { return "subRegionType"; }
 
    static constexpr char const * fractureSetString() { return "fractureSet"; }
 
    static constexpr char const * defaultApertureString() { return "defaultAperture"; }
 
    static constexpr char const * ruptureTimeString() { return "ruptureTime"; }
 
    static constexpr char const * faceBlockString() { return "faceBlock"; }
  };
 
protected:
  virtual void initializePreSubGroups() override;
 
private:
 
  template< typename SUBREGION_TYPE >
  string getUniqueSubRegionName() const
  {
    stdVector< string > subRegionNames;
    forElementSubRegions< SUBREGION_TYPE >( [&]( SUBREGION_TYPE const & sr )
    {
      subRegionNames.push_back( sr.getName() );
    } );
    GEOS_ERROR_IF( subRegionNames.size() != 1,
                   GEOS_FMT( "Surface region should have one unique sub region ({} found).", subRegionNames.size() ),
                   getDataContext() );
    return subRegionNames.front();
  }
 
  SurfaceSubRegionType m_subRegionType;
 
  real64 m_defaultAperture;
 
  string m_faceBlockName;
};
 
ENUM_STRINGS( SurfaceElementRegion::SurfaceSubRegionType,
              "faceElement",
              "embeddedElement" );
 
} /* namespace geos */
 
#endif /* CORECOMPONENTS_MESH_SurfaceElementRegion_HPP_ */