ProcessLib::ThermoRichardsMechanics Namespace Reference

Namespaces
namespace	ConstitutiveStress_StrainTemperature
namespace	ConstitutiveStressSaturation_StrainPressureTemperature

Classes
struct	BiotModel
struct	BishopsData
struct	BishopsModel
struct	BishopsPrevModel
struct	CapillaryPressureData
struct	DarcyLawModel
struct	EqPData
struct	EqPModel
struct	EqTData
struct	EqTModel
struct	EquivalentPlasticStrainData
struct	FluidThermalExpansionData
struct	FluidThermalExpansionModel
struct	GravityData
struct	GravityModel
struct	IntegrationPointData
struct	LiquidDensityData
struct	LiquidDensityModel
struct	LiquidViscosityModel
struct	LocalAssemblerInterface
class	MaterialStateData
struct	MediaData
struct	PermeabilityData
struct	PermeabilityModel
struct	PorosityData
struct	PorosityModel
struct	SaturationData
struct	SaturationDataDeriv
struct	SaturationModel
struct	SolidCompressibilityData
struct	SolidDensityData
struct	SolidDensityModel
struct	SolidMechanicsDataStateless
struct	SolidThermalExpansionData
struct	SolidThermalExpansionModel
struct	SpecificBodyForceData
struct	TemperatureData
struct	ThermoOsmosisData
struct	ThermoOsmosisModel
class	ThermoRichardsMechanicsLocalAssembler
struct	ThermoRichardsMechanicsLocalAssembler3Args
class	ThermoRichardsMechanicsProcess
	Global assembler for the monolithic scheme of the non-isothermal Richards flow coupled with mechanics. More...
struct	ThermoRichardsMechanicsProcessData
struct	TotalStressData
struct	TransportPorosityData
struct	TRMHeatStorageAndFluxData
struct	TRMHeatStorageAndFluxModel
struct	TRMStorageData
struct	TRMStorageModel
struct	TRMVaporDiffusionData
struct	TRMVaporDiffusionModel

Typedefs
template<int DisplacementDim>
using	KelvinVector = KV::KelvinVectorType<DisplacementDim>
template<int DisplacementDim>
using	KelvinMatrix = KV::KelvinMatrixType<DisplacementDim>
template<int DisplacementDim>
using	GlobalDimVector = Eigen::Vector<double, DisplacementDim>
template<int DisplacementDim>
using	GlobalDimMatrix
using	BiotData = BaseLib::StrongType<double, struct BiotTag>
template<int DisplacementDim>
using	DarcyLawData
using	LiquidViscosityData
using	InitializePorosityFromMediumProperty
	A type helping to avoid confusion of different boolean values.

Functions
template<int D>
constexpr GlobalDimVector< D >	DVnan ()
	Used to set a D dimensional vector to all not-a-number.
template<int D>
constexpr GlobalDimMatrix< D >	DMnan ()
	Used to set a D x D matrix to all not-a-number.
static void	bishopsModelEvalImpl (SpaceTimeData const &x_t, MediaData const &media_data, SaturationData const &S_L_data, BishopsData &out)
constexpr std::string_view	ioName (struct DarcyLawDataTag *)
constexpr std::string_view	ioName (struct LiquidViscosityDataTag *)
template<int DisplacementDim, typename ConstitutiveTraits >
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface< DisplacementDim, ConstitutiveTraits > > > &local_assemblers, NumLib::IntegrationOrder const integration_order, bool const is_axially_symmetric, ThermoRichardsMechanicsProcessData< DisplacementDim, ConstitutiveTraits > &process_data)
template void	createLocalAssemblers< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > > (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > > > > &local_assemblers, NumLib::IntegrationOrder const integration_order, bool const is_axially_symmetric, ThermoRichardsMechanicsProcessData< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > > &process_data)
template void	createLocalAssemblers< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > > (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > > > > &local_assemblers, NumLib::IntegrationOrder const integration_order, bool const is_axially_symmetric, ThermoRichardsMechanicsProcessData< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > > &process_data)
template void	createLocalAssemblers< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > > (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > > > > &local_assemblers, NumLib::IntegrationOrder const integration_order, bool const is_axially_symmetric, ThermoRichardsMechanicsProcessData< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > > &process_data)
template void	createLocalAssemblers< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > > (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > > > > &local_assemblers, NumLib::IntegrationOrder const integration_order, bool const is_axially_symmetric, ThermoRichardsMechanicsProcessData< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > > &process_data)
void	checkMPLProperties (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
void	checkProcessVariableComponents (ProcessVariable const &variable, const int dim)
template<int DisplacementDim, typename ConstitutiveTraits , typename CreateConstitutiveSetting >
std::unique_ptr< Process >	createThermoRichardsMechanicsProcessStage2 (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media, bool const mandatory_stress0_type)
template<int DisplacementDim>
std::unique_ptr< Process >	createThermoRichardsMechanicsProcess (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process >	createThermoRichardsMechanicsProcess< 2 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template std::unique_ptr< Process >	createThermoRichardsMechanicsProcess< 3 > (std::string const &name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)

Typedef Documentation

BiotData

using ProcessLib::ThermoRichardsMechanics::BiotData = BaseLib::StrongType<double, struct BiotTag>

Definition at line 18 of file Biot.h.

DarcyLawData

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::DarcyLawData

Initial value:

 BaseLib::StrongType<Eigen::Vector<double, DisplacementDim>,
                                         struct DarcyLawDataTag>

Definition at line 23 of file DarcyLaw.h.

GlobalDimMatrix

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::GlobalDimMatrix

Initial value:

 
    Eigen::Matrix<double, DisplacementDim, DisplacementDim, Eigen::RowMajor>

Definition at line 35 of file Base.h.

GlobalDimVector

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::GlobalDimVector = Eigen::Vector<double, DisplacementDim>

Definition at line 32 of file Base.h.

InitializePorosityFromMediumProperty

using ProcessLib::ThermoRichardsMechanics::InitializePorosityFromMediumProperty

Initial value:

 
    BaseLib::StrongType<bool, struct InitializePorosityFromMediumPropertyTag>

A type helping to avoid confusion of different boolean values.

Definition at line 27 of file ThermoRichardsMechanicsProcessData.h.

KelvinMatrix

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::KelvinMatrix = KV::KelvinMatrixType<DisplacementDim>

Definition at line 29 of file Base.h.

KelvinVector

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::KelvinVector = KV::KelvinVectorType<DisplacementDim>

Definition at line 26 of file Base.h.

LiquidViscosityData

using ProcessLib::ThermoRichardsMechanics::LiquidViscosityData

Initial value:

 
    BaseLib::StrongType<double, struct LiquidViscosityDataTag>

Definition at line 19 of file LiquidViscosity.h.

Function Documentation

bishopsModelEvalImpl()

static void ProcessLib::ThermoRichardsMechanics::bishopsModelEvalImpl ( SpaceTimeData const & x_t, MediaData const & media_data, SaturationData const & S_L_data, BishopsData & out )

static

Definition at line 15 of file Bishops.cpp.

{
    namespace MPL = MaterialPropertyLib;
    MPL::VariableArray variables;
    variables.liquid_saturation = S_L_data.S_L;
 
    auto const& medium = media_data.medium;
 
    out.chi_S_L = medium.property(MPL::PropertyType::bishops_effective_stress)
                      .template value<double>(variables, x_t.x, x_t.t, x_t.dt);
 
    out.dchi_dS_L = medium.property(MPL::PropertyType::bishops_effective_stress)
                        .template dValue<double>(
                            variables, MPL::Variable::liquid_saturation, x_t.x,
                            x_t.t, x_t.dt);
}

References ProcessLib::ThermoRichardsMechanics::BishopsData::chi_S_L, ProcessLib::ThermoRichardsMechanics::BishopsData::dchi_dS_L, ProcessLib::ConstitutiveRelations::SpaceTimeData::dt, MaterialPropertyLib::VariableArray::liquid_saturation, ProcessLib::ThermoRichardsMechanics::MediaData::medium, ProcessLib::ThermoRichardsMechanics::SaturationData::S_L, ProcessLib::ConstitutiveRelations::SpaceTimeData::t, and ProcessLib::ConstitutiveRelations::SpaceTimeData::x.

Referenced by ProcessLib::ThermoRichardsMechanics::BishopsModel::eval(), and ProcessLib::ThermoRichardsMechanics::BishopsPrevModel::eval().

checkMPLProperties()

void ProcessLib::ThermoRichardsMechanics::checkMPLProperties

(

std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &

media

)

Definition at line 37 of file CreateThermoRichardsMechanicsProcess.cpp.

{
    std::array const required_medium_properties = {
        MaterialPropertyLib::porosity, MaterialPropertyLib::biot_coefficient,
        MaterialPropertyLib::bishops_effective_stress,
        MaterialPropertyLib::relative_permeability};
    std::array const required_liquid_properties = {
        MaterialPropertyLib::viscosity, MaterialPropertyLib::density};
    std::array const required_solid_properties = {MaterialPropertyLib::density};
 
    // Thermal properties are not checked because they can be phase property or
    // medium property (will be enabled later).
    for (auto const& m : media)
    {
        checkRequiredProperties(*m.second, required_medium_properties);
        checkRequiredProperties(m.second->phase("AqueousLiquid"),
                                required_liquid_properties);
        checkRequiredProperties(m.second->phase("Solid"),
                                required_solid_properties);
    }
}

References MaterialPropertyLib::biot_coefficient, MaterialPropertyLib::bishops_effective_stress, MaterialPropertyLib::density, MaterialPropertyLib::porosity, MaterialPropertyLib::relative_permeability, and MaterialPropertyLib::viscosity.

Referenced by createThermoRichardsMechanicsProcessStage2().

checkProcessVariableComponents()

void ProcessLib::ThermoRichardsMechanics::checkProcessVariableComponents	(	ProcessVariable const &	variable,
		const int	dim )

Definition at line 60 of file CreateThermoRichardsMechanicsProcess.cpp.

{
    DBUG("Associate displacement with process variable '{:s}'.",
         variable.getName());
 
    if (variable.getNumberOfGlobalComponents() != dim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the displacement dimension: got {:d}, expected {:d}",
            variable.getName(),
            variable.getNumberOfGlobalComponents(),
            dim);
    }
}

References DBUG(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), and OGS_FATAL.

Referenced by createThermoRichardsMechanicsProcessStage2().

createLocalAssemblers()

template<int DisplacementDim, typename ConstitutiveTraits >

void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface< DisplacementDim, ConstitutiveTraits > > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		bool const	is_axially_symmetric,
		ThermoRichardsMechanicsProcessData< DisplacementDim, ConstitutiveTraits > &	process_data )

Definition at line 35 of file CreateThermoRichardsMechanicsLocalAssemblers.cpp.

{
    createLocalAssemblersHM<
        DisplacementDim,
        ThermoRichardsMechanicsLocalAssembler3Args<
            ConstitutiveTraits>::template LocalAssemblerImplementation>(
        mesh_elements, dof_table, local_assemblers, integration_order,
        is_axially_symmetric, process_data);
}

References ProcessLib::createLocalAssemblersHM().

Referenced by ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::initializeConcreteProcess().

createLocalAssemblers< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > >()

template void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > >	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > > > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		bool const	is_axially_symmetric,
		ThermoRichardsMechanicsProcessData< 2, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 2 > > &	process_data )

createLocalAssemblers< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > >()

template void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > >	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > > > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		bool const	is_axially_symmetric,
		ThermoRichardsMechanicsProcessData< 2, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 2 > > &	process_data )

createLocalAssemblers< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > >()

template void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > >	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > > > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		bool const	is_axially_symmetric,
		ThermoRichardsMechanicsProcessData< 3, ConstitutiveStress_StrainTemperature::ConstitutiveTraits< 3 > > &	process_data )

createLocalAssemblers< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > >()

template void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > >	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > > > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		bool const	is_axially_symmetric,
		ThermoRichardsMechanicsProcessData< 3, ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveTraits< 3 > > &	process_data )

createThermoRichardsMechanicsProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Input File Parameter

prj__processes__process__type

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__subtype

Definition at line 220 of file CreateThermoRichardsMechanicsProcess.cpp.

{
    config.checkConfigParameter("type", "THERMO_RICHARDS_MECHANICS");
    DBUG("Create ThermoRichardsMechanicsProcess.");
 
    auto const subtype =
        config.getConfigParameter<std::string>("subtype",
                                               "Stress_StrainTemperature");
    INFO("TRM process subtype is '{}'", subtype);
 
    if (subtype == "Stress_StrainTemperature")
    {
        bool const mandatory_stress0_type = false;
        return createThermoRichardsMechanicsProcessStage2<
            DisplacementDim,
            ConstitutiveStress_StrainTemperature::ConstitutiveTraits<
                DisplacementDim>,
            ConstitutiveStress_StrainTemperature::CreateConstitutiveSetting<
                DisplacementDim>>(name, mesh, std::move(jacobian_assembler),
                                  variables, parameters,
                                  local_coordinate_system, integration_order,
                                  config, media, mandatory_stress0_type);
    }
 
    if (subtype == "StressSaturation_StrainPressureTemperature")
    {
#ifdef OGS_USE_MFRONT
        bool const mandatory_stress0_type = true;
        return createThermoRichardsMechanicsProcessStage2<
            DisplacementDim,
            ConstitutiveStressSaturation_StrainPressureTemperature::
                ConstitutiveTraits<DisplacementDim>,
            ConstitutiveStressSaturation_StrainPressureTemperature::
                CreateConstitutiveSetting<DisplacementDim>>(
            name, mesh, std::move(jacobian_assembler), variables, parameters,
            local_coordinate_system, integration_order, config, media,
            mandatory_stress0_type);
#else
        OGS_FATAL(
            "TRM process subtype 'StressSaturation_StrainPressureTemperature' "
            "is not supported, because OGS has not been built with MFront.");
#endif
    }
 
    OGS_FATAL("Unknown TRM process subtype '{}'.", subtype);
}

References BaseLib::ConfigTree::checkConfigParameter(), createThermoRichardsMechanicsProcessStage2(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), INFO(), and OGS_FATAL.

createThermoRichardsMechanicsProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess< 2 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Referenced by ProjectData::parseProcesses().

createThermoRichardsMechanicsProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess< 3 >	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media )

Referenced by ProjectData::parseProcesses().

createThermoRichardsMechanicsProcessStage2()

template<int DisplacementDim, typename ConstitutiveTraits , typename CreateConstitutiveSetting >

std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcessStage2	(	std::string const &	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &	media,
		bool const	mandatory_stress0_type )

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__coupling_scheme

Process Variables

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__process_variables

Primary process variables as they appear in the global component vector:

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__process_variables__temperature

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__process_variables__pressure

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__process_variables__displacement

Process Parameters

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__specific_body_force

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__mass_lumping

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__apply_body_force_for_deformation

Input File Parameter

prj__processes__process__THERMO_RICHARDS_MECHANICS__initialize_porosity_from_medium_property

Definition at line 79 of file CreateThermoRichardsMechanicsProcess.cpp.

{
    auto const coupling_scheme =
        config.getConfigParameterOptional<std::string>("coupling_scheme");
    const bool use_monolithic_scheme =
        !(coupling_scheme && (*coupling_scheme == "staggered"));
 
 
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    ProcessVariable* variable_T;
    ProcessVariable* variable_p;
    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,
            {
             "temperature",
             "pressure",
             "displacement"});
        variable_T = &per_process_variables[0].get();
        variable_p = &per_process_variables[1].get();
        variable_u = &per_process_variables[2].get();
        process_variables.push_back(std::move(per_process_variables));
    }
    else  // staggered scheme.
    {
        OGS_FATAL(
            "So far, only the monolithic scheme is implemented for "
            "THERMO_RICHARDS_MECHANICS");
    }
 
    checkProcessVariableComponents(*variable_T, 1);
    checkProcessVariableComponents(*variable_p, 1);
    checkProcessVariableComponents(*variable_u, DisplacementDim);
 
 
    auto solid_constitutive_relations =
        CreateConstitutiveSetting::createSolidConstitutiveRelations(
            parameters, local_coordinate_system, materialIDs(mesh), config);
 
    // Specific body force
    Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.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}",
                b.size(), DisplacementDim);
        }
 
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
    DBUG(
        "Check the media properties of ThermoRichardsMechanics process "
        "...");
    checkMPLProperties(media);
    DBUG("Media properties verified.");
 
    auto initial_stress = ProcessLib::createInitialStress<DisplacementDim>(
        config, parameters, mesh, mandatory_stress0_type);
 
    bool mass_lumping = false;
    if (auto const mass_lumping_ptr =
        config.getConfigParameterOptional<bool>("mass_lumping"))
    {
        DBUG("Using mass lumping for the Richards flow equation.");
        mass_lumping = *mass_lumping_ptr;
    }
 
    bool const apply_body_force_for_deformation =
        config.getConfigParameter<bool>("apply_body_force_for_deformation",
                                        true);
 
    bool const initialize_porosity_from_medium_property =
        config.getConfigParameter("initialize_porosity_from_medium_property",
                                  true);
 
    const bool use_TaylorHood_elements =
        variable_p->getShapeFunctionOrder() !=
                variable_u->getShapeFunctionOrder()
            ? true
            : false;
 
    ThermoRichardsMechanicsProcessData<DisplacementDim, ConstitutiveTraits>
        process_data{materialIDs(mesh),
                     std::move(media_map),
                     std::move(solid_constitutive_relations),
                     std::move(initial_stress),
                     specific_body_force,
                     mass_lumping,
                     use_TaylorHood_elements,
                     apply_body_force_for_deformation,
                     InitializePorosityFromMediumProperty{
                         initialize_porosity_from_medium_property}};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<
        ThermoRichardsMechanicsProcess<DisplacementDim, ConstitutiveTraits>>(
        name, mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables),
        use_monolithic_scheme);
}

References checkMPLProperties(), checkProcessVariableComponents(), ProcessLib::createInitialStress(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), ProcessLib::ProcessVariable::getShapeFunctionOrder(), and OGS_FATAL.

Referenced by createThermoRichardsMechanicsProcess().

DMnan()

template<int D>

GlobalDimMatrix< D > ProcessLib::ThermoRichardsMechanics::DMnan ( )

constexpr

Used to set a D x D matrix to all not-a-number.

Definition at line 47 of file Base.h.

{
    return GlobalDimMatrix<D>::Constant(nan);
}

References ProcessLib::ConstitutiveRelations::nan.

DVnan()

template<int D>

GlobalDimVector< D > ProcessLib::ThermoRichardsMechanics::DVnan ( )

constexpr

Used to set a D dimensional vector to all not-a-number.

Definition at line 40 of file Base.h.

{
    return GlobalDimVector<D>::Constant(nan);
}

References ProcessLib::ConstitutiveRelations::nan.

ioName() [1/2]

std::string_view ProcessLib::ThermoRichardsMechanics::ioName ( struct DarcyLawDataTag * )

constexpr

Definition at line 26 of file DarcyLaw.h.

{
    return "velocity";
}

ioName() [2/2]

std::string_view ProcessLib::ThermoRichardsMechanics::ioName ( struct LiquidViscosityDataTag * )

constexpr

Definition at line 22 of file LiquidViscosity.h.

{
    return "viscosity";
}