GeosxState.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_GEOSXSTATE_HPP_
#define GEOS_MAININTERFACE_GEOSXSTATE_HPP_
 
// Source includes
#include "common/DataTypes.hpp"
#include "common/logger/Logger.hpp"
 
// System includes
#include <functional>
#include <memory>
 
// Forward declaration of conduit::Node.
namespace conduit
{
class Node;
}
 
#if defined( GEOS_USE_CALIPER )
//Forward declaration of cali::ConfigManager.
namespace cali
{
class ConfigManager;
}
#endif
 
 
namespace geos
{
 
// Forward declarations.
namespace dataRepository
{
class Group;
}
 
class ProblemManager;
class FieldSpecificationManager;
class FunctionManager;
class CommunicationTools;
struct CommandLineOptions;
 
string durationToString( std::chrono::system_clock::duration const duration );
 
enum class State
{
  UNINITIALIZED = 0,
  INITIALIZED = 1,
  READY_TO_RUN = 2,
  COMPLETED = 3
};
 
std::ostream & operator<<( std::ostream & os, State const state );
 
class GeosxState
{
public:
 
  explicit GeosxState( std::unique_ptr< CommandLineOptions > && commandLineOptions );
 
  ~GeosxState();
 
  GeosxState( GeosxState const & ) = delete;
  GeosxState( GeosxState && ) = delete;
  GeosxState & operator=( GeosxState const & ) = delete;
  GeosxState & operator=( GeosxState && ) = delete;
 
  bool initializeDataRepository();
 
  void applyInitialConditions();
 
  void run();
 
  State getState() const
  { return m_state; }
 
  CommandLineOptions const & getCommandLineOptions()
  {
    GEOS_ERROR_IF( m_commandLineOptions == nullptr, "Not initialized." );
    return *m_commandLineOptions;
  }
 
  conduit::Node & getRootConduitNode()
  {
    GEOS_ERROR_IF( m_rootNode == nullptr, "Not initialized." );
    return *m_rootNode;
  }
 
  ProblemManager & getProblemManager()
  {
    GEOS_ERROR_IF( m_problemManager == nullptr, "Not initialized." );
    return *m_problemManager;
  }
 
  dataRepository::Group & getProblemManagerAsGroup();
 
  FieldSpecificationManager & getFieldSpecificationManager();
 
  FunctionManager & getFunctionManager();
 
  CommunicationTools & getCommunicationTools()
  {
    GEOS_ERROR_IF( m_commTools == nullptr, "Not initialized." );
    return *m_commTools;
  }
 
  std::chrono::system_clock::duration getInitTime() const
  { return m_initTime; }
 
  std::chrono::system_clock::duration getRunTime() const
  { return m_runTime; }
 
private:
 
  State m_state;
 
  std::unique_ptr< CommandLineOptions > m_commandLineOptions;
 
  std::unique_ptr< conduit::Node > m_rootNode;
 
  std::unique_ptr< ProblemManager > m_problemManager;
 
  std::unique_ptr< CommunicationTools > m_commTools;
 
#if defined( GEOS_USE_CALIPER )
  std::unique_ptr< cali::ConfigManager > m_caliperManager;
#endif
 
  std::chrono::system_clock::duration m_initTime;
 
  std::chrono::system_clock::duration m_runTime;
};
 
GeosxState & getGlobalState();
 
} // namespace geos
 
#endif /* GEOS_MAININTERFACE_GEOSXSTATE_HPP_ */