Namespaces
namespace	detail

Classes
class	HydroMechanicsLocalAssemblerFracture

class	HydroMechanicsLocalAssemblerInterface

class	HydroMechanicsLocalAssemblerMatrix

class	HydroMechanicsLocalAssemblerMatrixNearFracture

class	HydroMechanicsProcess

struct	HydroMechanicsProcessData

struct	IntegrationPointDataFracture

struct	IntegrationPointDataMatrix

class	LocalDataInitializer

struct	SecondaryData
	Used for the extrapolation of the integration point values. More...

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

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

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

template<int GlobalDim, template< typename, typename, int > class LocalAssemblerMatrixImplementation, template< typename, typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, typename, int > class LocalAssemblerFractureImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, std::vector< std::unique_ptr< LocalAssemblerInterface > > &local_assemblers, NumLib::IntegrationOrder const integration_order, ExtraCtorArgs &&... extra_ctor_args)

template<int GlobalDim, typename RotationMatrix >
Eigen::Matrix< double, GlobalDim, GlobalDim >	createRotatedTensor (RotationMatrix const &R, double const value)

Function Documentation

◆ createHydroMechanicsProcess()

template<int GlobalDim>

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

Input File Parameter: prj__processes__process__type

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__coupling_scheme

Process Variables

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__process_variables

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

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__process_variables__process_variable

Process Parameters

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__intrinsic_permeability

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__specific_storage

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fluid_viscosity

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fluid_density

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__biot_coefficient

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__porosity

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__solid_density

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__specific_body_force

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_model

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_model__type

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties__material_id

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties__initial_aperture

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties__specific_storage

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties__biot_coefficient

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__fracture_properties__permeability_model

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__initial_effective_stress

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__initial_fracture_effective_stress

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__deactivate_matrix_in_flow

Input File Parameter: prj__processes__process__HYDRO_MECHANICS_WITH_LIE__reference_temperature

Definition at line 32 of file CreateHydroMechanicsProcess.cpp.

{
    config.checkConfigParameter("type", "HYDRO_MECHANICS_WITH_LIE");
    DBUG("Create HydroMechanicsProcess with LIE.");
    auto const coupling_scheme =
        config.getConfigParameterOptional<std::string>("coupling_scheme");
    const bool use_monolithic_scheme =
        !(coupling_scheme && (*coupling_scheme == "staggered"));
 
    auto const pv_conf = config.getConfigSubtree("process_variables");
    auto range =
        pv_conf.getConfigParameterList<std::string>("process_variable");
    std::vector<std::reference_wrapper<ProcessVariable>> p_u_process_variables;
    std::vector<std::reference_wrapper<ProcessVariable>> p_process_variables;
    std::vector<std::reference_wrapper<ProcessVariable>> u_process_variables;
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
    for (std::string const& pv_name : range)
    {
        if (pv_name != "pressure" && pv_name != "displacement" &&
            !pv_name.starts_with("displacement_jump"))
        {
            OGS_FATAL(
                "Found a process variable name '{}'. It should be "
                "'displacement' or 'displacement_jumpN' or 'pressure'",
                pv_name);
        }
        auto variable = std::find_if(variables.cbegin(), variables.cend(),
                                     [&pv_name](ProcessVariable const& v)
                                     { return v.getName() == pv_name; });
 
        if (variable == variables.end())
        {
            OGS_FATAL(
                "Could not find process variable '{:s}' in the provided "
                "variables list for config tag <{:s}>.",
                pv_name, "process_variable");
        }
        DBUG("Found process variable '{:s}' for config tag <{:s}>.",
             variable->getName(), "process_variable");
 
        if (pv_name.find("displacement") != std::string::npos &&
            variable->getNumberOfGlobalComponents() != GlobalDim)
        {
            OGS_FATAL(
                "Number of components of the process variable '{:s}' is "
                "different from the displacement dimension: got {:d}, expected "
                "{:d}",
                variable->getName(),
                variable->getNumberOfGlobalComponents(),
                GlobalDim);
        }
 
        if (!use_monolithic_scheme)
        {
            if (pv_name == "pressure")
            {
                p_process_variables.emplace_back(
                    const_cast<ProcessVariable&>(*variable));
            }
            else
            {
                u_process_variables.emplace_back(
                    const_cast<ProcessVariable&>(*variable));
            }
        }
        else
        {
            p_u_process_variables.emplace_back(
                const_cast<ProcessVariable&>(*variable));
        }
    }
 
    if (p_u_process_variables.size() > 3 || u_process_variables.size() > 2)
    {
        OGS_FATAL("Currently only one displacement jump is supported");
    }
 
    if (!use_monolithic_scheme)
    {
        process_variables.push_back(std::move(p_process_variables));
        process_variables.push_back(std::move(u_process_variables));
    }
    else
    {
        process_variables.push_back(std::move(p_u_process_variables));
    }
 
    auto solid_constitutive_relations =
        MaterialLib::Solids::createConstitutiveRelations<GlobalDim>(
            parameters, local_coordinate_system, config);
 
    // Intrinsic permeability
    auto& intrinsic_permeability = ParameterLib::findParameter<double>(
        config,
        "intrinsic_permeability", parameters, 1, &mesh);
 
    DBUG("Use '{:s}' as intrinsic permeability parameter.",
         intrinsic_permeability.name);
 
    // Storage coefficient
    auto& specific_storage = ParameterLib::findParameter<double>(
        config,
        "specific_storage", parameters, 1, &mesh);
 
    DBUG("Use '{:s}' as specific storage parameter.", specific_storage.name);
 
    // Fluid viscosity
    auto& fluid_viscosity = ParameterLib::findParameter<double>(
        config,
        "fluid_viscosity", parameters, 1, &mesh);
    DBUG("Use '{:s}' as fluid viscosity parameter.", fluid_viscosity.name);
 
    // Fluid density
    auto& fluid_density = ParameterLib::findParameter<double>(
        config,
        "fluid_density", parameters, 1, &mesh);
    DBUG("Use '{:s}' as fluid density parameter.", fluid_density.name);
 
    // Biot coefficient
    auto& biot_coefficient = ParameterLib::findParameter<double>(
        config,
        "biot_coefficient", parameters, 1, &mesh);
    DBUG("Use '{:s}' as Biot coefficient parameter.", biot_coefficient.name);
 
    // Porosity
    auto& porosity = ParameterLib::findParameter<double>(
        config,
        "porosity", parameters, 1, &mesh);
    DBUG("Use '{:s}' as porosity parameter.", porosity.name);
 
    // Solid density
    auto& solid_density = ParameterLib::findParameter<double>(
        config,
        "solid_density", parameters, 1, &mesh);
    DBUG("Use '{:s}' as solid density parameter.", solid_density.name);
 
    // Specific body force
    Eigen::Matrix<double, GlobalDim, 1> specific_body_force;
    {
        std::vector<double> const b =
            config.getConfigParameter<std::vector<double>>(
                "specific_body_force");
        if (b.size() != GlobalDim)
        {
            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(), GlobalDim);
        }
 
        std::copy_n(b.data(), b.size(), specific_body_force.data());
    }
 
    // Fracture constitutive relation.
    std::unique_ptr<MaterialLib::Fracture::FractureModelBase<GlobalDim>>
        fracture_model = nullptr;
    auto const opt_fracture_model_config =
        config.getConfigSubtreeOptional("fracture_model");
    if (opt_fracture_model_config)
    {
        auto& fracture_model_config = *opt_fracture_model_config;
 
        auto const frac_type =
            fracture_model_config.peekConfigParameter<std::string>("type");
 
        if (frac_type == "LinearElasticIsotropic")
        {
            fracture_model =
                MaterialLib::Fracture::createLinearElasticIsotropic<GlobalDim>(
                    parameters, fracture_model_config);
        }
        else if (frac_type == "Coulomb")
        {
            fracture_model = MaterialLib::Fracture::createCoulomb<GlobalDim>(
                parameters, fracture_model_config);
        }
        else if (frac_type == "CohesiveZoneModeI")
        {
            fracture_model = MaterialLib::Fracture::CohesiveZoneModeI::
                createCohesiveZoneModeI<GlobalDim>(parameters,
                                                   fracture_model_config);
        }
        else
        {
            OGS_FATAL(
                "Cannot construct fracture constitutive relation of given type "
                "'{:s}'.",
                frac_type);
        }
    }
 
    // Fracture properties
    std::unique_ptr<FracturePropertyHM> frac_prop = nullptr;
    auto opt_fracture_properties_config =
        config.getConfigSubtreeOptional("fracture_properties");
    if (opt_fracture_properties_config)
    {
        auto& fracture_properties_config = *opt_fracture_properties_config;
 
        frac_prop = std::make_unique<ProcessLib::LIE::FracturePropertyHM>(
            0 /*fracture_id*/,
            fracture_properties_config.getConfigParameter<int>("material_id"),
            ParameterLib::findParameter<double>(
                fracture_properties_config, "initial_aperture", parameters, 1,
                &mesh),
            ParameterLib::findParameter<double>(
                fracture_properties_config, "specific_storage", parameters, 1,
                &mesh),
            ParameterLib::findParameter<double>(
                fracture_properties_config, "biot_coefficient", parameters, 1,
                &mesh));
        if (frac_prop->aperture0.isTimeDependent())
        {
            OGS_FATAL(
                "The initial aperture parameter '{:s}' must not be "
                "time-dependent.",
                frac_prop->aperture0.name);
        }
 
        auto permeability_model_config =
            fracture_properties_config.getConfigSubtree("permeability_model");
        frac_prop->permeability_model =
            MaterialLib::Fracture::Permeability::createPermeabilityModel(
                permeability_model_config);
    }
 
    // initial effective stress in matrix
    auto& initial_effective_stress = ParameterLib::findParameter<double>(
        config,
        "initial_effective_stress", parameters,
        MathLib::KelvinVector::kelvin_vector_dimensions(GlobalDim), &mesh);
    DBUG("Use '{:s}' as initial effective stress parameter.",
         initial_effective_stress.name);
 
    // initial effective stress in fracture
    auto& initial_fracture_effective_stress = ParameterLib::findParameter<
        double>(
        config,
        "initial_fracture_effective_stress", parameters, GlobalDim, &mesh);
    DBUG("Use '{:s}' as initial fracture effective stress parameter.",
         initial_fracture_effective_stress.name);
 
    // deactivation of matrix elements in flow
    auto opt_deactivate_matrix_in_flow =
        config.getConfigParameterOptional<bool>("deactivate_matrix_in_flow");
    bool const deactivate_matrix_in_flow =
        opt_deactivate_matrix_in_flow && *opt_deactivate_matrix_in_flow;
    ;
    if (deactivate_matrix_in_flow)
        INFO("Deactivate matrix elements in flow calculation.");
 
    // Reference temperature
    const auto& reference_temperature =
        config.getConfigParameter<double>(
            "reference_temperature", std::numeric_limits<double>::quiet_NaN());
 
    HydroMechanicsProcessData<GlobalDim> process_data{
        materialIDs(mesh),
        std::move(solid_constitutive_relations),
        intrinsic_permeability,
        specific_storage,
        fluid_viscosity,
        fluid_density,
        biot_coefficient,
        porosity,
        solid_density,
        specific_body_force,
        std::move(fracture_model),
        std::move(frac_prop),
        initial_effective_stress,
        initial_fracture_effective_stress,
        deactivate_matrix_in_flow,
        reference_temperature};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<HydroMechanicsProcess<GlobalDim>>(
        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(), MaterialLib::Fracture::Permeability::createPermeabilityModel(), ProcessLib::createSecondaryVariables(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), MathLib::KelvinVector::kelvin_vector_dimensions(), and OGS_FATAL.

◆ createHydroMechanicsProcess< 2 >()

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

Referenced by ProjectData::parseProcesses().

◆ createHydroMechanicsProcess< 3 >()

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

Referenced by ProjectData::parseProcesses().

◆ createLocalAssemblers()

template<int GlobalDim, template< typename, typename, int > class LocalAssemblerMatrixImplementation, template< typename, typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, typename, int > class LocalAssemblerFractureImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::LIE::HydroMechanics::createLocalAssemblers	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		std::vector< std::unique_ptr< LocalAssemblerInterface > > &	local_assemblers,
		NumLib::IntegrationOrder const	integration_order,
		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 80 of file CreateLocalAssemblers.h.

{
    detail::createLocalAssemblers<
        GlobalDim, LocalAssemblerMatrixImplementation,
        LocalAssemblerMatrixNearFractureImplementation,
        LocalAssemblerFractureImplementation>(
        dof_table, mesh_elements, local_assemblers, integration_order,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References ProcessLib::LIE::HydroMechanics::detail::createLocalAssemblers().

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::initializeConcreteProcess().

◆ createRotatedTensor()

template<int GlobalDim, typename RotationMatrix >

Eigen::Matrix< double, GlobalDim, GlobalDim > ProcessLib::LIE::HydroMechanics::createRotatedTensor	(	RotationMatrix const &	R,
		double const	value )

Definition at line 28 of file HydroMechanicsLocalAssemblerFracture-impl.h.

{
    using M = Eigen::Matrix<double, GlobalDim, GlobalDim>;
    M tensor = M::Zero();
    tensor.diagonal().head(GlobalDim - 1).setConstant(value);
    return (R.transpose() * tensor * R).eval();
}

Namespaces

Classes

Functions