std::unique_ptr<Process> createHeatConductionProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{process__type} config.checkConfigParameter("type", "HEAT_CONDUCTION"); DBUG("Create HeatConductionProcess."); // Process variable. auto process_variables = findProcessVariables( variables, config, {//! \ogs_file_param_special{process__HEAT_CONDUCTION__process_variables__process_variable} "process_variable"}); // thermal conductivity parameter. auto& thermal_conductivity = findParameter<double>( config, //! \ogs_file_param_special{process__HEAT_CONDUCTION__thermal_conductivity} "thermal_conductivity", parameters, 1); DBUG("Use \'%s\' as thermal conductivity parameter.", thermal_conductivity.name.c_str()); // heat capacity parameter. auto& heat_capacity = findParameter<double>( config, //! \ogs_file_param_special{process__HEAT_CONDUCTION__heat_capacity} "heat_capacity", parameters, 1); DBUG("Use \'%s\' as heat capacity parameter.", heat_capacity.name.c_str()); // density parameter. auto& density = findParameter<double>( config, //! \ogs_file_param_special{process__HEAT_CONDUCTION__density} "density", parameters, 1); DBUG("Use \'%s\' as density parameter.", density.name.c_str()); HeatConductionProcessData process_data{thermal_conductivity, heat_capacity, density}; SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"HeatConduction_temperature"}); ProcessLib::parseSecondaryVariables(config, secondary_variables, named_function_caller); return std::unique_ptr<Process>{new HeatConductionProcess{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller)}}; }
std::unique_ptr<Process> createTESProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{prj__processes__process__type} config.checkConfigParameter("type", "TES"); DBUG("Create TESProcess."); //! \ogs_file_param{prj__processes__process__TES__process_variables} auto const pv_config = config.getConfigSubtree("process_variables"); auto per_process_variables = findProcessVariables( variables, pv_config, { //! \ogs_file_param_special{prj__processes__process__TES__process_variables__fluid_pressure} "fluid_pressure", //! \ogs_file_param_special{prj__processes__process__TES__process_variables__temperature} "temperature", //! \ogs_file_param_special{prj__processes__process__TES__process_variables__vapour_mass_fraction} "vapour_mass_fraction"}); std::vector<std::vector<std::reference_wrapper<ProcessVariable>>> process_variables; process_variables.push_back(std::move(per_process_variables)); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"TES_pressure", "TES_temperature", "TES_vapour_mass_fraction"}); ProcessLib::createSecondaryVariables(config, secondary_variables, named_function_caller); return std::make_unique<TESProcess>( mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(secondary_variables), std::move(named_function_caller), config); }
std::unique_ptr<Process> createTwoPhaseFlowWithPPProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config, std::map<std::string, std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const& curves) { //! \ogs_file_param{prj__processes__process__type} config.checkConfigParameter("type", "TWOPHASE_FLOW_PP"); DBUG("Create TwoPhaseFlowProcess with PP model."); //! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PP__process_variables} auto const pv_config = config.getConfigSubtree("process_variables"); auto per_process_variables = findProcessVariables( variables, pv_config, {//! \ogs_file_param_special{prj__processes__process__TWOPHASE_FLOW_PP__process_variables__gas_pressure} "gas_pressure", //! \ogs_file_param_special{prj__processes__process__TWOPHASE_FLOW_PP__process_variables__capillary_pressure} "capillary_pressure"}); std::vector<std::vector<std::reference_wrapper<ProcessVariable>>> process_variables; process_variables.push_back(std::move(per_process_variables)); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"TwoPhaseFlow_pressure"}); ProcessLib::createSecondaryVariables(config, secondary_variables, named_function_caller); // Specific body force std::vector<double> const b = //! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PP__specific_body_force} config.getConfigParameter<std::vector<double>>("specific_body_force"); assert(!b.empty() && b.size() < 4); Eigen::VectorXd specific_body_force(b.size()); bool const has_gravity = MathLib::toVector(b).norm() > 0; if (has_gravity) std::copy_n(b.data(), b.size(), specific_body_force.data()); //! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PP__mass_lumping} auto const mass_lumping = config.getConfigParameter<bool>("mass_lumping"); auto& temperature = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__TWOPHASE_FLOW_PP__temperature} "temperature", parameters, 1); //! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PP__material_property} auto const& mat_config = config.getConfigSubtree("material_property"); auto const material_ids = materialIDs(mesh); if (material_ids) { INFO("The twophase flow is in heterogeneous porous media."); } else { INFO("The twophase flow is in homogeneous porous media."); } std::unique_ptr<TwoPhaseFlowWithPPMaterialProperties> material = createTwoPhaseFlowWithPPMaterialProperties(mat_config, material_ids, parameters); TwoPhaseFlowWithPPProcessData process_data{ specific_body_force, has_gravity, mass_lumping, temperature, std::move(material)}; return std::make_unique<TwoPhaseFlowWithPPProcess>( mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller), mat_config, curves); }
std::unique_ptr<Process> createSmallDeformationProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters, boost::optional<ParameterLib::CoordinateSystem> const& local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{prj__processes__process__type} config.checkConfigParameter("type", "SMALL_DEFORMATION_WITH_LIE"); DBUG("Create SmallDeformationProcess with LIE."); // Process variables //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__process_variables} auto const pv_conf = config.getConfigSubtree("process_variables"); auto range = //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__process_variables__process_variable} pv_conf.getConfigParameterList<std::string>("process_variable"); std::vector<std::reference_wrapper<ProcessVariable>> per_process_variables; std::size_t n_var_du = 0; for (std::string const& pv_name : range) { if (pv_name != "displacement" && pv_name.find("displacement_jump") != 0) { OGS_FATAL( "Found a process variable name '%s'. It should be " "'displacement' or 'displacement_jumpN' or " "'displacement_junctionN'"); } if (pv_name.find("displacement_jump") == 0) { n_var_du++; } auto variable = std::find_if(variables.cbegin(), variables.cend(), [&pv_name](ProcessVariable const& v) { return v.getName() == pv_name; }); if (variable == variables.end()) { OGS_FATAL( "Could not find process variable '%s' in the provided " "variables " "list for config tag <%s>.", pv_name.c_str(), "process_variable"); } DBUG("Found process variable '%s' for config tag <%s>.", variable->getName().c_str(), "process_variable"); per_process_variables.emplace_back( const_cast<ProcessVariable&>(*variable)); } if (n_var_du < 1) { OGS_FATAL("No displacement jump variables are specified"); } DBUG("Associate displacement with process variable '%s'.", per_process_variables.back().get().getName().c_str()); if (per_process_variables.back().get().getNumberOfComponents() != DisplacementDim) { OGS_FATAL( "Number of components of the process variable '%s' is different " "from the displacement dimension: got %d, expected %d", per_process_variables.back().get().getName().c_str(), per_process_variables.back().get().getNumberOfComponents(), DisplacementDim); } std::vector<std::vector<std::reference_wrapper<ProcessVariable>>> process_variables; process_variables.push_back(std::move(per_process_variables)); auto solid_constitutive_relations = MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>( parameters, local_coordinate_system, config); // Fracture constitutive relation. // read type; auto const fracture_model_config = //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_model} config.getConfigSubtree("fracture_model"); auto const frac_type = //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_model__type} fracture_model_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Fracture::FractureModelBase<DisplacementDim>> fracture_model = nullptr; if (frac_type == "LinearElasticIsotropic") { fracture_model = MaterialLib::Fracture::createLinearElasticIsotropic< DisplacementDim>(parameters, fracture_model_config); } else if (frac_type == "MohrCoulomb") { fracture_model = MaterialLib::Fracture::createMohrCoulomb<DisplacementDim>( parameters, fracture_model_config); } else if (frac_type == "CohesiveZoneModeI") { fracture_model = MaterialLib::Fracture::CohesiveZoneModeI::createCohesiveZoneModeI< DisplacementDim>(parameters, fracture_model_config); } else { OGS_FATAL( "Cannot construct fracture constitutive relation of given type " "'%s'.", frac_type.c_str()); } // Fracture properties std::vector<FractureProperty> fracture_properties; for ( auto fracture_properties_config : //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties} config.getConfigSubtreeList("fracture_properties")) { fracture_properties.emplace_back( fracture_properties.size(), //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties__material_id} fracture_properties_config.getConfigParameter<int>("material_id"), ParameterLib::findParameter<double>( //! \ogs_file_param_special{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__fracture_properties__initial_aperture} fracture_properties_config, "initial_aperture", parameters, 1)); } if (n_var_du < fracture_properties.size()) { OGS_FATAL( "The number of displacement jumps and the number of " "<fracture_properties> " "are not consistent"); } // Reference temperature const auto& reference_temperature = //! \ogs_file_param{prj__processes__process__SMALL_DEFORMATION_WITH_LIE__reference_temperature} config.getConfigParameter<double>( "reference_temperature", std::numeric_limits<double>::quiet_NaN()); SmallDeformationProcessData<DisplacementDim> process_data( materialIDs(mesh), std::move(solid_constitutive_relations), std::move(fracture_model), std::move(fracture_properties), reference_temperature); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"SmallDeformation_displacement"}); ProcessLib::createSecondaryVariables(config, secondary_variables, named_function_caller); return std::make_unique<SmallDeformationProcess<DisplacementDim>>( mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller)); }
std::unique_ptr<Process> createHydroMechanicsProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{prj__processes__process__type} config.checkConfigParameter("type", "HYDRO_MECHANICS"); DBUG("Create HydroMechanicsProcess."); // Process variable. //! \ogs_file_param{prj__processes__process__HYDRO_MECHANICS__process_variables} auto const pv_config = config.getConfigSubtree("process_variables"); auto process_variables = findProcessVariables( variables, pv_config, { //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__process_variables__pressure} "pressure", //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__process_variables__displacement} "displacement" }); DBUG("Associate displacement with process variable \'%s\'.", process_variables[1].get().getName().c_str()); if (process_variables[1].get().getNumberOfComponents() != DisplacementDim) { OGS_FATAL( "Number of components of the process variable '%s' is different " "from the displacement dimension: got %d, expected %d", process_variables[1].get().getName().c_str(), process_variables[1].get().getNumberOfComponents(), DisplacementDim); } DBUG("Associate pressure with process variable \'%s\'.", process_variables[0].get().getName().c_str()); if (process_variables[0].get().getNumberOfComponents() != 1) { OGS_FATAL( "Pressure process variable '%s' is not a scalar variable but has " "%d components.", process_variables[0].get().getName().c_str(), process_variables[0].get().getNumberOfComponents()); } // Constitutive relation. // read type; auto const constitutive_relation_config = //! \ogs_file_param{prj__processes__process__HYDRO_MECHANICS__constitutive_relation} config.getConfigSubtree("constitutive_relation"); auto const type = //! \ogs_file_param{prj__processes__process__HYDRO_MECHANICS__constitutive_relation__type} constitutive_relation_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Solids::MechanicsBase<DisplacementDim>> material = nullptr; if (type == "LinearElasticIsotropic") { material = MaterialLib::Solids::createLinearElasticIsotropic<DisplacementDim>( parameters, constitutive_relation_config); } else { OGS_FATAL( "Cannot construct constitutive relation of given type \'%s\'.", type.c_str()); } // Intrinsic permeability auto& intrinsic_permeability = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__intrinsic_permeability} "intrinsic_permeability", parameters, 1); DBUG("Use \'%s\' as intrinsic conductivity parameter.", intrinsic_permeability.name.c_str()); // Storage coefficient auto& specific_storage = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__specific_storage} "specific_storage", parameters, 1); DBUG("Use \'%s\' as storage coefficient parameter.", specific_storage.name.c_str()); // Fluid viscosity auto& fluid_viscosity = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__fluid_viscosity} "fluid_viscosity", parameters, 1); DBUG("Use \'%s\' as fluid viscosity parameter.", fluid_viscosity.name.c_str()); // Fluid density auto& fluid_density = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__fluid_density} "fluid_density", parameters, 1); DBUG("Use \'%s\' as fluid density parameter.", fluid_density.name.c_str()); // Biot coefficient auto& biot_coefficient = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__biot_coefficient} "biot_coefficient", parameters, 1); DBUG("Use \'%s\' as Biot coefficient parameter.", biot_coefficient.name.c_str()); // Porosity auto& porosity = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__porosity} "porosity", parameters, 1); DBUG("Use \'%s\' as porosity parameter.", porosity.name.c_str()); // Solid density auto& solid_density = findParameter<double>( config, //! \ogs_file_param_special{prj__processes__process__HYDRO_MECHANICS__solid_density} "solid_density", parameters, 1); DBUG("Use \'%s\' as solid density parameter.", solid_density.name.c_str()); // Specific body force Eigen::Matrix<double, DisplacementDim, 1> specific_body_force; { std::vector<double> const b = //! \ogs_file_param{prj__processes__process__HYDRO_MECHANICS__specific_body_force} config.getConfigParameter<std::vector<double>>( "specific_body_force"); if (specific_body_force.size() != DisplacementDim) OGS_FATAL( "The size of the specific body force vector does not match the " "displacement dimension. Vector size is %d, displacement " "dimension is %d", specific_body_force.size(), DisplacementDim); std::copy_n(b.data(), b.size(), specific_body_force.data()); } HydroMechanicsProcessData<DisplacementDim> process_data{ std::move(material), intrinsic_permeability, specific_storage, fluid_viscosity, fluid_density, biot_coefficient, porosity, solid_density, specific_body_force}; SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"HydroMechanics_displacement"}); ProcessLib::parseSecondaryVariables(config, secondary_variables, named_function_caller); return std::unique_ptr<HydroMechanicsProcess<DisplacementDim>> { new HydroMechanicsProcess<DisplacementDim>{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller) } }; }
std::unique_ptr<Process> createLiquidFlowProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{process__type} config.checkConfigParameter("type", "LIQUID_FLOW"); DBUG("Create LiquidFlowProcess."); // Process variable. auto process_variables = findProcessVariables( variables, config, {//! \ogs_file_param_special{process__LIQUID_FLOW__process_variables__process_variable} "process_variable"}); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller({"LiquidFlow_pressure"}); ProcessLib::parseSecondaryVariables(config, secondary_variables, named_function_caller); // Get the gravity vector for the Darcy velocity //! \ogs_file_param{process__LIQUID_FLOW__darcy_gravity} auto const& darcy_g_config = config.getConfigSubtree("darcy_gravity"); const int gravity_axis_id_input = //! \ogs_file_param_special{process__LIQUID_FLOW__darcy_gravity_axis_id} darcy_g_config.getConfigParameter<int>("axis_id"); assert(gravity_axis_id_input < static_cast<int>(mesh.getDimension())); const double g = //! \ogs_file_param_special{process__LIQUID_FLOW__darcy_gravity_g} darcy_g_config.getConfigParameter<double>("g"); assert(g >= 0.); const int gravity_axis_id = (g == 0.) ? -1 : gravity_axis_id_input; //! \ogs_file_param{process__LIQUID_FLOW__material_property} auto const& mat_config = config.getConfigSubtree("material_property"); auto const& mat_ids = mesh.getProperties().getPropertyVector<int>("MaterialIDs"); if (mat_ids) { INFO("The liquid flow is in heterogeneous porous media."); const bool has_material_ids = true; return std::unique_ptr<Process>{new LiquidFlowProcess{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(secondary_variables), std::move(named_function_caller), *mat_ids, has_material_ids, gravity_axis_id, g, mat_config}}; } else { INFO("The liquid flow is in homogeneous porous media."); MeshLib::Properties dummy_property; // For a reference argument of LiquidFlowProcess(...). auto const& dummy_property_vector = dummy_property.createNewPropertyVector<int>( "MaterialIDs", MeshLib::MeshItemType::Cell, 1); // Since dummy_property_vector is only visible in this function, // the following constant, has_material_ids, is employed to indicate // that material_ids does not exist. const bool has_material_ids = false; return std::unique_ptr<Process>{new LiquidFlowProcess{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(secondary_variables), std::move(named_function_caller), *dummy_property_vector, has_material_ids, gravity_axis_id, g, mat_config}}; } }
std::unique_ptr<Process> createSmallDeformationProcess( MeshLib::Mesh& mesh, std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, unsigned const integration_order, BaseLib::ConfigTree const& config) { //! \ogs_file_param{process__type} config.checkConfigParameter("type", "SMALL_DEFORMATION_WITH_LIE"); DBUG("Create SmallDeformationProcess with LIE."); // Process variables auto const pv_conf = config.getConfigSubtree("process_variables"); auto range = pv_conf.getConfigParameterList<std::string>("process_variable"); std::vector<std::reference_wrapper<ProcessVariable>> process_variables; for (std::string const& pv_name : range) { if (pv_name != "displacement" && pv_name.find("displacement_jump")==std::string::npos) OGS_FATAL("Found a process variable name '%s'. It should be 'displacement' or 'displacement_jumpN'"); auto variable = std::find_if( variables.cbegin(), variables.cend(), [&pv_name](ProcessVariable const& v) { return v.getName() == pv_name; }); if (variable == variables.end()) { OGS_FATAL( "Could not find process variable '%s' in the provided variables " "list for config tag <%s>.", pv_name.c_str(), "process_variable"); } DBUG("Found process variable \'%s\' for config tag <%s>.", variable->getName().c_str(), "process_variable"); process_variables.emplace_back(const_cast<ProcessVariable&>(*variable)); } if (process_variables.size() > 2) OGS_FATAL("Currently only one displacement jump is supported"); DBUG("Associate displacement with process variable \'%s\'.", process_variables.back().get().getName().c_str()); if (process_variables.back().get().getNumberOfComponents() != DisplacementDim) { OGS_FATAL( "Number of components of the process variable '%s' is different " "from the displacement dimension: got %d, expected %d", process_variables.back().get().getName().c_str(), process_variables.back().get().getNumberOfComponents(), DisplacementDim); } // Constitutive relation. // read type; auto const constitutive_relation_config = //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__constitutive_relation} config.getConfigSubtree("constitutive_relation"); auto const type = constitutive_relation_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Solids::MechanicsBase<DisplacementDim>> material = nullptr; if (type == "LinearElasticIsotropic") { material = MaterialLib::Solids::createLinearElasticIsotropic<DisplacementDim>( parameters, constitutive_relation_config); } else { OGS_FATAL( "Cannot construct constitutive relation of given type \'%s\'.", type.c_str()); } // Fracture constitutive relation. // read type; auto const fracture_constitutive_relation_config = //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__constitutive_relation} config.getConfigSubtree("fracture_constitutive_relation"); auto const frac_type = fracture_constitutive_relation_config.peekConfigParameter<std::string>("type"); std::unique_ptr<MaterialLib::Fracture::FractureModelBase<DisplacementDim>> fracture_model = nullptr; if (frac_type == "LinearElasticIsotropic") { fracture_model = MaterialLib::Fracture::createLinearElasticIsotropic<DisplacementDim>( parameters, fracture_constitutive_relation_config); } else if (frac_type == "MohrCoulomb") { fracture_model = MaterialLib::Fracture::createMohrCoulomb<DisplacementDim>( parameters, fracture_constitutive_relation_config); } else { OGS_FATAL( "Cannot construct fracture constitutive relation of given type \'%s\'.", frac_type.c_str()); } // Fracture properties //! \ogs_file_param{process__SMALL_DEFORMATION_WITH_LIE__fracture_properties} auto fracture_properties_config = config.getConfigSubtree("fracture_properties"); auto ¶_b0 = ProcessLib::findParameter<double>(fracture_properties_config, "initial_aperture", parameters, 1); std::unique_ptr<FractureProperty> frac_prop(new FractureProperty()); frac_prop->mat_id = fracture_properties_config.getConfigParameter<int>("material_id"); frac_prop->aperture0 = ¶_b0; SmallDeformationProcessData<DisplacementDim> process_data( std::move(material), std::move(fracture_model), std::move(frac_prop)); SecondaryVariableCollection secondary_variables; NumLib::NamedFunctionCaller named_function_caller( {"SmallDeformation_displacement"}); ProcessLib::parseSecondaryVariables(config, secondary_variables, named_function_caller); return std::unique_ptr<SmallDeformationProcess<DisplacementDim>>{ new SmallDeformationProcess<DisplacementDim>{ mesh, std::move(jacobian_assembler), parameters, integration_order, std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(named_function_caller)}}; }