ProcessLib::LIE::HydroMechanics Namespace Reference

Namespaces
	detail

Classes
class	HydroMechanicsProcess
struct	HydroMechanicsProcessData
class	HydroMechanicsLocalAssemblerFracture
class	HydroMechanicsLocalAssemblerInterface
class	HydroMechanicsLocalAssemblerMatrix
class	HydroMechanicsLocalAssemblerMatrixNearFracture
struct	IntegrationPointDataFracture
struct	IntegrationPointDataMatrix
class	LocalDataInitializer

Functions
template<int GlobalDim>
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)
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)
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)
template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerMatrixImplementation, template< typename, typename, typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, typename, typename, int > class LocalAssemblerFractureImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (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 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	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

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS_WITH_LIE__process_variables

Input File Parameter:

prj__processes__process__HYDRO_MECHANICS_WITH_LIE__process_variables__process_variable

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"));
 
    // Process variables
    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.find("displacement_jump") != 0)
        {
            OGS_FATAL(
                "Found a process variable name '{:s}'. It should be "
                "'displacement' or 'displacement_jumpN' or 'pressure'");
        }
        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 MaterialPropertyLib::biot_coefficient, BaseLib::ConfigTree::checkConfigParameter(), MaterialLib::Fracture::Permeability::createPermeabilityModel(), ProcessLib::createSecondaryVariables(), DBUG(), ParameterLib::findParameter(), ProcessLib::TES::fluid_density(), ProcessLib::TES::fluid_viscosity(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterList(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, OGS_FATAL, and MaterialPropertyLib::reference_temperature.

createHydroMechanicsProcess< 2 >()

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

Referenced by ProjectData::parseProcesses().

createHydroMechanicsProcess< 3 >()

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

Referenced by ProjectData::parseProcesses().

createLocalAssemblers()

template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerMatrixImplementation, template< typename, typename, typename, int > class LocalAssemblerMatrixNearFractureImplementation, template< typename, 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,
		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 82 of file CreateLocalAssemblers.h.

{
    detail::createLocalAssemblers<
        GlobalDim, LocalAssemblerMatrixImplementation,
        LocalAssemblerMatrixNearFractureImplementation,
        LocalAssemblerFractureImplementation>(
        dof_table, shapefunction_order, mesh_elements, local_assemblers,
        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 25 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();
}