ProcessLib::ThermoHydroMechanics Namespace Reference

Namespaces
	detail

Classes
struct	IntegrationPointData
struct	LocalAssemblerInterface
class	LocalDataInitializer
struct	SecondaryData
class	ThermoHydroMechanicsLocalAssembler
class	ThermoHydroMechanicsProcess
struct	ThermoHydroMechanicsProcessData

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

createLocalAssemblers()

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

void ProcessLib::ThermoHydroMechanics::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 70 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::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess().

createThermoHydroMechanicsProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess	(	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_HYDRO_MECHANICS__coupling_scheme

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__process_variables

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__process_variables__temperature

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__process_variables__pressure

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__process_variables__displacement

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__specific_body_force

Input File Parameter:

prj__processes__process__THERMO_HYDRO_MECHANICS__initial_stress

Definition at line 30 of file CreateThermoHydroMechanicsProcess.cpp.

{
    config.checkConfigParameter("type", "THERMO_HYDRO_MECHANICS");
    DBUG("Create ThermoHydroMechanicsProcess.");
 
    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.
    {
        using namespace std::string_literals;
        for (auto const& variable_name :
             {"temperature"s, "pressure"s, "displacement"s})
        {
            auto per_process_variables =
                findProcessVariables(variables, pv_config, {variable_name});
            process_variables.push_back(std::move(per_process_variables));
        }
        variable_T = &process_variables[0][0].get();
        variable_p = &process_variables[1][0].get();
        variable_u = &process_variables[2][0].get();
    }
 
    if (variable_T->getShapeFunctionOrder() != 1)
    {
        OGS_FATAL(
            "The shape function order of temperature must be 1 but its input "
            "value in <process_variable><order> is {:d}. Please correct it.",
            variable_T->getShapeFunctionOrder());
    }
    if (variable_p->getShapeFunctionOrder() != 1)
    {
        OGS_FATAL(
            "The shape function order of pressure must be 1 but its input "
            "value in <process_variable><order> is {:d}. Please correct it.",
            variable_p->getShapeFunctionOrder());
    }
 
    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());
    }
 
    DBUG("Associate temperature with process variable '{:s}'.",
         variable_T->getName());
    if (variable_T->getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "temperature process variable '{:s}' is not a scalar variable but "
            "has {:d} components.",
            variable_T->getName(),
            variable_T->getNumberOfGlobalComponents());
    }
 
    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);
 
    // 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);
 
    ThermoHydroMechanicsProcessData<DisplacementDim> process_data{
        materialIDs(mesh), std::move(media_map),
        std::move(solid_constitutive_relations), initial_stress,
        specific_body_force};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<ThermoHydroMechanicsProcess<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(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), ProcessLib::ProcessVariable::getShapeFunctionOrder(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, and OGS_FATAL.

createThermoHydroMechanicsProcess< 2 >()

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

createThermoHydroMechanicsProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess< 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
	)

Referenced by ProjectData::parseProcesses().