19 #include <logog/include/logog.hpp> 22 #include <pybind11/eval.h> 50 #ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT 57 #ifdef OGS_BUILD_PROCESS_GROUNDWATERFLOW 60 #ifdef OGS_BUILD_PROCESS_HT 63 #ifdef OGS_BUILD_PROCESS_HEATCONDUCTION 66 #ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE 69 #ifdef OGS_BUILD_PROCESS_HYDROMECHANICS 72 #ifdef OGS_BUILD_PROCESS_LIE 76 #ifdef OGS_BUILD_PROCESS_LIQUIDFLOW 79 #ifdef OGS_BUILD_PROCESS_PHASEFIELD 82 #ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT 85 #ifdef OGS_BUILD_PROCESS_RICHARDSFLOW 88 #ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS 91 #ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION 94 #ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL 97 #ifdef OGS_BUILD_PROCESS_TES 100 #ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP 103 #ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS 106 #ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD 109 #ifdef OGS_BUILD_PROCESS_THERMOMECHANICS 112 #ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP 115 #ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO 123 DBUG(
"Reading geometry file '%s'.", fname.c_str());
125 gml_reader.readFile(fname);
133 mesh_config_parameter.
getValue<std::string>(), project_directory);
134 DBUG(
"Reading mesh file '%s'.", mesh_file.c_str());
136 auto mesh = std::unique_ptr<MeshLib::Mesh>(
140 OGS_FATAL(
"Could not read mesh from '%s' file. No mesh added.",
144 #ifdef DOXYGEN_DOCU_ONLY 147 #endif // DOXYGEN_DOCU_ONLY 149 if (
auto const axially_symmetric =
152 "axially_symmetric"))
154 mesh->setAxiallySymmetric(*axially_symmetric);
163 std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
169 DBUG(
"Reading multiple meshes.");
170 for (
auto mesh_config :
172 optional_meshes->getConfigParameterList(
"mesh"))
180 "Consider switching from mesh and geometry input to multiple " 182 "https://www.opengeosys.org/docs/tools/model-preparation/" 183 "constructmeshesfromgeometry/ tool for conversion.");
195 std::unique_ptr<MeshGeoToolsLib::SearchLength> search_length_algorithm =
197 bool const multiple_nodes_allowed =
false;
198 auto additional_meshes =
200 geoObjects, *meshes[0], std::move(search_length_algorithm),
201 multiple_nodes_allowed);
203 std::move(begin(additional_meshes), end(additional_meshes),
204 std::back_inserter(meshes));
210 boost::optional<BaseLib::ConfigTree>
const& config,
211 std::vector<std::unique_ptr<ParameterLib::ParameterBase>>
const& parameters)
218 DBUG(
"Reading coordinate system configuration.");
223 auto const& basis_vector_0 = ParameterLib::findParameter<double>(
226 "basis_vector_0", parameters, 0 );
227 int const dimension = basis_vector_0.getNumberOfComponents();
230 if (dimension != 2 && dimension != 3)
233 "Basis vector parameter '%s' must have two or three components, " 235 basis_vector_0.name.c_str(), dimension);
242 auto const& basis_vector_1 = ParameterLib::findParameter<double>(
245 "basis_vector_1", parameters, dimension);
258 auto const& basis_vector_2 = ParameterLib::findParameter<double>(
261 "basis_vector_2", parameters, dimension);
271 std::string
const& output_directory)
275 if (
auto const python_script =
279 #ifdef OGS_USE_PYTHON 280 namespace py = pybind11;
283 py::module::import(
"sys").attr(
"path").attr(
"append")(
286 auto const script_path =
290 py::object scope = py::module::import(
"__main__").attr(
"__dict__");
291 py::eval_file(script_path, scope);
293 OGS_FATAL(
"OpenGeoSys has not been built with Python support.");
294 #endif // OGS_USE_PYTHON 300 auto parameter_names_for_transformation =
311 if (std::find(begin(parameter_names_for_transformation),
312 end(parameter_names_for_transformation),
314 end(parameter_names_for_transformation))
316 if (!_local_coordinate_system)
319 "The parameter '%s' is using the local coordinate system " 320 "but no local coordinate system was provided.",
321 parameter->name.c_str());
323 parameter->setCoordinateSystem(*_local_coordinate_system);
326 parameter->initialize(_parameters);
358 DBUG(
"Parse process variables:");
360 std::set<std::string> names;
368 auto const mesh_name =
370 var_config.getConfigParameter<std::string>(
"mesh",
375 [&mesh_name](
auto const& m) {
return m->getName() == mesh_name; },
376 "Expected to find a mesh named " + mesh_name +
".");
380 if (!names.insert(pv.getName()).second)
382 OGS_FATAL(
"A process variable with name `%s' already exists.",
383 pv.getName().c_str());
395 std::set<std::string> names;
396 std::vector<std::string> parameter_names_for_transformation;
398 DBUG(
"Reading parameters:");
399 for (
auto parameter_config :
405 if (!names.insert(
p->name).second)
407 OGS_FATAL(
"A parameter with name `%s' already exists.",
411 auto const use_local_coordinate_system =
413 parameter_config.getConfigParameterOptional<
bool>(
414 "use_local_coordinate_system");
415 if (!!use_local_coordinate_system && *use_local_coordinate_system)
417 parameter_names_for_transformation.push_back(
p->name);
427 return parameter_names_for_transformation;
431 boost::optional<BaseLib::ConfigTree>
const& media_config)
438 DBUG(
"Reading media:");
442 ERR(
"A mesh is required to define medium materials.");
446 for (
auto const& medium_config :
448 media_config->getConfigSubtreeList(
"medium"))
451 auto const material_id = medium_config.getConfigAttribute<
int>(
"id", 0);
456 "Multiple media were specified for the same material id %d. " 457 "Keep in mind, that if no material id is specified, it is " 458 "assumed to be 0 by default.",
468 OGS_FATAL(
"No entity is found inside <media>.");
474 std::string
const& output_directory)
476 (void)project_directory;
477 (void)output_directory;
479 DBUG(
"Reading processes:");
485 process_config.peekConfigParameter<std::string>(
"type");
489 process_config.getConfigParameter<std::string>(
"name");
491 auto const integration_order =
493 process_config.getConfigParameter<
int>(
"integration_order");
495 std::unique_ptr<ProcessLib::Process> process;
499 process_config.getConfigSubtreeOptional(
"jacobian_assembler"));
501 #ifdef OGS_BUILD_PROCESS_GROUNDWATERFLOW 502 if (type ==
"GROUNDWATER_FLOW")
510 name, *
_mesh_vec[0], std::move(jacobian_assembler),
512 process_config,
_mesh_vec, output_directory);
516 #ifdef OGS_BUILD_PROCESS_LIQUIDFLOW 517 if (type ==
"LIQUID_FLOW")
520 name, *
_mesh_vec[0], std::move(jacobian_assembler),
526 #ifdef OGS_BUILD_PROCESS_TES 530 name, *
_mesh_vec[0], std::move(jacobian_assembler),
536 #ifdef OGS_BUILD_PROCESS_HEATCONDUCTION 537 if (type ==
"HEAT_CONDUCTION")
540 name, *
_mesh_vec[0], std::move(jacobian_assembler),
546 #ifdef OGS_BUILD_PROCESS_HEATTRANSPORTBHE 547 if (type ==
"HEAT_TRANSPORT_BHE")
552 "HEAT_TRANSPORT_BHE can only work with a 3-dimentional " 558 name, *
_mesh_vec[0], std::move(jacobian_assembler),
564 #ifdef OGS_BUILD_PROCESS_HYDROMECHANICS 565 if (type ==
"HYDRO_MECHANICS")
568 switch (process_config.getConfigParameter<
int>(
"dimension"))
574 std::move(jacobian_assembler),
582 3>(
name, *_mesh_vec[0],
583 std::move(jacobian_assembler),
590 "HYDRO_MECHANICS process does not support given " 596 #ifdef OGS_BUILD_PROCESS_LIE 597 if (type ==
"HYDRO_MECHANICS_WITH_LIE")
600 switch (process_config.getConfigParameter<
int>(
"dimension"))
603 process = ProcessLib::LIE::HydroMechanics::
604 createHydroMechanicsProcess<2>(
611 process = ProcessLib::LIE::HydroMechanics::
612 createHydroMechanicsProcess<3>(
613 name, *_mesh_vec[0], std::move(jacobian_assembler),
620 "HYDRO_MECHANICS_WITH_LIE process does not support " 626 #ifdef OGS_BUILD_PROCESS_HT 630 name, *
_mesh_vec[0], std::move(jacobian_assembler),
636 #ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT 637 if (type ==
"ComponentTransport")
641 name, *
_mesh_vec[0], std::move(jacobian_assembler),
647 #ifdef OGS_BUILD_PROCESS_PHASEFIELD 648 if (type ==
"PHASE_FIELD")
663 name, *_mesh_vec[0], std::move(jacobian_assembler),
672 #ifdef OGS_BUILD_PROCESS_RICHARDSCOMPONENTTRANSPORT 673 if (type ==
"RichardsComponentTransport")
677 name, *
_mesh_vec[0], std::move(jacobian_assembler),
683 #ifdef OGS_BUILD_PROCESS_SMALLDEFORMATION 684 if (type ==
"SMALL_DEFORMATION")
689 process = ProcessLib::SmallDeformation::
690 createSmallDeformationProcess<2>(
697 process = ProcessLib::SmallDeformation::
698 createSmallDeformationProcess<3>(
699 name, *_mesh_vec[0], std::move(jacobian_assembler),
706 "SMALL_DEFORMATION process does not support " 712 #ifdef OGS_BUILD_PROCESS_SMALLDEFORMATIONNONLOCAL 713 if (type ==
"SMALL_DEFORMATION_NONLOCAL")
718 process = ProcessLib::SmallDeformationNonlocal::
719 createSmallDeformationNonlocalProcess<2>(
726 process = ProcessLib::SmallDeformationNonlocal::
727 createSmallDeformationNonlocalProcess<3>(
728 name, *_mesh_vec[0], std::move(jacobian_assembler),
735 "SMALL_DEFORMATION_NONLOCAL process does not support " 736 "given dimension %d",
742 #ifdef OGS_BUILD_PROCESS_LIE 743 if (type ==
"SMALL_DEFORMATION_WITH_LIE")
746 switch (process_config.getConfigParameter<
int>(
"dimension"))
749 process = ProcessLib::LIE::SmallDeformation::
750 createSmallDeformationProcess<2>(
757 process = ProcessLib::LIE::SmallDeformation::
758 createSmallDeformationProcess<3>(
759 name, *_mesh_vec[0], std::move(jacobian_assembler),
766 "SMALL_DEFORMATION_WITH_LIE process does not support " 772 #ifdef OGS_BUILD_PROCESS_THERMOHYDROMECHANICS 773 if (type ==
"THERMO_HYDRO_MECHANICS")
776 switch (process_config.getConfigParameter<
int>(
"dimension"))
779 process = ProcessLib::ThermoHydroMechanics::
780 createThermoHydroMechanicsProcess<2>(
787 process = ProcessLib::ThermoHydroMechanics::
788 createThermoHydroMechanicsProcess<3>(
789 name, *_mesh_vec[0], std::move(jacobian_assembler),
796 "THERMO_HYDRO_MECHANICS process does not support given " 802 #ifdef OGS_BUILD_PROCESS_THERMOMECHANICALPHASEFIELD 803 if (type ==
"THERMO_MECHANICAL_PHASE_FIELD")
808 process = ProcessLib::ThermoMechanicalPhaseField::
809 createThermoMechanicalPhaseFieldProcess<2>(
816 process = ProcessLib::ThermoMechanicalPhaseField::
817 createThermoMechanicalPhaseFieldProcess<3>(
818 name, *_mesh_vec[0], std::move(jacobian_assembler),
827 #ifdef OGS_BUILD_PROCESS_THERMOMECHANICS 828 if (type ==
"THERMO_MECHANICS")
833 process = ProcessLib::ThermoMechanics::
834 createThermoMechanicsProcess<2>(
841 process = ProcessLib::ThermoMechanics::
842 createThermoMechanicsProcess<3>(
843 name, *_mesh_vec[0], std::move(jacobian_assembler),
852 #ifdef OGS_BUILD_PROCESS_RICHARDSFLOW 853 if (type ==
"RICHARDS_FLOW")
856 name, *
_mesh_vec[0], std::move(jacobian_assembler),
862 #ifdef OGS_BUILD_PROCESS_RICHARDSMECHANICS 863 if (type ==
"RICHARDS_MECHANICS")
866 switch (process_config.getConfigParameter<
int>(
"dimension"))
869 process = ProcessLib::RichardsMechanics::
870 createRichardsMechanicsProcess<2>(
877 process = ProcessLib::RichardsMechanics::
878 createRichardsMechanicsProcess<3>(
879 name, *_mesh_vec[0], std::move(jacobian_assembler),
888 #ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPP 889 if (type ==
"TWOPHASE_FLOW_PP")
893 name, *
_mesh_vec[0], std::move(jacobian_assembler),
899 #ifdef OGS_BUILD_PROCESS_TWOPHASEFLOWWITHPRHO 900 if (type ==
"TWOPHASE_FLOW_PRHO")
904 name, *
_mesh_vec[0], std::move(jacobian_assembler),
910 #ifdef OGS_BUILD_PROCESS_THERMALTWOPHASEFLOWWITHPP 911 if (type ==
"THERMAL_TWOPHASE_WITH_PP")
915 name, *
_mesh_vec[0], std::move(jacobian_assembler),
922 OGS_FATAL(
"Unknown process type: %s", type.c_str());
927 [&name](std::unique_ptr<ProcessLib::Process>
const&
p) {
928 return p->name ==
name;
931 OGS_FATAL(
"The process name '%s' is not unique.", name.c_str());
938 std::string
const& output_directory)
940 DBUG(
"Reading time loop configuration.");
948 OGS_FATAL(
"Initialization of time loop failed.");
954 DBUG(
"Reading linear solver configuration.");
960 auto const name = conf.getConfigParameter<std::string>(
"name");
964 std::make_unique<GlobalLinearSolver>(
"", &conf),
965 "The linear solver name is not unique");
971 DBUG(
"Reading linear solver configuration.");
978 conf.getConfigParameter<std::string>(
"linear_solver");
981 "A linear solver with the given name does not exist.");
984 auto const name = conf.getConfigParameter<std::string>(
"name");
989 "The nonlinear solver name is not unique");
994 boost::optional<BaseLib::ConfigTree>
const& config)
1001 DBUG(
"Reading curves configuration.");
1004 for (
auto conf : config->getConfigSubtreeList(
"curve"))
1007 auto const name = conf.getConfigParameter<std::string>(
"name");
1013 "The curve name is not unique.");
1018 boost::optional<BaseLib::ConfigTree>
const& config,
1019 std::string
const& output_directory)
1026 #ifdef OGS_BUILD_PROCESS_COMPONENTTRANSPORT 1028 "Ready for initializing interface to a chemical solver for water " 1029 "chemistry calculation.");
1031 if (
auto const* component_transport_process =
dynamic_cast< 1035 auto const& process_id_to_component_name_map =
1036 component_transport_process->getProcessIDToComponentNameMap();
1038 auto const chemical_solver =
1040 config->getConfigAttribute<std::string>(
"chemical_solver");
1042 if (boost::iequals(chemical_solver,
"Phreeqc"))
1045 "Configuring phreeqc interface for water chemistry " 1046 "calculation using file-based approach.");
1050 *
_mesh_vec[0], process_id_to_component_name_map, *config,
1053 else if (boost::iequals(chemical_solver,
"PhreeqcKernel"))
1056 "Configuring phreeqc interface for water chemistry " 1057 "calculation by direct memory access.");
1061 *
_mesh_vec[0], process_id_to_component_name_map, *config,
1067 "Unknown chemical solver. Please specify either Phreeqc or " 1068 "PhreeqcKernel as the solver for water chemistry calculation " 1075 (void)output_directory;
1078 "The specified type of the process to be solved is not component " 1079 "transport process so that water chemistry calculation could not "
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 &curves)
std::unique_ptr< Process > createGroundwaterFlowProcess(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::string const &output_directory)
Container class for geometric objects.
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > _parameters
Buffer for each parameter config passed to the process.
bool containsIf(Container const &container, Predicate &&predicate)
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)
Definition of the BoostXmlGmlInterface class.
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 > 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::unique_ptr< AbstractJacobianAssembler > createJacobianAssembler(boost::optional< BaseLib::ConfigTree > const &config)
void parseLinearSolvers(BaseLib::ConfigTree const &config)
void parseCurves(boost::optional< BaseLib::ConfigTree > const &config)
std::vector< std::unique_ptr< MeshLib::Mesh > > _mesh_vec
std::string copyPathToFileName(const std::string &file_name, const std::string &source)
std::map< std::string, std::unique_ptr< NumLib::NonlinearSolverBase > > _nonlinear_solvers
void parseProcessVariables(BaseLib::ConfigTree const &process_variables_config)
std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag > createNonlinearSolver(GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)
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)
boost::optional< ParameterLib::CoordinateSystem > parseLocalCoordinateSystem(boost::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const ¶meters)
Definition of the Mesh class.
Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
void parseMedia(boost::optional< BaseLib::ConfigTree > const &media_config)
Parses media configuration and saves them in an object.
std::unique_ptr< ProcessLib::TimeLoop > _time_loop
The time loop used to solve this project's processes.
Definition of the GEOObjects class.
T getConfigParameter(std::string const ¶m) const
MeshLib::Mesh * readMeshFromFile(const std::string &file_name)
static const std::string zero_parameter_name
std::map< int, std::unique_ptr< MaterialPropertyLib::Medium > > _media
std::unique_ptr< ChemistryLib::ChemicalSolverInterface > _chemical_system
std::unique_ptr< Medium > createMedium(BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const ¶meters)
std::map< std::string, std::unique_ptr< GlobalLinearSolver > > _linear_solvers
boost::optional< ParameterLib::CoordinateSystem > _local_coordinate_system
std::vector< std::unique_ptr< ProcessLib::Process > > _processes
Single, constant value parameter.
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, boost::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
void parseProcesses(BaseLib::ConfigTree const &processes_config, std::string const &project_directory, std::string const &output_directory)
std::unique_ptr< ChemicalSolverInterface > createChemicalSolverInterface(MeshLib::Mesh const &mesh, std::vector< std::pair< int, std::string >> const &process_id_to_component_name_map, BaseLib::ConfigTree const &config, std::string const &output_directory)
std::unique_ptr< GeoLib::GEOObjects > readGeometry(std::string const &filename)
Definition of readMeshFromFile function.
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::unique_ptr< MaterialPropertyLib::Medium >> const &media)
std::vector< std::string > parseParameters(BaseLib::ConfigTree const ¶meters_config)
void parseNonlinearSolvers(BaseLib::ConfigTree const &config)
void parseChemicalSystem(boost::optional< BaseLib::ConfigTree > const &config, const std::string &output_directory)
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 >> const &meshes, std::unique_ptr< ChemistryLib::ChemicalSolverInterface > &phreeqc_io)
Builds a TimeLoop from the given configuration.
void parseTimeLoop(BaseLib::ConfigTree const &config, const std::string &output_directory)
Parses the time loop configuration.
void insertIfKeyUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
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, boost::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)
ConfigTree getConfigSubtree(std::string const &root) const
Range< SubtreeIterator > getConfigSubtreeList(std::string const &root) const
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, boost::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config)
unsigned getDimension(MeshLib::MeshElemType eleType)
boost::optional< T > getConfigAttributeOptional(std::string const &attr) const
boost::optional< T > getConfigParameterOptional(std::string const ¶m) const
#define OGS_FATAL(fmt,...)
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::string const &output_directory, std::map< int, std::unique_ptr< MaterialPropertyLib::Medium >> const &media)
boost::optional< ConfigTree > getConfigSubtreeOptional(std::string const &root) const
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::unique_ptr< MaterialPropertyLib::Medium >> const &media)
std::vector< std::unique_ptr< MeshLib::Mesh > > readMeshes(std::vector< std::string > const &filenames)
std::vector< ProcessLib::ProcessVariable > _process_variables
std::iterator_traits< InputIt >::reference findElementOrError(InputIt begin, InputIt end, Predicate predicate, std::string const &error="")
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)
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::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::string const &output_directory, std::map< int, std::unique_ptr< MaterialPropertyLib::Medium >> const &media)
std::unique_ptr< CurveType > createPiecewiseLinearCurve(BaseLib::ConfigTree const &config)
std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > _curves
std::unique_ptr< MeshLib::Mesh > readSingleMesh(BaseLib::ConfigTree const &mesh_config_parameter, std::string const &project_directory)