MaterialLib::Solids::MFront::MFront< DisplacementDim > Class Template Reference

Detailed Description

template<int DisplacementDim>
class MaterialLib::Solids::MFront::MFront< DisplacementDim >

Uses a material model provided by MFront (via MFront's generic interface and the MGIS library).

Definition at line 40 of file MFront.h.

#include <MFront.h>

Inheritance diagram for MaterialLib::Solids::MFront::MFront< DisplacementDim >:

Collaboration diagram for MaterialLib::Solids::MFront::MFront< DisplacementDim >:

Classes
struct	MaterialStateVariables

Public Types
using	KelvinVector = MathLib::KelvinVector::KelvinVectorType< DisplacementDim >
using	KelvinMatrix = MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >
Public Types inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
using	KelvinVector = MathLib::KelvinVector::KelvinVectorType< DisplacementDim >
using	KelvinMatrix = MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >

Public Member Functions
	MFront (mgis::behaviour::Behaviour &&behaviour, std::vector< ParameterLib::Parameter< double > const * > &&material_properties, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system)
std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >	createMaterialStateVariables () const override
std::optional< std::tuple< KelvinVector, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, KelvinMatrix > >	integrateStress (MaterialPropertyLib::VariableArray const &variable_array_prev, MaterialPropertyLib::VariableArray const &variable_array, double const t, ParameterLib::SpatialPosition const &x, double const dt, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &material_state_variables) const override
std::vector< typename MechanicsBase< DisplacementDim >::InternalVariable >	getInternalVariables () const override
double	getBulkModulus (double const, ParameterLib::SpatialPosition const &, KelvinMatrix const *const) const override
double	computeFreeEnergyDensity (double const t, ParameterLib::SpatialPosition const &x, double const dt, KelvinVector const &eps, KelvinVector const &sigma, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &material_state_variables) const override
Public Member Functions inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
virtual std::optional< std::tuple< KelvinVector, std::unique_ptr< MaterialStateVariables >, KelvinMatrix > >	integrateStress (MaterialPropertyLib::VariableArray const &variable_array_prev, MaterialPropertyLib::VariableArray const &variable_array, double const t, ParameterLib::SpatialPosition const &x, double const dt, MaterialStateVariables const &material_state_variables) const =0
virtual ConstitutiveModel	getConstitutiveModel () const
	Gets the type of constitutive model. More...
virtual double	getTemperatureRelatedCoefficient (double const, double const, ParameterLib::SpatialPosition const &, double const, double const) const
virtual double	computeFreeEnergyDensity (double const t, ParameterLib::SpatialPosition const &x, double const dt, KelvinVector const &eps, KelvinVector const &sigma, MaterialStateVariables const &material_state_variables) const =0
virtual	~MechanicsBase ()=default

Private Attributes
mgis::behaviour::Behaviour	_behaviour
int const	equivalent_plastic_strain_offset_
std::vector< ParameterLib::Parameter< double > const * >	_material_properties
ParameterLib::CoordinateSystem const *const	_local_coordinate_system

Member Typedef Documentation

KelvinMatrix

template<int DisplacementDim>

using MaterialLib::Solids::MFront::MFront< DisplacementDim >::KelvinMatrix = MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>

Definition at line 71 of file MFront.h.

KelvinVector

template<int DisplacementDim>

using MaterialLib::Solids::MFront::MFront< DisplacementDim >::KelvinVector = MathLib::KelvinVector::KelvinVectorType<DisplacementDim>

Definition at line 69 of file MFront.h.

Constructor & Destructor Documentation

MFront()

template<int DisplacementDim>

MaterialLib::Solids::MFront::MFront< DisplacementDim >::MFront	(	mgis::behaviour::Behaviour &&	behaviour,
		std::vector< ParameterLib::Parameter< double > const * > &&	material_properties,
		std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system
	)

Definition at line 174 of file MFront.cpp.

    : _behaviour(std::move(behaviour)),
      equivalent_plastic_strain_offset_(
          getEquivalentPlasticStrainOffset(_behaviour)),
      _material_properties(std::move(material_properties)),
      _local_coordinate_system(
          local_coordinate_system ? &local_coordinate_system.value() : nullptr)
{
    auto const hypothesis = behaviour.hypothesis;
 
    if (_behaviour.gradients.size() != 1)
        OGS_FATAL(
            "The behaviour must have exactly a single gradient as input.");
 
    if (_behaviour.gradients[0].name != "Strain")
        OGS_FATAL("The behaviour must be driven by strain.");
 
    if (_behaviour.gradients[0].type != mgis::behaviour::Variable::STENSOR)
        OGS_FATAL("Strain must be a symmetric tensor.");
 
    if (mgis::behaviour::getVariableSize(_behaviour.gradients[0], hypothesis) !=
        MFront<DisplacementDim>::KelvinVector::SizeAtCompileTime)
        OGS_FATAL("Strain must have {:d} components instead of {:d}.",
                  MFront<DisplacementDim>::KelvinVector::SizeAtCompileTime,
                  mgis::behaviour::getVariableSize(_behaviour.gradients[0],
                                                   hypothesis));
 
    if (_behaviour.thermodynamic_forces.size() != 1)
        OGS_FATAL(
            "The behaviour must compute exactly one thermodynamic force.");
 
    if (_behaviour.thermodynamic_forces[0].name != "Stress")
        OGS_FATAL("The behaviour must compute stress.");
 
    if (_behaviour.thermodynamic_forces[0].type !=
        mgis::behaviour::Variable::STENSOR)
        OGS_FATAL("Stress must be a symmetric tensor.");
 
    if (mgis::behaviour::getVariableSize(_behaviour.thermodynamic_forces[0],
                                         hypothesis) !=
        MFront<DisplacementDim>::KelvinVector::SizeAtCompileTime)
        OGS_FATAL("Stress must have {:d} components instead of {:d}.",
                  MFront<DisplacementDim>::KelvinVector::SizeAtCompileTime,
                  mgis::behaviour::getVariableSize(
                      _behaviour.thermodynamic_forces[0], hypothesis));
 
    if (!_behaviour.esvs.empty())
    {
        if (_behaviour.esvs[0].name != "Temperature")
        {
            OGS_FATAL(
                "Only temperature is supported as external state variable.");
        }
 
        if (mgis::behaviour::getVariableSize(_behaviour.esvs[0], hypothesis) !=
            1)
            OGS_FATAL(
                "Temperature must be a scalar instead of having {:d} "
                "components.",
                mgis::behaviour::getVariableSize(
                    _behaviour.thermodynamic_forces[0], hypothesis));
    }
 
    if (_behaviour.mps.size() != _material_properties.size())
    {
        ERR("There are {:d} material properties in the loaded behaviour:",
            _behaviour.mps.size());
        for (auto const& mp : _behaviour.mps)
        {
            ERR("\t{:s}", mp.name);
        }
        OGS_FATAL("But the number of passed material properties is {:d}.",
                  _material_properties.size());
    }
}

References MaterialLib::Solids::MFront::MFront< DisplacementDim >::_behaviour, MaterialLib::Solids::MFront::MFront< DisplacementDim >::_material_properties, ERR(), and OGS_FATAL.

Member Function Documentation

computeFreeEnergyDensity()

template<int DisplacementDim>

double MaterialLib::Solids::MFront::MFront< DisplacementDim >::computeFreeEnergyDensity ( double const  t, ParameterLib::SpatialPosition const &  x, double const  dt, KelvinVector const &  eps, KelvinVector const &  sigma, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &  material_state_variables  ) const

override

Definition at line 493 of file MFront.cpp.

{
    // TODO implement
    return std::numeric_limits<double>::quiet_NaN();
}

createMaterialStateVariables()

template<int DisplacementDim>

std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables > MaterialLib::Solids::MFront::MFront< DisplacementDim >::createMaterialStateVariables

overridevirtual

Polymorphic creator for MaterialStateVariables objects specific for a material model.

Reimplemented from MaterialLib::Solids::MechanicsBase< DisplacementDim >.

Definition at line 256 of file MFront.cpp.

{
    return std::make_unique<MaterialStateVariables>(
        equivalent_plastic_strain_offset_, _behaviour);
}

getBulkModulus()

template<int DisplacementDim>

double MaterialLib::Solids::MFront::MFront< DisplacementDim >::getBulkModulus ( double const  , ParameterLib::SpatialPosition const &  , KelvinMatrix const * const  C  ) const

overridevirtual

Reimplemented from MaterialLib::Solids::MechanicsBase< DisplacementDim >.

Definition at line 475 of file MFront.cpp.

{
    if (C == nullptr)
    {
        OGS_FATAL(
            "MFront::getBulkModulus() requires the tangent stiffness C input "
            "argument to be valid.");
    }
    auto const& identity2 = MathLib::KelvinVector::Invariants<
        MathLib::KelvinVector::kelvin_vector_dimensions(
            DisplacementDim)>::identity2;
    return 1. / 9. * identity2.transpose() * *C * identity2;
}

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

getInternalVariables()

template<int DisplacementDim>

std::vector< typename MechanicsBase< DisplacementDim >::InternalVariable > MaterialLib::Solids::MFront::MFront< DisplacementDim >::getInternalVariables

overridevirtual

Returns internal variables defined by the specific material model, if any.

Reimplemented from MaterialLib::Solids::MechanicsBase< DisplacementDim >.

Definition at line 420 of file MFront.cpp.

{
    std::vector<typename MechanicsBase<DisplacementDim>::InternalVariable>
        internal_variables;
 
    for (auto const& iv : _behaviour.isvs)
    {
        auto const name = iv.name;
        auto const offset = mgis::behaviour::getVariableOffset(
            _behaviour.isvs, name, _behaviour.hypothesis);
        auto const size =
            mgis::behaviour::getVariableSize(iv, _behaviour.hypothesis);
 
        // TODO (naumov): For orthotropic materials the internal variables
        // should be rotated to the global coordinate system before output.
        // MFront stores the variables in local coordinate system.
        // The `size` variable could be used to find out the type of variable.
        typename MechanicsBase<DisplacementDim>::InternalVariable new_variable{
            name, static_cast<int>(size),
            [offset, size](
                typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
            {
                assert(dynamic_cast<MaterialStateVariables const*>(&state) !=
                       nullptr);
                auto const& internal_state_variables =
                    static_cast<MaterialStateVariables const&>(state)
                        ._behaviour_data.s1.internal_state_variables;
 
                cache.resize(size);
                std::copy_n(internal_state_variables.data() + offset,
                            size,
                            begin(cache));
                return cache;
            },
            [offset, size](
                typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> BaseLib::DynamicSpan<double>
            {
                assert(dynamic_cast<MaterialStateVariables const*>(&state) !=
                       nullptr);
                auto& internal_state_variables =
                    static_cast<MaterialStateVariables&>(state)
                        ._behaviour_data.s1.internal_state_variables;
 
                return {internal_state_variables.data() + offset, size};
            }};
        internal_variables.push_back(new_variable);
    }
 
    return internal_variables;
}

References MaterialPropertyLib::name.

integrateStress()

template<int DisplacementDim>

std::optional< std::tuple< typename MFront< DisplacementDim >::KelvinVector, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, typename MFront< DisplacementDim >::KelvinMatrix > > MaterialLib::Solids::MFront::MFront< DisplacementDim >::integrateStress ( MaterialPropertyLib::VariableArray const &  variable_array_prev, MaterialPropertyLib::VariableArray const &  variable_array, double const  t, ParameterLib::SpatialPosition const &  x, double const  dt, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &  material_state_variables  ) const

override

Definition at line 267 of file MFront.cpp.

{
    using namespace MathLib::KelvinVector;
 
    assert(
        dynamic_cast<MaterialStateVariables const*>(&material_state_variables));
    // New state, copy of current one, packed in unique_ptr for return.
    auto state = std::make_unique<MaterialStateVariables>(
        static_cast<MaterialStateVariables const&>(material_state_variables));
    auto& behaviour_data = state->_behaviour_data;
 
    // TODO add a test of material behaviour where the value of dt matters.
    behaviour_data.dt = dt;
    behaviour_data.rdt = 1.0;
    behaviour_data.K[0] = 4.0;  // if K[0] is greater than 3.5, the consistent
                                // tangent operator must be computed.
 
    // evaluate parameters at (t, x)
    {
        auto out = behaviour_data.s1.material_properties.begin();
        for (auto* param : _material_properties)
        {
            auto const& vals = (*param)(t, x);
            out = std::copy(vals.begin(), vals.end(), out);
        }
        assert(out == behaviour_data.s1.material_properties.end());
    }
 
    if (!behaviour_data.s0.external_state_variables.empty())
    {
        // assuming that there is only temperature
        if (!std::holds_alternative<double>(
                variable_array_prev[static_cast<int>(
                    MPL::Variable::temperature)]))
        {
            OGS_FATAL(
                "MPL::Variable::temperature is not set for variable_array_prev "
                "before calling MFront::integrateStress.");
        }
 
        behaviour_data.s1.external_state_variables[0] = std::get<double>(
            variable_array_prev[static_cast<int>(MPL::Variable::temperature)]);
    }
 
    if (!behaviour_data.s1.external_state_variables.empty())
    {
        // assuming that there is only temperature
        if (!std::holds_alternative<double>(
                variable_array[static_cast<int>(MPL::Variable::temperature)]))
        {
            OGS_FATAL(
                "MPL::Variable::temperature is not set for variable_array "
                "before calling MFront::integrateStress");
        }
 
        behaviour_data.s1.external_state_variables[0] = std::get<double>(
            variable_array[static_cast<int>(MPL::Variable::temperature)]);
    }
 
    // rotation tensor
    auto const Q = [this, &x]() -> KelvinMatrixType<DisplacementDim>
    {
        if (!_local_coordinate_system)
        {
            return KelvinMatrixType<DisplacementDim>::Identity();
        }
        return fourthOrderRotationMatrix(
            _local_coordinate_system->transformation<DisplacementDim>(x));
    }();
 
    auto const& eps_m_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev[static_cast<int>(
            MPL::Variable::mechanical_strain)]);
    auto const eps_prev_MFront = OGSToMFront(
        Q.transpose()
            .template topLeftCorner<kelvin_vector_dimensions(DisplacementDim),
                                    kelvin_vector_dimensions(
                                        DisplacementDim)>() *
        eps_m_prev);
    std::copy_n(eps_prev_MFront.data(), KelvinVector::SizeAtCompileTime,
                behaviour_data.s0.gradients.data());
 
    auto const& eps = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array[static_cast<int>(MPL::Variable::mechanical_strain)]);
    auto const eps_MFront = OGSToMFront(
        Q.transpose()
            .template topLeftCorner<kelvin_vector_dimensions(DisplacementDim),
                                    kelvin_vector_dimensions(
                                        DisplacementDim)>() *
        eps);
    std::copy_n(eps_MFront.data(), KelvinVector::SizeAtCompileTime,
                behaviour_data.s1.gradients.data());
 
    auto const& sigma_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev[static_cast<int>(MPL::Variable::stress)]);
    auto const sigma_prev_MFront = OGSToMFront(
        Q.transpose()
            .template topLeftCorner<kelvin_vector_dimensions(DisplacementDim),
                                    kelvin_vector_dimensions(
                                        DisplacementDim)>() *
        sigma_prev);
    std::copy_n(sigma_prev_MFront.data(), KelvinVector::SizeAtCompileTime,
                behaviour_data.s0.thermodynamic_forces.data());
    std::copy_n(sigma_prev_MFront.data(), KelvinVector::SizeAtCompileTime,
                behaviour_data.s1.thermodynamic_forces.data());
 
    auto v = mgis::behaviour::make_view(behaviour_data);
    auto const status = mgis::behaviour::integrate(v, _behaviour);
    if (status != 1)
    {
        throw NumLib::AssemblyException(
            "MFront: integration failed with status" + std::to_string(status) +
            ".");
    }
 
    KelvinVector sigma;
    std::copy_n(behaviour_data.s1.thermodynamic_forces.data(),
                KelvinVector::SizeAtCompileTime, sigma.data());
    sigma =
        Q.template topLeftCorner<kelvin_vector_dimensions(DisplacementDim),
                                 kelvin_vector_dimensions(DisplacementDim)>() *
        MFrontToOGS(sigma);
 
    // TODO row- vs. column-major storage order. This should only matter for
    // anisotropic materials.
    if (behaviour_data.K.size() !=
        KelvinMatrix::RowsAtCompileTime * KelvinMatrix::ColsAtCompileTime)
        OGS_FATAL("Stiffness matrix has wrong size.");
 
    KelvinMatrix C =
        Q * MFrontToOGS(Eigen::Map<KelvinMatrix>(behaviour_data.K.data())) *
        Q.transpose()
            .template topLeftCorner<kelvin_vector_dimensions(DisplacementDim),
                                    kelvin_vector_dimensions(
                                        DisplacementDim)>();
 
    return std::make_optional(
        std::make_tuple<typename MFront<DisplacementDim>::KelvinVector,
                        std::unique_ptr<typename MechanicsBase<
                            DisplacementDim>::MaterialStateVariables>,
                        typename MFront<DisplacementDim>::KelvinMatrix>(
            std::move(sigma), std::move(state), std::move(C)));
}

References MathLib::LinAlg::copy(), MathLib::KelvinVector::fourthOrderRotationMatrix(), MathLib::KelvinVector::kelvin_vector_dimensions(), anonymous_namespace{MFront.cpp}::MFrontToOGS(), OGS_FATAL, anonymous_namespace{MFront.cpp}::OGSToMFront(), and MaterialPropertyLib::temperature.

Member Data Documentation

_behaviour

template<int DisplacementDim>

mgis::behaviour::Behaviour MaterialLib::Solids::MFront::MFront< DisplacementDim >::_behaviour

private

Definition at line 114 of file MFront.h.

Referenced by MaterialLib::Solids::MFront::MFront< DisplacementDim >::MFront().

_local_coordinate_system

template<int DisplacementDim>

ParameterLib::CoordinateSystem const* const MaterialLib::Solids::MFront::MFront< DisplacementDim >::_local_coordinate_system

private

Definition at line 117 of file MFront.h.

_material_properties

template<int DisplacementDim>

std::vector<ParameterLib::Parameter<double> const*> MaterialLib::Solids::MFront::MFront< DisplacementDim >::_material_properties

private

Definition at line 116 of file MFront.h.

Referenced by MaterialLib::Solids::MFront::MFront< DisplacementDim >::MFront().

equivalent_plastic_strain_offset_

template<int DisplacementDim>

int const MaterialLib::Solids::MFront::MFront< DisplacementDim >::equivalent_plastic_strain_offset_

private

Definition at line 115 of file MFront.h.

---

The documentation for this class was generated from the following files:

• MaterialLib/SolidModels/MFront/MFront.h
• MaterialLib/SolidModels/MFront/MFront.cpp