ElementRegionBase.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * 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_ELEMENTREGIONBASE_HPP
#define GEOS_MESH_ELEMENTREGIONBASE_HPP
 
#include "CellElementSubRegion.hpp"
#include "FaceElementSubRegion.hpp"
#include "WellElementSubRegion.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "EmbeddedSurfaceSubRegion.hpp"
 
namespace geos
{
 
class FaceManager;
 
class ElementRegionBase : public ObjectManagerBase
{
public:
 
 
  ElementRegionBase() = delete;
 
  ElementRegionBase( string const & name, Group * const parent );
 
 
  ElementRegionBase( const ElementRegionBase & init );
 
  virtual ~ElementRegionBase() override;
 
 
 
  static string verifyMeshBodyName( Group const & meshBodies,
                                    string const & meshBodyBlockName );
 
 
 
  template< typename SUBREGION_TYPE >
  SUBREGION_TYPE & createElementSubRegion( string const & name );
 
 
  virtual void generateMesh( Group const & blocks ) = 0;
 
 
 
  Group & getSubRegions()
  {
    return getGroup( viewKeyStruct::elementSubRegions() );
  }
 
  Group const & getSubRegions() const
  {
    return getGroup( viewKeyStruct::elementSubRegions() );
  }
 
 
  template< typename SUBREGIONTYPE=ElementSubRegionBase, typename KEY_TYPE=void >
  SUBREGIONTYPE const & getSubRegion( KEY_TYPE const & key ) const
  {
    return this->getGroup( viewKeyStruct::elementSubRegions() ).getGroup< SUBREGIONTYPE >( key );
  }
 
  template< typename SUBREGIONTYPE=ElementSubRegionBase, typename KEY_TYPE=void >
  SUBREGIONTYPE & getSubRegion( KEY_TYPE const & key )
  {
    return this->getGroup( viewKeyStruct::elementSubRegions() ).getGroup< SUBREGIONTYPE >( key );
  }
 
  template< typename T=ElementSubRegionBase >
  bool hasSubRegion( string const & name ) const
  {
    return this->getGroup( viewKeyStruct::elementSubRegions() ).hasGroup< T >( name );
  }
 
 
  localIndex numSubRegions() const
  {
    return this->getSubRegions().numSubGroups();
  }
 
  template< typename SUBREGIONTYPE = ElementSubRegionBase, typename ... SUBREGIONTYPES >
  localIndex getNumberOfElements() const
  {
    localIndex numElem = 0;
    this->forElementSubRegions< SUBREGIONTYPE, SUBREGIONTYPES... >( [&]( Group const & group ) -> void
    {
      numElem += group.size();
    } );
    return numElem;
  }
 
  string_array & getMaterialList() {return m_materialList;}
 
  string_array const & getMaterialList() const {return m_materialList;}
 
  template< typename CONSTITUTIVE_TYPE >
  string_array getConstitutiveNames() const;
 
  static ElementRegionBase & getParentRegion( ElementSubRegionBase & subRegion )
  { return dynamicCast< ElementRegionBase & >( subRegion.getParent().getParent() ); }
 
  static ElementRegionBase const & getParentRegion( ElementSubRegionBase const & subRegion )
  { return dynamicCast< ElementRegionBase const & >( subRegion.getParent().getParent() ); }
 
 
 
 
 
  template< typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda ) const
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, WellElementSubRegion, EmbeddedSurfaceSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda )
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, WellElementSubRegion, EmbeddedSurfaceSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda ) const
  {
    this->getGroup( viewKeyStruct::elementSubRegions() ).forSubGroups< SUBREGIONTYPE, SUBREGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda )
  {
    this->getGroup( viewKeyStruct::elementSubRegions() ).forSubGroups< SUBREGIONTYPE, SUBREGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementSubRegionsIndex( LAMBDA && lambda ) const
  {
    forElementSubRegionsIndex< CellElementSubRegion, FaceElementSubRegion, WellElementSubRegion, EmbeddedSurfaceSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementSubRegionsIndex( LAMBDA && lambda )
  {
    forElementSubRegionsIndex< CellElementSubRegion, FaceElementSubRegion, WellElementSubRegion, EmbeddedSurfaceSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegionsIndex( LAMBDA && lambda ) const
  {
    for( localIndex esr=0; esr<this->numSubRegions(); ++esr )
    {
      ElementSubRegionBase const & subRegion = this->getSubRegion( esr );
      applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto const & castedSubRegion )
      {
        lambda( esr, castedSubRegion );
      } );
    }
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegionsIndex( LAMBDA && lambda )
  {
    for( localIndex esr=0; esr<this->numSubRegions(); ++esr )
    {
      ElementSubRegionBase & subRegion = this->getSubRegion( esr );
      applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto & castedSubRegion )
      {
        lambda( esr, castedSubRegion );
      } );
    }
  }
 
 
  struct viewKeyStruct : public ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * materialListString() { return "materialList"; }
    static constexpr char const * meshBodyString() { return "meshBody"; }
    static constexpr char const * elementSubRegions() { return "elementSubRegions"; }
  };
 
private:
 
  ElementRegionBase & operator=( const ElementRegionBase & rhs );
 
  string_array m_materialList;
 
  string m_meshBody;
 
};
 
 
 
 
 
template< typename CONSTITUTIVE_TYPE >
string_array ElementRegionBase::getConstitutiveNames() const
{
  string_array rval;
  for( string const & matName : m_materialList )
  {
    if( this->getSubRegion( 0 ).getConstitutiveModels().hasGroup< CONSTITUTIVE_TYPE >( matName ) )
    {
      rval.emplace_back( matName );
    }
  }
  return rval;
}
 
 
template< typename SUBREGION_TYPE >
SUBREGION_TYPE & ElementRegionBase::createElementSubRegion( string const & name )
{
  return getGroup( viewKeyStruct::elementSubRegions() ).registerGroup< SUBREGION_TYPE >( name );
}
 
 
}
 
 
 
#endif /* GEOS_MESH_ELEMENTREGIONBASE_HPP */