Namespaces
namespace	ConstitutiveStress_StrainTemperature

namespace	ConstitutiveStressSaturation_StrainPressureTemperature

namespace	detail

Classes
struct	BiotModel

struct	BishopsData

struct	BishopsModel

struct	CapillaryPressureData

struct	DarcyLawData

struct	DarcyLawModel

struct	ElasticTangentStiffnessData

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	LiquidViscosityData

struct	LiquidViscosityModel

struct	LocalAssemblerInterface

class	MaterialStateData

struct	MediaData

struct	PermeabilityData

struct	PermeabilityModel

struct	PorosityData

struct	PorosityModel

struct	PrevState
	Represents a previous state of type T. More...

struct	SaturationData

struct	SaturationDataDeriv

struct	SaturationModel

struct	SolidCompressibilityData

struct	SolidCompressibilityModel

struct	SolidDensityData

struct	SolidDensityModel

struct	SolidThermalExpansionData

struct	SolidThermalExpansionModel

struct	SpaceTimeData

struct	StrainData

struct	SwellingDataStateful

struct	SwellingDataStateless

struct	SwellingModel

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	TransportPorosityModel

struct	TRMHeatStorageAndFluxData

struct	TRMHeatStorageAndFluxModel

struct	TRMStorageData

struct	TRMStorageModel

struct	TRMVaporDiffusionData

struct	TRMVaporDiffusionModel

Typedefs
template<int DisplacementDim>
using	KelvinVector = MathLib::KelvinVector::KelvinVectorType< DisplacementDim >

template<int DisplacementDim>
using	KelvinMatrix = MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >

template<int DisplacementDim>
using	GlobalDimVector = Eigen::Vector< double, DisplacementDim >

template<int DisplacementDim>
using	GlobalDimMatrix = Eigen::Matrix< double, DisplacementDim, DisplacementDim, Eigen::RowMajor >

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

Functions
template<int DisplacementDim>
constexpr KelvinVector< DisplacementDim >	KVnan ()
	Used to set a Kelvin vector to all not-a-number.

template<int DisplacementDim>
constexpr KelvinMatrix< DisplacementDim >	KMnan ()
	Used to set a Kelvin matrix to all not-a-number.

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.

template<int DisplacementDim>
constexpr KelvinVector< DisplacementDim >	KVzero ()
	Used to set a Kelvin vector to all zero.

template<int DisplacementDim>
constexpr KelvinMatrix< DisplacementDim >	KMzero ()
	Used to set a Kelvin matrix to all zero.

template<typename T >
constexpr bool	areEvalArgumentTypesUnique ()

template<typename Model >
constexpr void	assertEvalArgsUnique (Model const &)

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)

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)

Variables
static constexpr double	nan = std::numeric_limits<double>::quiet_NaN()
	Convenience alias for not a number.

Typedef Documentation

◆ BiotData

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

Definition at line 18 of file Biot.h.

◆ GlobalDimMatrix

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::GlobalDimMatrix = typedef Eigen::Matrix<double, DisplacementDim, DisplacementDim, Eigen::RowMajor>

Definition at line 30 of file Base.h.

◆ GlobalDimVector

template<int DisplacementDim>

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

Definition at line 27 of file Base.h.

◆ KelvinMatrix

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::KelvinMatrix = typedef MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>

Definition at line 24 of file Base.h.

◆ KelvinVector

template<int DisplacementDim>

using ProcessLib::ThermoRichardsMechanics::KelvinVector = typedef MathLib::KelvinVector::KelvinVectorType<DisplacementDim>

Definition at line 21 of file Base.h.

Function Documentation

◆ areEvalArgumentTypesUnique()

template<typename T >

constexpr bool ProcessLib::ThermoRichardsMechanics::areEvalArgumentTypesUnique ( )

constexpr

Checks whether the argument types of the eval() method of the given type T are unique.

Argument types differing only in constness, reference or volatility are considered equal.

Definition at line 42 of file Invoke.h.

{
    return detail::areEvalArgumentTypesUnique(&T::eval);
}

References ProcessLib::ThermoRichardsMechanics::detail::areEvalArgumentTypesUnique().

◆ assertEvalArgsUnique()

template<typename Model >

constexpr void ProcessLib::ThermoRichardsMechanics::assertEvalArgsUnique ( Model const & )

constexpr

Statically asserts that the argument types of the passed Model's eval() method are unique.

Definition at line 50 of file Invoke.h.

{
    static_assert(areEvalArgumentTypesUnique<std::remove_cvref_t<Model>>());
}

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::ConstitutiveSetting< DisplacementDim >::eval(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveSetting< DisplacementDim >::eval().

◆ checkMPLProperties()

void ProcessLib::ThermoRichardsMechanics::checkMPLProperties ( std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & media )

Definition at line 36 of file CreateThermoRichardsMechanicsProcess.cpp.

{
    std::array const required_medium_properties = {
        MaterialPropertyLib::porosity, MaterialPropertyLib::biot_coefficient,
        MaterialPropertyLib::bishops_effective_stress,
        MaterialPropertyLib::relative_permeability,
        MaterialPropertyLib::saturation};
    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, MaterialPropertyLib::saturation, 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().

◆ 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 219 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")
    {
        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);
    }
 
    if (subtype == "StressSaturation_StrainPressureTemperature")
    {
#ifdef OGS_USE_MFRONT
        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);
#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
	)

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__initial_stress

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

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, 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.");
 
    // Initial stress conditions
    auto const initial_stress = ParameterLib::findOptionalTagParameter<double>(
        config, "initial_stress", parameters,
        // Symmetric tensor size, 4 or 6, not a Kelvin vector.
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim),
        &mesh);
 
    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);
 
    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),
                     initial_stress,
                     specific_body_force,
                     mass_lumping,
                     use_TaylorHood_elements,
                     apply_body_force_for_deformation};
 
    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(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), ProcessLib::ProcessVariable::getShapeFunctionOrder(), MathLib::KelvinVector::kelvin_vector_dimensions(), and OGS_FATAL.

Referenced by createThermoRichardsMechanicsProcess().

◆ DMnan()

template<int D>

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

constexpr

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

Definition at line 59 of file Base.h.

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

References nan.

◆ DVnan()

template<int D>

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

constexpr

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

Definition at line 52 of file Base.h.

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

References nan.

◆ KMnan()

template<int DisplacementDim>

constexpr KelvinMatrix< DisplacementDim > ProcessLib::ThermoRichardsMechanics::KMnan ( )

constexpr

Used to set a Kelvin matrix to all not-a-number.

Definition at line 45 of file Base.h.

{
    return KelvinMatrix<DisplacementDim>::Constant(nan);
}

References nan.

◆ KMzero()

template<int DisplacementDim>

constexpr KelvinMatrix< DisplacementDim > ProcessLib::ThermoRichardsMechanics::KMzero ( )

constexpr

Used to set a Kelvin matrix to all zero.

Definition at line 73 of file Base.h.

{
    return KelvinMatrix<DisplacementDim>::Zero();
}

◆ KVnan()

template<int DisplacementDim>

constexpr KelvinVector< DisplacementDim > ProcessLib::ThermoRichardsMechanics::KVnan ( )

constexpr

Used to set a Kelvin vector to all not-a-number.

Definition at line 38 of file Base.h.

{
    return KelvinVector<DisplacementDim>::Constant(nan);
}

References nan.

◆ KVzero()

template<int DisplacementDim>

constexpr KelvinVector< DisplacementDim > ProcessLib::ThermoRichardsMechanics::KVzero ( )

constexpr

Used to set a Kelvin vector to all zero.

Definition at line 66 of file Base.h.

{
    return KelvinVector<DisplacementDim>::Zero();
}

Variable Documentation

◆ nan

constexpr double ProcessLib::ThermoRichardsMechanics::nan = std::numeric_limits<double>::quiet_NaN()

staticconstexpr

Convenience alias for not a number.

Definition at line 34 of file Base.h.

Referenced by DMnan(), DVnan(), KMnan(), and KVnan().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ BiotData

◆ GlobalDimMatrix

◆ GlobalDimVector

◆ KelvinMatrix

◆ KelvinVector

Function Documentation

◆ areEvalArgumentTypesUnique()

◆ assertEvalArgsUnique()

◆ checkMPLProperties()

◆ checkProcessVariableComponents()

◆ createLocalAssemblers()

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

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

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

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

◆ createThermoRichardsMechanicsProcess()

◆ createThermoRichardsMechanicsProcess< 2 >()

◆ createThermoRichardsMechanicsProcess< 3 >()

◆ createThermoRichardsMechanicsProcessStage2()

Process Variables

Process Parameters

◆ DMnan()

◆ DVnan()

◆ KMnan()

◆ KMzero()

◆ KVnan()

◆ KVzero()

Variable Documentation

◆ nan