ProcessLib::HydroMechanics Namespace Reference

Namespaces
	detail

Classes
struct	IntegrationPointData
struct	SecondaryData
class	HydroMechanicsLocalAssembler
class	HydroMechanicsProcess
struct	HydroMechanicsProcessData
struct	LocalAssemblerInterface
class	LocalDataInitializer

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

Function Documentation

createHydroMechanicsProcess()

template<int DisplacementDim>

std::unique_ptr< Process > ProcessLib::HydroMechanics::createHydroMechanicsProcess	(	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__HYDRO_MECHANICS__coupling_scheme

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__process_variables

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__process_variables__pressure

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__process_variables__displacement

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__specific_body_force

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__mass_lumping

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS__initial_stress

Definition at line 32 of file CreateHydroMechanicsProcess.cpp.

{
    config.checkConfigParameter("type", "HYDRO_MECHANICS");
    DBUG("Create HydroMechanicsProcess.");
 
    if (DisplacementDim == 2)
    {
        if (mesh.isAxiallySymmetric() &&
            MeshLib::is2DMeshOnRotatedVerticalPlane(mesh))
        {
            OGS_FATAL(
                "Mesh {:s} is on a plane rotated around the vertical axis. The "
                "axisymmetric problem can not use such mesh.",
                mesh.getName());
        }
    }
 
    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_p;
    ProcessVariable* variable_u;
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
 
    int const hydraulic_process_id = 0;
    int mechanics_related_process_id = 0;
 
    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));
        }
        mechanics_related_process_id = 1;
        variable_p = &process_variables[hydraulic_process_id][0].get();
        variable_u = &process_variables[mechanics_related_process_id][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, 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 mass_lumping = config.getConfigParameter<bool>("mass_lumping", false);
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    std::array const requiredMediumProperties = {
        MaterialPropertyLib::reference_temperature,
        MaterialPropertyLib::permeability, MaterialPropertyLib::porosity,
        MaterialPropertyLib::biot_coefficient};
    std::array const requiredFluidProperties = {MaterialPropertyLib::viscosity,
                                                MaterialPropertyLib::density};
    std::array const requiredSolidProperties = {MaterialPropertyLib::density};
 
    for (auto const& element : mesh.getElements())
    {
        auto const element_id = element->getID();
        media_map->checkElementHasMedium(element_id);
        auto const& medium = *media_map->getMedium(element_id);
        checkRequiredProperties(medium, requiredMediumProperties);
        checkRequiredProperties(fluidPhase(medium), requiredFluidProperties);
        checkRequiredProperties(medium.phase("Solid"), requiredSolidProperties);
    }
    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);
 
    HydroMechanicsProcessData<DisplacementDim> process_data{
        materialIDs(mesh),
        std::move(media_map),
        std::move(solid_constitutive_relations),
        initial_stress,
        specific_body_force,
        mass_lumping,
        hydraulic_process_id,
        mechanics_related_process_id};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<HydroMechanicsProcess<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 MaterialPropertyLib::biot_coefficient, BaseLib::ConfigTree::checkConfigParameter(), MaterialPropertyLib::checkRequiredProperties(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), MaterialPropertyLib::density, ProcessLib::findProcessVariables(), MaterialPropertyLib::fluidPhase(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), MeshLib::is2DMeshOnRotatedVerticalPlane(), MeshLib::Mesh::isAxiallySymmetric(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, OGS_FATAL, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::reference_temperature, and MaterialPropertyLib::viscosity.

Referenced by ProjectData::parseProcesses().

createHydroMechanicsProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::HydroMechanics::createHydroMechanicsProcess< 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
	)

createHydroMechanicsProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::HydroMechanics::createHydroMechanicsProcess< 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
	)

createLocalAssemblers()

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

void ProcessLib::HydroMechanics::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::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess().