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 45 of file ProjectData.h.

#include <ProjectData.h>

Public Member Functions
	ProjectData ()
	ProjectData (BaseLib::ConfigTree const &project_config, 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::vector< std::string >	getMeshNames () 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 &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.

Referenced by ProjectData().

◆ ProjectData() [2/3]

ProjectData::ProjectData	(	BaseLib::ConfigTree const &	project_config,
		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.
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 522 of file ProjectData.cpp.

    : _mesh_vec(readMeshes(project_config, mesh_directory)),
      _named_rasters(readRasters(project_config,
                                 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;
 
        // 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
 
        auto const script_path =
            BaseLib::joinPaths(script_directory, *python_script);
 
        // 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_config.projectDirectory().string();
        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);
    }
    std::vector<MeshToolsLib::InitialConditionDataSet> data_initial_conditions;
    parseOverwriteMeshData(project_config, data_initial_conditions, _mesh_vec,
                           _parameters);
    MeshToolsLib::overwriteMeshFieldDataByMaterialIDs(data_initial_conditions);
    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"),
                   output_directory,
                   std::move(chemical_solver_interface));
    parseNonlinearSolvers(project_config.getConfigSubtree("nonlinear_solvers"));
    parseTimeLoop(project_config.getConfigSubtree("time_loop"),
                  output_directory);
}

References _mesh_vec, _named_rasters, BaseLib::ConfigTree::getConfigParameterOptional(), getNodes(), OGS_FATAL, and readMeshes().

◆ ProjectData() [3/3]

ProjectData::ProjectData ( ProjectData & )

delete

References ProjectData().

Member Function Documentation

◆ getMedia()

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

inline

Definition at line 83 of file ProjectData.h.

    {
        return _media;
    }

References _media.

◆ getMesh()

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

Definition at line 1487 of file ProjectData.cpp.

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

References _mesh_vec, and MeshLib::findMeshByName().

◆ getMeshNames()

std::vector< std::string > ProjectData::getMeshNames ( ) const

Definition at line 1492 of file ProjectData.cpp.

{
    return _mesh_vec | MeshLib::views::names | ranges::to<std::vector>;
}

References _mesh_vec, and MeshLib::views::names.

◆ getProcesses()

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

inline

Provides read access to the process container.

Definition at line 71 of file ProjectData.h.

    {
        return _processes;
    }

References _processes.

◆ getTimeLoop()

ProcessLib::TimeLoop & ProjectData::getTimeLoop ( )

inline

Definition at line 77 of file ProjectData.h.

77{ 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:140

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 754 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.

◆ 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 1464 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().

◆ 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 1417 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().

◆ 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 703 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 create_medium = [dim = _mesh_vec[0]->getDimension(),
                              &medium_config, this](int const id)
        {
            return MaterialPropertyLib::createMedium(
                id, _mesh_vec[0]->getDimension(), medium_config, _parameters,
                _local_coordinate_system ? &*_local_coordinate_system : nullptr,
                _curves);
        };
 
        auto const material_id_string =
            medium_config.getConfigAttribute<std::string>("id", "0");
 
        std::vector<int> const material_ids_of_this_medium =
            MaterialLib::parseMaterialIdString(material_id_string,
                                               materialIDs(*_mesh_vec[0]));
 
        for (auto const& id : material_ids_of_this_medium)
        {
            MaterialLib::createMediumForId(
                id, _media, material_ids_of_this_medium, create_medium);
        }
    }
 
    if (_media.empty())
    {
        OGS_FATAL("No entity is found inside <media>.");
    }
}

References _curves, _local_coordinate_system, _media, _mesh_vec, _parameters, MaterialPropertyLib::createMedium(), MaterialLib::createMediumForId(), DBUG(), ERR(), OGS_FATAL, and MaterialLib::parseMaterialIdString().

◆ 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 1440 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().

◆ 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 661 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.

◆ parseProcesses()

void ProjectData::parseProcesses	(	BaseLib::ConfigTree const &	processes_config,
		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 820 of file ProjectData.cpp.

{
    (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_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_WELLBORESIMULATOR
            if (type == "WELLBORE_SIMULATOR")
        {
            if (_mesh_vec[0]->getDimension() != 1)
            {
                OGS_FATAL(
                    "WELLBORE_SIMULATOR can only work with a 1-dimensional "
                    "mesh!");
            }
 
            process =
                ProcessLib::WellboreSimulator::createWellboreSimulatorProcess(
                    name, *_mesh_vec[0], std::move(jacobian_assembler),
                    _process_variables, _parameters, integration_order,
                    process_config, _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_HM
            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, _media);
                    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, _media);
                    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_HMPHASEFIELD
            if (type == "HM_PHASE_FIELD")
        {
            switch (_mesh_vec[0]->getDimension())
            {
                case 2:
                    process =
                        ProcessLib::HMPhaseField::createHMPhaseFieldProcess<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::HMPhaseField::createHMPhaseFieldProcess<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_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_LIE_M
            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_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_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));
    }
}

◆ 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 629 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.

◆ parseTimeLoop()

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

private

Parses the time loop configuration.

Definition at line 1396 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.

Member Data Documentation

◆ _curves

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

private

Definition at line 148 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 142 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 135 of file ProjectData.h.

Referenced by parseMedia(), and parseProcesses().

◆ _media

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

private

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

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

◆ _named_rasters

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

private

Definition at line 128 of file ProjectData.h.

Referenced by ProjectData(), and parseParameters().

◆ _nonlinear_solvers

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

private

Definition at line 145 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 133 of file ProjectData.h.

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

◆ _process_variables

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

private

Definition at line 130 of file ProjectData.h.

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

◆ _processes

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

private

Definition at line 129 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 140 of file ProjectData.h.

Referenced by getTimeLoop(), and parseTimeLoop().

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

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()

◆ getMeshNames()

◆ 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