MaterialLib::Solids Namespace Reference

Namespaces
namespace	Creep
namespace	Ehlers
namespace	Lubby2
namespace	MFront
namespace	Phasefield

Classes
class	LinearElasticIsotropic
class	LinearElasticOrthotropic
class	LinearElasticTransverseIsotropic
	Linear transverse isotropic elastic model. More...
struct	MechanicsBase

Enumerations
enum class	ConstitutiveModel {   Ehlers , LinearElasticIsotropic , Lubby2 , CreepBGRa ,   Invalid }

Functions
template<int DisplacementDim>
std::unique_ptr< MaterialLib::Solids::MechanicsBase< DisplacementDim > >	createConstitutiveRelation (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 2 > >	createConstitutiveRelation (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< DisplacementDim > > >	createConstitutiveRelations (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, MeshLib::PropertyVector< int > const *const material_ids, BaseLib::ConfigTree const &config)
template std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< 2 > > >	createConstitutiveRelations< 2 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, MeshLib::PropertyVector< int > const *const material_ids, BaseLib::ConfigTree const &config)
template std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< 3 > > >	createConstitutiveRelations< 3 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, MeshLib::PropertyVector< int > const *const material_ids, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
std::unique_ptr< MaterialLib::Solids::MechanicsBase< DisplacementDim > >	createConstitutiveRelationIce (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 2 > >	createConstitutiveRelationIce (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template<typename SolidConstitutiveRelation >
std::map< int, std::shared_ptr< SolidConstitutiveRelation > >	createConstitutiveRelationsGeneric (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, MeshLib::PropertyVector< int > const *const material_ids, BaseLib::ConfigTree const &config, std::unique_ptr< SolidConstitutiveRelation >(*create_constitutive_relation)(std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &, std::optional< ParameterLib::CoordinateSystem > const &, BaseLib::ConfigTree const &))
template<int DisplacementDim>
std::unique_ptr< LinearElasticIsotropic< DisplacementDim > >	createLinearElasticIsotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, BaseLib::ConfigTree const &config, const bool skip_type_checking)
template<int DisplacementDim>
std::unique_ptr< LinearElasticOrthotropic< DisplacementDim > >	createLinearElasticOrthotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config, const bool skip_type_checking)
template std::unique_ptr< LinearElasticOrthotropic< 2 > >	createLinearElasticOrthotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config, const bool skip_type_checking)
template<int DisplacementDim>
std::unique_ptr< LinearElasticTransverseIsotropic< DisplacementDim > >	createLinearElasticTransverseIsotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config, const bool skip_type_checking)
template std::unique_ptr< LinearElasticTransverseIsotropic< 2 > >	createLinearElasticTransverseIsotropic (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config, const bool skip_type_checking)
template<int DisplacementDim>
MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >	elasticTangentStiffness (double const first_lame_parameter, double const shear_modulus)
template<typename SolidMaterialsMap >
auto &	selectSolidConstitutiveRelation (SolidMaterialsMap const &constitutive_relations, MeshLib::PropertyVector< int > const *const material_ids, std::size_t const element_id)

Enumeration Type Documentation

ConstitutiveModel

enum class MaterialLib::Solids::ConstitutiveModel

strong

Enumerator
Ehlers
LinearElasticIsotropic
Lubby2
CreepBGRa
Invalid

Definition at line 37 of file MechanicsBase.h.

{
    Ehlers,
    LinearElasticIsotropic,
    Lubby2,
    CreepBGRa,
    Invalid
};

Function Documentation

createConstitutiveRelation() [1/2]

template<int DisplacementDim>

template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 3 > > MaterialLib::Solids::createConstitutiveRelation	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

Input File Parameter

material__solid__constitutive_relation__type

Definition at line 33 of file CreateConstitutiveRelation.cpp.

{
    auto const type =
        config.peekConfigParameter<std::string>("type");
 
    if (type == "Ehlers")
    {
        return MaterialLib::Solids::Ehlers::createEhlers<DisplacementDim>(
            parameters, config);
    }
    if (type == "LinearElasticIsotropic")
    {
        const bool skip_type_checking = false;
        return MaterialLib::Solids::createLinearElasticIsotropic<
            DisplacementDim>(parameters, config, skip_type_checking);
    }
    if (type == "LinearElasticOrthotropic")
    {
        const bool skip_type_checking = false;
        return MaterialLib::Solids::createLinearElasticOrthotropic<
            DisplacementDim>(
            parameters, local_coordinate_system, config, skip_type_checking);
    }
    if (type == "LinearElasticTransverseIsotropic")
    {
        const bool skip_type_checking = false;
        return MaterialLib::Solids::createLinearElasticTransverseIsotropic<
            DisplacementDim>(
            parameters, local_coordinate_system, config, skip_type_checking);
    }
    if (type == "Lubby2")
    {
        return MaterialLib::Solids::Lubby2::createLubby2<DisplacementDim>(
            parameters, config);
    }
    if (type == "CreepBGRa")
    {
        return MaterialLib::Solids::Creep::createCreepBGRa<DisplacementDim>(
            parameters, config);
    }
    if (type == "MFront")
    {
#ifdef OGS_USE_MFRONT
        return MaterialLib::Solids::MFront::createMFront<DisplacementDim>(
            parameters, local_coordinate_system, config);
#else   // OGS_USE_MFRONT
        OGS_FATAL(
            "OGS is compiled without MFront support. See OGS_USE_MFRONT CMake "
            "option.");
#endif  // OGS_USE_MFRONT
    }
    OGS_FATAL("Cannot construct constitutive relation of given type '{:s}'.",
              type);
}

References MaterialLib::Solids::Creep::createCreepBGRa(), MaterialLib::Solids::Ehlers::createEhlers(), createLinearElasticIsotropic(), createLinearElasticOrthotropic(), createLinearElasticTransverseIsotropic(), MaterialLib::Solids::Lubby2::createLubby2(), MaterialLib::Solids::MFront::createMFront(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by createConstitutiveRelationIce(), and createConstitutiveRelations().

createConstitutiveRelation() [2/2]

template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 2 > > MaterialLib::Solids::createConstitutiveRelation	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

createConstitutiveRelationIce() [1/2]

template<int DisplacementDim>

template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 3 > > MaterialLib::Solids::createConstitutiveRelationIce	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

Input File Parameter

material__solid__ice_constitutive_relation

Definition at line 22 of file CreateConstitutiveRelationIce.cpp.

{
    auto const ice_constitutive_relation_config =
        config.getConfigSubtreeOptional("ice_constitutive_relation");
 
    if (!ice_constitutive_relation_config)
    {
        return nullptr;
    }
 
    return MaterialLib::Solids::createConstitutiveRelation<DisplacementDim>(
        parameters, local_coordinate_system, *ice_constitutive_relation_config);
}

References createConstitutiveRelation(), and BaseLib::ConfigTree::getConfigSubtreeOptional().

Referenced by ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess().

createConstitutiveRelationIce() [2/2]

template std::unique_ptr< MaterialLib::Solids::MechanicsBase< 2 > > MaterialLib::Solids::createConstitutiveRelationIce	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

createConstitutiveRelations()

template<int DisplacementDim>

std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< DisplacementDim > > > MaterialLib::Solids::createConstitutiveRelations	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		MeshLib::PropertyVector< int > const *const	material_ids,
		BaseLib::ConfigTree const &	config )

Definition at line 110 of file CreateConstitutiveRelation.cpp.

{
    return createConstitutiveRelationsGeneric<
        MaterialLib::Solids::MechanicsBase<DisplacementDim>>(
        parameters,
        local_coordinate_system,
        material_ids,
        config,
        createConstitutiveRelation<DisplacementDim>);
}

References createConstitutiveRelation(), and createConstitutiveRelationsGeneric().

Referenced by ProcessLib::HMPhaseField::createHMPhaseFieldProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::PhaseField::createPhaseFieldProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), ProcessLib::RichardsMechanics::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations(), ProcessLib::SmallDeformation::ConstitutiveRelations::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations(), ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), and ProcessLib::ThermoMechanics::createThermoMechanicsProcess().

createConstitutiveRelations< 2 >()

template std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< 2 > > > MaterialLib::Solids::createConstitutiveRelations< 2 >	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		MeshLib::PropertyVector< int > const *const	material_ids,
		BaseLib::ConfigTree const &	config )

createConstitutiveRelations< 3 >()

template std::map< int, std::shared_ptr< MaterialLib::Solids::MechanicsBase< 3 > > > MaterialLib::Solids::createConstitutiveRelations< 3 >	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		MeshLib::PropertyVector< int > const *const	material_ids,
		BaseLib::ConfigTree const &	config )

createConstitutiveRelationsGeneric()

template<typename SolidConstitutiveRelation >

std::map< int, std::shared_ptr< SolidConstitutiveRelation > > MaterialLib::Solids::createConstitutiveRelationsGeneric	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		MeshLib::PropertyVector< int > const *const	material_ids,
		BaseLib::ConfigTree const &	config,
		std::unique_ptr< SolidConstitutiveRelation >(*	create_constitutive_relation )(std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &, std::optional< ParameterLib::CoordinateSystem > const &, BaseLib::ConfigTree const &) )

Input File Parameter

material__solid__constitutive_relation

Input File Parameter

material__solid__constitutive_relation__id

Definition at line 22 of file CreateConstitutiveRelationsGeneric.h.

{
    auto const constitutive_relation_configs =
        config.getConfigSubtreeList("constitutive_relation");
 
    std::map<int, std::shared_ptr<SolidConstitutiveRelation>>
        constitutive_relations;
 
    for (auto const& constitutive_relation_config :
         constitutive_relation_configs)
    {
        auto create = [&create_constitutive_relation,
                       &parameters,
                       &local_coordinate_system,
                       &constitutive_relation_config](int const /*id*/)
        {
            return create_constitutive_relation(parameters,
                                                local_coordinate_system,
                                                constitutive_relation_config);
        };
 
        auto const material_id_string =
            constitutive_relation_config.getConfigAttribute<std::string>("id",
                                                                         "0");
 
        auto const material_ids_of_this_constitutive_relation =
            MaterialLib::parseMaterialIdString(material_id_string,
                                               material_ids);
 
        for (auto const& material_id :
             material_ids_of_this_constitutive_relation)
        {
            MaterialLib::createMediumForId(
                material_id,
                constitutive_relations,
                material_ids_of_this_constitutive_relation,
                create);
        }
    }
 
    DBUG("Found {:d} constitutive relations.", constitutive_relations.size());
 
    return constitutive_relations;
}

References MaterialLib::createMediumForId(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), and MaterialLib::parseMaterialIdString().

Referenced by createConstitutiveRelations(), ProcessLib::LargeDeformation::ConstitutiveRelations::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::CreateConstitutiveSetting< DisplacementDim >::createSolidConstitutiveRelations().

createLinearElasticIsotropic()

template<int DisplacementDim>

std::unique_ptr< LinearElasticIsotropic< DisplacementDim > > MaterialLib::Solids::createLinearElasticIsotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		BaseLib::ConfigTree const &	config,
		const bool	skip_type_checking )

Input File Parameter

material__solid__constitutive_relation__type

Input File Parameter

material__solid__constitutive_relation__LinearElasticIsotropic__youngs_modulus

Input File Parameter

material__solid__constitutive_relation__LinearElasticIsotropic__poissons_ratio

Definition at line 23 of file CreateLinearElasticIsotropic.h.

{
    if (!skip_type_checking)
    {
        config.checkConfigParameter("type", "LinearElasticIsotropic");
        DBUG("Create LinearElasticIsotropic material");
    }
 
    // Youngs modulus
    auto& youngs_modulus = ParameterLib::findParameter<double>(
        config, "youngs_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as youngs_modulus parameter.", youngs_modulus.name);
 
    // Poissons ratio
    auto& poissons_ratio = ParameterLib::findParameter<double>(
        config, "poissons_ratio", parameters, 1);
 
    DBUG("Use '{:s}' as poissons_ratio parameter.", poissons_ratio.name);
 
    typename LinearElasticIsotropic<DisplacementDim>::MaterialProperties mp{
        youngs_modulus, poissons_ratio};
 
    return std::make_unique<LinearElasticIsotropic<DisplacementDim>>(mp);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and ParameterLib::findParameter().

Referenced by createConstitutiveRelation(), and MaterialLib::Solids::Creep::createCreepBGRa().

createLinearElasticOrthotropic() [1/2]

template<int DisplacementDim>

template std::unique_ptr< LinearElasticOrthotropic< 3 > > MaterialLib::Solids::createLinearElasticOrthotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config,
		const bool	skip_type_checking )

Input File Parameter

material__solid__constitutive_relation__type

Input File Parameter

material__solid__constitutive_relation__LinearElasticOrthotropic__youngs_moduli

Input File Parameter

material__solid__constitutive_relation__LinearElasticOrthotropic__shear_moduli

Input File Parameter

material__solid__constitutive_relation__LinearElasticOrthotropic__poissons_ratios

Definition at line 20 of file CreateLinearElasticOrthotropic.cpp.

{
    if (!skip_type_checking)
    {
        config.checkConfigParameter("type", "LinearElasticOrthotropic");
        DBUG("Create LinearElasticOrthotropic material");
    }
 
    // The three Youngs moduli are required even in two-dimensional case. Same
    // for the shear moduli and the Poissons ratios.
    auto& youngs_moduli = ParameterLib::findParameter<double>(
        config, "youngs_moduli", parameters, 3);
    DBUG("Use '{:s}' as youngs_moduli parameter.", youngs_moduli.name);
 
    // Shear moduli
    auto& shear_moduli = ParameterLib::findParameter<double>(
        config, "shear_moduli", parameters, 3);
    DBUG("Use '{:s}' as shear_moduli parameter.", shear_moduli.name);
 
    // Poissons ratios
    auto& poissons_ratios = ParameterLib::findParameter<double>(
        config, "poissons_ratios", parameters, 3);
    DBUG("Use '{:s}' as poissons_ratios parameter.", poissons_ratios.name);
 
    typename LinearElasticOrthotropic<DisplacementDim>::MaterialProperties mp{
        youngs_moduli, shear_moduli, poissons_ratios};
 
    return std::make_unique<LinearElasticOrthotropic<DisplacementDim>>(
        mp, local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and ParameterLib::findParameter().

Referenced by createConstitutiveRelation().

createLinearElasticOrthotropic() [2/2]

template std::unique_ptr< LinearElasticOrthotropic< 2 > > MaterialLib::Solids::createLinearElasticOrthotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config,
		const bool	skip_type_checking )

createLinearElasticTransverseIsotropic() [1/2]

template<int DisplacementDim>

std::unique_ptr< LinearElasticTransverseIsotropic< DisplacementDim > > MaterialLib::Solids::createLinearElasticTransverseIsotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config,
		const bool	skip_type_checking )

Input File Parameter

material__solid__constitutive_relation__type

Input File Parameter

material__solid__constitutive_relation__LinearElasticTransverseIsotropic__youngs_modulus_i

Input File Parameter

material__solid__constitutive_relation__LinearElasticTransverseIsotropic__youngs_modulus_a

Input File Parameter

material__solid__constitutive_relation__LinearElasticTransverseIsotropic__poissons_ratio_ii

Input File Parameter

material__solid__constitutive_relation__LinearElasticTransverseIsotropic__poissons_ratio_ia

Input File Parameter

material__solid__constitutive_relation__LinearElasticTransverseIsotropic__shear_modulus_ia

Definition at line 22 of file CreateLinearElasticTransverseIsotropic.cpp.

{
    if (!skip_type_checking)
    {
        config.checkConfigParameter("type", "LinearElasticTransverseIsotropic");
        DBUG("Create LinearElasticTransverseIsotropic material");
    }
 
    auto const& E_i = ParameterLib::findParameter<double>(
        config, "youngs_modulus_i", parameters, 1);
    DBUG("Use '{}' as the in-plane Young’s modulus, E_i.", E_i.name);
 
    auto const& E_a = ParameterLib::findParameter<double>(
        config, "youngs_modulus_a", parameters, 1);
    DBUG(
        "Use '{}' as the Young’s modulus w.r.t. the direction of anisotropy, "
        "E_a.",
        E_a.name);
 
    auto const& nu_ii = ParameterLib::findParameter<double>(
        config, "poissons_ratio_ii", parameters, 1);
    DBUG("Use '{}' as the in-plane Poisson’s ratio, nu_ii.", nu_ii.name);
 
    auto const& nu_ia = ParameterLib::findParameter<double>(
        config, "poissons_ratio_ia", parameters, 1);
    DBUG(
        "Use '{}' as the Poisson ratio perpendicular to the plane of isotropy, "
        "due to strain in the plane of isotropy, nu_ia.",
        nu_ia.name);
 
    auto const& G_ia = ParameterLib::findParameter<double>(
        config, "shear_modulus_ia", parameters, 1);
    DBUG(
        "Use '{}' as the shear modulus between directions of isotropy and "
        "anisotropy , G_ia.",
        G_ia.name);
 
    return std::make_unique<LinearElasticTransverseIsotropic<DisplacementDim>>(
        E_i, E_a, nu_ii, nu_ia, G_ia, local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and ParameterLib::findParameter().

Referenced by createConstitutiveRelation().

createLinearElasticTransverseIsotropic() [2/2]

template std::unique_ptr< LinearElasticTransverseIsotropic< 2 > > MaterialLib::Solids::createLinearElasticTransverseIsotropic	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config,
		const bool	skip_type_checking )

elasticTangentStiffness()

template<int DisplacementDim>

MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > MaterialLib::Solids::elasticTangentStiffness	(	double const	first_lame_parameter,
		double const	shear_modulus )

Definition at line 125 of file LinearElasticIsotropic.h.

{
    using KelvinMatrix =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;
 
    KelvinMatrix tangentStiffness = KelvinMatrix::Zero();
    tangentStiffness.template topLeftCorner<3, 3>().setConstant(
        first_lame_parameter);
    tangentStiffness.noalias() += 2 * shear_modulus * KelvinMatrix::Identity();
    return tangentStiffness;
}

Referenced by MaterialLib::Solids::LinearElasticIsotropic< DisplacementDim >::getElasticTensor(), and MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::integrateStress().

selectSolidConstitutiveRelation()

template<typename SolidMaterialsMap >

auto & MaterialLib::Solids::selectSolidConstitutiveRelation	(	SolidMaterialsMap const &	constitutive_relations,
		MeshLib::PropertyVector< int > const *const	material_ids,
		std::size_t const	element_id )

Choose solid material model for given element id out of a set of models, possibly using the material ids.

Only two possibilities yield a valid result and result in OGS_FATAL call otherwise.

1. If the material id is not defined then search for a constitutive relation with id 0 (the default value if not specified).
2. There is only one constitutive relation with id 0 then the material and element ids are ignored and the only constitutive relation (under id 0) is returned.
3. If material ids are defined then search for a constitutive relation corresponding to the material id of the current element.

Definition at line 36 of file SelectSolidConstitutiveRelation.h.

{
    // Multiple constitutive relations and no material ids should not be valid.
    if (constitutive_relations.size() > 1 && material_ids == nullptr)
    {
        OGS_FATAL(
            "There are {} constitutive relations provided in the project file "
            "but no MaterialIDs could be found in the mesh.",
            constitutive_relations.size());
    }
 
    int const material_id = ((constitutive_relations.size() == 1 &&
                              constitutive_relations.begin()->first == 0) ||
                             material_ids == nullptr)
                                ? 0
                                : (*material_ids)[element_id];
 
    auto const constitutive_relation = constitutive_relations.find(material_id);
    if (constitutive_relation == end(constitutive_relations))
    {
        OGS_FATAL(
            "No constitutive relation found for material id {:d} and element "
            "{:d}. There are {:d} constitutive relations available, "
            "corresponding to the ids: {}",
            material_id, element_id, constitutive_relations.size(),
            fmt::join(constitutive_relations | ranges::views::keys, " "));
    }
 
    if (constitutive_relation->second == nullptr)
    {
        OGS_FATAL(
            "The constitutive relation found for material id {:d} and element "
            "{:d} is a nullptr, which is impossible.",
            material_id, element_id);
    }
 
    return *constitutive_relation->second;
}

References OGS_FATAL.

Referenced by ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::HMPhaseFieldLocalAssembler(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::HydroMechanicsLocalAssembler(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::HydroMechanicsLocalAssemblerMatrix(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrix< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrix(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::ThermoHydroMechanicsLocalAssembler(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForPressureEquations(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianPhaseFieldEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcrete(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations().