ProblemManager.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_MAININTERFACE_PROBLEMMANAGER_HPP_
#define GEOS_MAININTERFACE_PROBLEMMANAGER_HPP_
 
#include "dataRepository/Group.hpp"
 
namespace geos
{
 
class PhysicsSolverManager;
class DomainPartition;
class GeometricObjectManager;
class FiniteElementDiscretization;
class MeshLevel;
namespace constitutive
{
class ConstitutiveManager;
}
class EventManager;
class TasksManager;
class FunctionManager;
class FieldSpecificationManager;
struct CommandLineOptions;
class CellBlockManagerABC;
class ParticleBlockManagerABC;
 
class ProblemManager : public dataRepository::Group
{
public:
 
  explicit ProblemManager( conduit::Node & root );
 
  ~ProblemManager() override;
 
  virtual void setSchemaDeviations( xmlWrapper::xmlNode schemaRoot,
                                    xmlWrapper::xmlNode schemaParent,
                                    integer documentationType ) override;
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  void parseCommandLineInput();
 
  static bool parseRestart( string & restartFileName, CommandLineOptions const & options );
 
  void generateDocumentation();
 
  void parseInputFile();
 
  void parseInputString( string const & xmlString );
 
  void parseXMLDocument( xmlWrapper::xmlDocument & xmlDocument );
 
  void generateMesh();
 
  void importFields();
 
  void applyNumericalMethods();
 
  void initializationOrder( string_array & order ) override final;
 
  void problemSetup();
 
  bool runSimulation();
 
  void readRestartOverwrite();
 
  void applyInitialConditions();
 
  DomainPartition & getDomainPartition();
 
  DomainPartition const & getDomainPartition() const;
 
  string const & getProblemName() const
  { return getGroup< Group >( groupKeys.commandLine ).getReference< string >( viewKeys.problemName ); }
 
  string const & getInputFileName() const
  { return getGroup< Group >( groupKeys.commandLine ).getReference< string >( viewKeys.inputFileName ); }
 
  string const & getRestartFileName() const
  { return getGroup< Group >( groupKeys.commandLine ).getReference< string >( viewKeys.restartFileName ); }
 
  string const & getSchemaFileName() const
  { return getGroup< Group >( groupKeys.commandLine ).getReference< string >( viewKeys.schemaFileName ); }
 
  struct viewKeysStruct
  {
    dataRepository::ViewKey inputFileName            = {"inputFileName"};            
    dataRepository::ViewKey restartFileName          = {"restartFileName"};          
    dataRepository::ViewKey beginFromRestart         = {"beginFromRestart"};         
    dataRepository::ViewKey xPartitionsOverride      = {"xPartitionsOverride"};      
    dataRepository::ViewKey yPartitionsOverride      = {"yPartitionsOverride"};      
    dataRepository::ViewKey zPartitionsOverride      = {"zPartitionsOverride"};      
    dataRepository::ViewKey overridePartitionNumbers = {"overridePartitionNumbers"}; 
    dataRepository::ViewKey schemaFileName           = {"schemaFileName"};           
    dataRepository::ViewKey problemName              = {"problemName"};              
    dataRepository::ViewKey outputDirectory          = {"outputDirectory"};          
    dataRepository::ViewKey useNonblockingMPI        = {"useNonblockingMPI"};        
    dataRepository::ViewKey suppressPinned           = {"suppressPinned"};           
  } viewKeys; 
 
  struct groupKeysStruct
  {
    static constexpr char const * numericalMethodsManagerString() { return "NumericalMethods"; }
    dataRepository::GroupKey commandLine    = { "commandLine" };                          
    dataRepository::GroupKey constitutiveManager = { "Constitutive" };                    
    dataRepository::GroupKey domain    = { "domain" };                                    
    dataRepository::GroupKey eventManager = { "Events" };                                 
    dataRepository::GroupKey fieldSpecificationManager = { "FieldSpecifications" };       
    dataRepository::GroupKey functionManager = { "Functions" };                           
    dataRepository::GroupKey geometricObjectManager = { "Geometry" };                     
    dataRepository::GroupKey meshManager = { "Mesh" };                                    
    dataRepository::GroupKey numericalMethodsManager = { numericalMethodsManagerString() }; 
    dataRepository::GroupKey outputManager = { "Outputs" };                               
    dataRepository::GroupKey physicsSolverManager = { "Solvers" };                        
    dataRepository::GroupKey tasksManager = { "Tasks" };                                  
  } groupKeys; 
 
  PhysicsSolverManager & getPhysicsSolverManager()
  {
    return *m_physicsSolverManager;
  }
 
  PhysicsSolverManager const & getPhysicsSolverManager() const
  {
    return *m_physicsSolverManager;
  }
 
  FunctionManager & getFunctionManager()
  {
    GEOS_ERROR_IF( m_functionManager == nullptr, "Not initialized." );
    return *m_functionManager;
  }
 
  FunctionManager const & getFunctionManager() const
  {
    GEOS_ERROR_IF( m_functionManager == nullptr, "Not initialized." );
    return *m_functionManager;
  }
 
  FieldSpecificationManager & getFieldSpecificationManager()
  {
    GEOS_ERROR_IF( m_fieldSpecificationManager == nullptr, "Not initialized." );
    return *m_fieldSpecificationManager;
  }
 
  FieldSpecificationManager const & getFieldSpecificationManager() const
  {
    GEOS_ERROR_IF( m_fieldSpecificationManager == nullptr, "Not initialized." );
    return *m_fieldSpecificationManager;
  }
 
  EventManager & getEventManager()
  {return *m_eventManager;}
 
  TasksManager & getTasksManager()
  {return *m_tasksManager;}
 
protected:
  virtual void postInputInitialization() override final;
 
private:
 
  map< std::tuple< string, string, string, string >, localIndex > calculateRegionQuadrature( Group & meshBodies );
 
 
  map< std::pair< string, Group const * const >, arrayView1d< string const > const >
  getDiscretizations() const;
 
  void generateMeshLevel( MeshLevel & meshLevel,
                          CellBlockManagerABC const & cellBlockManager,
                          Group const * const discretization,
                          arrayView1d< string const > const & targetRegions );
 
  void generateMeshLevel( MeshLevel & meshLevel,
                          ParticleBlockManagerABC & particleBlockManager,
                          arrayView1d< string const > const & );
 
  void setRegionQuadrature( Group & meshBodies,
                            constitutive::ConstitutiveManager const & constitutiveManager,
                            map< std::tuple< string, string, string, string >, localIndex > const & regionQuadrature );
 
  PhysicsSolverManager * m_physicsSolverManager;
 
  EventManager * m_eventManager;
 
  TasksManager * m_tasksManager;
 
  FunctionManager * m_functionManager;
 
  FieldSpecificationManager * m_fieldSpecificationManager;
};
 
} /* namespace geos */
 
#endif /* GEOS_MAININTERFACE_PROBLEMMANAGER_HPP_ */