DomainPartition.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 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_DOMAINPARTITION_HPP_
#define GEOS_MESH_DOMAINPARTITION_HPP_
 
#include "common/MpiWrapper.hpp"
#include "constitutive/ConstitutiveManager.hpp"
#include "dataRepository/Group.hpp"
#include "discretizationMethods/NumericalMethodsManager.hpp"
#include "mesh/MeshBody.hpp"
#include "mesh/mpiCommunications/NeighborCommunicator.hpp"
 
namespace geos
{
 
class SiloFile;
namespace dataRepository
{
namespace keys
{
string const partitionManager( "partitionManager" );
}
}
 
class ObjectManagerBase;
class PartitionBase;
 
class DomainPartition : public dataRepository::Group
{
public:
  DomainPartition( string const & name,
                   Group * const parent );
 
  ~DomainPartition() override;
 
  DomainPartition() = delete;
 
  DomainPartition( DomainPartition const & ) = delete;
 
  DomainPartition( DomainPartition && ) = delete;
 
  DomainPartition & operator=( DomainPartition const & ) = delete;
 
  DomainPartition & operator=( DomainPartition && ) = delete;
 
  void initializationOrder( string_array & order ) override final;
 
 
  void setupCommunications( bool use_nonblocking );
 
  void setupBaseLevelMeshGlobalInfo();
 
  void addNeighbors( const unsigned int idim,
                     MPI_Comm & cartcomm,
                     int * ncoords );
 
  void outputPartitionInformation() const;
 
 
 
  struct groupKeysStruct
  {
    static constexpr char const * meshBodiesString() { return "MeshBodies"; }
    static constexpr char const * constitutiveManagerString() { return "Constitutive"; }
 
    dataRepository::GroupKey meshBodies = { meshBodiesString() };
    dataRepository::GroupKey constitutiveManager = { constitutiveManagerString() };
    dataRepository::GroupKey communicationManager = { "communicationManager" };
  }
  groupKeys;
 
  constitutive::ConstitutiveManager const & getConstitutiveManager() const
  { return this->getGroup< constitutive::ConstitutiveManager >( groupKeys.constitutiveManager ); }
 
  constitutive::ConstitutiveManager & getConstitutiveManager()
  { return this->getGroup< constitutive::ConstitutiveManager >( groupKeys.constitutiveManager ); }
 
  NumericalMethodsManager const & getNumericalMethodManager() const
  { return this->getParent().getGroup< NumericalMethodsManager >( "NumericalMethods" ); }
 
  NumericalMethodsManager & getNumericalMethodManager()
  { return this->getParent().getGroup< NumericalMethodsManager >( "NumericalMethods" ); }
 
  Group const & getMeshBodies() const
  { return this->getGroup( groupKeys.meshBodies ); }
 
  Group & getMeshBodies()
  { return this->getGroup( groupKeys.meshBodies ); }
 
  template< typename KEY_TYPE >
  bool hasMeshBody( KEY_TYPE const & key ) const
  { return getMeshBodies().hasGroup< MeshBody >( key ); }
 
  template< typename KEY_TYPE >
// TODO uncomment these to disallow using a non string or char const * key
//            std::enable_if_t< std::is_same< T, string >::value ||
//                              std::is_same< T, const char * >::value, bool > = false >
  MeshBody const & getMeshBody( KEY_TYPE const & key ) const
  { return getMeshBodies().getGroup< MeshBody >( key ); }
 
  template< typename KEY_TYPE >
//  std::enable_if_t< std::is_same< T, string >::value ||
//                    std::is_same< T, const char * >::value, bool > = false >
  MeshBody & getMeshBody( KEY_TYPE const & key )
  { return getMeshBodies().getGroup< MeshBody >( key ); }
 
 
  template< typename FUNCTION >
  void forMeshBodies( FUNCTION && function ) const
  {
    getMeshBodies().forSubGroups< MeshBody >( std::forward< FUNCTION >( function ) );
  }
 
  template< typename FUNCTION >
  void forMeshBodies( FUNCTION && function )
  {
    getMeshBodies().forSubGroups< MeshBody >( std::forward< FUNCTION >( function ) );
  }
 
  template< typename FUNCTION >
  void forMeshBodiesIndex( FUNCTION && function ) const
  {
    getMeshBodies().forSubGroupsIndex< MeshBody >( std::forward< FUNCTION >( function ) );
  }
 
  template< typename FUNCTION >
  void forMeshBodiesIndex( FUNCTION && function )
  {
    getMeshBodies().forSubGroupsIndex< MeshBody >( std::forward< FUNCTION >( function ) );
  }
 
  std::vector< NeighborCommunicator > & getNeighbors()
  { return m_neighbors; }
 
  std::vector< NeighborCommunicator > const & getNeighbors() const
  { return m_neighbors; };
 
private:
 
  std::vector< NeighborCommunicator > m_neighbors;
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_DOMAINPARTITION_HPP_ */