ProjectData Class Reference

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 49 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)
	ProjectData (ProjectData &)=delete
std::vector< std::unique_ptr< ProcessLib::Process > > const &	getProcesses () const
	Provides read access to the process container. More...
ProcessLib::TimeLoop &	getTimeLoop ()

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. More...
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. More...
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< 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. More...
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. More...
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
	)

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.

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 284 of file ProjectData.cpp.

    : _mesh_vec(readMeshes(project_config, project_directory))
{
    if (auto const python_script =
        project_config.getConfigParameterOptional<std::string>("python_script"))
    {
#ifdef OGS_USE_PYTHON
        namespace py = pybind11;
 
        // Append to python's module search path
        auto py_path = py::module::import("sys").attr("path");
        py_path.attr("append")(project_directory);  // .prj directory
        // virtualenv
        py_path.attr("append")(
            CMakeInfoLib::CMakeInfo::python_virtualenv_sitepackages);
 
        auto const script_path =
            BaseLib::copyPathToFileName(*python_script, project_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;
        py::eval_file(script_path, scope);
#else
        OGS_FATAL("OpenGeoSys has not been built with Python support.");
#endif  // OGS_USE_PYTHON
    }
 
    parseCurves(project_config.getConfigSubtreeOptional("curves"));
 
    auto parameter_names_for_transformation =
        parseParameters(project_config.getConfigSubtree("parameters"));
 
    _local_coordinate_system = parseLocalCoordinateSystem(
        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(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), OGS_FATAL, parseChemicalSolverInterface(), parseCurves(), parseLinearSolvers(), anonymous_namespace{ProjectData.cpp}::parseLocalCoordinateSystem(), parseMedia(), parseNonlinearSolvers(), parseParameters(), parseProcesses(), parseProcessVariables(), parseTimeLoop(), and anonymous_namespace{FileTools.cpp}::project_directory.

ProjectData() [3/3]

ProjectData::ProjectData ( ProjectData &  )

delete

Member Function Documentation

getProcesses()

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

inline

Provides read access to the process container.

Definition at line 74 of file ProjectData.h.

    {
        return _processes;
    }

References _processes.

Referenced by main().

getTimeLoop()

ProcessLib::TimeLoop& ProjectData::getTimeLoop ( )

inline

Definition at line 80 of file ProjectData.h.

{ return *_time_loop; }

References _time_loop.

Referenced by main().

parseChemicalSolverInterface()

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

private

Input File Parameter:

prj__chemical_system__chemical_solver

Definition at line 513 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
    {
        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, and ChemistryLib::Phreeqc.

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 1176 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(), BaseLib::insertIfKeyUniqueElseError(), and MaterialPropertyLib::name.

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 1135 of file ProjectData.cpp.

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

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

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 450 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 =
            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(
                    _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(), anonymous_namespace{generateStructuredMesh.cpp}::getDimension(), OGS_FATAL, and 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 1152 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& 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(), BaseLib::insertIfKeyUniqueElseError(), and MaterialPropertyLib::name.

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 411 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, _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));
 
    return parameter_names_for_transformation;
}

References _curves, _mesh_vec, _parameters, ParameterLib::createParameter(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), OGS_FATAL, MathLib::p, 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

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__dimension

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS_WITH_LIE__dimension

Input File Parameter:

prj__processes__process__SMALL_DEFORMATION_WITH_LIE__dimension

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__dimension

Input File Parameter:

prj__processes__process__RICHARDS_MECHANICS__dimension

Definition at line 569 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");
 
        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")
        {
            switch (process_config.getConfigParameter<int>("dimension"))
            {
                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_LIE
            if (type == "HYDRO_MECHANICS_WITH_LIE")
        {
            switch (process_config.getConfigParameter<int>("dimension"))
            {
                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);
                    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);
                    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")
        {
            switch (process_config.getConfigParameter<int>("dimension"))
            {
                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")
        {
            switch (process_config.getConfigParameter<int>("dimension"))
            {
                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, _curves, _media);
        }
        else
#endif
#ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS
            if (type == "RICHARDS_MECHANICS")
        {
            switch (process_config.getConfigParameter<int>("dimension"))
            {
                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, _curves, _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, _curves);
        }
        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, _curves);
        }
        else
#endif
        {
            OGS_FATAL("Unknown process type: {:s}", type);
        }
 
        if (BaseLib::containsIf(
                _processes,
                [&name](std::unique_ptr<ProcessLib::Process> const& p)
                { return p->name == name; }))
        {
            OGS_FATAL("The process name '{:s}' is not unique.", name);
        }
        _processes.push_back(std::move(process));
    }
}

References _curves, _local_coordinate_system, _media, _mesh_vec, _parameters, _process_variables, _processes, BaseLib::containsIf(), ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess< 2 >(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess< 3 >(), ProcessLib::createJacobianAssembler(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), ProcessLib::PhaseField::createPhaseFieldProcess< 2 >(), ProcessLib::PhaseField::createPhaseFieldProcess< 3 >(), ProcessLib::RichardsComponentTransport::createRichardsComponentTransportProcess(), ProcessLib::RichardsFlow::createRichardsFlowProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 2 >(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 3 >(), ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess< 2 >(), ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess< 3 >(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess< 2 >(), ProcessLib::SmallDeformation::createSmallDeformationProcess< 2 >(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess< 3 >(), ProcessLib::SmallDeformation::createSmallDeformationProcess< 3 >(), ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(), ProcessLib::StokesFlow::createStokesFlowProcess< 2 >(), ProcessLib::TES::createTESProcess(), ProcessLib::TH2M::createTH2MProcess< 2 >(), ProcessLib::TH2M::createTH2MProcess< 3 >(), ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess< 2 >(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess< 3 >(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess< 2 >(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess< 3 >(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess< 2 >(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess< 3 >(), ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess< 2 >(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess< 3 >(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowWithPrhoProcess(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), anonymous_namespace{generateStructuredMesh.cpp}::getDimension(), MaterialPropertyLib::name, OGS_FATAL, MathLib::p, and anonymous_namespace{FileTools.cpp}::project_directory.

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 376 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 = *BaseLib::findElementOrError(
            begin(_mesh_vec), end(_mesh_vec),
            [&mesh_name](auto const& m) { return m->getName() == mesh_name; },
            "Expected to find a mesh named " + 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(), BaseLib::findElementOrError(), 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 1121 of file ProjectData.cpp.

{
    DBUG("Reading time loop configuration.");
 
    _time_loop = ProcessLib::createTimeLoop(
        config, output_directory, _processes, _nonlinear_solvers, _mesh_vec);
 
    if (!_time_loop)
    {
        OGS_FATAL("Initialization of time loop failed.");
    }
}

References _mesh_vec, _nonlinear_solvers, _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 142 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 136 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 129 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 131 of file ProjectData.h.

Referenced by parseMedia(), and parseProcesses().

_mesh_vec

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

private

Definition at line 122 of file ProjectData.h.

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

_nonlinear_solvers

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

private

Definition at line 139 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 127 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 124 of file ProjectData.h.

Referenced by parseProcesses(), and parseProcessVariables().

_processes

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

private

Definition at line 123 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 134 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