ProjectData.h

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <memory>
#include <optional>
#include <string>
 
#include "BaseLib/ConfigTree-fwd.h"
#include "BaseLib/ExportSymbol.h"
#include "ChemistryLib/ChemicalSolverInterface.h"
#include "MaterialLib/MPL/Medium.h"
#include "MathLib/InterpolationAlgorithms/PiecewiseLinearInterpolation.h"
#include "ParameterLib/CoordinateSystem.h"
#include "ParameterLib/Parameter.h"
#include "ProcessLib/Process.h"
#include "ProcessLib/ProcessVariable.h"
 
#ifdef OGS_EMBED_PYTHON_INTERPRETER
#include <pybind11/embed.h>
#endif
 
namespace MeshLib
{
class Mesh;
}
 
namespace NumLib
{
class NonlinearSolverBase;
}
 
namespace ProcessLib
{
class TimeLoop;
}
 
class ProjectData final
{
public:
    ProjectData();
 
    ProjectData(BaseLib::ConfigTree const& project_config,
                std::string const& project_directory,
                std::string const& output_directory,
                std::string const& mesh_directory,
                [[maybe_unused]] std::string const& script_directory);
 
    ProjectData(ProjectData&) = delete;
 
    //
    // Process interface
    //
 
    std::vector<std::unique_ptr<ProcessLib::Process>> const& getProcesses()
        const
    {
        return _processes;
    }
 
    ProcessLib::TimeLoop& getTimeLoop() { return *_time_loop; }
 
    MeshLib::Mesh* getMesh(std::string const& mesh_name) const;
 
    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
    getMedia() const
    {
        return _media;
    }
 
private:
    void parseProcessVariables(
        BaseLib::ConfigTree const& process_variables_config);
 
    std::vector<std::string> parseParameters(
        BaseLib::ConfigTree const& parameters_config);
 
    void parseMedia(std::optional<BaseLib::ConfigTree> const& media_config);
 
    void parseProcesses(BaseLib::ConfigTree const& processes_config,
                        std::string const& project_directory,
                        std::string const& output_directory,
                        std::unique_ptr<ChemistryLib::ChemicalSolverInterface>&&
                            chemical_solver_interface);
 
    void parseTimeLoop(BaseLib::ConfigTree const& config,
                       const std::string& output_directory);
 
    void parseLinearSolvers(BaseLib::ConfigTree const& config);
 
    void parseNonlinearSolvers(BaseLib::ConfigTree const& config);
 
    void parseCurves(std::optional<BaseLib::ConfigTree> const& config);
 
    std::unique_ptr<ChemistryLib::ChemicalSolverInterface>
    parseChemicalSolverInterface(
        std::optional<BaseLib::ConfigTree> const& config,
        const std::string& output_directory);
 
    std::vector<std::unique_ptr<MeshLib::Mesh>> _mesh_vec;
    std::vector<std::unique_ptr<ProcessLib::Process>> _processes;
    std::vector<ProcessLib::ProcessVariable> _process_variables;
 
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>> _parameters;
 
    std::optional<ParameterLib::CoordinateSystem> _local_coordinate_system;
 
    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> _media;
 
    std::unique_ptr<ProcessLib::TimeLoop> _time_loop;
 
    std::map<std::string, std::unique_ptr<GlobalLinearSolver>> _linear_solvers;
 
    std::map<std::string, std::unique_ptr<NumLib::NonlinearSolverBase>>
        _nonlinear_solvers;
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>>
        _curves;
 
#ifdef OGS_EMBED_PYTHON_INTERPRETER
    std::optional<pybind11::scoped_interpreter> _py_scoped_interpreter;
#endif
};