Namespaces
namespace	detail

Classes
struct	DeformationGradient
	Meta data for deformation gradient. More...

struct	ForcesGradsCombinations

struct	GreenLagrangeStrain
	Meta data for Green-Lagrange strain. More...

struct	LiquidPressure

struct	MaterialStateVariablesMFront

class	MFront

struct	MFrontConfig

class	MFrontGeneric

class	OGSMFrontTangentOperatorBlocksView

struct	OGSMFrontTangentOperatorData
	Used for disambiguation with MFront's thermodynamic forces data. More...

struct	OGSMFrontThermodynamicForcesData
	Used for disambiguation with MFront's tangent operator blocks data. More...

class	OGSMFrontThermodynamicForcesView

struct	Saturation

struct	SecondPiolaKirchhoffStress

struct	Strain
	Meta data for strain. More...

struct	Stress

struct	Temperature

struct	Variable

Functions
template<int DisplacementDim>
std::unique_ptr< MechanicsBase< DisplacementDim > >	createMFront (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< MechanicsBase< 2 > >	createMFront< 2 > (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< MechanicsBase< 3 > >	createMFront< 3 > (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)

MFrontConfig	createMFrontConfig (int const displacement_dim, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, BaseLib::ConfigTree const &config)

template<int DisplacementDim, typename Gradients , typename TDynForces , typename ExtStateVars >
std::unique_ptr< MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars > >	createMFrontGeneric (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, BaseLib::ConfigTree const &config)

const char *	varTypeToString (int v)

int	getEquivalentPlasticStrainOffset (mgis::behaviour::Behaviour const &b)

template<int DisplacementDim>
OGSMFrontTangentOperatorData	tangentOperatorDataMFrontToOGS (std::vector< double > const &mfront_data, std::optional< MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > > const &Q, mgis::behaviour::Behaviour const &behaviour)

template OGSMFrontTangentOperatorData	tangentOperatorDataMFrontToOGS< 2 > (std::vector< double > const &mfront_data, std::optional< MathLib::KelvinVector::KelvinMatrixType< 2 > > const &Q, mgis::behaviour::Behaviour const &behaviour)

template OGSMFrontTangentOperatorData	tangentOperatorDataMFrontToOGS< 3 > (std::vector< double > const &mfront_data, std::optional< MathLib::KelvinVector::KelvinMatrixType< 3 > > const &Q, mgis::behaviour::Behaviour const &behaviour)

template<typename Derived >
constexpr auto	eigenSwap45View (Eigen::MatrixBase< Derived > const &matrix)

template<int DisplacementDim, typename Derived >
constexpr auto	ogsTensorToMFrontTensor (Eigen::MatrixBase< Derived > const &matrix)

Variables
static constexpr Strain	strain
	Instance that can be used for overload resolution/template type deduction.

static constexpr GreenLagrangeStrain	green_lagrange_strain
	Instance that can be used for overload resolution/template type deduction.

static constexpr DeformationGradient	deformation_gradient
	Instance that can be used for overload resolution/template type deduction.

static constexpr LiquidPressure	liquid_pressure

static constexpr Stress	stress

static constexpr SecondPiolaKirchhoffStress	second_piola_kirchhoff_stress

static constexpr Saturation	saturation

static constexpr Temperature	temperature

Function Documentation

◆ createMFront()

template<int DisplacementDim>

std::unique_ptr< MechanicsBase< DisplacementDim > > MaterialLib::Solids::MFront::createMFront	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

Definition at line 26 of file CreateMFront.cpp.

{
    auto conf = createMFrontConfig(DisplacementDim, parameters, config);
 
    return std::make_unique<MFront<DisplacementDim>>(
        std::move(conf.behaviour), std::move(conf.material_properties),
        std::move(conf.state_variables_initial_properties),
        local_coordinate_system);
}

References createMFrontConfig().

Referenced by MaterialLib::Solids::createConstitutiveRelation().

◆ createMFront< 2 >()

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

◆ createMFront< 3 >()

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

◆ createMFrontConfig()

MFrontConfig MaterialLib::Solids::MFront::createMFrontConfig	(	int const	displacement_dim,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		BaseLib::ConfigTree const &	config )

Input File Parameter: material__solid__constitutive_relation__type

Input File Parameter: material__solid__constitutive_relation__MFront__library

Input File Parameter: material__solid__constitutive_relation__MFront__library__path_is_relative_to_prj_file

Input File Parameter: material__solid__constitutive_relation__MFront__behaviour

Definition at line 324 of file CreateMFrontGeneric.cpp.

{
    INFO("### MFRONT ########################################################");
 
    config.checkConfigParameter("type", "MFront");
 
    auto const library = config.getConfigSubtreeOptional("library");
 
    bool const library_path_is_relative_to_prj_file =
        library /* If no library tag is specified in the prj file, the lib
                   shipped with OGS is used, whose path is not relative to the
                   project file. */
        &&
        library->getConfigAttribute("path_is_relative_to_prj_file", true);
 
    std::string const library_name =
        library ? library->getValue<std::string>() : "libOgsMFrontBehaviour";
 
    auto const lib_path =
        library_path_is_relative_to_prj_file
            ? BaseLib::joinPaths(BaseLib::getProjectDirectory(), library_name)
            : library_name;
 
    mgis::behaviour::Hypothesis hypothesis;
    if (displacement_dim == 2)
    {
        // TODO support the axial symmetry modelling hypothesis.
        WARN(
            "The model is defined in 2D. On the material level currently a "
            "plane strain setting is used. In particular it is not checked if "
            "axial symmetry or plane stress are assumed. Special material "
            "behaviour for these settings is currently not supported.");
        hypothesis = mgis::behaviour::Hypothesis::PLANESTRAIN;
    }
    else if (displacement_dim == 3)
    {
        hypothesis = mgis::behaviour::Hypothesis::TRIDIMENSIONAL;
    }
    else
    {
        OGS_FATAL("Displacement dim {} is not supported.", displacement_dim);
    }
 
    auto behaviour = loadBehaviour(
        lib_path,
        config.getConfigParameter<std::string>("behaviour"),
        hypothesis);
 
    INFO("Behaviour:      `{:s}'.", behaviour.behaviour);
    INFO("Hypothesis:     `{:s}'.", mgis::behaviour::toString(hypothesis));
    INFO("Source:         `{:s}'.", behaviour.source);
    INFO("TFEL version:   `{:s}'.", behaviour.tfel_version);
    INFO("Behaviour type: `{:s}'.", btypeToString(behaviour.btype));
    INFO("Kinematic:      `{:s}'.", toString(behaviour.kinematic));
    INFO("Symmetry:       `{:s}'.", toString(behaviour.symmetry));
 
    varInfo("Mat. props.", behaviour.mps, hypothesis);
    varInfo("Gradients", behaviour.gradients, hypothesis);
    varInfo("Thdyn. forces", behaviour.thermodynamic_forces, hypothesis);
    varInfo("Int. StVars.", behaviour.isvs, hypothesis);
    varInfo("Ext. StVars.", behaviour.esvs, hypothesis);
 
    // TODO read parameters from prj file, not yet (2018-11-05) supported by
    // MGIS library.
    varInfo("Real-valued parameters", behaviour.params);
    varInfo("Integer parameters", behaviour.iparams);
    varInfo("Unsigned parameters", behaviour.usparams);
 
    INFO("#Tangent operator blocks: {}.", behaviour.to_blocks.size());
    for (auto const& [var1, var2] : behaviour.to_blocks)
    {
        INFO("  --> ({}, {}).", var1.name, var2.name);
    }
 
    std::vector<ParameterLib::Parameter<double> const*> material_properties =
        readMaterialProperties(behaviour, hypothesis, parameters, config);
 
    std::map<std::string, ParameterLib::Parameter<double> const*>
        state_variables_initial_properties =
            readStateVariablesInitialValueProperties(behaviour, hypothesis,
                                                     parameters, config);
 
    INFO("### MFRONT END ####################################################");
 
    return {std::move(behaviour), std::move(material_properties),
            std::move(state_variables_initial_properties)};
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtreeOptional(), BaseLib::getProjectDirectory(), INFO(), BaseLib::joinPaths(), OGS_FATAL, and WARN().

Referenced by createMFront(), and createMFrontGeneric().

◆ createMFrontGeneric()

template<int DisplacementDim, typename Gradients , typename TDynForces , typename ExtStateVars >

std::unique_ptr< MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars > > MaterialLib::Solids::MFront::createMFrontGeneric	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system,
		BaseLib::ConfigTree const &	config )

Definition at line 35 of file CreateMFrontGeneric.h.

{
    auto conf = createMFrontConfig(DisplacementDim, parameters, config);
 
    return std::make_unique<
        MFrontGeneric<DisplacementDim, Gradients, TDynForces, ExtStateVars>>(
        std::move(conf.behaviour), std::move(conf.material_properties),
        std::move(conf.state_variables_initial_properties),
        local_coordinate_system);
}

References createMFrontConfig().

Referenced by ProcessLib::LargeDeformation::ConstitutiveRelations::createMFrontGeneric(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::createMFrontGeneric().

◆ eigenSwap45View()

template<typename Derived >

auto MaterialLib::Solids::MFront::eigenSwap45View ( Eigen::MatrixBase< Derived > const & matrix )

constexpr

Converts between OGS' and MFront's Kelvin vectors and matrices and vice versa. Numbering of the Kelvin vectors and matrices in the two cases is: MFront: 11 22 33 12 13 23 OGS: 11 22 33 12 23 13 The function swaps the 4th and 5th row and column of a matrix.

Definition at line 36 of file MFrontGeneric.h.

{
    using Matrix =
        Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime,
                      Derived::ColsAtCompileTime>;
 
    return Matrix::NullaryExpr(
        matrix.rows(), matrix.cols(),
        [&m = matrix.derived()](Eigen::Index const row, Eigen::Index const col)
        {
            constexpr std::ptrdiff_t result[6] = {0, 1, 2, 3, 5, 4};
            return m(result[row], result[col]);
        });
}

Referenced by MaterialLib::Solids::MFront::detail::SetGradient< DisplacementDim >::operator()(), and tangentOperatorDataMFrontToOGS().

◆ getEquivalentPlasticStrainOffset()

int MaterialLib::Solids::MFront::getEquivalentPlasticStrainOffset ( mgis::behaviour::Behaviour const & b )

Definition at line 29 of file MFrontGeneric.cpp.

{
    return mgis::behaviour::contains(b.isvs, "EquivalentPlasticStrain")
               ? mgis::behaviour::getVariableOffset(
                     b.isvs, "EquivalentPlasticStrain", b.hypothesis)
               : -1;
}

Referenced by MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::MFrontGeneric().

◆ ogsTensorToMFrontTensor()

template<int DisplacementDim, typename Derived >

auto MaterialLib::Solids::MFront::ogsTensorToMFrontTensor ( Eigen::MatrixBase< Derived > const & matrix )

constexpr

Converts between OGS' and MFront's tensors, which are represented as vectors. An OGS tensor 11 12 13 21 22 23 31 32 33 0 1 2 3 4 5 6 7 8 is converted to MFront tensor 11 22 33 12 21 13 31 23 32 0 4 8 1 3 2 6 5 7.

Definition at line 59 of file MFrontGeneric.h.

{
    using Matrix =
        Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime,
                      Derived::ColsAtCompileTime>;
 
    if constexpr (DisplacementDim == 2)
    {
        return Matrix::NullaryExpr(
            matrix.rows(), matrix.cols(),
            [&m = matrix.derived()](Eigen::Index const row,
                                    Eigen::Index const col)
            {
                constexpr std::ptrdiff_t result[5] = {0, 3, 4, 1, 2};
                return m(result[row], result[col]);
            });
    }
    if constexpr (DisplacementDim == 3)
    {
        return Matrix::NullaryExpr(
            matrix.rows(), matrix.cols(),
            [&m = matrix.derived()](Eigen::Index const row,
                                    Eigen::Index const col)
            {
                constexpr std::ptrdiff_t result[9] = {0, 4, 8, 1, 3,
                                                      2, 6, 5, 7};
                return m(result[row], result[col]);
            });
    }
}

References ogsTensorToMFrontTensor().

Referenced by ogsTensorToMFrontTensor().

◆ tangentOperatorDataMFrontToOGS()

template<int DisplacementDim>

OGSMFrontTangentOperatorData MaterialLib::Solids::MFront::tangentOperatorDataMFrontToOGS	(	std::vector< double > const &	mfront_data,
		std::optional< MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > > const &	Q,
		mgis::behaviour::Behaviour const &	behaviour )

Transforms MFront's to OGS's tangent operator data.

Essentially swaps some off-diagonal components of symmetric tensors and applies the given rotation of the frame of reference Q.

Definition at line 38 of file MFrontGeneric.cpp.

{
    using VT = mgis::behaviour::Variable::Type;
    using KM = MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;
    using KV = MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
 
    std::vector<double> ogs_data(mfront_data.size());
 
    std::size_t offset = 0;
    constexpr auto kv_size =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
 
    for (auto const& [var1, var2] : behaviour.to_blocks)
    {
        std::size_t size;
 
        auto const* const d_in = mfront_data.data() + offset;
        auto* const d_out = ogs_data.data() + offset;
 
        if (var1.type == VT::SCALAR && var2.type == VT::SCALAR)
        {
            size = 1;
            *d_out = *d_in;
        }
        else if (var1.type == VT::SCALAR && var2.type == VT::STENSOR)
        {
            assert(getVariableSize(var2, behaviour.hypothesis) == kv_size);
            size = kv_size;
 
            if (Q)
            {
                OGS_FATAL(
                    "Coordinate frame rotation not yet implemented for "
                    "dScalar/dSTensor.");
            }
 
            Eigen::Map<KV>{d_out} = eigenSwap45View(Eigen::Map<const KV>{d_in});
        }
        else if (var1.type == VT::STENSOR && var2.type == VT::SCALAR)
        {
            assert(getVariableSize(var1, behaviour.hypothesis) == kv_size);
            size = kv_size;
 
            if (Q)
            {
                OGS_FATAL(
                    "Coordinate frame rotation not yet implemented for "
                    "dSTensor/dScalar.");
            }
 
            Eigen::Map<KV>{d_out} = eigenSwap45View(Eigen::Map<const KV>{d_in});
        }
        else if (var1.type == VT::STENSOR && var2.type == VT::STENSOR)
        {
            assert(getVariableSize(var1, behaviour.hypothesis) == kv_size);
            assert(getVariableSize(var2, behaviour.hypothesis) == kv_size);
            size = kv_size * kv_size;
 
            if (Q)
            {
                Eigen::Map<KM>{d_out} =
                    *Q * eigenSwap45View(Eigen::Map<const KM>{d_in}) *
                    Q->transpose();
            }
            else
            {
                Eigen::Map<KM>{d_out} =
                    eigenSwap45View(Eigen::Map<const KM>{d_in});
            }
        }
        else
        {
            OGS_FATAL("unsupported variable type combination");
        }
 
        offset += size;
    }
 
    return {std::move(ogs_data)};
}

References eigenSwap45View(), MathLib::KelvinVector::kelvin_vector_dimensions(), and OGS_FATAL.

◆ tangentOperatorDataMFrontToOGS< 2 >()

template OGSMFrontTangentOperatorData MaterialLib::Solids::MFront::tangentOperatorDataMFrontToOGS< 2 >	(	std::vector< double > const &	mfront_data,
		std::optional< MathLib::KelvinVector::KelvinMatrixType< 2 > > const &	Q,
		mgis::behaviour::Behaviour const &	behaviour )

◆ tangentOperatorDataMFrontToOGS< 3 >()

template OGSMFrontTangentOperatorData MaterialLib::Solids::MFront::tangentOperatorDataMFrontToOGS< 3 >	(	std::vector< double > const &	mfront_data,
		std::optional< MathLib::KelvinVector::KelvinMatrixType< 3 > > const &	Q,
		mgis::behaviour::Behaviour const &	behaviour )

◆ varTypeToString()

const char * MaterialLib::Solids::MFront::varTypeToString ( int v )

Definition at line 14 of file MFrontGeneric.cpp.

{
    using V = mgis::behaviour::Variable;
    if (v == V::SCALAR)
        return "SCALAR";
    if (v == V::VECTOR)
        return "VECTOR";
    if (v == V::STENSOR)
        return "STENSOR";
    if (v == V::TENSOR)
        return "TENSOR";
 
    OGS_FATAL("Unknown variable type {}.", v);
}

References OGS_FATAL.

Referenced by MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::MFrontGeneric(), MaterialLib::Solids::MFront::detail::SetGradient< DisplacementDim >::operator()(), and anonymous_namespace{CreateMFrontGeneric.cpp}::varInfo().

Variable Documentation

◆ deformation_gradient

DeformationGradient MaterialLib::Solids::MFront::deformation_gradient

staticconstexpr

Instance that can be used for overload resolution/template type deduction.

Definition at line 130 of file Variable.h.

◆ green_lagrange_strain

GreenLagrangeStrain MaterialLib::Solids::MFront::green_lagrange_strain

staticconstexpr

Instance that can be used for overload resolution/template type deduction.

Definition at line 112 of file Variable.h.

Referenced by ProcessLib::LargeDeformation::ConstitutiveRelations::SolidMechanicsModel< DisplacementDim >::eval().

◆ liquid_pressure

LiquidPressure MaterialLib::Solids::MFront::liquid_pressure

staticconstexpr

Definition at line 143 of file Variable.h.

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::SolidMechanicsModel< DisplacementDim >::eval().

◆ saturation

Saturation MaterialLib::Solids::MFront::saturation

staticconstexpr

Definition at line 180 of file Variable.h.

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::SolidMechanicsModel< DisplacementDim >::eval().

◆ second_piola_kirchhoff_stress

SecondPiolaKirchhoffStress MaterialLib::Solids::MFront::second_piola_kirchhoff_stress

staticconstexpr

Definition at line 167 of file Variable.h.

Referenced by ProcessLib::LargeDeformation::ConstitutiveRelations::SolidMechanicsModel< DisplacementDim >::eval().

◆ strain

Strain MaterialLib::Solids::MFront::strain

staticconstexpr

Instance that can be used for overload resolution/template type deduction.

Definition at line 92 of file Variable.h.

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::SolidMechanicsModel< DisplacementDim >::eval(), and MaterialLib::Solids::MFront::MFront< DisplacementDim >::integrateStress().

◆ stress

Stress MaterialLib::Solids::MFront::stress

staticconstexpr

Definition at line 155 of file Variable.h.

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::SolidMechanicsModel< DisplacementDim >::eval(), and MaterialLib::Solids::MFront::MFront< DisplacementDim >::integrateStress().

◆ temperature

Temperature MaterialLib::Solids::MFront::temperature

staticconstexpr

Definition at line 193 of file Variable.h.

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::SolidMechanicsModel< DisplacementDim >::eval().

Namespaces

Classes

Functions

Variables

Function Documentation

◆ createMFront()

◆ createMFront< 2 >()

◆ createMFront< 3 >()

◆ createMFrontConfig()

◆ createMFrontGeneric()

◆ eigenSwap45View()

◆ getEquivalentPlasticStrainOffset()

◆ ogsTensorToMFrontTensor()

◆ tangentOperatorDataMFrontToOGS()

◆ tangentOperatorDataMFrontToOGS< 2 >()

◆ tangentOperatorDataMFrontToOGS< 3 >()

◆ varTypeToString()

Variable Documentation

◆ deformation_gradient

◆ green_lagrange_strain

◆ liquid_pressure

◆ saturation

◆ second_piola_kirchhoff_stress

◆ strain

◆ stress

◆ temperature