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> createGroundwaterFlowProcess( MeshLib::Mesh& mesh, Process::NonlinearSolver& nonlinear_solver, std::unique_ptr<Process::TimeDiscretization>&& time_discretization, std::vector<ProcessVariable> const& variables, std::vector<std::unique_ptr<ParameterBase>> const& parameters, BaseLib::ConfigTree const& config) { //! \ogs_file_param{process__type} config.checkConfigParameter("type", "GROUNDWATER_FLOW"); DBUG("Create GroundwaterFlowProcess."); // Process variable. auto process_variables = findProcessVariables( variables, config, {//! \ogs_file_param_special{process__GROUNDWATER_FLOW__process_variables__process_variable} "process_variable"}); // Hydraulic conductivity parameter. auto& hydraulic_conductivity = findParameter<double, MeshLib::Element const&>( config, //! \ogs_file_param_special{process__GROUNDWATER_FLOW__hydraulic_conductivity} "hydraulic_conductivity", parameters); DBUG("Use \'%s\' as hydraulic conductivity parameter.", hydraulic_conductivity.name.c_str()); GroundwaterFlowProcessData process_data{hydraulic_conductivity}; SecondaryVariableCollection secondary_variables{ //! \ogs_file_param{process__secondary_variables} config.getConfigSubtreeOptional("secondary_variables"), {//! \ogs_file_param_special{process__GROUNDWATER_FLOW__secondary_variables__darcy_velocity_x} "darcy_velocity_x", //! \ogs_file_param_special{process__GROUNDWATER_FLOW__secondary_variables__darcy_velocity_y} "darcy_velocity_y", //! \ogs_file_param_special{process__GROUNDWATER_FLOW__secondary_variables__darcy_velocity_z} "darcy_velocity_z"}}; ProcessOutput //! \ogs_file_param{process__output} process_output{config.getConfigSubtree("output"), process_variables, secondary_variables}; return std::unique_ptr<Process>{new GroundwaterFlowProcess{ mesh, nonlinear_solver, std::move(time_discretization), std::move(process_variables), std::move(process_data), std::move(secondary_variables), std::move(process_output)}}; }
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> 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}}; } }