MeshObjectPath.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_MESHOBJECTPATH_HPP_
#define GEOS_MESH_MESHOBJECTPATH_HPP_
 
 
#include "common/format/EnumStrings.hpp"
#include "MeshLevel.hpp"
 
namespace geos
{
class MeshBody;
class MeshLevel;
 
class MeshObjectPath
{
public:
 
  using permutationMapType = std::map< string, std::map< string, std::map< string, stdVector< string > > > >;
 
  enum class ObjectTypes : int
  {
    nodes,  
    edges,  
    faces,  
    elems,  
    invalid 
  };
 
  using SetNameToTypesMap = std::map< std::string, std::map< MeshObjectPath::ObjectTypes, localIndex > >;
 
  MeshObjectPath( string const path,
                  dataRepository::Group const & meshBodies );
 
  void processPath( string const path,
                    dataRepository::Group const & meshBodies );
 
  ObjectTypes const & getObjectType() const
  {
    return m_objectType;
  }
 
  permutationMapType const & pathPermutations() const
  {
    return m_pathPermutations;
  }
 
  bool containsMeshLevel( MeshLevel const & meshLevel ) const;
 
  template< typename OBJECT_TYPE = dataRepository::Group,
            typename FUNC >
  void forObjectsInPath( dataRepository::Group & meshBodies,
                         FUNC && func ) const;
 
  template< typename OBJECT_TYPE = dataRepository::Group,
            typename FUNC >
  void forObjectsInPath( dataRepository::Group const & meshBodies,
                         FUNC && func ) const;
 
  template< typename OBJECT_TYPE = dataRepository::Group,
            typename FUNC >
  void forObjectsInPath( MeshLevel & level, FUNC && func ) const;
 
  template< typename TYPE, typename ... NEXT_TYPES,
            typename FUNC >
  void forManagersForSetName( MeshLevel const & mesh, string const & setName,
                              FUNC && func ) const;
 
#if defined(MESH_OBJECT_PATH_PRIVATE_FUNCTION_UNIT_TESTING)
  template< typename OBJECT_TYPE >
  bool testCheckObjectTypeConsistency()
  {
    return checkObjectTypeConsistency< OBJECT_TYPE >();
  }
 
  stdVector< string > testFillPathTokens( string const & path,
                                          dataRepository::Group const & meshBodies )
  {
    return fillPathTokens( path, meshBodies );
  }
 
#endif
 
private:
 
  template< typename OBJECT_TYPE,
            typename FUNC >
  void forObjectsInPath( std::pair< string const, std::map< string, stdVector< string > > > const & levelPair,
                         MeshLevel & meshLevel,
                         FUNC && func ) const;
 
  template< typename OBJECT_TYPE,
            typename FUNC >
  void forObjectsInPath( std::pair< string const, std::map< string, stdVector< string > > > const & levelPair,
                         MeshLevel const & meshLevel,
                         FUNC && func ) const;
 
  template< typename OBJECT_TYPE >
  bool checkObjectTypeConsistency() const;
 
  void printPermutations() const;
 
  stdVector< string > fillPathTokens( string const & path,
                                      dataRepository::Group const & meshBodies ) const;
 
  void processPathTokens( stdVector< string > const & pathTokens,
                          dataRepository::Group const & meshBodies );
 
 
 
  ObjectTypes const m_objectType;
 
  permutationMapType m_pathPermutations;
 
};
 
} /* namespace geos */
 
#include "MeshBody.hpp"
 
namespace geos
{
 
ENUM_STRINGS( MeshObjectPath::ObjectTypes,
              MeshLevel::groupStructKeys::nodeManagerString(),
              MeshLevel::groupStructKeys::edgeManagerString(),
              MeshLevel::groupStructKeys::faceManagerString(),
              MeshLevel::groupStructKeys::elemManagerString(),
              "invalid" );
 
template< typename OBJECT_TYPE >
bool MeshObjectPath::checkObjectTypeConsistency() const
{
  bool consistent = false;
  if( m_objectType == ObjectTypes::nodes )
  {
    consistent = std::is_same< NodeManager, OBJECT_TYPE >::value;
  }
  else if( m_objectType == ObjectTypes::edges )
  {
    consistent = std::is_same< EdgeManager, OBJECT_TYPE >::value;
  }
  else if( m_objectType == ObjectTypes::faces )
  {
    consistent = std::is_same< FaceManager, OBJECT_TYPE >::value;
  }
  else if( m_objectType == ObjectTypes::elems )
  {
    consistent = std::is_base_of< ElementRegionBase, OBJECT_TYPE >::value ||
                 std::is_base_of< ElementSubRegionBase, OBJECT_TYPE >::value;
  }
  return consistent;
}
 
template< typename OBJECT_TYPE,
          typename FUNC >
void MeshObjectPath::forObjectsInPath( std::pair< string const, std::map< string, stdVector< string > > > const & levelPair,
                                       MeshLevel & meshLevel,
                                       FUNC && func ) const
{
  forObjectsInPath< OBJECT_TYPE >( levelPair, const_cast< MeshLevel const & >( meshLevel ), [&]( OBJECT_TYPE const & object )
  {
    func( const_cast< OBJECT_TYPE & >(object) );
  } );
}
 
template< typename OBJECT_TYPE,
          typename FUNC >
void MeshObjectPath::forObjectsInPath( std::pair< string const, std::map< string, stdVector< string > > > const & levelPair,
                                       MeshLevel const & meshLevel,
                                       FUNC && func ) const
{
  if( m_objectType == ObjectTypes::nodes )
  {
    func( dynamic_cast< OBJECT_TYPE const & >(meshLevel.getNodeManager() ) );
  }
  else if( m_objectType == ObjectTypes::edges )
  {
    func( dynamic_cast< OBJECT_TYPE const & >(meshLevel.getEdgeManager()) );
  }
  else if( m_objectType == ObjectTypes::faces )
  {
    func( dynamic_cast< OBJECT_TYPE const & >(meshLevel.getFaceManager()) );
  }
  else if( m_objectType == ObjectTypes::elems )
  {
    ElementRegionManager const & elemRegionMan = meshLevel.getElemManager();
    for( auto & elemRegionPair : levelPair.second )
    {
      ElementRegionBase const & elemRegion = elemRegionMan.getRegion( elemRegionPair.first );
      if( std::is_base_of< ElementRegionBase, OBJECT_TYPE >::value )
      {
        func( dynamic_cast< OBJECT_TYPE const & >(elemRegion) );
      }
      else
      {
        for( auto & elemSubRegionName : elemRegionPair.second )
        {
          ElementSubRegionBase const & subRegion = elemRegion.getSubRegion( elemSubRegionName );
          if( std::is_base_of< ElementSubRegionBase, OBJECT_TYPE >::value ||
              std::is_same< dataRepository::Group, OBJECT_TYPE >::value )
          {
            func( dynamic_cast< OBJECT_TYPE const & >(subRegion) );
          }
          else
          {
            GEOS_ERROR( "You shouldn't be here" );
          }
        }
      }
    }
  }
}
 
template< typename OBJECT_TYPE,
          typename FUNC >
void MeshObjectPath::forObjectsInPath( dataRepository::Group & meshBodies,
                                       FUNC && func ) const
{
  forObjectsInPath< OBJECT_TYPE >( const_cast< dataRepository::Group const & >(meshBodies),
                                   [&]( auto const & object )
  {
    func( const_cast< OBJECT_TYPE & >(object) );
  } );
}
 
template< typename OBJECT_TYPE, typename FUNC >
void MeshObjectPath::forObjectsInPath( dataRepository::Group const & meshBodies,
                                       FUNC && func ) const
{
  checkObjectTypeConsistency< OBJECT_TYPE >();
  for( auto const & meshBodyPair : m_pathPermutations )
  {
    MeshBody const & meshBody = meshBodies.getGroup< MeshBody >( meshBodyPair.first );
    for( auto const & meshLevelPair : meshBodyPair.second )
    {
      MeshLevel const & meshLevel = meshBody.getMeshLevel( meshLevelPair.first );
      forObjectsInPath< OBJECT_TYPE, FUNC >( meshLevelPair, meshLevel, std::forward< FUNC >( func ));
    }
  }
}
 
template< typename OBJECT_TYPE,
          typename FUNC >
void MeshObjectPath::forObjectsInPath( MeshLevel & meshLevel,
                                       FUNC && func ) const
{
  string const bodyName = meshLevel.getParent().getParent().getName();
  string const levelName = meshLevel.getName();
 
  auto bodyIter = m_pathPermutations.find( bodyName );
  if( bodyIter != m_pathPermutations.end() )
  {
    auto const levelIter = bodyIter->second.find( levelName );
    if( levelIter != bodyIter->second.end() )
    {
      // string const objectTypeName = stringutilities::toLower( OBJECT_TYPE::catalogName());
      // if( objectTypeName == stringutilities::toLower( EnumStrings< ObjectTypes >::toString( m_objectType ) ) ||
      //     ( objectTypeName.find( "elem" )!=string::npos && m_objectType==ObjectTypes::elems ) ||
      //     ( objectTypeName == "group") )
      if( checkObjectTypeConsistency< OBJECT_TYPE >() ||
          std::is_same< OBJECT_TYPE, dataRepository::Group >::value )
      {
        forObjectsInPath< OBJECT_TYPE, FUNC >( *levelIter, meshLevel, std::forward< FUNC >( func ) );
      }
    }
  }
}
 
template< typename TYPE, typename ... NEXT_TYPES,
          typename FUNC >
void MeshObjectPath::forManagersForSetName( MeshLevel const & mesh, string const & setName,
                                            FUNC && func ) const
{
  mesh.forSubGroups< TYPE >( [&]( dataRepository::Group const & targetManager )
  {
    TYPE const * manager = dynamic_cast< TYPE const * >( &targetManager );
 
    if( manager != nullptr )
    {
      if( manager->sets().hasWrapper( setName ))
      {
        auto const & targetSet = manager->getSet( setName );
        if( std::is_same_v< TYPE, NodeManager > &&
            getObjectType() !=  MeshObjectPath::ObjectTypes::nodes &&
            targetSet.size() > 0 )
        {
          func( MeshObjectPath::ObjectTypes::nodes, setName );
        }
        else if( std::is_same_v< TYPE, EdgeManager >  &&
                 getObjectType() !=  MeshObjectPath::ObjectTypes::edges &&
                 targetSet.size() > 0 )
        {
          func( MeshObjectPath::ObjectTypes::edges, setName );
        }
        else if( std::is_same_v< TYPE, FaceManager > &&
                 getObjectType() !=  MeshObjectPath::ObjectTypes::faces &&
                 targetSet.size() > 0 )
        {
          func( MeshObjectPath::ObjectTypes::faces, setName );
        }
      }
    }
  } );
 
  if constexpr ( sizeof...(NEXT_TYPES) > 0 )
    forManagersForSetName< NEXT_TYPES... >( mesh, setName, func );
}
 
 
 
} /* namespace geos */
 
#endif /* GEOS_MESH_MESHOBJECTPATH_HPP_ */