Loading [MathJax]/extensions/tex2jax.js
OGS
ProjectData Class Referencefinal

Detailed Description

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

Definition at line 60 of file ProjectData.h.

#include <ProjectData.h>

Public Member Functions

 ProjectData ()
 
 ProjectData (BaseLib::ConfigTree const &project_config, std::string const &project_directory, std::string const &output_directory, std::string const &mesh_directory, std::string const &script_directory)
 
 ProjectData (ProjectData &)=delete
 
std::vector< std::unique_ptr< ProcessLib::Process > > const & getProcesses () const
 Provides read access to the process container.
 
ProcessLib::TimeLoopgetTimeLoop ()
 
MeshLib::MeshgetMesh (std::string const &mesh_name) const
 
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & getMedia () const
 

Private Member Functions

void parseProcessVariables (BaseLib::ConfigTree const &process_variables_config)
 
std::vector< std::string > parseParameters (BaseLib::ConfigTree const &parameters_config)
 
void parseMedia (std::optional< BaseLib::ConfigTree > const &media_config)
 Parses media configuration and saves them in an object.
 
void parseProcesses (BaseLib::ConfigTree const &processes_config, std::string const &project_directory, std::string const &output_directory, std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &&chemical_solver_interface)
 
void parseTimeLoop (BaseLib::ConfigTree const &config, const std::string &output_directory)
 Parses the time loop configuration.
 
void parseLinearSolvers (BaseLib::ConfigTree const &config)
 
void parseNonlinearSolvers (BaseLib::ConfigTree const &config)
 
void parseCurves (std::optional< BaseLib::ConfigTree > const &config)
 
std::unique_ptr< ChemistryLib::ChemicalSolverInterfaceparseChemicalSolverInterface (std::optional< BaseLib::ConfigTree > const &config, const std::string &output_directory)
 

Private Attributes

std::vector< std::unique_ptr< MeshLib::Mesh > > _mesh_vec
 
std::vector< GeoLib::NamedRaster_named_rasters
 
std::vector< std::unique_ptr< ProcessLib::Process > > _processes
 
std::vector< ProcessLib::ProcessVariable_process_variables
 
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > _parameters
 Buffer for each parameter config passed to the process.
 
std::optional< ParameterLib::CoordinateSystem_local_coordinate_system
 
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > _media
 
std::unique_ptr< ProcessLib::TimeLoop_time_loop
 The time loop used to solve this project's processes.
 
std::map< std::string, std::unique_ptr< GlobalLinearSolver > > _linear_solvers
 
std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase > > _nonlinear_solvers
 
std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > _curves
 

Constructor & Destructor Documentation

◆ ProjectData() [1/3]

ProjectData::ProjectData ( )
default

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

◆ ProjectData() [2/3]

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

Constructs project data by parsing provided configuration.

Parameters
project_configConfiguration as read from the prj file.
project_directoryWhere to look for files referenced in the config_tree.
output_directoryWhere to write simulation output files to.
mesh_directoryDirectory where meshes are read from.
script_directoryDirectory 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 371 of file ProjectData.cpp.

376 : _mesh_vec(readMeshes(project_config, mesh_directory, project_directory)),
377 _named_rasters(readRasters(project_config, project_directory,
378 GeoLib::AABB(_mesh_vec[0]->getNodes().begin(),
379 _mesh_vec[0]->getNodes().end())
380 .getMinMaxPoints()))
381{
382 // for debugging raster reading implementation
383 // writeRasters(_named_rasters, output_directory);
384 if (auto const python_script =
386 project_config.getConfigParameterOptional<std::string>("python_script"))
387 {
388 namespace py = pybind11;
389
390#ifdef OGS_EMBED_PYTHON_INTERPRETER
391 _py_scoped_interpreter.emplace(ApplicationsLib::setupEmbeddedPython());
392#endif
393
394 // Append to python's module search path
395 auto py_path = py::module::import("sys").attr("path");
396 py_path.attr("append")(script_directory); // .prj or -s directory
397
398 auto const script_path =
399 BaseLib::joinPaths(script_directory, *python_script);
400
401 // Evaluate in scope of main module
402 py::object scope = py::module::import("__main__").attr("__dict__");
403 // add (global) variables
404 auto globals = py::dict(scope);
405 globals["ogs_prj_directory"] = project_directory;
406 globals["ogs_mesh_directory"] = mesh_directory;
407 globals["ogs_script_directory"] = script_directory;
408 try
409 {
410 py::eval_file(script_path, scope);
411 }
412 catch (py::error_already_set const& e)
413 {
414 OGS_FATAL("Error evaluating python script {}: {}", script_path,
415 e.what());
416 }
417 }
418
420 parseCurves(project_config.getConfigSubtreeOptional("curves"));
421
422 auto parameter_names_for_transformation =
424 parseParameters(project_config.getConfigSubtree("parameters"));
425
428 project_config.getConfigSubtreeOptional("local_coordinate_system"),
430
431 for (auto& parameter : _parameters)
432 {
433 if (std::find(begin(parameter_names_for_transformation),
434 end(parameter_names_for_transformation),
435 parameter->name) !=
436 end(parameter_names_for_transformation))
437 {
439 {
440 OGS_FATAL(
441 "The parameter '{:s}' is using the local coordinate system "
442 "but no local coordinate system was provided.",
443 parameter->name);
444 }
445 parameter->setCoordinateSystem(*_local_coordinate_system);
446 }
447
448 parameter->initialize(_parameters);
449 }
450
452 parseProcessVariables(project_config.getConfigSubtree("process_variables"));
453
455 parseMedia(project_config.getConfigSubtreeOptional("media"));
456
458 parseLinearSolvers(project_config.getConfigSubtree("linear_solvers"));
459
460 auto chemical_solver_interface = parseChemicalSolverInterface(
462 project_config.getConfigSubtreeOptional("chemical_system"),
463 output_directory);
464
466 parseProcesses(project_config.getConfigSubtree("processes"),
467 project_directory, output_directory,
468 std::move(chemical_solver_interface));
469
471 parseNonlinearSolvers(project_config.getConfigSubtree("nonlinear_solvers"));
472
474 parseTimeLoop(project_config.getConfigSubtree("time_loop"),
475 output_directory);
476}
#define OGS_FATAL(...)
Definition Error.h:26
std::vector< std::size_t > getNodes(GeoLib::Point const &pnt, std::vector< MeshLib::Node * > const &nodes, MeshLib::PropertyVector< int > const &mat_ids, std::pair< int, int > const &mat_limits, std::pair< double, double > const &elevation_limits, MeshLib::Mesh const &mesh)
Class AABB is an axis aligned bounding box around a given set of geometric points of (template) type ...
Definition AABB.h:56
std::optional< ParameterLib::CoordinateSystem > _local_coordinate_system
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)
std::unique_ptr< ChemistryLib::ChemicalSolverInterface > parseChemicalSolverInterface(std::optional< BaseLib::ConfigTree > const &config, const std::string &output_directory)
void parseMedia(std::optional< BaseLib::ConfigTree > const &media_config)
Parses media configuration and saves them in an object.
void parseLinearSolvers(BaseLib::ConfigTree const &config)
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > _parameters
Buffer for each parameter config passed to the process.
std::vector< GeoLib::NamedRaster > _named_rasters
void parseNonlinearSolvers(BaseLib::ConfigTree const &config)
void parseProcessVariables(BaseLib::ConfigTree const &process_variables_config)
void parseCurves(std::optional< BaseLib::ConfigTree > const &config)
std::vector< std::unique_ptr< MeshLib::Mesh > > _mesh_vec
void parseTimeLoop(BaseLib::ConfigTree const &config, const std::string &output_directory)
Parses the time loop configuration.
std::vector< std::string > parseParameters(BaseLib::ConfigTree const &parameters_config)
std::vector< std::unique_ptr< MeshLib::Mesh > > readMeshes(std::vector< std::string > const &filenames)
pybind11::scoped_interpreter setupEmbeddedPython()
std::string joinPaths(std::string const &pathA, std::string const &pathB)
std::optional< ParameterLib::CoordinateSystem > createCoordinateSystem(std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::string project_directory
The directory where the prj file resides.
Definition FileTools.cpp:34
std::vector< GeoLib::NamedRaster > readRasters(BaseLib::ConfigTree const &config, std::string const &raster_directory, GeoLib::MinMaxPoints const &min_max_points)

References BaseLib::ConfigTree::getConfigParameterOptional(), and OGS_FATAL.

◆ ProjectData() [3/3]

ProjectData::ProjectData ( ProjectData & )
delete

Member Function Documentation

◆ getMedia()

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

Definition at line 100 of file ProjectData.h.

101 {
102 return _media;
103 }
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > _media

References _media.

◆ getMesh()

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

Definition at line 1450 of file ProjectData.cpp.

1451{
1452 return MeshLib::findMeshByName(_mesh_vec, mesh_name);
1453}
Mesh & findMeshByName(std::vector< std::unique_ptr< Mesh > > const &meshes, std::string_view const name)
Definition Mesh.cpp:364

References _mesh_vec, and MeshLib::findMeshByName().

◆ getProcesses()

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

Provides read access to the process container.

Definition at line 89 of file ProjectData.h.

91 {
92 return _processes;
93 }
std::vector< std::unique_ptr< ProcessLib::Process > > _processes

References _processes.

◆ getTimeLoop()

ProcessLib::TimeLoop & ProjectData::getTimeLoop ( )
inline

Definition at line 95 of file ProjectData.h.

95{ return *_time_loop; }
std::unique_ptr< ProcessLib::TimeLoop > _time_loop
The time loop used to solve this project's processes.

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

606{
607 if (!config)
608 {
609 return nullptr;
610 }
611
612 std::unique_ptr<ChemistryLib::ChemicalSolverInterface>
613 chemical_solver_interface;
614#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
615 INFO(
616 "Ready for initializing interface to a chemical solver for water "
617 "chemistry calculation.");
618
619 auto const chemical_solver =
621 config->getConfigAttribute<std::string>("chemical_solver");
622
623 if (boost::iequals(chemical_solver, "Phreeqc"))
624 {
625 INFO(
626 "Configuring phreeqc interface for water chemistry calculation "
627 "using file-based approach.");
628
629 chemical_solver_interface = ChemistryLib::createChemicalSolverInterface<
631 *config, output_directory);
632 }
633 else if (boost::iequals(chemical_solver, "PhreeqcKernel"))
634 {
635 OGS_FATAL(
636 "The chemical solver option of PhreeqcKernel is not accessible for "
637 "the time being. Please set 'Phreeqc'' as the chemical solver for "
638 "reactive transport modeling.");
639 }
640 else if (boost::iequals(chemical_solver, "SelfContained"))
641 {
642 INFO(
643 "Use self-contained chemical solver for water chemistry "
644 "calculation.");
645
646 chemical_solver_interface = ChemistryLib::createChemicalSolverInterface<
648 _mesh_vec, _linear_solvers, *config, output_directory);
649 }
650 else
651 {
652 OGS_FATAL(
653 "Unknown chemical solver. Please specify either Phreeqc or "
654 "PhreeqcKernel as the solver for water chemistry calculation "
655 "instead.");
656 }
657#else
658 (void)output_directory;
659
660 OGS_FATAL(
661 "Found the type of the process to be solved is not component transport "
662 "process. Please specify the process type to ComponentTransport. At "
663 "the present, water chemistry calculation is only available for "
664 "component transport process.");
665#endif
666 return chemical_solver_interface;
667}
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
std::map< std::string, std::unique_ptr< GlobalLinearSolver > > _linear_solvers
std::unique_ptr< ChemicalSolverInterface > createChemicalSolverInterface(std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< std::string, std::unique_ptr< GlobalLinearSolver > > const &linear_solvers, BaseLib::ConfigTree const &config, std::string const &output_directory)

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

1428{
1429 if (!config)
1430 {
1431 return;
1432 }
1433
1434 DBUG("Reading curves configuration.");
1435
1437 for (auto conf : config->getConfigSubtreeList("curve"))
1438 {
1440 auto const name = conf.getConfigParameter<std::string>("name");
1442 _curves,
1443 name,
1446 "The curve name is not unique.");
1447 }
1448}
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > _curves
void insertIfKeyUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
Definition Algorithm.h:104
std::unique_ptr< CurveType > createPiecewiseLinearCurve(BaseLib::ConfigTree const &config)

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

1381{
1382 DBUG("Reading linear solver configuration.");
1383
1385 for (auto conf : config.getConfigSubtreeList("linear_solver"))
1386 {
1388 auto const name = conf.getConfigParameter<std::string>("name");
1389 auto const linear_solver_parser =
1391 auto const solver_options =
1392 linear_solver_parser.parseNameAndOptions("", &conf);
1393
1396 name,
1397 std::make_unique<GlobalLinearSolver>(std::get<0>(solver_options),
1398 std::get<1>(solver_options)),
1399 "The linear solver name is not unique");
1400 }
1401}

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

554{
555 if (!media_config)
556 {
557 return;
558 }
559
560 DBUG("Reading media:");
561
562 if (_mesh_vec.empty() || _mesh_vec[0] == nullptr)
563 {
564 ERR("A mesh is required to define medium materials.");
565 return;
566 }
567
568 for (auto const& medium_config :
570 media_config->getConfigSubtreeList("medium"))
571 {
572 auto create_medium = [dim = _mesh_vec[0]->getDimension(),
573 &medium_config, this](int const id)
574 {
576 id, _mesh_vec[0]->getDimension(), medium_config, _parameters,
578 _curves);
579 };
580
581 auto const material_id_string =
583 medium_config.getConfigAttribute<std::string>("id", "0");
584
585 std::vector<int> const material_ids_of_this_medium =
586 MaterialLib::parseMaterialIdString(material_id_string,
588
589 for (auto const& id : material_ids_of_this_medium)
590 {
592 id, _media, material_ids_of_this_medium, create_medium);
593 }
594 }
595
596 if (_media.empty())
597 {
598 OGS_FATAL("No entity is found inside <media>.");
599 }
600}
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:45
void createMediumForId(int const id, std::map< int, std::shared_ptr< T > > &media, std::vector< int > const &material_ids_of_this_medium, CreateMedium &&create_medium)
std::vector< int > parseMaterialIdString(std::string const &material_id_string, MeshLib::PropertyVector< int > const *const material_ids)
std::unique_ptr< Medium > createMedium(int const material_id, int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
PropertyVector< int > const * materialIDs(Mesh const &mesh)
Definition Mesh.cpp:268
unsigned getDimension(MeshLib::MeshElemType eleType)

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

1404{
1405 DBUG("Reading non-linear solver configuration.");
1406
1408 for (auto conf : config.getConfigSubtreeList("nonlinear_solver"))
1409 {
1410 auto const ls_name =
1412 conf.getConfigParameter<std::string>("linear_solver");
1413 auto const& linear_solver = BaseLib::getOrError(
1414 _linear_solvers, ls_name,
1415 "A linear solver with the given name does not exist.");
1416
1418 auto const name = conf.getConfigParameter<std::string>("name");
1421 name,
1422 NumLib::createNonlinearSolver(*linear_solver, conf).first,
1423 "The nonlinear solver name is not unique");
1424 }
1425}
std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase > > _nonlinear_solvers
std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag > createNonlinearSolver(GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)
OGS_NO_DANGLING Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
Definition Algorithm.h:118

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

512{
513 using namespace ProcessLib;
514
515 std::set<std::string> names;
516 std::vector<std::string> parameter_names_for_transformation;
517
518 DBUG("Reading parameters:");
519 for (auto parameter_config :
521 parameters_config.getConfigSubtreeList("parameter"))
522 {
523 auto p = ParameterLib::createParameter(parameter_config, _mesh_vec,
525 if (!names.insert(p->name).second)
526 {
527 OGS_FATAL("A parameter with name `{:s}' already exists.", p->name);
528 }
529
530 auto const use_local_coordinate_system =
532 parameter_config.getConfigParameterOptional<bool>(
533 "use_local_coordinate_system");
534 if (!!use_local_coordinate_system && *use_local_coordinate_system)
535 {
536 parameter_names_for_transformation.push_back(p->name);
537 }
538
539 _parameters.push_back(std::move(p));
540 }
541
542 _parameters.push_back(
545 _parameters.push_back(
548
549 return parameter_names_for_transformation;
550}
static PROCESSLIB_EXPORT const std::string constant_one_parameter_name
Definition Process.h:47
constexpr ranges::views::view_closure names
For an element of a range view return its name.
Definition Mesh.h:231
std::unique_ptr< ParameterBase > createParameter(BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::vector< GeoLib::NamedRaster > const &named_rasters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
Definition Parameter.cpp:27
Single, constant value parameter.
static PROCESSLIB_EXPORT const std::string zero_parameter_name

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 & project_directory,
std::string const & output_directory,
std::unique_ptr< ChemistryLib::ChemicalSolverInterface > && chemical_solver_interface )
private

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

Input File Parameter
prj__processes__process
Input File Parameter
prj__processes__process__type
Input File Parameter
prj__processes__process__name
Input File Parameter
prj__processes__process__integration_order
Input File Parameter
prj__processes__process__jacobian_assembler

Definition at line 669 of file ProjectData.cpp.

675{
676 (void)project_directory; // to avoid compilation warning
677 (void)output_directory; // to avoid compilation warning
678
679 DBUG("Reading processes:");
681 for (auto process_config : processes_config.getConfigSubtreeList("process"))
682 {
683 auto const type =
685 process_config.peekConfigParameter<std::string>("type");
686
687 auto const name =
689 process_config.getConfigParameter<std::string>("name");
690
691 [[maybe_unused]] auto const integration_order =
693 process_config.getConfigParameter<int>("integration_order");
694
695 std::unique_ptr<ProcessLib::Process> process;
696
697 auto jacobian_assembler = ProcessLib::createJacobianAssembler(
699 process_config.getConfigSubtreeOptional("jacobian_assembler"));
700
701#ifdef OGS_BUILD_PROCESS_STEADYSTATEDIFFUSION
702 if (type == "STEADY_STATE_DIFFUSION")
703 {
704 // The existence check of the in the configuration referenced
705 // process variables is checked in the physical process.
706 // TODO at the moment we have only one mesh, later there can be
707 // several meshes. Then we have to assign the referenced mesh
708 // here.
709 process =
711 name, *_mesh_vec[0], std::move(jacobian_assembler),
712 _process_variables, _parameters, integration_order,
713 process_config, _mesh_vec, _media);
714 }
715 else
716#endif
717#ifdef OGS_BUILD_PROCESS_LIQUIDFLOW
718 if (type == "LIQUID_FLOW")
719 {
721 name, *_mesh_vec[0], std::move(jacobian_assembler),
722 _process_variables, _parameters, integration_order,
723 process_config, _mesh_vec, _media);
724 }
725 else
726#endif
727#ifdef OGS_BUILD_PROCESS_STOKESFLOW
728 if (type == "StokesFlow")
729 {
730 WARN(
731 "The StokesFlow process is deprecated and will be removed in "
732 "OGS-6.5.5.");
733 switch (_mesh_vec[0]->getDimension())
734 {
735 case 2:
736 process =
738 name, *_mesh_vec[0], std::move(jacobian_assembler),
739 _process_variables, _parameters, integration_order,
740 process_config, _media);
741 break;
742 default:
743 OGS_FATAL(
744 "StokesFlow process does not support given "
745 "dimension {:d}",
746 _mesh_vec[0]->getDimension());
747 }
748 }
749 else
750#endif
751#ifdef OGS_BUILD_PROCESS_TES
752 if (type == "TES")
753 {
754 WARN(
755 "The TES process is deprecated and will be removed in "
756 "OGS-6.5.5.");
758 name, *_mesh_vec[0], std::move(jacobian_assembler),
759 _process_variables, _parameters, integration_order,
760 process_config);
761 }
762 else
763#endif
764#ifdef OGS_BUILD_PROCESS_TH2M
765 if (type == "TH2M")
766 {
767 switch (_mesh_vec[0]->getDimension())
768 {
769 case 2:
771 name, *_mesh_vec[0], std::move(jacobian_assembler),
773 _local_coordinate_system, integration_order,
774 process_config, _media);
775 break;
776 case 3:
778 name, *_mesh_vec[0], std::move(jacobian_assembler),
780 _local_coordinate_system, integration_order,
781 process_config, _media);
782 break;
783 default:
784 OGS_FATAL("TH2M process does not support given dimension");
785 }
786 }
787 else
788#endif
789#ifdef OGS_BUILD_PROCESS_HEATCONDUCTION
790 if (type == "HEAT_CONDUCTION")
791 {
793 name, *_mesh_vec[0], std::move(jacobian_assembler),
794 _process_variables, _parameters, integration_order,
795 process_config, _media);
796 }
797 else
798#endif
799#ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE
800 if (type == "HEAT_TRANSPORT_BHE")
801 {
802 if (_mesh_vec[0]->getDimension() != 3)
803 {
804 OGS_FATAL(
805 "HEAT_TRANSPORT_BHE can only work with a 3-dimensional "
806 "mesh! ");
807 }
808
809 process =
811 name, *_mesh_vec[0], std::move(jacobian_assembler),
812 _process_variables, _parameters, integration_order,
813 process_config, _curves, _media);
814 }
815 else
816#endif
817#ifdef OGS_BUILD_PROCESS_WELLBORESIMULATOR
818 if (type == "WELLBORE_SIMULATOR")
819 {
820 if (_mesh_vec[0]->getDimension() != 1)
821 {
822 OGS_FATAL(
823 "WELLBORE_SIMULATOR can only work with a 1-dimensional "
824 "mesh!");
825 }
826
827 process =
829 name, *_mesh_vec[0], std::move(jacobian_assembler),
830 _process_variables, _parameters, integration_order,
831 process_config, _media);
832 }
833 else
834#endif
835#ifdef OGS_BUILD_PROCESS_HYDROMECHANICS
836 if (type == "HYDRO_MECHANICS")
837 {
838 if (
839 process_config.getConfigParameterOptional<int>("dimension"))
840 {
841 OGS_FATAL(
842 "The 'dimension' tag has been removed in the merge-request "
843 "!4766. The dimension is now taken from the main mesh and "
844 "the tag must be removed. There is a python script in the "
845 "merge-request description for automatic conversion.");
846 }
847 switch (_mesh_vec[0]->getDimension())
848 {
849 case 2:
850 process =
852 2>(name, *_mesh_vec[0],
853 std::move(jacobian_assembler),
855 _local_coordinate_system, integration_order,
856 process_config, _media);
857 break;
858 case 3:
859 process =
861 3>(name, *_mesh_vec[0],
862 std::move(jacobian_assembler),
864 _local_coordinate_system, integration_order,
865 process_config, _media);
866 break;
867 default:
868 OGS_FATAL(
869 "HYDRO_MECHANICS process does not support given "
870 "dimension");
871 }
872 }
873 else
874#endif
875#ifdef OGS_BUILD_PROCESS_LARGEDEFORMATION
876 if (type == "LARGE_DEFORMATION")
877 {
878 switch (_mesh_vec[0]->getDimension())
879 {
880 case 2:
883 name, *_mesh_vec[0], std::move(jacobian_assembler),
885 _local_coordinate_system, integration_order,
886 process_config, _media);
887 break;
888 case 3:
891 name, *_mesh_vec[0], std::move(jacobian_assembler),
893 _local_coordinate_system, integration_order,
894 process_config, _media);
895 break;
896 default:
897 OGS_FATAL(
898 "LARGE_DEFORMATION process does not support given "
899 "dimension");
900 }
901 }
902 else
903#endif
904#ifdef OGS_BUILD_PROCESS_LIE_HM
905 if (type == "HYDRO_MECHANICS_WITH_LIE")
906 {
907 if (
908 process_config.getConfigParameterOptional<int>("dimension"))
909 {
910 OGS_FATAL(
911 "The 'dimension' tag has been removed in the merge-request "
912 "!4766."
913 "The dimension is now taken from the main mesh and the tag "
914 "must be"
915 "removed. There is a python script in the merge-request "
916 "description"
917 "for automatic conversion.");
918 }
919 switch (_mesh_vec[0]->getDimension())
920 {
921 case 2:
924 name, *_mesh_vec[0], std::move(jacobian_assembler),
926 _local_coordinate_system, integration_order,
927 process_config, _media);
928 break;
929 case 3:
932 name, *_mesh_vec[0], std::move(jacobian_assembler),
934 _local_coordinate_system, integration_order,
935 process_config, _media);
936 break;
937 default:
938 OGS_FATAL(
939 "HYDRO_MECHANICS_WITH_LIE process does not support "
940 "given dimension");
941 }
942 }
943 else
944#endif
945#ifdef OGS_BUILD_PROCESS_HT
946 if (type == "HT")
947 {
949 name, *_mesh_vec[0], std::move(jacobian_assembler),
950 _process_variables, _parameters, integration_order,
951 process_config, _mesh_vec, _media);
952 }
953 else
954#endif
955#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
956 if (type == "ComponentTransport")
957 {
958 process =
960 name, *_mesh_vec[0], std::move(jacobian_assembler),
961 _process_variables, _parameters, integration_order,
962 process_config, _mesh_vec, _media,
963 std::move(chemical_solver_interface));
964 }
965 else
966#endif
967#ifdef OGS_BUILD_PROCESS_PHASEFIELD
968 if (type == "PHASE_FIELD")
969 {
970 switch (_mesh_vec[0]->getDimension())
971 {
972 case 2:
973 process =
975 name, *_mesh_vec[0], std::move(jacobian_assembler),
977 _local_coordinate_system, integration_order,
978 process_config);
979 break;
980 case 3:
981 process =
983 name, *_mesh_vec[0], std::move(jacobian_assembler),
985 _local_coordinate_system, integration_order,
986 process_config);
987 break;
988 }
989 }
990 else
991#endif
992#ifdef OGS_BUILD_PROCESS_HMPHASEFIELD
993 if (type == "HM_PHASE_FIELD")
994 {
995 switch (_mesh_vec[0]->getDimension())
996 {
997 case 2:
998 process =
1000 name, *_mesh_vec[0], std::move(jacobian_assembler),
1002 _local_coordinate_system, integration_order,
1003 process_config, _media);
1004 break;
1005 case 3:
1006 process =
1008 name, *_mesh_vec[0], std::move(jacobian_assembler),
1010 _local_coordinate_system, integration_order,
1011 process_config, _media);
1012 break;
1013 }
1014 }
1015 else
1016#endif
1017#ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT
1018 if (type == "RichardsComponentTransport")
1019 {
1022 name, *_mesh_vec[0], std::move(jacobian_assembler),
1023 _process_variables, _parameters, integration_order,
1024 process_config, _media);
1025 }
1026 else
1027#endif
1028#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION
1029 if (type == "SMALL_DEFORMATION")
1030 {
1031 switch (_mesh_vec[0]->getDimension())
1032 {
1033 case 2:
1036 name, *_mesh_vec[0], std::move(jacobian_assembler),
1038 _local_coordinate_system, integration_order,
1039 process_config, _media);
1040 break;
1041 case 3:
1044 name, *_mesh_vec[0], std::move(jacobian_assembler),
1046 _local_coordinate_system, integration_order,
1047 process_config, _media);
1048 break;
1049 default:
1050 OGS_FATAL(
1051 "SMALL_DEFORMATION process does not support given "
1052 "dimension");
1053 }
1054 }
1055 else
1056#endif
1057#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL
1058 if (type == "SMALL_DEFORMATION_NONLOCAL")
1059 {
1060 WARN(
1061 "The SMALL_DEFORMATION_NONLOCAL process is deprecated and will "
1062 "be removed in OGS-6.5.5.");
1063 switch (_mesh_vec[0]->getDimension())
1064 {
1065 case 2:
1068 name, *_mesh_vec[0], std::move(jacobian_assembler),
1070 _local_coordinate_system, integration_order,
1071 process_config);
1072 break;
1073 case 3:
1076 name, *_mesh_vec[0], std::move(jacobian_assembler),
1078 _local_coordinate_system, integration_order,
1079 process_config);
1080 break;
1081 default:
1082 OGS_FATAL(
1083 "SMALL_DEFORMATION_NONLOCAL process does not support "
1084 "given dimension {:d}",
1085 _mesh_vec[0]->getDimension());
1086 }
1087 }
1088 else
1089#endif
1090#ifdef OGS_BUILD_PROCESS_LIE_M
1091 if (type == "SMALL_DEFORMATION_WITH_LIE")
1092 {
1093 if (
1094 process_config.getConfigParameterOptional<int>("dimension"))
1095 {
1096 OGS_FATAL(
1097 "The 'dimension' tag has been removed in the merge-request "
1098 "!4766."
1099 "The dimension is now taken from the main mesh and the tag "
1100 "must be"
1101 "removed. There is a python script in the merge-request "
1102 "description"
1103 "for automatic conversion.");
1104 }
1105 switch (_mesh_vec[0]->getDimension())
1106 {
1107 case 2:
1110 name, *_mesh_vec[0], std::move(jacobian_assembler),
1112 _local_coordinate_system, integration_order,
1113 process_config);
1114 break;
1115 case 3:
1118 name, *_mesh_vec[0], std::move(jacobian_assembler),
1120 _local_coordinate_system, integration_order,
1121 process_config);
1122 break;
1123 default:
1124 OGS_FATAL(
1125 "SMALL_DEFORMATION_WITH_LIE process does not support "
1126 "given dimension");
1127 }
1128 }
1129 else
1130#endif
1131#ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS
1132 if (type == "THERMO_HYDRO_MECHANICS")
1133 {
1134 if (
1135 process_config.getConfigParameterOptional<int>("dimension"))
1136 {
1137 OGS_FATAL(
1138 "The 'dimension' tag has been removed in the merge-request "
1139 "!4766."
1140 "The dimension is now taken from the main mesh and the tag "
1141 "must be"
1142 "removed. There is a python script in the merge-request "
1143 "description"
1144 "for automatic conversion.");
1145 }
1146 switch (_mesh_vec[0]->getDimension())
1147 {
1148 case 2:
1151 name, *_mesh_vec[0], std::move(jacobian_assembler),
1153 _local_coordinate_system, integration_order,
1154 process_config, _media);
1155 break;
1156 case 3:
1159 name, *_mesh_vec[0], std::move(jacobian_assembler),
1161 _local_coordinate_system, integration_order,
1162 process_config, _media);
1163 break;
1164 default:
1165 OGS_FATAL(
1166 "THERMO_HYDRO_MECHANICS process does not support given "
1167 "dimension");
1168 }
1169 }
1170 else
1171#endif
1172#ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD
1173 if (type == "THERMO_MECHANICAL_PHASE_FIELD")
1174 {
1175 WARN(
1176 "The THERMO_MECHANICAL_PHASE_FIELD process is deprecated and "
1177 "will be removed in OGS-6.5.5.");
1178 switch (_mesh_vec[0]->getDimension())
1179 {
1180 case 2:
1183 name, *_mesh_vec[0], std::move(jacobian_assembler),
1185 _local_coordinate_system, integration_order,
1186 process_config);
1187 break;
1188 case 3:
1191 name, *_mesh_vec[0], std::move(jacobian_assembler),
1193 _local_coordinate_system, integration_order,
1194 process_config);
1195 break;
1196 }
1197 }
1198 else
1199#endif
1200#ifdef OGS_BUILD_PROCESS_THERMOMECHANICS
1201 if (type == "THERMO_MECHANICS")
1202 {
1203 switch (_mesh_vec[0]->getDimension())
1204 {
1205 case 2:
1208 name, *_mesh_vec[0], std::move(jacobian_assembler),
1210 _local_coordinate_system, integration_order,
1211 process_config, _media);
1212 break;
1213 case 3:
1216 name, *_mesh_vec[0], std::move(jacobian_assembler),
1218 _local_coordinate_system, integration_order,
1219 process_config, _media);
1220 break;
1221 }
1222 }
1223 else
1224#endif
1225#ifdef OGS_BUILD_PROCESS_RICHARDSFLOW
1226 if (type == "RICHARDS_FLOW")
1227 {
1229 name, *_mesh_vec[0], std::move(jacobian_assembler),
1230 _process_variables, _parameters, integration_order,
1231 process_config, _media);
1232 }
1233 else
1234#endif
1235#ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS
1236 if (type == "RICHARDS_MECHANICS")
1237 {
1238 if (
1239 process_config.getConfigParameterOptional<int>("dimension"))
1240 {
1241 OGS_FATAL(
1242 "The 'dimension' tag has been removed in the merge-request "
1243 "!4766."
1244 "The dimension is now taken from the main mesh and the tag "
1245 "must be"
1246 "removed. There is a python script in the merge-request "
1247 "description"
1248 "for automatic conversion.");
1249 }
1250 switch (_mesh_vec[0]->getDimension())
1251 {
1252 case 2:
1255 name, *_mesh_vec[0], std::move(jacobian_assembler),
1257 _local_coordinate_system, integration_order,
1258 process_config, _media);
1259 break;
1260 case 3:
1263 name, *_mesh_vec[0], std::move(jacobian_assembler),
1265 _local_coordinate_system, integration_order,
1266 process_config, _media);
1267 break;
1268 }
1269 }
1270 else
1271#endif
1272#ifdef OGS_BUILD_PROCESS_THERMORICHARDSFLOW
1273 if (type == "THERMO_RICHARDS_FLOW")
1274 {
1275 process =
1277 name, *_mesh_vec[0], std::move(jacobian_assembler),
1278 _process_variables, _parameters, integration_order,
1279 process_config, _media);
1280 }
1281 else
1282#endif
1283#ifdef OGS_BUILD_PROCESS_THERMORICHARDSMECHANICS
1284 if (type == "THERMO_RICHARDS_MECHANICS")
1285 {
1286 switch (_mesh_vec[0]->getDimension())
1287 {
1288 case 2:
1291 name, *_mesh_vec[0], std::move(jacobian_assembler),
1293 _local_coordinate_system, integration_order,
1294 process_config, _media);
1295 break;
1296 case 3:
1299 name, *_mesh_vec[0], std::move(jacobian_assembler),
1301 _local_coordinate_system, integration_order,
1302 process_config, _media);
1303 break;
1304 }
1305 }
1306 else
1307#endif
1308
1309#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP
1310 if (type == "TWOPHASE_FLOW_PP")
1311 {
1312 process =
1314 name, *_mesh_vec[0], std::move(jacobian_assembler),
1315 _process_variables, _parameters, integration_order,
1316 process_config, _media);
1317 }
1318 else
1319#endif
1320#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO
1321 if (type == "TWOPHASE_FLOW_PRHO")
1322 {
1323 WARN(
1324 "The TWOPHASE_FLOW_PRHO process is deprecated and will be "
1325 "removed in OGS-6.5.5.");
1328 name, *_mesh_vec[0], std::move(jacobian_assembler),
1329 _process_variables, _parameters, integration_order,
1330 process_config, _media);
1331 }
1332 else
1333#endif
1334#ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP
1335 if (type == "THERMAL_TWOPHASE_WITH_PP")
1336 {
1339 name, *_mesh_vec[0], std::move(jacobian_assembler),
1340 _process_variables, _parameters, integration_order,
1341 process_config, _media);
1342 }
1343 else
1344#endif
1345 {
1346 OGS_FATAL("Unknown process type: {:s}", type);
1347 }
1348
1349 if (ranges::contains(_processes, name,
1350 [](std::unique_ptr<ProcessLib::Process> const& p)
1351 { return p->name; }))
1352 {
1353 OGS_FATAL("The process name '{:s}' is not unique.", name);
1354 }
1355 _processes.push_back(std::move(process));
1356 }
1357}
void WARN(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:40
std::vector< ProcessLib::ProcessVariable > _process_variables
std::unique_ptr< Process > createComponentTransportProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media, std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &&chemical_solver_interface)
template std::unique_ptr< Process > createHMPhaseFieldProcess< 3 >(std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createHMPhaseFieldProcess< 2 >(std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createHTProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createHeatConductionProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createHeatTransportBHEProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createHydroMechanicsProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createHydroMechanicsProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createHydroMechanicsProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createSmallDeformationProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createSmallDeformationProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createLargeDeformationProcess< 2 >(std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createLargeDeformationProcess< 3 >(std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createLiquidFlowProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createPhaseFieldProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createPhaseFieldProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
std::unique_ptr< Process > createRichardsComponentTransportProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createRichardsFlowProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createRichardsMechanicsProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createRichardsMechanicsProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createSmallDeformationNonlocalProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createSmallDeformationNonlocalProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createSmallDeformationProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createSmallDeformationProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createSteadyStateDiffusion(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createStokesFlowProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createTESProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createTH2MProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createTH2MProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createThermalTwoPhaseFlowWithPPProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoHydroMechanicsProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoHydroMechanicsProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoMechanicalPhaseFieldProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createThermoMechanicalPhaseFieldProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createThermoMechanicsProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoMechanicsProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createThermoRichardsFlowProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoRichardsMechanicsProcess< 3 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createThermoRichardsMechanicsProcess< 2 >(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createTwoPhaseFlowWithPPProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createTwoPhaseFlowWithPrhoProcess(std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< Process > createWellboreSimulatorProcess(std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
std::unique_ptr< AbstractJacobianAssembler > createJacobianAssembler(std::optional< BaseLib::ConfigTree > const &config)

References _curves, _local_coordinate_system, _media, _mesh_vec, _parameters, _process_variables, _processes, ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess< 2 >(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess< 3 >(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess< 2 >(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess< 3 >(), ProcessLib::createJacobianAssembler(), ProcessLib::LargeDeformation::createLargeDeformationProcess< 2 >(), ProcessLib::LargeDeformation::createLargeDeformationProcess< 3 >(), 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(), ProcessLib::WellboreSimulator::createWellboreSimulatorProcess(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), OGS_FATAL, and WARN().

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

480{
481 DBUG("Parse process variables:");
482
483 std::set<std::string> names;
484
485 for (auto var_config
487 : process_variables_config.getConfigSubtreeList("process_variable"))
488 {
489 // Either the mesh name is given, or the first mesh's name will be
490 // taken. Taking the first mesh's value is deprecated.
491 auto const mesh_name =
493 var_config.getConfigParameter<std::string>("mesh",
494 _mesh_vec[0]->getName());
495
496 auto& mesh = MeshLib::findMeshByName(_mesh_vec, mesh_name);
497
498 auto pv = ProcessLib::ProcessVariable{var_config, mesh, _mesh_vec,
500 if (!names.insert(pv.getName()).second)
501 {
502 OGS_FATAL("A process variable with name `{:s}' already exists.",
503 pv.getName());
504 }
505
506 _process_variables.push_back(std::move(pv));
507 }
508}

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

1361{
1362 DBUG("Reading time loop configuration.");
1363
1364 bool const compensate_non_equilibrium_initial_residuum = std::any_of(
1365 std::begin(_process_variables),
1366 std::end(_process_variables),
1367 [](auto const& process_variable)
1368 { return process_variable.compensateNonEquilibriumInitialResiduum(); });
1369
1371 config, output_directory, _processes, _nonlinear_solvers, _mesh_vec,
1372 compensate_non_equilibrium_initial_residuum);
1373
1374 if (!_time_loop)
1375 {
1376 OGS_FATAL("Initialization of time loop failed.");
1377 }
1378}
std::unique_ptr< TimeLoop > createTimeLoop(BaseLib::ConfigTree const &config, std::string const &output_directory, const std::vector< std::unique_ptr< Process > > &processes, const std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase > > &nonlinear_solvers, std::vector< std::unique_ptr< MeshLib::Mesh > > &meshes, bool const compensate_non_equilibrium_initial_residuum)
Builds a TimeLoop from the given configuration.

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

◆ _linear_solvers

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

◆ _local_coordinate_system

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

Definition at line 153 of file ProjectData.h.

Referenced by parseMedia(), and parseProcesses().

◆ _media

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

Definition at line 155 of file ProjectData.h.

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

◆ _mesh_vec

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

◆ _named_rasters

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

Definition at line 146 of file ProjectData.h.

Referenced by parseParameters().

◆ _nonlinear_solvers

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

Definition at line 163 of file ProjectData.h.

Referenced by parseNonlinearSolvers(), and parseTimeLoop().

◆ _parameters

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

Buffer for each parameter config passed to the process.

Definition at line 151 of file ProjectData.h.

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

◆ _process_variables

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

Definition at line 148 of file ProjectData.h.

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

◆ _processes

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

Definition at line 147 of file ProjectData.h.

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

◆ _time_loop

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

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

Definition at line 158 of file ProjectData.h.

Referenced by getTimeLoop(), and parseTimeLoop().


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