Detailed Description

The ProjectData Object contains all the data needed for a certain project, i.e. all geometric data (stored in a GEOObjects-object), all the meshes, processes, and process variables.

Definition at line 60 of file ProjectData.h.

#include <ProjectData.h>

Public Member Functions
	ProjectData ()

	ProjectData (BaseLib::ConfigTree const &project_config, std::string const &project_directory, std::string const &output_directory, std::string const &mesh_directory, std::string const &script_directory)

	ProjectData (ProjectData &)=delete

std::vector< std::unique_ptr< ProcessLib::Process > > const &	getProcesses () const
	Provides read access to the process container.

ProcessLib::TimeLoop &	getTimeLoop ()

MeshLib::Mesh &	getMesh (std::string const &mesh_name) const

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	getMedia () const

Private Member Functions
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)
	Parses media configuration and saves them in an object.

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)
	Parses the time loop configuration.

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)

Private Attributes
std::vector< std::unique_ptr< MeshLib::Mesh > >	_mesh_vec

std::vector< GeoLib::NamedRaster >	_named_rasters

std::vector< std::unique_ptr< ProcessLib::Process > >	_processes

std::vector< ProcessLib::ProcessVariable >	_process_variables

std::vector< std::unique_ptr< ParameterLib::ParameterBase > >	_parameters
	Buffer for each parameter config passed to the process.

std::optional< ParameterLib::CoordinateSystem >	_local_coordinate_system

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > >	_media

std::unique_ptr< ProcessLib::TimeLoop >	_time_loop
	The time loop used to solve this project's processes.

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

Constructor & Destructor Documentation

◆ ProjectData() [1/3]

ProjectData::ProjectData ( )

default

The empty constructor used in the gui, for example, when the project's configuration is not loaded yet.

◆ ProjectData() [2/3]

ProjectData::ProjectData	(	BaseLib::ConfigTree const &	project_config,
		std::string const &	project_directory,
		std::string const &	output_directory,
		std::string const &	mesh_directory,
		std::string const &	script_directory )

Constructs project data by parsing provided configuration.

Parameters

project_config	Configuration as read from the prj file.
project_directory	Where to look for files referenced in the `config_tree`.
output_directory	Where to write simulation output files to.
mesh_directory	Directory where meshes are read from.
script_directory	Directory where scripts (e.g. Python BCs) are read from.

Input File Parameter: prj__python_script

Input File Parameter: prj__curves

Input File Parameter: prj__parameters

Input File Parameter: prj__local_coordinate_system

Input File Parameter: prj__process_variables

Input File Parameter: prj__media

Input File Parameter: prj__linear_solvers

Input File Parameter: prj__chemical_system

Input File Parameter: prj__processes

Input File Parameter: prj__nonlinear_solvers

Input File Parameter: prj__time_loop

Definition at line 344 of file ProjectData.cpp.

    : _mesh_vec(readMeshes(project_config, mesh_directory, project_directory)),
      _named_rasters(readRasters(project_config, project_directory,
                                 GeoLib::AABB(_mesh_vec[0]->getNodes().begin(),
                                              _mesh_vec[0]->getNodes().end())
                                     .getMinMaxPoints()))
{
    // for debugging raster reading implementation
    // writeRasters(_named_rasters, output_directory);
    if (auto const python_script =
        project_config.getConfigParameterOptional<std::string>("python_script"))
    {
        namespace py = pybind11;
 
#ifdef OGS_EMBED_PYTHON_INTERPRETER
        _py_scoped_interpreter.emplace(ApplicationsLib::setupEmbeddedPython());
#endif
 
        // Append to python's module search path
        auto py_path = py::module::import("sys").attr("path");
        py_path.attr("append")(script_directory);  // .prj or -s directory
        // virtualenv
        py_path.attr("append")(
            CMakeInfoLib::CMakeInfo::python_virtualenv_sitepackages);
 
        auto const script_path =
            BaseLib::copyPathToFileName(*python_script, script_directory);
 
        // Evaluate in scope of main module
        py::object scope = py::module::import("__main__").attr("__dict__");
        // add (global) variables
        auto globals = py::dict(scope);
        globals["ogs_prj_directory"] = project_directory;
        globals["ogs_mesh_directory"] = mesh_directory;
        globals["ogs_script_directory"] = script_directory;
        try
        {
            py::eval_file(script_path, scope);
        }
        catch (py::error_already_set const& e)
        {
            OGS_FATAL("Error evaluating python script {}: {}", script_path,
                      e.what());
        }
    }
 
    parseCurves(project_config.getConfigSubtreeOptional("curves"));
 
    auto parameter_names_for_transformation =
        parseParameters(project_config.getConfigSubtree("parameters"));
 
    _local_coordinate_system = ParameterLib::createCoordinateSystem(
        project_config.getConfigSubtreeOptional("local_coordinate_system"),
        _parameters);
 
    for (auto& parameter : _parameters)
    {
        if (std::find(begin(parameter_names_for_transformation),
                      end(parameter_names_for_transformation),
                      parameter->name) !=
            end(parameter_names_for_transformation))
        {
            if (!_local_coordinate_system)
            {
                OGS_FATAL(
                    "The parameter '{:s}' is using the local coordinate system "
                    "but no local coordinate system was provided.",
                    parameter->name);
            }
            parameter->setCoordinateSystem(*_local_coordinate_system);
        }
 
        parameter->initialize(_parameters);
    }
 
    parseProcessVariables(project_config.getConfigSubtree("process_variables"));
 
    parseMedia(project_config.getConfigSubtreeOptional("media"));
 
    parseLinearSolvers(project_config.getConfigSubtree("linear_solvers"));
 
    auto chemical_solver_interface = parseChemicalSolverInterface(
        project_config.getConfigSubtreeOptional("chemical_system"),
        output_directory);
 
    parseProcesses(project_config.getConfigSubtree("processes"),
                   project_directory, output_directory,
                   std::move(chemical_solver_interface));
 
    parseNonlinearSolvers(project_config.getConfigSubtree("nonlinear_solvers"));
 
    parseTimeLoop(project_config.getConfigSubtree("time_loop"),
                  output_directory);
}

References _local_coordinate_system, _parameters, BaseLib::copyPathToFileName(), ParameterLib::createCoordinateSystem(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), OGS_FATAL, parseChemicalSolverInterface(), parseCurves(), parseLinearSolvers(), parseMedia(), parseNonlinearSolvers(), parseParameters(), parseProcesses(), parseProcessVariables(), parseTimeLoop(), and ApplicationsLib::setupEmbeddedPython().

◆ ProjectData() [3/3]

ProjectData::ProjectData ( ProjectData & )

delete

Member Function Documentation

◆ getMedia()

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & ProjectData::getMedia ( ) const

inline

Definition at line 100 of file ProjectData.h.

    {
        return _media;
    }

References _media.

◆ getMesh()

MeshLib::Mesh & ProjectData::getMesh ( std::string const & mesh_name ) const

Definition at line 1384 of file ProjectData.cpp.

{
    return MeshLib::findMeshByName(_mesh_vec, mesh_name);
}

References _mesh_vec, and MeshLib::findMeshByName().

◆ getProcesses()

std::vector< std::unique_ptr< ProcessLib::Process > > const & ProjectData::getProcesses ( ) const

inline

Provides read access to the process container.

Definition at line 89 of file ProjectData.h.

    {
        return _processes;
    }

References _processes.

◆ getTimeLoop()

ProcessLib::TimeLoop & ProjectData::getTimeLoop ( )

inline

Definition at line 95 of file ProjectData.h.

95{ return *_time_loop; }

ProjectData::_time_loop

std::unique_ptr< ProcessLib::TimeLoop > _time_loop

The time loop used to solve this project's processes.

Definition ProjectData.h:158

References _time_loop.

◆ parseChemicalSolverInterface()

std::unique_ptr< ChemistryLib::ChemicalSolverInterface > ProjectData::parseChemicalSolverInterface	(	std::optional< BaseLib::ConfigTree > const &	config,
		const std::string &	output_directory )

private

Definition at line 592 of file ProjectData.cpp.

{
    if (!config)
    {
        return nullptr;
    }
 
    std::unique_ptr<ChemistryLib::ChemicalSolverInterface>
        chemical_solver_interface;
#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
    INFO(
        "Ready for initializing interface to a chemical solver for water "
        "chemistry calculation.");
 
    auto const chemical_solver =
        config->getConfigAttribute<std::string>("chemical_solver");
 
    if (boost::iequals(chemical_solver, "Phreeqc"))
    {
        INFO(
            "Configuring phreeqc interface for water chemistry calculation "
            "using file-based approach.");
 
        chemical_solver_interface = ChemistryLib::createChemicalSolverInterface<
            ChemistryLib::ChemicalSolver::Phreeqc>(_mesh_vec, _linear_solvers,
                                                   *config, output_directory);
    }
    else if (boost::iequals(chemical_solver, "PhreeqcKernel"))
    {
        OGS_FATAL(
            "The chemical solver option of PhreeqcKernel is not accessible for "
            "the time being. Please set 'Phreeqc'' as the chemical solver for "
            "reactive transport modeling.");
    }
    else if (boost::iequals(chemical_solver, "SelfContained"))
    {
        INFO(
            "Use self-contained chemical solver for water chemistry "
            "calculation.");
 
        chemical_solver_interface = ChemistryLib::createChemicalSolverInterface<
            ChemistryLib::ChemicalSolver::SelfContained>(
            _mesh_vec, _linear_solvers, *config, output_directory);
    }
    else
    {
        OGS_FATAL(
            "Unknown chemical solver. Please specify either Phreeqc or "
            "PhreeqcKernel as the solver for water chemistry calculation "
            "instead.");
    }
#else
    (void)output_directory;
 
    OGS_FATAL(
        "Found the type of the process to be solved is not component transport "
        "process. Please specify the process type to ComponentTransport. At "
        "the present, water chemistry calculation is only available for "
        "component transport process.");
#endif
    return chemical_solver_interface;
}

References _linear_solvers, _mesh_vec, ChemistryLib::createChemicalSolverInterface(), INFO(), OGS_FATAL, ChemistryLib::Phreeqc, and ChemistryLib::SelfContained.

Referenced by ProjectData().

◆ parseCurves()

void ProjectData::parseCurves ( std::optional< BaseLib::ConfigTree > const & config )

private

Input File Parameter: prj__curves__curve

Input File Parameter: prj__curves__curve__name

Definition at line 1361 of file ProjectData.cpp.

{
    if (!config)
    {
        return;
    }
 
    DBUG("Reading curves configuration.");
 
    for (auto conf : config->getConfigSubtreeList("curve"))
    {
        auto const name = conf.getConfigParameter<std::string>("name");
        BaseLib::insertIfKeyUniqueElseError(
            _curves,
            name,
            MathLib::createPiecewiseLinearCurve<
                MathLib::PiecewiseLinearInterpolation>(conf),
            "The curve name is not unique.");
    }
}

References _curves, MathLib::createPiecewiseLinearCurve(), DBUG(), and BaseLib::insertIfKeyUniqueElseError().

Referenced by ProjectData().

◆ parseLinearSolvers()

void ProjectData::parseLinearSolvers ( BaseLib::ConfigTree const & config )

private

Input File Parameter: prj__linear_solvers__linear_solver

Input File Parameter: prj__linear_solvers__linear_solver__name

Definition at line 1314 of file ProjectData.cpp.

{
    DBUG("Reading linear solver configuration.");
 
    for (auto conf : config.getConfigSubtreeList("linear_solver"))
    {
        auto const name = conf.getConfigParameter<std::string>("name");
        auto const linear_solver_parser =
            MathLib::LinearSolverOptionsParser<GlobalLinearSolver>{};
        auto const solver_options =
            linear_solver_parser.parseNameAndOptions("", &conf);
 
        BaseLib::insertIfKeyUniqueElseError(
            _linear_solvers,
            name,
            std::make_unique<GlobalLinearSolver>(std::get<0>(solver_options),
                                                 std::get<1>(solver_options)),
            "The linear solver name is not unique");
    }
}

References _linear_solvers, DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), and BaseLib::insertIfKeyUniqueElseError().

Referenced by ProjectData().

◆ parseMedia()

void ProjectData::parseMedia ( std::optional< BaseLib::ConfigTree > const & media_config )

private

Parses media configuration and saves them in an object.

Input File Parameter: prj__media__medium

Input File Parameter: prj__media__medium__id

Definition at line 528 of file ProjectData.cpp.

{
    if (!media_config)
    {
        return;
    }
 
    DBUG("Reading media:");
 
    if (_mesh_vec.empty() || _mesh_vec[0] == nullptr)
    {
        ERR("A mesh is required to define medium materials.");
        return;
    }
 
    for (auto const& medium_config :
         media_config->getConfigSubtreeList("medium"))
    {
        auto material_id_string =
            medium_config.getConfigAttribute<std::string>("id", "0");
 
        auto const material_ids_of_this_medium =
            BaseLib::splitMaterialIdString(material_id_string);
 
        for (auto const& id : material_ids_of_this_medium)
        {
            if (_media.find(id) != end(_media))
            {
                OGS_FATAL(
                    "Multiple media were specified for the same material id "
                    "'{:d}'. Keep in mind, that if no material id is "
                    "specified, it is assumed to be 0 by default.",
                    id);
            }
 
            if (id == material_ids_of_this_medium[0])
            {
                _media[id] = MaterialPropertyLib::createMedium(
                    id, _mesh_vec[0]->getDimension(), medium_config,
                    _parameters,
                    _local_coordinate_system ? &*_local_coordinate_system
                                             : nullptr,
                    _curves);
            }
            else
            {
                // This medium has multiple material IDs assigned and this is
                // not the first material ID. Therefore we can reuse the medium
                // we created before.
                _media[id] = _media[material_ids_of_this_medium[0]];
            }
        }
    }
 
    if (_media.empty())
    {
        OGS_FATAL("No entity is found inside <media>.");
    }
}

References _curves, _local_coordinate_system, _media, _mesh_vec, _parameters, MaterialPropertyLib::createMedium(), DBUG(), ERR(), OGS_FATAL, and BaseLib::splitMaterialIdString().

Referenced by ProjectData().

◆ parseNonlinearSolvers()

void ProjectData::parseNonlinearSolvers ( BaseLib::ConfigTree const & config )

private

Input File Parameter: prj__nonlinear_solvers__nonlinear_solver

Input File Parameter: prj__nonlinear_solvers__nonlinear_solver__linear_solver

Input File Parameter: prj__nonlinear_solvers__nonlinear_solver__name

Definition at line 1337 of file ProjectData.cpp.

{
    DBUG("Reading non-linear solver configuration.");
 
    for (auto conf : config.getConfigSubtreeList("nonlinear_solver"))
    {
        auto const ls_name =
            conf.getConfigParameter<std::string>("linear_solver");
        auto const& linear_solver = BaseLib::getOrError(
            _linear_solvers, ls_name,
            "A linear solver with the given name does not exist.");
 
        auto const name = conf.getConfigParameter<std::string>("name");
        BaseLib::insertIfKeyUniqueElseError(
            _nonlinear_solvers,
            name,
            NumLib::createNonlinearSolver(*linear_solver, conf).first,
            "The nonlinear solver name is not unique");
    }
}

References _linear_solvers, _nonlinear_solvers, NumLib::createNonlinearSolver(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::getOrError(), and BaseLib::insertIfKeyUniqueElseError().

Referenced by ProjectData().

◆ parseParameters()

std::vector< std::string > ProjectData::parseParameters ( BaseLib::ConfigTree const & parameters_config )

private

Parses the parameters configuration and saves them. Checks for double parameters' names. Returns names of vectors which are to be transformed using local coordinate system.

Input File Parameter: prj__parameters__parameter

Input File Parameter: prj__parameters__parameter__use_local_coordinate_system

Definition at line 486 of file ProjectData.cpp.

{
    using namespace ProcessLib;
 
    std::set<std::string> names;
    std::vector<std::string> parameter_names_for_transformation;
 
    DBUG("Reading parameters:");
    for (auto parameter_config :
         parameters_config.getConfigSubtreeList("parameter"))
    {
        auto p = ParameterLib::createParameter(parameter_config, _mesh_vec,
                                               _named_rasters, _curves);
        if (!names.insert(p->name).second)
        {
            OGS_FATAL("A parameter with name `{:s}' already exists.", p->name);
        }
 
        auto const use_local_coordinate_system =
            parameter_config.getConfigParameterOptional<bool>(
                "use_local_coordinate_system");
        if (!!use_local_coordinate_system && *use_local_coordinate_system)
        {
            parameter_names_for_transformation.push_back(p->name);
        }
 
        _parameters.push_back(std::move(p));
    }
 
    _parameters.push_back(
        std::make_unique<ParameterLib::ConstantParameter<double>>(
            ProcessLib::DeactivatedSubdomain::zero_parameter_name, 0.0));
    _parameters.push_back(
        std::make_unique<ParameterLib::ConstantParameter<double>>(
            ProcessLib::Process::constant_one_parameter_name, 1.0));
 
    return parameter_names_for_transformation;
}

References _curves, _mesh_vec, _named_rasters, _parameters, ProcessLib::Process::constant_one_parameter_name, ParameterLib::createParameter(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), OGS_FATAL, and ProcessLib::DeactivatedSubdomain::zero_parameter_name.

Referenced by ProjectData().

◆ parseProcesses()

void ProjectData::parseProcesses	(	BaseLib::ConfigTree const &	processes_config,
		std::string const &	project_directory,
		std::string const &	output_directory,
		std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &&	chemical_solver_interface )

private

Parses the processes configuration and creates new processes for each process entry passing the corresponding subtree to the process constructor.

Input File Parameter: prj__processes__process

Input File Parameter: prj__processes__process__type

Input File Parameter: prj__processes__process__name

Input File Parameter: prj__processes__process__integration_order

Input File Parameter: prj__processes__process__jacobian_assembler

Definition at line 658 of file ProjectData.cpp.

{
    (void)project_directory;  // to avoid compilation warning
    (void)output_directory;   // to avoid compilation warning
 
    DBUG("Reading processes:");
    for (auto process_config : processes_config.getConfigSubtreeList("process"))
    {
        auto const type =
            process_config.peekConfigParameter<std::string>("type");
 
        auto const name =
            process_config.getConfigParameter<std::string>("name");
 
        [[maybe_unused]] auto const integration_order =
            process_config.getConfigParameter<int>("integration_order");
 
        std::unique_ptr<ProcessLib::Process> process;
 
        auto jacobian_assembler = ProcessLib::createJacobianAssembler(
            process_config.getConfigSubtreeOptional("jacobian_assembler"));
 
#ifdef OGS_BUILD_PROCESS_STEADYSTATEDIFFUSION
        if (type == "STEADY_STATE_DIFFUSION")
        {
            // The existence check of the in the configuration referenced
            // process variables is checked in the physical process.
            // TODO at the moment we have only one mesh, later there can be
            // several meshes. Then we have to assign the referenced mesh
            // here.
            process =
                ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _mesh_vec, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_LIQUIDFLOW
            if (type == "LIQUID_FLOW")
        {
            process = ProcessLib::LiquidFlow::createLiquidFlowProcess(
                name, *_mesh_vec[0], std::move(jacobian_assembler),
                _process_variables, _parameters, integration_order,
                process_config, _mesh_vec, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_STOKESFLOW
            if (type == "StokesFlow")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process =
                        ProcessLib::StokesFlow::createStokesFlowProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters, integration_order,
                            process_config, _media);
                    break;
                default:
                    OGS_FATAL(
                        "StokesFlow process does not support given "
                        "dimension {:d}",
                        _mesh_vec[0]->getDimension());
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_TES
            if (type == "TES")
        {
            process = ProcessLib::TES::createTESProcess(
                name, *_mesh_vec[0], std::move(jacobian_assembler),
                _process_variables, _parameters, integration_order,
                process_config);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_TH2M
            if (type == "TH2M")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::TH2M::createTH2MProcess<2>(
                        name, *_mesh_vec[0], std::move(jacobian_assembler),
                        _process_variables, _parameters,
                        _local_coordinate_system, integration_order,
                        process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::TH2M::createTH2MProcess<3>(
                        name, *_mesh_vec[0], std::move(jacobian_assembler),
                        _process_variables, _parameters,
                        _local_coordinate_system, integration_order,
                        process_config, _media);
                    break;
                default:
                    OGS_FATAL("TH2M process does not support given dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_HEATCONDUCTION
            if (type == "HEAT_CONDUCTION")
        {
            process = ProcessLib::HeatConduction::createHeatConductionProcess(
                name, *_mesh_vec[0], std::move(jacobian_assembler),
                _process_variables, _parameters, integration_order,
                process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE
            if (type == "HEAT_TRANSPORT_BHE")
        {
            if (_mesh_vec[0]->getDimension() != 3)
            {
                OGS_FATAL(
                    "HEAT_TRANSPORT_BHE can only work with a 3-dimensional "
                    "mesh! ");
            }
 
            process =
                ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _curves, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_HYDROMECHANICS
            if (type == "HYDRO_MECHANICS")
        {
            if (  
                process_config.getConfigParameterOptional<int>("dimension"))
            {
                OGS_FATAL(
                    "The 'dimension' tag has been removed in the merge-request "
                    "!4766."
                    "The dimension is now taken from the main mesh and the tag "
                    "must be"
                    "removed. There is a python script in the merge-request "
                    "description"
                    "for automatic conversion.");
            }
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process =
                        ProcessLib::HydroMechanics::createHydroMechanicsProcess<
                            2>(name, *_mesh_vec[0],
                               std::move(jacobian_assembler),
                               _process_variables, _parameters,
                               _local_coordinate_system, integration_order,
                               process_config, _media);
                    break;
                case 3:
                    process =
                        ProcessLib::HydroMechanics::createHydroMechanicsProcess<
                            3>(name, *_mesh_vec[0],
                               std::move(jacobian_assembler),
                               _process_variables, _parameters,
                               _local_coordinate_system, integration_order,
                               process_config, _media);
                    break;
                default:
                    OGS_FATAL(
                        "HYDRO_MECHANICS process does not support given "
                        "dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_LARGEDEFORMATION
            if (type == "LARGE_DEFORMATION")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::LargeDeformation::
                        createLargeDeformationProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::LargeDeformation::
                        createLargeDeformationProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                default:
                    OGS_FATAL(
                        "LARGE_DEFORMATION process does not support given "
                        "dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_LIE
            if (type == "HYDRO_MECHANICS_WITH_LIE")
        {
            if (  
                process_config.getConfigParameterOptional<int>("dimension"))
            {
                OGS_FATAL(
                    "The 'dimension' tag has been removed in the merge-request "
                    "!4766."
                    "The dimension is now taken from the main mesh and the tag "
                    "must be"
                    "removed. There is a python script in the merge-request "
                    "description"
                    "for automatic conversion.");
            }
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::LIE::HydroMechanics::
                        createHydroMechanicsProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                case 3:
                    process = ProcessLib::LIE::HydroMechanics::
                        createHydroMechanicsProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                default:
                    OGS_FATAL(
                        "HYDRO_MECHANICS_WITH_LIE process does not support "
                        "given dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_HT
            if (type == "HT")
        {
            process = ProcessLib::HT::createHTProcess(
                name, *_mesh_vec[0], std::move(jacobian_assembler),
                _process_variables, _parameters, integration_order,
                process_config, _mesh_vec, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
            if (type == "ComponentTransport")
        {
            process =
                ProcessLib::ComponentTransport::createComponentTransportProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _mesh_vec, _media,
                    std::move(chemical_solver_interface));
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_PHASEFIELD
            if (type == "PHASE_FIELD")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process =
                        ProcessLib::PhaseField::createPhaseFieldProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                case 3:
                    process =
                        ProcessLib::PhaseField::createPhaseFieldProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT
            if (type == "RichardsComponentTransport")
        {
            process = ProcessLib::RichardsComponentTransport::
                createRichardsComponentTransportProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION
            if (type == "SMALL_DEFORMATION")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::SmallDeformation::
                        createSmallDeformationProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::SmallDeformation::
                        createSmallDeformationProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                default:
                    OGS_FATAL(
                        "SMALL_DEFORMATION process does not support given "
                        "dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL
            if (type == "SMALL_DEFORMATION_NONLOCAL")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::SmallDeformationNonlocal::
                        createSmallDeformationNonlocalProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                case 3:
                    process = ProcessLib::SmallDeformationNonlocal::
                        createSmallDeformationNonlocalProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                default:
                    OGS_FATAL(
                        "SMALL_DEFORMATION_NONLOCAL process does not support "
                        "given dimension {:d}",
                        _mesh_vec[0]->getDimension());
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_LIE
            if (type == "SMALL_DEFORMATION_WITH_LIE")
        {
            if (  
                process_config.getConfigParameterOptional<int>("dimension"))
            {
                OGS_FATAL(
                    "The 'dimension' tag has been removed in the merge-request "
                    "!4766."
                    "The dimension is now taken from the main mesh and the tag "
                    "must be"
                    "removed. There is a python script in the merge-request "
                    "description"
                    "for automatic conversion.");
            }
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::LIE::SmallDeformation::
                        createSmallDeformationProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                case 3:
                    process = ProcessLib::LIE::SmallDeformation::
                        createSmallDeformationProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                default:
                    OGS_FATAL(
                        "SMALL_DEFORMATION_WITH_LIE process does not support "
                        "given dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS
            if (type == "THERMO_HYDRO_MECHANICS")
        {
            if (  
                process_config.getConfigParameterOptional<int>("dimension"))
            {
                OGS_FATAL(
                    "The 'dimension' tag has been removed in the merge-request "
                    "!4766."
                    "The dimension is now taken from the main mesh and the tag "
                    "must be"
                    "removed. There is a python script in the merge-request "
                    "description"
                    "for automatic conversion.");
            }
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::ThermoHydroMechanics::
                        createThermoHydroMechanicsProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::ThermoHydroMechanics::
                        createThermoHydroMechanicsProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                default:
                    OGS_FATAL(
                        "THERMO_HYDRO_MECHANICS process does not support given "
                        "dimension");
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD
            if (type == "THERMO_MECHANICAL_PHASE_FIELD")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::ThermoMechanicalPhaseField::
                        createThermoMechanicalPhaseFieldProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
                case 3:
                    process = ProcessLib::ThermoMechanicalPhaseField::
                        createThermoMechanicalPhaseFieldProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config);
                    break;
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMOMECHANICS
            if (type == "THERMO_MECHANICS")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::ThermoMechanics::
                        createThermoMechanicsProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::ThermoMechanics::
                        createThermoMechanicsProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_RICHARDSFLOW
            if (type == "RICHARDS_FLOW")
        {
            process = ProcessLib::RichardsFlow::createRichardsFlowProcess(
                name, *_mesh_vec[0], std::move(jacobian_assembler),
                _process_variables, _parameters, integration_order,
                process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS
            if (type == "RICHARDS_MECHANICS")
        {
            if (  
                process_config.getConfigParameterOptional<int>("dimension"))
            {
                OGS_FATAL(
                    "The 'dimension' tag has been removed in the merge-request "
                    "!4766."
                    "The dimension is now taken from the main mesh and the tag "
                    "must be"
                    "removed. There is a python script in the merge-request "
                    "description"
                    "for automatic conversion.");
            }
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::RichardsMechanics::
                        createRichardsMechanicsProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::RichardsMechanics::
                        createRichardsMechanicsProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
            }
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMORICHARDSFLOW
            if (type == "THERMO_RICHARDS_FLOW")
        {
            process =
                ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMORICHARDSMECHANICS
            if (type == "THERMO_RICHARDS_MECHANICS")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process = ProcessLib::ThermoRichardsMechanics::
                        createThermoRichardsMechanicsProcess<2>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
                case 3:
                    process = ProcessLib::ThermoRichardsMechanics::
                        createThermoRichardsMechanicsProcess<3>(
                            name, *_mesh_vec[0], std::move(jacobian_assembler),
                            _process_variables, _parameters,
                            _local_coordinate_system, integration_order,
                            process_config, _media);
                    break;
            }
        }
        else
#endif
 
#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP
            if (type == "TWOPHASE_FLOW_PP")
        {
            process =
                ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO
            if (type == "TWOPHASE_FLOW_PRHO")
        {
            process = ProcessLib::TwoPhaseFlowWithPrho::
                createTwoPhaseFlowWithPrhoProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP
            if (type == "THERMAL_TWOPHASE_WITH_PP")
        {
            process = ProcessLib::ThermalTwoPhaseFlowWithPP::
                createThermalTwoPhaseFlowWithPPProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _media);
        }
        else
#endif
        {
            OGS_FATAL("Unknown process type: {:s}", type);
        }
 
        if (ranges::contains(_processes, name,
                             [](std::unique_ptr<ProcessLib::Process> const& p)
                             { return p->name; }))
        {
            OGS_FATAL("The process name '{:s}' is not unique.", name);
        }
        _processes.push_back(std::move(process));
    }
}

Referenced by ProjectData().

◆ parseProcessVariables()

void ProjectData::parseProcessVariables ( BaseLib::ConfigTree const & process_variables_config )

private

Parses the process variables configuration and creates new variables for each variable entry passing the corresponding subtree to the process variable constructor.

Input File Parameter: prj__process_variables__process_variable

Input File Parameter: prj__process_variables__process_variable__mesh

Definition at line 454 of file ProjectData.cpp.

{
    DBUG("Parse process variables:");
 
    std::set<std::string> names;
 
    for (auto var_config
         : process_variables_config.getConfigSubtreeList("process_variable"))
    {
        // Either the mesh name is given, or the first mesh's name will be
        // taken. Taking the first mesh's value is deprecated.
        auto const mesh_name =
            var_config.getConfigParameter<std::string>("mesh",
                                                       _mesh_vec[0]->getName());
 
        auto& mesh = MeshLib::findMeshByName(_mesh_vec, mesh_name);
 
        auto pv = ProcessLib::ProcessVariable{var_config, mesh, _mesh_vec,
                                              _parameters, _curves};
        if (!names.insert(pv.getName()).second)
        {
            OGS_FATAL("A process variable with name `{:s}' already exists.",
                      pv.getName());
        }
 
        _process_variables.push_back(std::move(pv));
    }
}

References _curves, _mesh_vec, _parameters, _process_variables, DBUG(), MeshLib::findMeshByName(), BaseLib::ConfigTree::getConfigSubtreeList(), and OGS_FATAL.

Referenced by ProjectData().

◆ parseTimeLoop()

void ProjectData::parseTimeLoop	(	BaseLib::ConfigTree const &	config,
		const std::string &	output_directory )

private

Parses the time loop configuration.

Definition at line 1293 of file ProjectData.cpp.

{
    DBUG("Reading time loop configuration.");
 
    bool const compensate_non_equilibrium_initial_residuum = std::any_of(
        std::begin(_process_variables),
        std::end(_process_variables),
        [](auto const& process_variable)
        { return process_variable.compensateNonEquilibriumInitialResiduum(); });
 
    _time_loop = ProcessLib::createTimeLoop(
        config, output_directory, _processes, _nonlinear_solvers, _mesh_vec,
        compensate_non_equilibrium_initial_residuum);
 
    if (!_time_loop)
    {
        OGS_FATAL("Initialization of time loop failed.");
    }
}

References _mesh_vec, _nonlinear_solvers, _process_variables, _processes, _time_loop, ProcessLib::createTimeLoop(), DBUG(), and OGS_FATAL.

Referenced by ProjectData().

Member Data Documentation

◆ _curves

std::map<std::string, std::unique_ptr<MathLib::PiecewiseLinearInterpolation> > ProjectData::_curves

private

Definition at line 166 of file ProjectData.h.

Referenced by parseCurves(), parseMedia(), parseParameters(), parseProcesses(), and parseProcessVariables().

◆ _linear_solvers

std::map<std::string, std::unique_ptr<GlobalLinearSolver> > ProjectData::_linear_solvers

private

Definition at line 160 of file ProjectData.h.

Referenced by parseChemicalSolverInterface(), parseLinearSolvers(), and parseNonlinearSolvers().

◆ _local_coordinate_system

std::optional<ParameterLib::CoordinateSystem> ProjectData::_local_coordinate_system

private

Definition at line 153 of file ProjectData.h.

Referenced by ProjectData(), parseMedia(), and parseProcesses().

◆ _media

std::map<int, std::shared_ptr<MaterialPropertyLib::Medium> > ProjectData::_media

private

Definition at line 155 of file ProjectData.h.

Referenced by getMedia(), parseMedia(), and parseProcesses().

◆ _mesh_vec

std::vector<std::unique_ptr<MeshLib::Mesh> > ProjectData::_mesh_vec

private

Definition at line 145 of file ProjectData.h.

Referenced by getMesh(), parseChemicalSolverInterface(), parseMedia(), parseParameters(), parseProcesses(), parseProcessVariables(), and parseTimeLoop().

◆ _named_rasters

std::vector<GeoLib::NamedRaster> ProjectData::_named_rasters

private

Definition at line 146 of file ProjectData.h.

Referenced by parseParameters().

◆ _nonlinear_solvers

std::map<std::string, std::unique_ptr<NumLib::NonlinearSolverBase> > ProjectData::_nonlinear_solvers

private

Definition at line 163 of file ProjectData.h.

Referenced by parseNonlinearSolvers(), and parseTimeLoop().

◆ _parameters

std::vector<std::unique_ptr<ParameterLib::ParameterBase> > ProjectData::_parameters

private

Buffer for each parameter config passed to the process.

Definition at line 151 of file ProjectData.h.

Referenced by ProjectData(), parseMedia(), parseParameters(), parseProcesses(), and parseProcessVariables().

◆ _process_variables

std::vector<ProcessLib::ProcessVariable> ProjectData::_process_variables

private

Definition at line 148 of file ProjectData.h.

Referenced by parseProcesses(), parseProcessVariables(), and parseTimeLoop().

◆ _processes

std::vector<std::unique_ptr<ProcessLib::Process> > ProjectData::_processes

private

Definition at line 147 of file ProjectData.h.

Referenced by getProcesses(), parseProcesses(), and parseTimeLoop().

◆ _time_loop

std::unique_ptr<ProcessLib::TimeLoop> ProjectData::_time_loop

private

The time loop used to solve this project's processes.

Definition at line 158 of file ProjectData.h.

Referenced by getTimeLoop(), and parseTimeLoop().

The documentation for this class was generated from the following files:

Applications/ApplicationsLib/ProjectData.h
Applications/ApplicationsLib/ProjectData.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ProjectData() [1/3]

◆ ProjectData() [2/3]

◆ ProjectData() [3/3]

Member Function Documentation

◆ getMedia()

◆ getMesh()

◆ getProcesses()

◆ getTimeLoop()

◆ parseChemicalSolverInterface()

◆ parseCurves()

◆ parseLinearSolvers()

◆ parseMedia()

◆ parseNonlinearSolvers()

◆ parseParameters()

◆ parseProcesses()

◆ parseProcessVariables()

◆ parseTimeLoop()

Member Data Documentation

◆ _curves

◆ _linear_solvers

◆ _local_coordinate_system

◆ _media

◆ _mesh_vec

◆ _named_rasters

◆ _nonlinear_solvers

◆ _parameters

◆ _process_variables

◆ _processes

◆ _time_loop