16#include <pybind11/eval.h>
19#include <boost/algorithm/string/predicate.hpp>
21#include <range/v3/action/sort.hpp>
22#include <range/v3/action/unique.hpp>
23#include <range/v3/range/conversion.hpp>
32#include "InfoLib/CMakeInfo.h"
37#elif defined(USE_PETSC)
59#ifdef OGS_EMBED_PYTHON_INTERPRETER
63#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
67#ifdef OGS_BUILD_PROCESS_STEADYSTATEDIFFUSION
70#ifdef OGS_BUILD_PROCESS_HT
73#ifdef OGS_BUILD_PROCESS_HEATCONDUCTION
76#ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE
79#ifdef OGS_BUILD_PROCESS_HYDROMECHANICS
82#ifdef OGS_BUILD_PROCESS_LIE
86#ifdef OGS_BUILD_PROCESS_LIQUIDFLOW
89#ifdef OGS_BUILD_PROCESS_STOKESFLOW
93#ifdef OGS_BUILD_PROCESS_THERMORICHARDSMECHANICS
97#ifdef OGS_BUILD_PROCESS_PHASEFIELD
100#ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT
103#ifdef OGS_BUILD_PROCESS_RICHARDSFLOW
106#ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS
109#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION
112#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL
115#ifdef OGS_BUILD_PROCESS_TES
118#ifdef OGS_BUILD_PROCESS_TH2M
121#ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP
124#ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS
127#ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD
130#ifdef OGS_BUILD_PROCESS_THERMOMECHANICS
133#ifdef OGS_BUILD_PROCESS_THERMORICHARDSFLOW
136#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP
139#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO
147 DBUG(
"Reading geometry file '{:s}'.", fname);
154 std::string
const& directory)
157 mesh_config_parameter.
getValue<std::string>(), directory);
158 DBUG(
"Reading mesh file '{:s}'.", mesh_file);
160 auto mesh = std::unique_ptr<MeshLib::Mesh>(
164 OGS_FATAL(
"Could not read mesh from '{:s}' file. No mesh added.",
168#ifdef DOXYGEN_DOCU_ONLY
173 if (
auto const axially_symmetric =
176 "axially_symmetric"))
178 mesh->setAxiallySymmetric(*axially_symmetric);
187 std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
195 DBUG(
"Reading multiple meshes.");
197 auto const configs = optional_meshes->getConfigParameterList(
"mesh");
198 std::transform(configs.begin(), configs.end(),
199 std::back_inserter(meshes),
200 [&directory](
auto const& mesh_config)
201 { return readSingleMesh(mesh_config, directory); });
202 if (
auto const geometry_file_name =
206 std::string
const geometry_file =
225 std::unique_ptr<MeshGeoToolsLib::SearchLength> search_length_algorithm =
227 bool const multiple_nodes_allowed =
false;
228 auto additional_meshes =
230 geoObjects, *meshes[0], std::move(search_length_algorithm),
231 multiple_nodes_allowed);
233 std::move(begin(additional_meshes), end(additional_meshes),
234 std::back_inserter(meshes));
238 ranges::actions::sort;
239 auto const sorted_names = meshes | mesh_names;
240 auto const unique_names = meshes | mesh_names | ranges::actions::unique;
241 if (unique_names.size() < sorted_names.size())
244 "Mesh names aren't unique. From project file read mesh names are:");
257 std::optional<BaseLib::ConfigTree>
const& config,
258 std::vector<std::unique_ptr<ParameterLib::ParameterBase>>
const& parameters)
265 DBUG(
"Reading coordinate system configuration.");
270 auto const& basis_vector_0 = ParameterLib::findParameter<double>(
273 "basis_vector_0", parameters, 0 );
274 int const dimension = basis_vector_0.getNumberOfGlobalComponents();
277 if (dimension != 2 && dimension != 3)
280 "Basis vector parameter '{:s}' must have two or three components, "
282 basis_vector_0.name, dimension);
289 auto const& basis_vector_1 = ParameterLib::findParameter<double>(
292 "basis_vector_1", parameters, dimension);
305 auto const& basis_vector_2 = ParameterLib::findParameter<double>(
308 "basis_vector_2", parameters, dimension);
317 std::string
const& project_directory,
318 std::string
const& output_directory,
319 std::string
const& mesh_directory,
320 [[maybe_unused]] std::string
const& script_directory)
321 : _mesh_vec(
readMeshes(project_config, mesh_directory))
323 if (
auto const python_script =
327 namespace py = pybind11;
329#ifdef OGS_EMBED_PYTHON_INTERPRETER
334 auto py_path = py::module::import(
"sys").attr(
"path");
335 py_path.attr(
"append")(script_directory);
337 py_path.attr(
"append")(
338 CMakeInfoLib::CMakeInfo::python_virtualenv_sitepackages);
340 auto const script_path =
344 py::object scope = py::module::import(
"__main__").attr(
"__dict__");
346 auto globals = py::dict(scope);
347 globals[
"ogs_prj_directory"] = project_directory;
348 globals[
"ogs_mesh_directory"] = mesh_directory;
349 globals[
"ogs_script_directory"] = script_directory;
350 py::eval_file(script_path, scope);
356 auto parameter_names_for_transformation =
367 if (std::find(begin(parameter_names_for_transformation),
368 end(parameter_names_for_transformation),
370 end(parameter_names_for_transformation))
375 "The parameter '{:s}' is using the local coordinate system "
376 "but no local coordinate system was provided.",
401 project_directory, output_directory,
402 std::move(chemical_solver_interface));
415 DBUG(
"Parse process variables:");
417 std::set<std::string> names;
425 auto const mesh_name =
427 var_config.getConfigParameter<std::string>(
"mesh",
432 [&mesh_name](
auto const& m) {
return m->getName() == mesh_name; },
433 "Expected to find a mesh named " + mesh_name +
".");
437 if (!names.insert(pv.getName()).second)
439 OGS_FATAL(
"A process variable with name `{:s}' already exists.",
452 std::set<std::string> names;
453 std::vector<std::string> parameter_names_for_transformation;
455 DBUG(
"Reading parameters:");
456 for (
auto parameter_config :
462 if (!names.insert(p->name).second)
464 OGS_FATAL(
"A parameter with name `{:s}' already exists.", p->name);
467 auto const use_local_coordinate_system =
469 parameter_config.getConfigParameterOptional<
bool>(
470 "use_local_coordinate_system");
471 if (!!use_local_coordinate_system && *use_local_coordinate_system)
473 parameter_names_for_transformation.push_back(p->name);
486 return parameter_names_for_transformation;
490 std::optional<BaseLib::ConfigTree>
const& media_config)
497 DBUG(
"Reading media:");
501 ERR(
"A mesh is required to define medium materials.");
505 for (
auto const& medium_config :
507 media_config->getConfigSubtreeList(
"medium"))
509 auto material_id_string =
511 medium_config.getConfigAttribute<std::string>(
"id",
"0");
513 auto const material_ids_of_this_medium =
516 for (
auto const&
id : material_ids_of_this_medium)
521 "Multiple media were specified for the same material id "
522 "'{:d}'. Keep in mind, that if no material id is "
523 "specified, it is assumed to be 0 by default.",
527 if (
id == material_ids_of_this_medium[0])
530 id,
_mesh_vec[0]->getDimension(), medium_config,
548 OGS_FATAL(
"No entity is found inside <media>.");
552std::unique_ptr<ChemistryLib::ChemicalSolverInterface>
554 std::optional<BaseLib::ConfigTree>
const& config,
555 std::string
const& output_directory)
562 std::unique_ptr<ChemistryLib::ChemicalSolverInterface>
563 chemical_solver_interface;
564#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
566 "Ready for initializing interface to a chemical solver for water "
567 "chemistry calculation.");
569 auto const chemical_solver =
571 config->getConfigAttribute<std::string>(
"chemical_solver");
573 if (boost::iequals(chemical_solver,
"Phreeqc"))
576 "Configuring phreeqc interface for water chemistry calculation "
577 "using file-based approach.");
581 *config, output_directory);
583 else if (boost::iequals(chemical_solver,
"PhreeqcKernel"))
586 "The chemical solver option of PhreeqcKernel is not accessible for "
587 "the time being. Please set 'Phreeqc'' as the chemical solver for "
588 "reactive transport modeling.");
590 else if (boost::iequals(chemical_solver,
"SelfContained"))
593 "Use self-contained chemical solver for water chemistry "
603 "Unknown chemical solver. Please specify either Phreeqc or "
604 "PhreeqcKernel as the solver for water chemistry calculation "
608 (void)output_directory;
611 "Found the type of the process to be solved is not component transport "
612 "process. Please specify the process type to ComponentTransport. At "
613 "the present, water chemistry calculation is only available for "
614 "component transport process.");
616 return chemical_solver_interface;
621 std::string
const& project_directory,
622 std::string
const& output_directory,
623 [[maybe_unused]] std::unique_ptr<ChemistryLib::ChemicalSolverInterface>&&
624 chemical_solver_interface)
626 (void)project_directory;
627 (void)output_directory;
629 DBUG(
"Reading processes:");
635 process_config.peekConfigParameter<std::string>(
"type");
639 process_config.getConfigParameter<std::string>(
"name");
641 [[maybe_unused]]
auto const integration_order =
643 process_config.getConfigParameter<
int>(
"integration_order");
645 std::unique_ptr<ProcessLib::Process> process;
649 process_config.getConfigSubtreeOptional(
"jacobian_assembler"));
651#ifdef OGS_BUILD_PROCESS_STEADYSTATEDIFFUSION
652 if (type ==
"STEADY_STATE_DIFFUSION")
661 name, *
_mesh_vec[0], std::move(jacobian_assembler),
667#ifdef OGS_BUILD_PROCESS_LIQUIDFLOW
668 if (type ==
"LIQUID_FLOW")
671 name, *
_mesh_vec[0], std::move(jacobian_assembler),
677#ifdef OGS_BUILD_PROCESS_STOKESFLOW
678 if (type ==
"StokesFlow")
685 name, *
_mesh_vec[0], std::move(jacobian_assembler),
691 "StokesFlow process does not support given "
698#ifdef OGS_BUILD_PROCESS_TES
702 name, *
_mesh_vec[0], std::move(jacobian_assembler),
708#ifdef OGS_BUILD_PROCESS_TH2M
715 name, *
_mesh_vec[0], std::move(jacobian_assembler),
722 name, *
_mesh_vec[0], std::move(jacobian_assembler),
728 OGS_FATAL(
"TH2M process does not support given dimension");
733#ifdef OGS_BUILD_PROCESS_HEATCONDUCTION
734 if (type ==
"HEAT_CONDUCTION")
737 name, *
_mesh_vec[0], std::move(jacobian_assembler),
743#ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE
744 if (type ==
"HEAT_TRANSPORT_BHE")
749 "HEAT_TRANSPORT_BHE can only work with a 3-dimensional "
755 name, *
_mesh_vec[0], std::move(jacobian_assembler),
761#ifdef OGS_BUILD_PROCESS_HYDROMECHANICS
762 if (type ==
"HYDRO_MECHANICS")
765 switch (process_config.getConfigParameter<
int>(
"dimension"))
771 std::move(jacobian_assembler),
780 std::move(jacobian_assembler),
787 "HYDRO_MECHANICS process does not support given "
793#ifdef OGS_BUILD_PROCESS_LIE
794 if (type ==
"HYDRO_MECHANICS_WITH_LIE")
797 switch (process_config.getConfigParameter<
int>(
"dimension"))
802 name, *
_mesh_vec[0], std::move(jacobian_assembler),
810 name, *
_mesh_vec[0], std::move(jacobian_assembler),
817 "HYDRO_MECHANICS_WITH_LIE process does not support "
823#ifdef OGS_BUILD_PROCESS_HT
827 name, *
_mesh_vec[0], std::move(jacobian_assembler),
833#ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT
834 if (type ==
"ComponentTransport")
838 name, *
_mesh_vec[0], std::move(jacobian_assembler),
841 std::move(chemical_solver_interface));
845#ifdef OGS_BUILD_PROCESS_PHASEFIELD
846 if (type ==
"PHASE_FIELD")
853 name, *
_mesh_vec[0], std::move(jacobian_assembler),
861 name, *
_mesh_vec[0], std::move(jacobian_assembler),
870#ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT
871 if (type ==
"RichardsComponentTransport")
875 name, *
_mesh_vec[0], std::move(jacobian_assembler),
881#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION
882 if (type ==
"SMALL_DEFORMATION")
889 name, *
_mesh_vec[0], std::move(jacobian_assembler),
897 name, *
_mesh_vec[0], std::move(jacobian_assembler),
904 "SMALL_DEFORMATION process does not support given "
910#ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL
911 if (type ==
"SMALL_DEFORMATION_NONLOCAL")
918 name, *
_mesh_vec[0], std::move(jacobian_assembler),
926 name, *
_mesh_vec[0], std::move(jacobian_assembler),
933 "SMALL_DEFORMATION_NONLOCAL process does not support "
934 "given dimension {:d}",
940#ifdef OGS_BUILD_PROCESS_LIE
941 if (type ==
"SMALL_DEFORMATION_WITH_LIE")
944 switch (process_config.getConfigParameter<
int>(
"dimension"))
949 name, *
_mesh_vec[0], std::move(jacobian_assembler),
957 name, *
_mesh_vec[0], std::move(jacobian_assembler),
964 "SMALL_DEFORMATION_WITH_LIE process does not support "
970#ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS
971 if (type ==
"THERMO_HYDRO_MECHANICS")
974 switch (process_config.getConfigParameter<
int>(
"dimension"))
979 name, *
_mesh_vec[0], std::move(jacobian_assembler),
987 name, *
_mesh_vec[0], std::move(jacobian_assembler),
994 "THERMO_HYDRO_MECHANICS process does not support given "
1000#ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD
1001 if (type ==
"THERMO_MECHANICAL_PHASE_FIELD")
1008 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1016 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1025#ifdef OGS_BUILD_PROCESS_THERMOMECHANICS
1026 if (type ==
"THERMO_MECHANICS")
1033 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1041 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1050#ifdef OGS_BUILD_PROCESS_RICHARDSFLOW
1051 if (type ==
"RICHARDS_FLOW")
1054 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1060#ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS
1061 if (type ==
"RICHARDS_MECHANICS")
1064 switch (process_config.getConfigParameter<
int>(
"dimension"))
1069 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1077 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1086#ifdef OGS_BUILD_PROCESS_THERMORICHARDSFLOW
1087 if (type ==
"THERMO_RICHARDS_FLOW")
1091 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1097#ifdef OGS_BUILD_PROCESS_THERMORICHARDSMECHANICS
1098 if (type ==
"THERMO_RICHARDS_MECHANICS")
1105 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1113 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1123#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP
1124 if (type ==
"TWOPHASE_FLOW_PP")
1128 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1134#ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO
1135 if (type ==
"TWOPHASE_FLOW_PRHO")
1139 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1145#ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP
1146 if (type ==
"THERMAL_TWOPHASE_WITH_PP")
1150 name, *
_mesh_vec[0], std::move(jacobian_assembler),
1157 OGS_FATAL(
"Unknown process type: {:s}", type);
1162 [&name](std::unique_ptr<ProcessLib::Process>
const& p)
1163 {
return p->name == name; }))
1165 OGS_FATAL(
"The process name '{:s}' is not unique.", name);
1172 std::string
const& output_directory)
1174 DBUG(
"Reading time loop configuration.");
1176 bool const compensate_non_equilibrium_initial_residuum = std::any_of(
1179 [](
auto const& process_variable)
1180 {
return process_variable.compensateNonEquilibriumInitialResiduum(); });
1184 compensate_non_equilibrium_initial_residuum);
1188 OGS_FATAL(
"Initialization of time loop failed.");
1194 DBUG(
"Reading linear solver configuration.");
1200 auto const name = conf.getConfigParameter<std::string>(
"name");
1201 auto const linear_solver_parser =
1203 auto const solver_options =
1204 linear_solver_parser.parseNameAndOptions(
"", &conf);
1209 std::make_unique<GlobalLinearSolver>(std::get<0>(solver_options),
1210 std::get<1>(solver_options)),
1211 "The linear solver name is not unique");
1217 DBUG(
"Reading non-linear solver configuration.");
1222 auto const ls_name =
1224 conf.getConfigParameter<std::string>(
"linear_solver");
1227 "A linear solver with the given name does not exist.");
1230 auto const name = conf.getConfigParameter<std::string>(
"name");
1235 "The nonlinear solver name is not unique");
1246 DBUG(
"Reading curves configuration.");
1249 for (
auto conf : config->getConfigSubtreeList(
"curve"))
1252 auto const name = conf.getConfigParameter<std::string>(
"name");
1258 "The curve name is not unique.");
Definition of the BoostXmlGmlInterface class.
Functionality to build different search length algorithm objects from given config.
Definition of the GEOObjects class.
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
void WARN(fmt::format_string< Args... > fmt, Args &&... args)
Definition of the Mesh class.
Base class for different search length strategies.
std::optional< ConfigTree > getConfigSubtreeOptional(std::string const &root) const
std::optional< T > getConfigParameterOptional(std::string const ¶m) const
T getConfigParameter(std::string const ¶m) const
Range< SubtreeIterator > getConfigSubtreeList(std::string const &root) const
ConfigTree getConfigSubtree(std::string const &root) const
std::optional< T > getConfigAttributeOptional(std::string const &attr) const
Container class for geometric objects.
bool readFile(const std::string &fname) override
Reads an xml-file containing OGS geometry.
static PROCESSLIB_EXPORT const std::string constant_one_parameter_name
std::map< std::string, std::unique_ptr< GlobalLinearSolver > > _linear_solvers
std::optional< ParameterLib::CoordinateSystem > _local_coordinate_system
std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase > > _nonlinear_solvers
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< std::unique_ptr< ProcessLib::Process > > _processes
void parseNonlinearSolvers(BaseLib::ConfigTree const &config)
std::vector< ProcessLib::ProcessVariable > _process_variables
void parseProcessVariables(BaseLib::ConfigTree const &process_variables_config)
std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > _curves
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::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > _media
std::vector< std::string > parseParameters(BaseLib::ConfigTree const ¶meters_config)
std::unique_ptr< ProcessLib::TimeLoop > _time_loop
The time loop used to solve this project's processes.
std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag > createNonlinearSolver(GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)
pybind11::scoped_interpreter setupEmbeddedPython()
Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
std::iterator_traits< InputIt >::reference findElementOrError(InputIt begin, InputIt end, Predicate predicate, std::string const &error="")
std::vector< int > splitMaterialIdString(std::string const &material_id_string)
void insertIfKeyUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
bool containsIf(Container const &container, Predicate &&predicate)
std::string copyPathToFileName(const std::string &file_name, const std::string &source)
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)
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 ¶meters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< CurveType > createPiecewiseLinearCurve(BaseLib::ConfigTree const &config)
MeshLib::Mesh * readMeshFromFile(const std::string &file_name)
constexpr ranges::views::view_closure names
For an element of a range view return its name.
void setMeshSpaceDimension(std::vector< std::unique_ptr< Mesh > > const &meshes)
std::unique_ptr< ParameterBase > createParameter(BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< Process > createComponentTransportProcess(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 ¶meters, 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)
std::unique_ptr< Process > createHTProcess(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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createHydroMechanicsProcess< 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 ¶meters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
std::unique_ptr< Process > createLiquidFlowProcess(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 ¶meters, 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< 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 ¶meters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createPhaseFieldProcess< 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 ¶meters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
std::unique_ptr< Process > createRichardsComponentTransportProcess(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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process > createRichardsMechanicsProcess< 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 ¶meters, 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< 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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createTH2MProcess< 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 ¶meters, 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< 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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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)
template std::unique_ptr< Process > createThermoHydroMechanicsProcess< 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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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< 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 ¶meters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
template std::unique_ptr< Process > createThermoMechanicalPhaseFieldProcess< 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 ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters, 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 > createTwoPhaseFlowWithPrhoProcess(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 ¶meters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
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.
std::unique_ptr< AbstractJacobianAssembler > createJacobianAssembler(std::optional< BaseLib::ConfigTree > const &config)
std::vector< std::unique_ptr< MeshLib::Mesh > > readMeshes(BaseLib::ConfigTree const &config, std::string const &directory)
std::optional< ParameterLib::CoordinateSystem > parseLocalCoordinateSystem(std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const ¶meters)
std::unique_ptr< MeshLib::Mesh > readSingleMesh(BaseLib::ConfigTree const &mesh_config_parameter, std::string const &directory)
void readGeometry(std::string const &fname, GeoLib::GEOObjects &geo_objects)
Definition of readMeshFromFile function.
Single, constant value parameter.
static PROCESSLIB_EXPORT const std::string zero_parameter_name