MeshBody.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_MESHBODY_HPP_
#define GEOS_MESH_MESHBODY_HPP_
 
#include "MeshLevel.hpp"
#include "dataRepository/KeyNames.hpp"
 
namespace geos
{
 
class MeshLevel;
 
class MeshBody : public dataRepository::Group
{
public:
 
  MeshBody( string const & name,
            Group * const parent );
 
  MeshLevel & createMeshLevel( localIndex const newLevel );
 
  MeshLevel & createMeshLevel( string const & name );
 
  MeshLevel & createMeshLevel( string const & sourceLevelName,
                               string const & newLevelName,
                               int const order );
 
  MeshLevel & createShallowMeshLevel( string const & sourceLevelName,
                                      string const & newLevelName );
 
  Group & getMeshLevels() { return m_meshLevels; }
  Group const & getMeshLevels() const { return m_meshLevels; }
 
  template< typename T, std::enable_if_t< std::is_same< T, string >::value ||
                                          std::is_same< T, const char * >::value, bool > = false >
  MeshLevel & getMeshLevel( T const & level ) const
  { return m_meshLevels.getGroup< MeshLevel >( level ); }
 
  template< typename T, std::enable_if_t< std::is_same< T, string >::value ||
                                          std::is_same< T, const char * >::value, bool > = false >
  MeshLevel & getMeshLevel( T const & level )
  { return m_meshLevels.getGroup< MeshLevel >( level ); }
 
 
  MeshLevel & getBaseDiscretization()
  {
    return getMeshLevel( groupStructKeys::baseDiscretizationString() );
  }
 
  MeshLevel const & getBaseDiscretization() const
  {
    return getMeshLevel( groupStructKeys::baseDiscretizationString() );
  }
 
  template< typename FUNCTION >
  void forMeshLevels( FUNCTION && function ) const
  {
    m_meshLevels.forSubGroups< MeshLevel >( std::forward< FUNCTION >( function ) );
  }
 
  template< typename FUNCTION >
  void forMeshLevels( FUNCTION && function )
  {
    m_meshLevels.forSubGroups< MeshLevel >( std::forward< FUNCTION >( function ) );
  }
 
  void setGlobalLengthScale( real64 scale );
 
  real64 getGlobalLengthScale() const
  {
    return m_globalLengthScale;
  }
 
  bool hasParticles() const
  {
    return m_hasParticles;
  }
 
  void setHasParticles( bool hasParticles );
 
  CellBlockManagerABC const & getCellBlockManager() const
  {
    return this->getGroup< CellBlockManagerABC >( dataRepository::keys::cellManager );
  }
 
  void deregisterCellBlockManager()
  {
    this->deregisterGroup( dataRepository::keys::cellManager );
  }
 
  struct viewKeysStruct
  {} viewKeys; 
 
  struct groupStructKeys
  {
    static constexpr char const * meshLevelsString() { return "meshLevels"; }
 
    static constexpr char const * baseDiscretizationString() { return "Level0"; }
  } groupKeys; 
 
 
private:
 
  Group & m_meshLevels;
 
  real64 m_globalLengthScale { 0. };
 
  bool m_hasParticles;
 
  static string intToMeshLevelString( localIndex const meshLevel );
 
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_MESHBODY_HPP_ */