ProcessLib::RichardsMechanics Namespace Reference

Classes
struct	CapillaryPressureData
struct	ConstitutiveSetting
struct	CreateConstitutiveSetting
struct	IntegrationPointData
struct	LocalAssemblerInterface
struct	MediaData
struct	MicroPorosityParameters
struct	MicroPorosityStateSpace
class	RichardsMechanicsLocalAssembler
class	RichardsMechanicsProcess
struct	RichardsMechanicsProcessData
struct	SaturationSecantDerivative
struct	SecondaryData

Typedefs
using	TemperatureData = BaseLib::StrongType<double, struct TemperatureDataTag>
template<int DisplacementDim>
using	StatefulData
	Data whose state must be tracked by the process.
template<int DisplacementDim>
using	StatefulDataPrev
template<int DisplacementDim>
using	OutputData
	Data that is needed for output purposes, but not directly for the assembly.
template<int DisplacementDim>
using	ConstitutiveData
	Data that is needed for the equation system assembly.
template<int DisplacementDim>
using	ConstitutiveTempData = std::tuple<>
template<int DisplacementDim>
using	ConstitutiveModels = std::tuple<>
	Constitutive models used for assembly.
using	Density = BaseLib::StrongType<double, struct DensityTag>
using	DrySolidDensity = BaseLib::StrongType<double, struct DrySolidDensityTag>
using	EffectivePorePressure
using	LiquidDensity = BaseLib::StrongType<double, struct LiquidDensityTag>
using	MicroPressure = BaseLib::StrongType<double, struct MicroPressureTag>
using	MicroSaturation = BaseLib::StrongType<double, struct MicroSaturationTag>
template<int DisplacementDim>
using	StiffnessTensor

Functions
template<int DisplacementDim>
std::ostream &	operator<< (std::ostream &os, MicroPorosityStateSpace< DisplacementDim > const &state)
template<int DisplacementDim>
MicroPorosityStateSpace< DisplacementDim >	computeMicroPorosity (MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &I_2_C_el_inverse, double const rho_LR_m, double const mu_LR, MicroPorosityParameters const &micro_porosity_parameters, double const alpha_B, double const phi, double const p_L, double const p_L_m_prev, MaterialPropertyLib::VariableArray const &, double const S_L_m_prev, double const phi_m_prev, ParameterLib::SpatialPosition const pos, double const t, double const dt, MaterialPropertyLib::Property const &saturation_micro, MaterialPropertyLib::Property const &swelling_stress_rate)
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, typename TRMProcessData>
ConstitutiveModels< DisplacementDim >	createConstitutiveModels (TRMProcessData const &process_data, MaterialLib::Solids::MechanicsBase< DisplacementDim > const &solid_material)
constexpr std::string_view	ioName (struct DrySolidDensityTag *)
constexpr std::string_view	ioName (struct MicroPressureTag *)
constexpr std::string_view	ioName (struct MicroSaturationTag *)
void	checkMPLProperties (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
template<int DisplacementDim>
std::unique_ptr< Process >	createRichardsMechanicsProcess (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 >	createRichardsMechanicsProcess< 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 >	createRichardsMechanicsProcess< 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)
template<int DisplacementDim>
void	updateSwellingStressAndVolumetricStrain (MaterialPropertyLib::Medium const &medium, MaterialPropertyLib::Phase const &solid_phase, MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > const &C_el, double const rho_LR, double const mu, std::optional< MicroPorosityParameters > micro_porosity_parameters, double const alpha, double const phi, double const p_cap_ip, MPL::VariableArray &variables, MPL::VariableArray &variables_prev, ParameterLib::SpatialPosition const &x_position, double const t, double const dt, ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingDataStateful< DisplacementDim > &sigma_sw, PrevState< ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingDataStateful< DisplacementDim > > const &sigma_sw_prev, PrevState< ProcessLib::ThermoRichardsMechanics::TransportPorosityData > const phi_M_prev, PrevState< ProcessLib::ThermoRichardsMechanics::PorosityData > const phi_prev, ProcessLib::ThermoRichardsMechanics::TransportPorosityData &phi_M, PrevState< MicroPressure > const p_L_m_prev, PrevState< MicroSaturation > const S_L_m_prev, MicroPressure &p_L_m, MicroSaturation &S_L_m)

Typedef Documentation

ConstitutiveData

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::ConstitutiveData

Initial value:

 std::tuple<
    
    StiffnessTensor<DisplacementDim>,
    ProcessLib::ThermoRichardsMechanics::PorosityData, Density, LiquidDensity,
    ProcessLib::ThermoRichardsMechanics::BiotData,
    ProcessLib::ThermoRichardsMechanics::SaturationDataDeriv,
    ProcessLib::ThermoRichardsMechanics::LiquidViscosityData,
    ProcessLib::ThermoRichardsMechanics::SolidCompressibilityData,
    ProcessLib::ThermoRichardsMechanics::BishopsData,
    PrevState<ProcessLib::ThermoRichardsMechanics::BishopsData>,
    ProcessLib::ThermoRichardsMechanics::PermeabilityData<DisplacementDim>,
    SaturationSecantDerivative>

Data that is needed for the equation system assembly.

Definition at line 54 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveData.h.

ConstitutiveModels

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::ConstitutiveModels = std::tuple<>

Constitutive models used for assembly.

Definition at line 14 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveModels.h.

ConstitutiveTempData

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::ConstitutiveTempData = std::tuple<>

Data that stores intermediate values, which are not needed outside the constitutive setting.

Definition at line 70 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveData.h.

Density

using ProcessLib::RichardsMechanics::Density = BaseLib::StrongType<double, struct DensityTag>

Definition at line 11 of file Density.h.

DrySolidDensity

using ProcessLib::RichardsMechanics::DrySolidDensity = BaseLib::StrongType<double, struct DrySolidDensityTag>

Definition at line 13 of file DrySolidDensity.h.

EffectivePorePressure

using ProcessLib::RichardsMechanics::EffectivePorePressure

Initial value:

 
    BaseLib::StrongType<double, struct EffectivePorePressureTag>

Definition at line 10 of file EffectivePorePressure.h.

LiquidDensity

using ProcessLib::RichardsMechanics::LiquidDensity = BaseLib::StrongType<double, struct LiquidDensityTag>

Definition at line 10 of file RichardsMechanics/ConstitutiveRelations/LiquidDensity.h.

MicroPressure

using ProcessLib::RichardsMechanics::MicroPressure = BaseLib::StrongType<double, struct MicroPressureTag>

Definition at line 12 of file MicroPressure.h.

MicroSaturation

using ProcessLib::RichardsMechanics::MicroSaturation = BaseLib::StrongType<double, struct MicroSaturationTag>

Definition at line 12 of file MicroSaturation.h.

OutputData

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::OutputData

Initial value:

 std::tuple<
    ProcessLib::ThermoRichardsMechanics::DarcyLawData<DisplacementDim>,
    DrySolidDensity>

Data that is needed for output purposes, but not directly for the assembly.

Definition at line 48 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveData.h.

StatefulData

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::StatefulData

Initial value:

 std::tuple<
    StrainData<DisplacementDim>,
    ProcessLib::ConstitutiveRelations::EffectiveStressData<DisplacementDim>,
    ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::
        SwellingDataStateful<DisplacementDim>,
    ProcessLib::ConstitutiveRelations::MechanicalStrainData<DisplacementDim>,
    ProcessLib::ThermoRichardsMechanics::SaturationData,
    ProcessLib::ThermoRichardsMechanics::PorosityData,
    ProcessLib::ThermoRichardsMechanics::TransportPorosityData, MicroPressure,
    MicroSaturation>

Data whose state must be tracked by the process.

Definition at line 31 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveData.h.

StatefulDataPrev

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::StatefulDataPrev

Initial value:

 ProcessLib::ConstitutiveRelations::PrevStateOf<
    StatefulData<DisplacementDim>>

Definition at line 43 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveData.h.

StiffnessTensor

template<int DisplacementDim>

using ProcessLib::RichardsMechanics::StiffnessTensor

Initial value:

 BaseLib::StrongType<KelvinMatrix<DisplacementDim>,
                                            struct StiffnessTensorTag>

Definition at line 11 of file StiffnessTensor.h.

TemperatureData

using ProcessLib::RichardsMechanics::TemperatureData = BaseLib::StrongType<double, struct TemperatureDataTag>

Definition at line 46 of file RichardsMechanics/ConstitutiveRelations/Base.h.

Function Documentation

checkMPLProperties()

void ProcessLib::RichardsMechanics::checkMPLProperties

(

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

media

)

Definition at line 25 of file CreateRichardsMechanicsProcess.cpp.

{
    std::array const required_medium_properties = {
        MaterialPropertyLib::reference_temperature,
        MaterialPropertyLib::bishops_effective_stress,
        MaterialPropertyLib::relative_permeability,
        MaterialPropertyLib::saturation,
        MaterialPropertyLib::porosity,
        MaterialPropertyLib::biot_coefficient};
    std::array const required_liquid_properties = {
        MaterialPropertyLib::viscosity, MaterialPropertyLib::density};
    std::array const required_solid_properties = {MaterialPropertyLib::density};
 
    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::reference_temperature, MaterialPropertyLib::relative_permeability, MaterialPropertyLib::saturation, and MaterialPropertyLib::viscosity.

Referenced by createRichardsMechanicsProcess().

computeMicroPorosity()

template<int DisplacementDim>

MicroPorosityStateSpace< DisplacementDim > ProcessLib::RichardsMechanics::computeMicroPorosity	(	MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &	I_2_C_el_inverse,
		double const	rho_LR_m,
		double const	mu_LR,
		MicroPorosityParameters const &	micro_porosity_parameters,
		double const	alpha_B,
		double const	phi,
		double const	p_L,
		double const	p_L_m_prev,
		MaterialPropertyLib::VariableArray const &	,
		double const	S_L_m_prev,
		double const	phi_m_prev,
		ParameterLib::SpatialPosition const	pos,
		double const	t,
		double const	dt,
		MaterialPropertyLib::Property const &	saturation_micro,
		MaterialPropertyLib::Property const &	swelling_stress_rate )

Definition at line 58 of file ComputeMicroPorosity.h.

{
    namespace MPL = MaterialPropertyLib;
    static constexpr int kelvin_vector_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    // phi_m, e_sw, p_L_m, sigma_sw
    static constexpr int nls_size = 1 + 1 + 1 + kelvin_vector_size;
 
    static constexpr int i_phi_m = 0;
    static constexpr int i_e_sw = 1;
    static constexpr int i_p_L_m = 2;
    static constexpr int i_sigma_sw = 3;
 
    using ResidualVectorType = Eigen::Matrix<double, nls_size, 1>;
    using JacobianMatrix =
        Eigen::Matrix<double, nls_size, nls_size, Eigen::RowMajor>;
 
    Eigen::FullPivLU<Eigen::Matrix<double, nls_size, nls_size, Eigen::RowMajor>>
        linear_solver;
 
    JacobianMatrix jacobian;
 
    // Agglomerated solution vector construction.
    ResidualVectorType solution = ResidualVectorType::Zero();
 
    if (p_L >= 0 && p_L_m_prev >= 0)
    {
        return {solution[i_phi_m], solution[i_e_sw], solution[i_p_L_m],
                solution.template segment<kelvin_vector_size>(i_sigma_sw)};
    }
 
    double const alpha_bar =
        micro_porosity_parameters.mass_exchange_coefficient;
 
    auto const update_residual = [&](ResidualVectorType& residual)
    {
        double const delta_phi_m = solution[i_phi_m];
        double const delta_e_sw = solution[i_e_sw];
        auto const& delta_sigma_sw =
            solution.template segment<kelvin_vector_size>(i_sigma_sw);
        double const delta_p_L_m = solution[i_p_L_m];
 
        double const phi_m = phi_m_prev + delta_phi_m;
        double const p_L_m = p_L_m_prev + delta_p_L_m;
        MPL::VariableArray variables_prev;
        variables_prev.capillary_pressure = -p_L_m_prev;
        variables_prev.liquid_saturation = S_L_m_prev;
 
        MPL::VariableArray variables;
        variables.capillary_pressure = -p_L_m;
 
        double const S_L_m =
            saturation_micro.template value<double>(variables, pos, t, dt);
        variables.liquid_saturation = S_L_m;
        double const delta_S_L_m = S_L_m - S_L_m_prev;
 
        auto const sigma_sw_dot =
            MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
                swelling_stress_rate.template value<Eigen::Matrix3d>(
                    variables, variables_prev, pos, t, dt));
 
        residual[i_phi_m] = delta_phi_m - (alpha_B - phi) * delta_e_sw;
        residual[i_e_sw] = delta_e_sw + I_2_C_el_inverse.dot(delta_sigma_sw);
        residual.template segment<kelvin_vector_size>(i_sigma_sw).noalias() =
            delta_sigma_sw - sigma_sw_dot * dt;
 
        residual[i_p_L_m] =
            rho_LR_m *
                (phi_m * delta_S_L_m - (alpha_B - phi) * S_L_m * delta_e_sw) +
            phi_m * S_L_m * rho_LR_m * delta_e_sw -
            micro_porosity_parameters.mass_exchange_coefficient / mu_LR *
                (p_L - p_L_m) * dt;
    };
 
    auto const update_jacobian = [&](JacobianMatrix& jacobian)
    {
        jacobian = JacobianMatrix::Identity();
 
        double const delta_phi_m = solution[i_phi_m];
        double const delta_e_sw = solution[i_e_sw];
        double const delta_p_L_m = solution[i_p_L_m];
 
        double const phi_m = phi_m_prev + delta_phi_m;
        double const p_L_m = p_L_m_prev + delta_p_L_m;
        MPL::VariableArray variables_prev;
        variables_prev.capillary_pressure = -p_L_m_prev;
        MPL::VariableArray variables;
        variables.capillary_pressure = -p_L_m;
 
        double const S_L_m =
            saturation_micro.template value<double>(variables, pos, t, dt);
        variables_prev.liquid_saturation = S_L_m_prev;
        variables.liquid_saturation = S_L_m;
        double const delta_S_L_m = S_L_m - S_L_m_prev;
 
        double const dS_L_m_dp_cap_m = saturation_micro.template dValue<double>(
            variables, MPL::Variable::capillary_pressure, pos, t, dt);
        auto const dsigma_sw_dS_L_m =
            MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
                swelling_stress_rate.template dValue<Eigen::Matrix3d>(
                    variables, variables_prev, MPL::Variable::liquid_saturation,
                    pos, t, dt));
 
        jacobian(i_phi_m, i_e_sw) = -(alpha_B - phi);
 
        jacobian.template block<1, kelvin_vector_size>(i_e_sw, i_sigma_sw) =
            I_2_C_el_inverse.transpose();
 
        jacobian.template block<kelvin_vector_size, 1>(i_sigma_sw, i_p_L_m) =
            -dsigma_sw_dS_L_m * dS_L_m_dp_cap_m;
 
        jacobian(i_p_L_m, i_phi_m) =
            rho_LR_m * (delta_S_L_m + S_L_m * delta_e_sw);
 
        jacobian(i_p_L_m, i_e_sw) = -rho_LR_m * S_L_m * (alpha_B - phi - phi_m);
 
        jacobian(i_p_L_m, i_p_L_m) =
            alpha_bar / mu_LR * dt -
            rho_LR_m * (phi_m - (alpha_B - phi - phi_m) * delta_e_sw) *
                dS_L_m_dp_cap_m;
    };
 
    auto const update_solution = [&](ResidualVectorType const& increment)
    { solution += increment; };
 
    auto newton_solver = NumLib::NewtonRaphson(
        linear_solver, update_jacobian, update_residual, update_solution,
        micro_porosity_parameters.nonlinear_solver_parameters);
 
    auto const success_iterations = newton_solver.solve(jacobian);
 
    if (!success_iterations)
    {
        OGS_FATAL(
            "Could not find solution for local double structure nonlinear "
            "problem.");
    }
 
    return {solution[i_phi_m], solution[i_e_sw], solution[i_p_L_m],
            solution.template segment<kelvin_vector_size>(i_sigma_sw)};
}

References MaterialPropertyLib::capillary_pressure, MaterialPropertyLib::VariableArray::capillary_pressure, MathLib::KelvinVector::kelvin_vector_dimensions(), MaterialPropertyLib::liquid_saturation, MaterialPropertyLib::VariableArray::liquid_saturation, ProcessLib::RichardsMechanics::MicroPorosityParameters::mass_exchange_coefficient, ProcessLib::RichardsMechanics::MicroPorosityParameters::nonlinear_solver_parameters, OGS_FATAL, and MathLib::KelvinVector::tensorToKelvin().

Referenced by updateSwellingStressAndVolumetricStrain().

createConstitutiveModels()

template<int DisplacementDim, typename TRMProcessData>

ConstitutiveModels< DisplacementDim > ProcessLib::RichardsMechanics::createConstitutiveModels	(	TRMProcessData const &	process_data,
		MaterialLib::Solids::MechanicsBase< DisplacementDim > const &	solid_material )

Definition at line 17 of file RichardsMechanics/ConstitutiveRelations/ConstitutiveModels.h.

{
    return ProcessLib::Graph::constructModels<
        ConstitutiveModels<DisplacementDim>>(
        ProcessLib::ConstitutiveRelations::SpecificBodyForce<DisplacementDim>(
            process_data.specific_body_force),
        solid_material);
}

References ProcessLib::Graph::constructModels().

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian().

createRichardsMechanicsProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess	(	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__RICHARDS_MECHANICS__coupling_scheme

Process Variables

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__process_variables

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

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__process_variables__pressure

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__process_variables__displacement

Process Parameters

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__specific_body_force

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__micro_porosity

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__micro_porosity__nonlinear_solver

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__micro_porosity__mass_exchange_coefficient

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__mass_lumping

Input File Parameter

prj__processes__process__RICHARDS_MECHANICS__explicit_hm_coupling_in_unsaturated_zone

Input File Parameter

prj__processes__process__linear

Definition at line 50 of file CreateRichardsMechanicsProcess.cpp.

{
    config.checkConfigParameter("type", "RICHARDS_MECHANICS");
    DBUG("Create RichardsMechanicsProcess.");
 
    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_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,
            {
             "pressure",
             "displacement"});
        variable_p = &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 : {"pressure"s, "displacement"s})
        {
            auto per_process_variables =
                findProcessVariables(variables, pv_config, {variable_name});
            process_variables.push_back(std::move(per_process_variables));
        }
        variable_p = &process_variables[0][0].get();
        variable_u = &process_variables[1][0].get();
    }
 
    DBUG("Associate displacement with process variable '{:s}'.",
         variable_u->getName());
 
    if (variable_u->getNumberOfGlobalComponents() != DisplacementDim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the displacement dimension: got {:d}, expected {:d}",
            variable_u->getName(),
            variable_u->getNumberOfGlobalComponents(),
            DisplacementDim);
    }
 
    DBUG("Associate pressure with process variable '{:s}'.",
         variable_p->getName());
    if (variable_p->getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "Pressure process variable '{:s}' is not a scalar variable but has "
            "{:d} components.",
            variable_p->getName(),
            variable_p->getNumberOfGlobalComponents());
    }
 
    auto solid_constitutive_relations =
        MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
            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 RichardsMechanics process ...");
    checkMPLProperties(media);
    DBUG("Media properties verified.");
 
    // Initial stress conditions
    auto const initial_stress =
        ProcessLib::createInitialStress<DisplacementDim>(config, parameters,
                                                         mesh);
 
    std::optional<MicroPorosityParameters> micro_porosity_parameters;
    if (auto const micro_porosity_config =
        config.getConfigSubtreeOptional("micro_porosity"))
    {
        micro_porosity_parameters = MicroPorosityParameters{
            NumLib::createNewtonRaphsonSolverParameters(
                micro_porosity_config->getConfigSubtree("nonlinear_solver")),
            micro_porosity_config->getConfigParameter<double>(
                "mass_exchange_coefficient")};
    }
 
    auto const mass_lumping =
        config.getConfigParameter<bool>("mass_lumping", false);
 
    auto const explicit_hm_coupling_in_unsaturated_zone =
        config.getConfigParameter<bool>(
            "explicit_hm_coupling_in_unsaturated_zone", false);
 
    auto const is_linear =
        config.getConfigParameter("linear", false);
 
    bool const use_numerical_jacobian =
        jacobian_assembler->isPerturbationEnabled();
 
    RichardsMechanicsProcessData<DisplacementDim> process_data{
        materialIDs(mesh),
        std::move(media_map),
        std::move(solid_constitutive_relations),
        initial_stress,
        specific_body_force,
        micro_porosity_parameters,
        mass_lumping,
        explicit_hm_coupling_in_unsaturated_zone,
        use_numerical_jacobian};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<RichardsMechanicsProcess<DisplacementDim>>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables),
        use_monolithic_scheme, is_linear);
}

References BaseLib::ConfigTree::checkConfigParameter(), checkMPLProperties(), MaterialLib::Solids::createConstitutiveRelations(), ProcessLib::createInitialStress(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), NumLib::createNewtonRaphsonSolverParameters(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), and OGS_FATAL.

createRichardsMechanicsProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 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().

createRichardsMechanicsProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 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().

DMnan()

template<int D>

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

constexpr

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

Definition at line 27 of file RichardsMechanics/ConstitutiveRelations/Base.h.

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

References ProcessLib::ConstitutiveRelations::nan.

DVnan()

template<int D>

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

constexpr

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

Definition at line 20 of file RichardsMechanics/ConstitutiveRelations/Base.h.

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

References ProcessLib::ConstitutiveRelations::nan.

ioName() [1/3]

std::string_view ProcessLib::RichardsMechanics::ioName ( struct DrySolidDensityTag * )

constexpr

Definition at line 15 of file DrySolidDensity.h.

{
    return "dry_density_solid";
}

ioName() [2/3]

std::string_view ProcessLib::RichardsMechanics::ioName ( struct MicroPressureTag * )

constexpr

Definition at line 14 of file MicroPressure.h.

{
    return "micro_pressure";
}

ioName() [3/3]

std::string_view ProcessLib::RichardsMechanics::ioName ( struct MicroSaturationTag * )

constexpr

Definition at line 14 of file MicroSaturation.h.

{
    return "micro_saturation";
}

operator<<()

template<int DisplacementDim>

std::ostream & ProcessLib::RichardsMechanics::operator<<	(	std::ostream &	os,
		MicroPorosityStateSpace< DisplacementDim > const &	state )

Definition at line 38 of file ComputeMicroPorosity.h.

{
    return os << "phi_m: " << state.phi_m << ", "
              << "e_sw: " << state.e_sw << ", "
              << "p_L_m: " << state.p_L_m << ", "
              << "sigma_sw: " << state.sigma_sw.transpose();
}

References ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::e_sw, ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::p_L_m, ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::phi_m, and ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::sigma_sw.

updateSwellingStressAndVolumetricStrain()

template<int DisplacementDim>

void ProcessLib::RichardsMechanics::updateSwellingStressAndVolumetricStrain	(	MaterialPropertyLib::Medium const &	medium,
		MaterialPropertyLib::Phase const &	solid_phase,
		MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > const &	C_el,
		double const	rho_LR,
		double const	mu,
		std::optional< MicroPorosityParameters >	micro_porosity_parameters,
		double const	alpha,
		double const	phi,
		double const	p_cap_ip,
		MPL::VariableArray &	variables,
		MPL::VariableArray &	variables_prev,
		ParameterLib::SpatialPosition const &	x_position,
		double const	t,
		double const	dt,
		ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingDataStateful< DisplacementDim > &	sigma_sw,
		PrevState< ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingDataStateful< DisplacementDim > > const &	sigma_sw_prev,
		PrevState< ProcessLib::ThermoRichardsMechanics::TransportPorosityData > const	phi_M_prev,
		PrevState< ProcessLib::ThermoRichardsMechanics::PorosityData > const	phi_prev,
		ProcessLib::ThermoRichardsMechanics::TransportPorosityData &	phi_M,
		PrevState< MicroPressure > const	p_L_m_prev,
		PrevState< MicroSaturation > const	S_L_m_prev,
		MicroPressure &	p_L_m,
		MicroSaturation &	S_L_m )

Definition at line 27 of file RichardsMechanicsFEM-impl.h.

{
    auto const& identity2 = MathLib::KelvinVector::Invariants<
        MathLib::KelvinVector::kelvin_vector_dimensions(
            DisplacementDim)>::identity2;
 
    if (!medium.hasProperty(MPL::PropertyType::saturation_micro))
    {
        // If there is swelling, compute it. Update volumetric strain rate,
        // s.t. it corresponds to the mechanical part only.
        sigma_sw = *sigma_sw_prev;
        if (solid_phase.hasProperty(MPL::PropertyType::swelling_stress_rate))
        {
            auto const sigma_sw_dot =
                MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
                    MPL::formEigenTensor<3>(
                        solid_phase[MPL::PropertyType::swelling_stress_rate]
                            .value(variables, variables_prev, x_position, t,
                                   dt)));
            sigma_sw.sigma_sw += sigma_sw_dot * dt;
 
            variables.volumetric_mechanical_strain =
                variables.volumetric_strain +
                identity2.transpose() * C_el.inverse() * sigma_sw.sigma_sw;
            variables_prev.volumetric_mechanical_strain =
                variables_prev.volumetric_strain + identity2.transpose() *
                                                       C_el.inverse() *
                                                       sigma_sw_prev->sigma_sw;
        }
        else
        {
            variables.volumetric_mechanical_strain =
                variables.volumetric_strain;
            variables_prev.volumetric_mechanical_strain =
                variables_prev.volumetric_strain;
        }
    }
 
    // TODO (naumov) saturation_micro must be always defined together with
    // the micro_porosity_parameters.
    if (medium.hasProperty(MPL::PropertyType::saturation_micro))
    {
        double const phi_m_prev = phi_prev->phi - phi_M_prev->phi;
 
        auto const [delta_phi_m, delta_e_sw, delta_p_L_m, delta_sigma_sw] =
            computeMicroPorosity<DisplacementDim>(
                identity2.transpose() * C_el.inverse(), rho_LR, mu,
                *micro_porosity_parameters, alpha, phi, -p_cap_ip, **p_L_m_prev,
                variables_prev, **S_L_m_prev, phi_m_prev, x_position, t, dt,
                medium.property(MPL::PropertyType::saturation_micro),
                solid_phase.property(MPL::PropertyType::swelling_stress_rate));
 
        phi_M.phi = phi - (phi_m_prev + delta_phi_m);
        variables_prev.transport_porosity = phi_M_prev->phi;
        variables.transport_porosity = phi_M.phi;
 
        *p_L_m = **p_L_m_prev + delta_p_L_m;
        {  // Update micro saturation.
            MPL::VariableArray variables_prev;
            variables_prev.capillary_pressure = -**p_L_m_prev;
            MPL::VariableArray variables;
            variables.capillary_pressure = -*p_L_m;
 
            *S_L_m = medium.property(MPL::PropertyType::saturation_micro)
                         .template value<double>(variables, x_position, t, dt);
        }
        sigma_sw.sigma_sw = sigma_sw_prev->sigma_sw + delta_sigma_sw;
    }
}

References MaterialPropertyLib::VariableArray::capillary_pressure, computeMicroPorosity(), MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::Medium::hasProperty(), MaterialPropertyLib::Phase::hasProperty(), MathLib::KelvinVector::kelvin_vector_dimensions(), ProcessLib::ThermoRichardsMechanics::TransportPorosityData::phi, MaterialPropertyLib::Medium::property(), MaterialPropertyLib::Phase::property(), MaterialPropertyLib::saturation_micro, MaterialPropertyLib::swelling_stress_rate, MathLib::KelvinVector::tensorToKelvin(), MaterialPropertyLib::VariableArray::transport_porosity, MaterialPropertyLib::VariableArray::volumetric_mechanical_strain, and MaterialPropertyLib::VariableArray::volumetric_strain.

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianEvalConstitutiveSetting(), and ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete().