本文整理汇总了C++中baselib::ConfigTree::getConfigSubtree方法的典型用法代码示例。如果您正苦于以下问题:C++ ConfigTree::getConfigSubtree方法的具体用法?C++ ConfigTree::getConfigSubtree怎么用?C++ ConfigTree::getConfigSubtree使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类baselib::ConfigTree
的用法示例。
在下文中一共展示了ConfigTree::getConfigSubtree方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: createFluidProperties
std::unique_ptr<FluidProperties> createFluidProperties(
BaseLib::ConfigTree const& config)
{
//! \ogs_file_param{material__fluid__density}
auto const& rho_conf = config.getConfigSubtree("density");
auto liquid_density = MaterialLib::Fluid::createFluidDensityModel(rho_conf);
//! \ogs_file_param{material__fluid__viscosity}
auto const& mu_conf = config.getConfigSubtree("viscosity");
auto viscosity = MaterialLib::Fluid::createViscosityModel(mu_conf);
const bool is_mu_density_dependent =
(viscosity->getName().find("density dependent") != std::string::npos);
bool is_cp_density_dependent = false;
std::unique_ptr<MaterialLib::Fluid::FluidProperty> specific_heat_capacity =
nullptr;
auto heat_capacity__opt_conf =
//! \ogs_file_param{material__fluid__specific_heat_capacity}
config.getConfigSubtreeOptional("specific_heat_capacity");
if (heat_capacity__opt_conf)
{
const auto& heat_capacity_conf = *heat_capacity__opt_conf;
specific_heat_capacity =
createSpecificFluidHeatCapacityModel(heat_capacity_conf);
is_cp_density_dependent =
(specific_heat_capacity->getName().find("density dependent") !=
std::string::npos);
}
bool is_KT_density_dependent = false;
std::unique_ptr<MaterialLib::Fluid::FluidProperty> thermal_conductivity =
nullptr;
auto const& thermal_conductivity_opt_conf =
//! \ogs_file_param{material__fluid__thermal_conductivity}
config.getConfigSubtreeOptional("thermal_conductivity");
if (thermal_conductivity_opt_conf)
{
auto const& thermal_conductivity_conf = *thermal_conductivity_opt_conf;
thermal_conductivity =
MaterialLib::Fluid::createFluidThermalConductivityModel(
thermal_conductivity_conf);
is_KT_density_dependent =
(specific_heat_capacity->getName().find("density dependent") !=
std::string::npos);
}
if (is_mu_density_dependent || is_cp_density_dependent ||
is_KT_density_dependent)
return std::make_unique<
MaterialLib::Fluid::FluidPropertiesWithDensityDependentModels>(
std::move(liquid_density), std::move(viscosity),
std::move(specific_heat_capacity), std::move(thermal_conductivity),
is_mu_density_dependent, is_cp_density_dependent,
is_KT_density_dependent);
return std::make_unique<
MaterialLib::Fluid::PrimaryVariableDependentFluidProperties>(
std::move(liquid_density), std::move(viscosity),
std::move(specific_heat_capacity), std::move(thermal_conductivity));
}
示例2: createBoreholeGeometry
static std::tuple<BoreholeGeometry,
RefrigerantProperties,
GroutParameters,
FlowAndTemperatureControl,
PipeConfigurationCoaxial>
parseBHECoaxialConfig(
BaseLib::ConfigTree const& config,
std::map<std::string,
std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
curves)
{
auto const borehole_geometry =
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__borehole}
createBoreholeGeometry(config.getConfigSubtree("borehole"));
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__pipes}
auto const& pipes_config = config.getConfigSubtree("pipes");
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__pipes__outer}
Pipe const outer_pipe = createPipe(pipes_config.getConfigSubtree("outer"));
Pipe const inner_pipe =
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__pipes__inner}
createPipe(pipes_config.getConfigSubtree("inner"));
const auto pipe_longitudinal_dispersion_length =
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__pipes__longitudinal_dispersion_length}
pipes_config.getConfigParameter<double>(
"longitudinal_dispersion_length");
PipeConfigurationCoaxial const pipes{inner_pipe, outer_pipe,
pipe_longitudinal_dispersion_length};
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__grout}
auto const grout = createGroutParameters(config.getConfigSubtree("grout"));
auto const refrigerant =
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__refrigerant}
createRefrigerantProperties(config.getConfigSubtree("refrigerant"));
auto const flowAndTemperatureControl = createFlowAndTemperatureControl(
//! \ogs_file_param{prj__processes__process__HEAT_TRANSPORT_BHE__borehole_heat_exchangers__borehole_heat_exchanger__flow_and_temperature_control}
config.getConfigSubtree("flow_and_temperature_control"),
curves,
refrigerant);
return {borehole_geometry, refrigerant, grout, flowAndTemperatureControl,
pipes};
}
示例3: createGroundwaterFlowProcess
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)}};
}
示例4: createWettingPhaseVanGenuchten
std::unique_ptr<RelativePermeability> createRelativePermeabilityModel(
BaseLib::ConfigTree const& config)
{
//! \ogs_file_param{material__porous_medium__relative_permeability__type}
auto const type = config.peekConfigParameter<std::string>("type");
if (type == "WettingPhaseVanGenuchten")
{
return createWettingPhaseVanGenuchten(config);
}
if (type == "NonWettingPhaseVanGenuchten")
{
return createNonWettingPhaseVanGenuchten(config);
}
if (type == "WettingPhaseBrooksCoreyOilGas")
{
return createWettingPhaseBrooksCoreyOilGas(config);
}
if (type == "NonWettingPhaseBrooksCoreyOilGas")
{
return createNonWettingPhaseBrooksCoreyOilGas(config);
}
if (type == "Curve")
{
//! \ogs_file_param{material__porous_medium__relative_permeability__type}
config.checkConfigParameter("type", "Curve");
//! \ogs_file_param{material__porous_medium__relative_permeability__Curve__curve}
auto const& curve_config = config.getConfigSubtree("curve");
auto curve = MathLib::createPiecewiseLinearCurve<MathLib
::PiecewiseLinearInterpolation>(curve_config);
return std::make_unique<RelativePermeabilityCurve>(std::move(curve));
}
OGS_FATAL(
"The relative permeability model %s is unavailable.\n"
"The available models are:"
"\n\tWettingPhaseVanGenuchten,"
"\n\tNonWettingPhaseVanGenuchten,"
"\n\tWettingPhaseBrooksCoreyOilGas,"
"\n\tNonWettingPhaseBrooksCoreyOilGas,",
"\n\tCurve.\n",
type.data());
}
示例5:
std::vector<std::reference_wrapper<ProcessVariable>>
findProcessVariables(
std::vector<ProcessVariable> const& variables,
BaseLib::ConfigTree const& process_config,
std::initializer_list<std::string> tag_names)
{
std::vector<std::reference_wrapper<ProcessVariable>> vars;
vars.reserve(tag_names.size());
//! \ogs_file_param{process__process_variables}
auto const pv_conf = process_config.getConfigSubtree("process_variables");
for (auto const& tag : tag_names) {
vars.emplace_back(findProcessVariable(variables, pv_conf, tag));
}
return vars;
}
示例6: 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);
}
示例7: DBUG
std::unique_ptr<TwoPhaseFlowWithPrhoMaterialProperties>
createTwoPhaseFlowPrhoMaterialProperties(
BaseLib::ConfigTree const& config,
boost::optional<MeshLib::PropertyVector<int> const&> material_ids,
std::vector<std::unique_ptr<ParameterBase>> const& parameters)
{
DBUG("Reading material properties of two-phase flow process.");
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__fluid}
auto const& fluid_config = config.getConfigSubtree("fluid");
// Get fluid properties
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__liquid_density}
auto const& rho_conf = fluid_config.getConfigSubtree("liquid_density");
auto _liquid_density =
MaterialLib::Fluid::createFluidDensityModel(rho_conf);
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__gas_density}
auto const& rho_gas_conf = fluid_config.getConfigSubtree("gas_density");
auto _gas_density =
MaterialLib::Fluid::createFluidDensityModel(rho_gas_conf);
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__liquid_viscosity}
auto const& mu_conf = fluid_config.getConfigSubtree("liquid_viscosity");
auto _viscosity = MaterialLib::Fluid::createViscosityModel(mu_conf);
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__gas_viscosity}
auto const& mu_gas_conf = fluid_config.getConfigSubtree("gas_viscosity");
auto _gas_viscosity = MaterialLib::Fluid::createViscosityModel(mu_gas_conf);
// Get porous properties
std::vector<int> mat_ids;
std::vector<int> mat_krel_ids;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
_intrinsic_permeability_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
_porosity_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
_storage_models;
std::vector<
std::unique_ptr<MaterialLib::PorousMedium::CapillaryPressureSaturation>>
_capillary_pressure_models;
std::vector<
std::unique_ptr<MaterialLib::PorousMedium::RelativePermeability>>
_relative_permeability_models;
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium}
auto const& poro_config = config.getConfigSubtree("porous_medium");
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium}
for (auto const& conf : poro_config.getConfigSubtreeList("porous_medium"))
{
//! \ogs_file_attr{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__id}
auto const id = conf.getConfigAttributeOptional<int>("id");
mat_ids.push_back(*id);
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__permeability}
auto const& permeability_conf = conf.getConfigSubtree("permeability");
_intrinsic_permeability_models.emplace_back(
MaterialLib::PorousMedium::createPermeabilityModel(
permeability_conf, parameters));
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__porosity}
auto const& porosity_conf = conf.getConfigSubtree("porosity");
auto n = MaterialLib::PorousMedium::createPorosityModel(porosity_conf,
parameters);
_porosity_models.emplace_back(std::move(n));
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__storage}
auto const& storage_conf = conf.getConfigSubtree("storage");
auto beta = MaterialLib::PorousMedium::createStorageModel(storage_conf);
_storage_models.emplace_back(std::move(beta));
auto const& capillary_pressure_conf =
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__capillary_pressure}
conf.getConfigSubtree("capillary_pressure");
auto pc = MaterialLib::PorousMedium::createCapillaryPressureModel(
capillary_pressure_conf);
_capillary_pressure_models.emplace_back(std::move(pc));
auto const& krel_config =
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__relative_permeability}
conf.getConfigSubtree("relative_permeability");
for (
auto const& krel_conf :
//! \ogs_file_param{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__relative_permeability__relative_permeability}
krel_config.getConfigSubtreeList("relative_permeability"))
{
auto const krel_id =
//! \ogs_file_attr{prj__processes__process__TWOPHASE_FLOW_PRHO__material_property__porous_medium__porous_medium__relative_permeability__relative_permeability__id}
krel_conf.getConfigAttributeOptional<int>("id");
mat_krel_ids.push_back(*krel_id);
auto krel_n =
MaterialLib::PorousMedium::createRelativePermeabilityModel(
krel_conf);
_relative_permeability_models.emplace_back(std::move(krel_n));
}
BaseLib::reorderVector(_relative_permeability_models, mat_krel_ids);
}
BaseLib::reorderVector(_intrinsic_permeability_models, mat_ids);
BaseLib::reorderVector(_porosity_models, mat_ids);
BaseLib::reorderVector(_storage_models, mat_ids);
//.........这里部分代码省略.........
示例8: named_function_caller
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);
}
示例9: if
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);
}
//.........这里部分代码省略.........
示例10: DBUG
std::unique_ptr<RichardsFlowMaterialProperties>
createRichardsFlowMaterialProperties(
BaseLib::ConfigTree const& config,
MeshLib::PropertyVector<int> const* const material_ids,
std::vector<std::unique_ptr<ParameterBase>> const& parameters)
{
DBUG("Reading material properties of Richards flow process.");
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__fluid}
auto const& fluid_config = config.getConfigSubtree("fluid");
auto fluid_properties =
MaterialLib::Fluid::createFluidProperties(fluid_config);
// Get porous properties
std::vector<int> mat_ids;
std::vector<int> mat_krel_ids;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
intrinsic_permeability_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
porosity_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
storage_models;
std::vector<
std::unique_ptr<MaterialLib::PorousMedium::CapillaryPressureSaturation>>
capillary_pressure_models;
std::vector<
std::unique_ptr<MaterialLib::PorousMedium::RelativePermeability>>
relative_permeability_models;
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium}
auto const& poro_config = config.getConfigSubtree("porous_medium");
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium}
for (auto const& conf : poro_config.getConfigSubtreeList("porous_medium"))
{
//! \ogs_file_attr{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__id}
auto const id = conf.getConfigAttributeOptional<int>("id");
mat_ids.push_back(*id);
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__permeability}
auto const& permeability_conf = conf.getConfigSubtree("permeability");
intrinsic_permeability_models.emplace_back(
MaterialLib::PorousMedium::createPermeabilityModel(
permeability_conf, parameters));
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__porosity}
auto const& porosity_conf = conf.getConfigSubtree("porosity");
auto n = MaterialLib::PorousMedium::createPorosityModel(porosity_conf,
parameters);
porosity_models.emplace_back(std::move(n));
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__storage}
auto const& storage_conf = conf.getConfigSubtree("storage");
auto beta = MaterialLib::PorousMedium::createStorageModel(storage_conf);
storage_models.emplace_back(std::move(beta));
auto const& capillary_pressure_conf =
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__capillary_pressure}
conf.getConfigSubtree("capillary_pressure");
auto pc = MaterialLib::PorousMedium::createCapillaryPressureModel(
capillary_pressure_conf);
capillary_pressure_models.emplace_back(std::move(pc));
auto const& krel_config =
//! \ogs_file_param{prj__processes__process__RICHARDS_FLOW__material_property__porous_medium__porous_medium__relative_permeability}
conf.getConfigSubtree("relative_permeability");
auto krel = MaterialLib::PorousMedium::createRelativePermeabilityModel(
krel_config);
relative_permeability_models.emplace_back(std::move(krel));
}
BaseLib::reorderVector(intrinsic_permeability_models, mat_ids);
BaseLib::reorderVector(porosity_models, mat_ids);
BaseLib::reorderVector(storage_models, mat_ids);
return std::unique_ptr<RichardsFlowMaterialProperties>{
new RichardsFlowMaterialProperties{
material_ids, std::move(fluid_properties),
std::move(intrinsic_permeability_models),
std::move(porosity_models), std::move(storage_models),
std::move(capillary_pressure_models),
std::move(relative_permeability_models)}};
}
示例11: named_function_caller
std::unique_ptr<Process> createPhaseFieldProcess(
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", "PHASE_FIELD");
DBUG("Create PhaseFieldProcess.");
auto const staggered_scheme =
//! \ogs_file_param{prj__processes__process__PHASE_FIELD__coupling_scheme}
config.getConfigParameterOptional<std::string>("coupling_scheme");
const bool use_monolithic_scheme =
!(staggered_scheme && (*staggered_scheme == "staggered"));
// Process variable.
//! \ogs_file_param{prj__processes__process__PHASE_FIELD__process_variables}
auto const pv_config = config.getConfigSubtree("process_variables");
ProcessVariable* variable_ph;
ProcessVariable* variable_u;
std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
process_variables;
if (use_monolithic_scheme) // monolithic scheme.
{
auto per_process_variables = findProcessVariables(
variables, pv_config,
{//! \ogs_file_param_special{prj__processes__process__PHASE_FIELD__process_variables__phasefield}
"phasefield",
//! \ogs_file_param_special{prj__processes__process__PHASE_FIELD__process_variables__displacement}
"displacement"});
variable_ph = &per_process_variables[0].get();
variable_u = &per_process_variables[1].get();
process_variables.push_back(std::move(per_process_variables));
}
else // staggered scheme.
{
using namespace std::string_literals;
for (auto const& variable_name : {"phasefield"s, "displacement"s})
{
auto per_process_variables =
findProcessVariables(variables, pv_config, {variable_name});
process_variables.push_back(std::move(per_process_variables));
}
variable_ph = &process_variables[0][0].get();
variable_u = &process_variables[1][0].get();
}
DBUG("Associate displacement with process variable \'%s\'.",
variable_u->getName().c_str());
if (variable_u->getNumberOfComponents() != DisplacementDim)
{
OGS_FATAL(
"Number of components of the process variable '%s' is different "
"from the displacement dimension: got %d, expected %d",
variable_u->getName().c_str(),
variable_u->getNumberOfComponents(),
DisplacementDim);
}
DBUG("Associate phase field with process variable \'%s\'.",
variable_ph->getName().c_str());
if (variable_ph->getNumberOfComponents() != 1)
{
OGS_FATAL(
"Pressure process variable '%s' is not a scalar variable but has "
"%d components.",
variable_ph->getName().c_str(),
variable_ph->getNumberOfComponents());
}
// Constitutive relation.
// read type;
auto const constitutive_relation_config =
//! \ogs_file_param{prj__processes__process__PHASE_FIELD__constitutive_relation}
config.getConfigSubtree("constitutive_relation");
auto const phasefield_parameters_config =
//! \ogs_file_param{prj__processes__process__PHASE_FIELD__phasefield_parameters}
config.getConfigSubtree("phasefield_parameters");
auto const type =
//! \ogs_file_param{prj__processes__process__PHASE_FIELD__constitutive_relation__type}
constitutive_relation_config.peekConfigParameter<std::string>("type");
std::unique_ptr<MaterialLib::Solids::PhaseFieldExtension<DisplacementDim>>
material = nullptr;
if (type == "LinearElasticIsotropic")
{
auto elastic_model = MaterialLib::Solids::createLinearElasticIsotropic<
DisplacementDim>(parameters, constitutive_relation_config);
material =
std::make_unique<MaterialLib::Solids::LinearElasticIsotropicPhaseField<
DisplacementDim>>(std::move(elastic_model->getMaterialProperties()));
}
//.........这里部分代码省略.........
示例12: Process
TESProcess::TESProcess(
MeshLib::Mesh& mesh,
Process::NonlinearSolver& nonlinear_solver,
std::unique_ptr<Process::TimeDiscretization>&&
time_discretization,
std::vector<std::reference_wrapper<ProcessVariable>>&& process_variables,
SecondaryVariableCollection&& secondary_variables,
ProcessOutput&& process_output,
const BaseLib::ConfigTree& config)
: Process(
mesh, nonlinear_solver, std::move(time_discretization),
std::move(process_variables), std::move(secondary_variables),
std::move(process_output))
{
DBUG("Create TESProcess.");
// physical parameters for local assembly
{
std::vector<std::pair<std::string, double*>> params{
{"fluid_specific_heat_source",
&_assembly_params.fluid_specific_heat_source},
{"fluid_specific_isobaric_heat_capacity", &_assembly_params.cpG},
{"solid_specific_heat_source",
&_assembly_params.solid_specific_heat_source},
{"solid_heat_conductivity", &_assembly_params.solid_heat_cond},
{"solid_specific_isobaric_heat_capacity", &_assembly_params.cpS},
{"tortuosity", &_assembly_params.tortuosity},
{"diffusion_coefficient",
&_assembly_params.diffusion_coefficient_component},
{"porosity", &_assembly_params.poro},
{"solid_density_dry", &_assembly_params.rho_SR_dry},
{"solid_density_initial", &_assembly_params.initial_solid_density}};
for (auto const& p : params)
{
if (auto const par = config.getConfigParameterOptional<double>(p.first))
{
DBUG("setting parameter `%s' to value `%g'", p.first.c_str(),
*par);
*p.second = *par;
}
}
}
// characteristic values of primary variables
{
std::vector<std::pair<std::string, Trafo*>> const params{
{"characteristic_pressure", &_assembly_params.trafo_p},
{"characteristic_temperature", &_assembly_params.trafo_T},
{"characteristic_vapour_mass_fraction", &_assembly_params.trafo_x}};
for (auto const& p : params)
{
if (auto const par = config.getConfigParameterOptional<double>(p.first))
{
INFO("setting parameter `%s' to value `%g'", p.first.c_str(),
*par);
*p.second = Trafo{*par};
}
}
}
// permeability
if (auto par =
config.getConfigParameterOptional<double>("solid_hydraulic_permeability"))
{
DBUG(
"setting parameter `solid_hydraulic_permeability' to isotropic "
"value `%g'",
*par);
const auto dim = mesh.getDimension();
_assembly_params.solid_perm_tensor =
Eigen::MatrixXd::Identity(dim, dim) * (*par);
}
// reactive system
_assembly_params.react_sys = Adsorption::AdsorptionReaction::newInstance(
config.getConfigSubtree("reactive_system"));
// debug output
if (auto const param =
config.getConfigParameterOptional<bool>("output_element_matrices"))
{
DBUG("output_element_matrices: %s", (*param) ? "true" : "false");
_assembly_params.output_element_matrices = *param;
}
// TODO somewhere else
/*
if (auto const param =
config.getConfigParameterOptional<bool>("output_global_matrix"))
{
DBUG("output_global_matrix: %s", (*param) ? "true" : "false");
this->_process_output.output_global_matrix = *param;
}
*/
}
示例13: DBUG
std::unique_ptr<LiquidFlowMaterialProperties>
createLiquidFlowMaterialProperties(
BaseLib::ConfigTree const& config,
std::vector<std::unique_ptr<ParameterBase>> const& parameters,
bool const has_material_ids,
MeshLib::PropertyVector<int> const& material_ids)
{
DBUG("Reading material properties of liquid flow process.");
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__fluid}
auto const& fluid_config = config.getConfigSubtree("fluid");
auto fluid_properties =
MaterialLib::Fluid::createFluidProperties(fluid_config);
// Get porous properties
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
intrinsic_permeability_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
porosity_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
storage_models;
std::vector<int> mat_ids;
auto const& porous_medium_configs =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium}
config.getConfigSubtree("porous_medium");
for (
auto const& porous_medium_config :
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium}
porous_medium_configs.getConfigSubtreeList("porous_medium"))
{
//! \ogs_file_attr{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__id}
auto const id = porous_medium_config.getConfigAttribute<int>("id");
mat_ids.push_back(id);
auto const& permeability_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__permeability}
porous_medium_config.getConfigSubtree("permeability");
intrinsic_permeability_models.emplace_back(
MaterialLib::PorousMedium::createPermeabilityModel(
permeability_config, parameters));
auto const& porosity_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__porosity}
porous_medium_config.getConfigSubtree("porosity");
auto n = MaterialLib::PorousMedium::createPorosityModel(porosity_config,
parameters);
porosity_models.emplace_back(std::move(n));
auto const& storage_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__storage}
porous_medium_config.getConfigSubtree("storage");
auto beta =
MaterialLib::PorousMedium::createStorageModel(storage_config);
storage_models.emplace_back(std::move(beta));
}
BaseLib::reorderVector(intrinsic_permeability_models, mat_ids);
BaseLib::reorderVector(porosity_models, mat_ids);
BaseLib::reorderVector(storage_models, mat_ids);
return std::make_unique<LiquidFlowMaterialProperties>(
std::move(fluid_properties), std::move(intrinsic_permeability_models),
std::move(porosity_models), std::move(storage_models), has_material_ids,
material_ids);
}