Namespaces
	detail

Classes
struct	IntegrationPointData

struct	LocalAssemblerInterface

class	LocalDataInitializer

struct	SecondaryData

class	ThermoRichardsMechanicsLocalAssembler

class	ThermoRichardsMechanicsProcess
	Global assembler for the monolithic scheme of the non-isothermal Richards flow coupled with mechanics. More...

struct	ThermoRichardsMechanicsProcessData

Functions
template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (const unsigned, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)

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

void	checkProcessVariableComponents (ProcessVariable const &variable, const int dim)

template<int DisplacementDim>
std::unique_ptr< Process >	createThermoRichardsMechanicsProcess (std::string 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 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 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)

Function Documentation

◆ checkMPLProperties()

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

Definition at line 30 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
     // meduim 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::checkRequiredProperties(), MaterialPropertyLib::density, MaterialPropertyLib::porosity, MaterialPropertyLib::relative_permeability, MaterialPropertyLib::saturation, and MaterialPropertyLib::viscosity.

Referenced by createThermoRichardsMechanicsProcess().

◆ checkProcessVariableComponents()

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

Definition at line 54 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 createThermoRichardsMechanicsProcess().

◆ createLocalAssemblers()

template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::ThermoRichardsMechanics::createLocalAssemblers	(	const unsigned	,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		const unsigned	shapefunction_order,
		std::vector< std::unique_ptr< LocalAssemblerInterface >> &	local_assemblers,
		ExtraCtorArgs &&...	extra_ctor_args
	)

Creates local assemblers for each element of the given mesh.

Template Parameters

LocalAssemblerImplementation	the individual local assembler type
LocalAssemblerInterface	the general local assembler interface
ExtraCtorArgs	types of additional constructor arguments. Those arguments will be passed to the constructor of `LocalAssemblerImplementation`.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 68 of file CreateLocalAssemblers.h.

 {
     DBUG("Create local assemblers.");
  
     detail::createLocalAssemblers<GlobalDim, LocalAssemblerImplementation>(
         dof_table, shapefunction_order, mesh_elements, local_assemblers,
         std::forward<ExtraCtorArgs>(extra_ctor_args)...);
 }

References DBUG().

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

◆ createThermoRichardsMechanicsProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess	(	std::string	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__coupling_scheme

Input File Parameter:: prj__processes__process__THERMO_RICHARDS_MECHANICS__process_variables

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

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

Definition at line 72 of file CreateThermoRichardsMechanicsProcess.cpp.

 {
     config.checkConfigParameter("type", "THERMO_RICHARDS_MECHANICS");
     DBUG("Create ThermoRichardsMechanicsProcess.");
  
     auto const coupling_scheme =
         config.getConfigParameterOptional<std::string>("coupling_scheme");
     const bool use_monolithic_scheme =
         !(coupling_scheme && (*coupling_scheme == "staggered"));
  
     // Process variable.
  
     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 =
         MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
             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;
     }
  
     ThermoRichardsMechanicsProcessData<DisplacementDim> process_data{
         materialIDs(mesh),
         std::move(media_map),
         std::move(solid_constitutive_relations),
         initial_stress,
         specific_body_force,
         mass_lumping};
  
     SecondaryVariableCollection secondary_variables;
  
     ProcessLib::createSecondaryVariables(config, secondary_variables);
  
     return std::make_unique<ThermoRichardsMechanicsProcess<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);
 }

References BaseLib::ConfigTree::checkConfigParameter(), checkMPLProperties(), checkProcessVariableComponents(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, and OGS_FATAL.

◆ createThermoRichardsMechanicsProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess< 2 >	(	std::string	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	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
	)