ParticleRegionBase.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_PARTICLEREGIONBASE_HPP
#define GEOS_MESH_PARTICLEREGIONBASE_HPP
 
#include "ParticleSubRegion.hpp"
#include "mesh/ObjectManagerBase.hpp"
 
namespace geos
{
 
class ParticleRegionBase : public ObjectManagerBase
{
public:
 
 
  ParticleRegionBase() = delete;
 
  ParticleRegionBase( string const & name, Group * const parent );
 
 
  ParticleRegionBase( const ParticleRegionBase & init );
 
  virtual ~ParticleRegionBase() override;
 
 
 
  static string verifyMeshBodyName( Group const & meshBodies,
                                    string const & meshBodyBlockName );
 
 
  virtual void generateMesh( Group & particleBlocks )
  {
    GEOS_UNUSED_VAR( particleBlocks );
    GEOS_ERROR( "ParticleRegionBase::GenerateMesh() should be overriden if called." );
  }
 
 
 
  subGroupMap & getSubRegions()
  {
    return getGroup( viewKeyStruct::particleSubRegions() ).getSubGroups();
  }
 
  subGroupMap const & getSubRegions() const
  {
    return getGroup( viewKeyStruct::particleSubRegions() ).getSubGroups();
  }
 
 
  template< typename SUBREGIONTYPE=ParticleSubRegionBase, typename KEY_TYPE=void >
  SUBREGIONTYPE const & getSubRegion( KEY_TYPE const & key ) const
  {
    return this->getGroup( viewKeyStruct::particleSubRegions() ).getGroup< SUBREGIONTYPE >( key );
  }
 
  template< typename SUBREGIONTYPE=ParticleSubRegionBase, typename KEY_TYPE=void >
  SUBREGIONTYPE & getSubRegion( KEY_TYPE const & key )
  {
    return this->getGroup( viewKeyStruct::particleSubRegions() ).getGroup< SUBREGIONTYPE >( key );
  }
 
  localIndex numSubRegions() const
  {
    return this->getGroup( viewKeyStruct::particleSubRegions() ).getSubGroups().size();
  }
 
  template< typename SUBREGIONTYPE = ParticleSubRegionBase, typename ... SUBREGIONTYPES >
  localIndex getNumberOfParticles() const
  {
    localIndex numParticle = 0;
    this->forParticleSubRegions< SUBREGIONTYPE, SUBREGIONTYPES... >( [&]( Group const & group ) -> void
    {
      numParticle += group.size();
    } );
    return numParticle;
  }
 
  string_array & getMaterialList() {return m_materialList;}
 
  string_array const & getMaterialList() const {return m_materialList;}
 
  template< typename CONSTITUTIVE_TYPE >
  string_array getConstitutiveNames() const;
 
 
 
 
 
 
  template< typename LAMBDA >
  void forParticleSubRegions( LAMBDA && lambda ) const
  {
    forParticleSubRegions< ParticleSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forParticleSubRegions( LAMBDA && lambda )
  {
    forParticleSubRegions< ParticleSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forParticleSubRegions( LAMBDA && lambda ) const
  {
    this->getGroup( viewKeyStruct::particleSubRegions() ).forSubGroups< SUBREGIONTYPE, SUBREGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forParticleSubRegions( LAMBDA && lambda )
  {
    this->getGroup( viewKeyStruct::particleSubRegions() ).forSubGroups< SUBREGIONTYPE, SUBREGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forParticleSubRegionsIndex( LAMBDA && lambda ) const
  {
    forParticleSubRegionsIndex< ParticleSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forParticleSubRegionsIndex( LAMBDA && lambda )
  {
    forParticleSubRegionsIndex< ParticleSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forParticleSubRegionsIndex( LAMBDA && lambda ) const
  {
    for( localIndex esr=0; esr<this->numSubRegions(); ++esr )
    {
      ParticleSubRegionBase const & subRegion = this->getSubRegion( esr );
      applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto const & castedSubRegion )
      {
        lambda( esr, castedSubRegion );
      } );
    }
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forParticleSubRegionsIndex( LAMBDA && lambda )
  {
    for( localIndex esr=0; esr<this->numSubRegions(); ++esr )
    {
      ParticleSubRegionBase & 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 * particleSubRegions() { return "particleSubRegions"; }
  };
 
private:
 
  ParticleRegionBase & operator=( const ParticleRegionBase & rhs );
 
  string_array m_materialList;
 
  string m_meshBody;
 
};
 
 
 
 
 
template< typename CONSTITUTIVE_TYPE >
string_array ParticleRegionBase::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;
}
 
}
 
 
 
#endif /* GEOS_MESH_PARTICLEREGIONBASE_HPP */