ProcessLib::ThermoRichardsFlow Namespace Reference

Classes
struct	HydrostaticElasticityModel
struct	IntegrationPointData
struct	LocalAssemblerInterface
struct	RigidElasticityModel
struct	SimplifiedElasticityModel
class	ThermoRichardsFlowLocalAssembler
class	ThermoRichardsFlowProcess
	Global assembler for the monolithic scheme of the non-isothermal Richards flow. More...
struct	ThermoRichardsFlowProcessData
struct	UniaxialElasticityModel
struct	UserDefinedElasticityModel

Functions
std::unique_ptr< SimplifiedElasticityModel >	createElasticityModel (BaseLib::ConfigTree const &config)
void	checkMPLProperties (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
void	checkProcessVariableComponents (ProcessVariable const &variable)
std::unique_ptr< Process >	createThermoRichardsFlowProcess (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, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)

Function Documentation

checkMPLProperties()

void ProcessLib::ThermoRichardsFlow::checkMPLProperties

(

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

media

)

Definition at line 33 of file CreateThermoRichardsFlowProcess.cpp.

{
    std::array const required_medium_properties = {
        MaterialPropertyLib::permeability, MaterialPropertyLib::porosity,
        MaterialPropertyLib::biot_coefficient,
        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::density, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::relative_permeability, MaterialPropertyLib::saturation, and MaterialPropertyLib::viscosity.

Referenced by createThermoRichardsFlowProcess().

checkProcessVariableComponents()

void ProcessLib::ThermoRichardsFlow::checkProcessVariableComponents

(

ProcessVariable const &

variable

)

Definition at line 59 of file CreateThermoRichardsFlowProcess.cpp.

{
    if (variable.getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from one: got {:d}.",
            variable.getName(),
            variable.getNumberOfGlobalComponents());
    }
}

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

Referenced by createThermoRichardsFlowProcess().

createElasticityModel()

std::unique_ptr< SimplifiedElasticityModel > ProcessLib::ThermoRichardsFlow::createElasticityModel

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__simplified_elasticity

Definition at line 27 of file CreateSimplifiedElasticityModel.cpp.

{
    std::unique_ptr<SimplifiedElasticityModel> simplified_elasticity =
        std::make_unique<RigidElasticityModel>();
    if (auto const simplified_elasticity_switch =
        config.getConfigParameterOptional<std::string>("simplified_elasticity"))
    {
        DBUG("Using simplified_elasticity for the Richards flow equation");
        if (*simplified_elasticity_switch == "uniaxial")
        {
            DBUG("assuming local uniaxial deformation only.");
            simplified_elasticity = std::make_unique<UniaxialElasticityModel>();
        }
        else if (*simplified_elasticity_switch == "hydrostatic")
        {
            DBUG("assuming constant hydrostatic stress locally.");
            simplified_elasticity =
                std::make_unique<HydrostaticElasticityModel>();
        }
        else if (*simplified_elasticity_switch == "user_defined")
        {
            DBUG("using user defined elasticity model.");
            simplified_elasticity =
                std::make_unique<UserDefinedElasticityModel>();
        }
        else if (*simplified_elasticity_switch == "rigid")
        {
            DBUG("using user defined elasticity model.");
            simplified_elasticity = std::make_unique<RigidElasticityModel>();
        }
    }
    return simplified_elasticity;
}

References DBUG(), and BaseLib::ConfigTree::getConfigParameterOptional().

Referenced by createThermoRichardsFlowProcess().

createThermoRichardsFlowProcess()

std::unique_ptr< Process > ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess	(	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,
		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_FLOW__coupling_scheme

Process Variables

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__process_variables

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

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__process_variables__temperature

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__process_variables__pressure

Process Parameters

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__specific_body_force

Input File Parameter

prj__processes__process__THERMO_RICHARDS_FLOW__mass_lumping

Definition at line 71 of file CreateThermoRichardsFlowProcess.cpp.

{
    config.checkConfigParameter("type", "THERMO_RICHARDS_FLOW");
    DBUG("Create ThermoRichardsFlowProcess.");
 
    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;
    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"});
        variable_T = &per_process_variables[0].get();
        variable_p = &per_process_variables[1].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_FLOW");
    }
 
    checkProcessVariableComponents(*variable_T);
    checkProcessVariableComponents(*variable_p);
 
    // Specific body force parameter.
    Eigen::VectorXd specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.size() != mesh.getDimension())
        {
            OGS_FATAL(
                "specific body force (gravity vector) has {:d} components, "
                "but mesh dimension is {:d}",
                b.size(), mesh.getDimension());
        }
        specific_body_force.resize(b.size());
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
    DBUG(
        "Check the media properties of ThermoRichardsFlow process "
        "...");
    checkMPLProperties(media);
    DBUG("Media properties verified.");
 
    bool const mass_lumping =
        config.getConfigParameter<bool>("mass_lumping", false);
 
    std::unique_ptr<SimplifiedElasticityModel> simplified_elasticity =
        createElasticityModel(config);
 
    ThermoRichardsFlowProcessData process_data{
        std::move(media_map), std::move(specific_body_force), mass_lumping,
        std::move(simplified_elasticity)};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<ThermoRichardsFlowProcess>(
        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);
}

References BaseLib::ConfigTree::checkConfigParameter(), checkMPLProperties(), checkProcessVariableComponents(), createElasticityModel(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), MeshLib::Mesh::getDimension(), and OGS_FATAL.

Referenced by ProjectData::parseProcesses().