MaterialLib::Solids Namespace Reference

Namespaces
namespace	Creep
namespace	Ehlers
namespace	Lubby2
namespace	MFront
namespace	Phasefield

Classes
class	LinearElasticIsotropic
class	LinearElasticOrthotropic
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::unique_ptr< MaterialLib::Solids::MechanicsBase< DisplacementDim > > >	createConstitutiveRelations (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template std::map< int, std::unique_ptr< MaterialLib::Solids::MechanicsBase< 2 > > >	createConstitutiveRelations< 2 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)
template std::map< int, std::unique_ptr< MaterialLib::Solids::MechanicsBase< 3 > > >	createConstitutiveRelations< 3 > (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::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::unique_ptr< SolidConstitutiveRelation > >	createConstitutiveRelationsGeneric (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, 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>
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 32 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 == "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 createLinearElasticIsotropic(), createLinearElasticOrthotropic(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

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 BaseLib::ConfigTree::getConfigSubtreeOptional().

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::unique_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,
		BaseLib::ConfigTree const &	config
	)

Definition at line 102 of file CreateConstitutiveRelation.cpp.

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

References createConstitutiveRelationsGeneric().

createConstitutiveRelations< 2 >()

template std::map< int, std::unique_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,
		BaseLib::ConfigTree const &	config
	)

createConstitutiveRelations< 3 >()

template std::map< int, std::unique_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,
		BaseLib::ConfigTree const &	config
	)

createConstitutiveRelationsGeneric()

template<typename SolidConstitutiveRelation >

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

Input File Parameter:

material__solid__constitutive_relation

Input File Parameter:

material__solid__constitutive_relation__id

Definition at line 20 of file CreateConstitutiveRelationsGeneric.h.

{
    auto const constitutive_relation_configs =
        config.getConfigSubtreeList("constitutive_relation");
 
    std::map<int, std::unique_ptr<SolidConstitutiveRelation>>
        constitutive_relations;
 
    for (auto const& constitutive_relation_config :
         constitutive_relation_configs)
    {
        int const material_id =
            constitutive_relation_config.getConfigAttribute<int>("id", 0);
 
        if (constitutive_relations.find(material_id) !=
            constitutive_relations.end())
        {
            OGS_FATAL(
                "Multiple constitutive relations were specified for the same "
                "material id {:d}. Keep in mind, that if no material id is "
                "specified, it is assumed to be 0 by default.",
                material_id);
        }
 
        constitutive_relations.emplace(
            material_id,
            create_constitutive_relation(parameters,
                                         local_coordinate_system,
                                         constitutive_relation_config));
    }
 
    DBUG("Found {:d} constitutive relations.", constitutive_relations.size());
 
    return constitutive_relations;
}

References DBUG(), BaseLib::ConfigTree::getConfigSubtreeList(), and OGS_FATAL.

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(), and DBUG().

Referenced by createConstitutiveRelation().

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(), and DBUG().

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
	)

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;
}

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::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::HydroMechanicsLocalAssembler(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, GlobalDim >::HydroMechanicsLocalAssemblerMatrix(), ProcessLib::PhaseField::PhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::PhaseFieldLocalAssembler(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::RichardsMechanicsLocalAssembler(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrix< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrix(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, DisplacementDim >::SmallDeformationLocalAssemblerMatrixNearFracture(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::SmallDeformationNonlocalLocalAssembler(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::TH2MLocalAssembler(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::ThermoHydroMechanicsLocalAssembler(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicalPhaseFieldLocalAssembler(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::ThermoMechanicsLocalAssembler(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForPressureEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcrete(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations().