MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars > Class Template Reference

Detailed Description

template<int DisplacementDim, typename Gradients, typename TDynForces, typename ExtStateVars>
class MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >

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

Definition at line 247 of file MFrontGeneric.h.

#include <MFrontGeneric.h>

Collaboration diagram for MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >:

Public Types
using	KelvinVector
using	KelvinMatrix
using	InternalVariable

Public Member Functions
	MFrontGeneric (mgis::behaviour::Behaviour &&behaviour, std::vector< ParameterLib::Parameter< double > const * > &&material_properties, std::map< std::string, ParameterLib::Parameter< double > const * > &&state_variables_initial_properties, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system)
std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >	createMaterialStateVariables () const
void	initializeInternalStateVariables (double const t, ParameterLib::SpatialPosition const &x, typename MechanicsBase< DisplacementDim >::MaterialStateVariables &material_state_variables) const
std::optional< std::tuple< OGSMFrontThermodynamicForcesData, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, OGSMFrontTangentOperatorData > >	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
std::vector< InternalVariable >	getInternalVariables () const
template<typename ForcesGradsCombinations = typename ForcesGradsCombinations<Gradients, TDynForces, ExtStateVars>::type>
OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >	createTangentOperatorBlocksView () const
OGSMFrontThermodynamicForcesView< DisplacementDim, TDynForces >	createThermodynamicForcesView () const
double	getBulkModulus (double const, ParameterLib::SpatialPosition const &, KelvinMatrix const *const C) const
double	computeFreeEnergyDensity (double const, ParameterLib::SpatialPosition const &, double const, KelvinVector const &, KelvinVector const &, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &) const

Private Types
using	GradientsAndExtStateVars

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

Member Typedef Documentation

GradientsAndExtStateVars

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

using MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::GradientsAndExtStateVars

private

Initial value:

 
        boost::mp11::mp_append<Gradients, ExtStateVars>

Definition at line 253 of file MFrontGeneric.h.

InternalVariable

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

using MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::InternalVariable

Initial value:

 
        typename MechanicsBase<DisplacementDim>::InternalVariable

Definition at line 263 of file MFrontGeneric.h.

KelvinMatrix

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

using MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::KelvinMatrix

Initial value:

 
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>

Definition at line 261 of file MFrontGeneric.h.

KelvinVector

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

using MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::KelvinVector

Initial value:

 
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>

Definition at line 259 of file MFrontGeneric.h.

Constructor & Destructor Documentation

MFrontGeneric()

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

MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::MFrontGeneric ( mgis::behaviour::Behaviour && behaviour, std::vector< ParameterLib::Parameter< double > const * > && material_properties, std::map< std::string, ParameterLib::Parameter< double > const * > && state_variables_initial_properties, std::optional< ParameterLib::CoordinateSystem > const & local_coordinate_system )

inline

Definition at line 266 of file MFrontGeneric.h.

        : _behaviour(std::move(behaviour)),
          equivalent_plastic_strain_offset_(
              getEquivalentPlasticStrainOffset(_behaviour)),
          _material_properties(std::move(material_properties)),
          _state_variables_initial_properties(
              std::move(state_variables_initial_properties)),
          _local_coordinate_system(local_coordinate_system
                                       ? &local_coordinate_system.value()
                                       : nullptr)
    {
        {
            auto check_gradient = [&grads = _behaviour.gradients,
                                   hyp = _behaviour.hypothesis,
                                   i = 0]<typename Grad>(Grad) mutable
            {
                // TODO allow reordering of gradients and thermodynamic forces?
                if (grads[i].name != Grad::name)
                {
                    OGS_FATAL(
                        "OGS expects the {}th gradient to be {} but MFront "
                        "provides {}.",
                        i, Grad::name, grads[i].name);
                }
 
                if (grads[i].type != Grad::type)
                {
                    OGS_FATAL(
                        "The behaviour's {}th driver ({}) must be of type {}.",
                        i, grads[i].name, varTypeToString(Grad::type));
                }
 
                if (mgis::behaviour::getVariableSize(grads[i], hyp) !=
                    Grad::template size<DisplacementDim>())
                {
                    OGS_FATAL(
                        "The behaviour's {}th driver's ({}) size in OGS is {} "
                        "but {} in MFront.",
                        i, grads[i].name,
                        Grad::template size<DisplacementDim>(),
                        mgis::behaviour::getVariableSize(grads[i], hyp));
                }
 
                i++;
            };
 
            if (_behaviour.gradients.size() !=
                boost::mp11::mp_size<Gradients>::value)
                OGS_FATAL(
                    "The behaviour must have exactly {} gradients as input.",
                    boost::mp11::mp_size<Gradients>::value);
 
            boost::mp11::mp_for_each<Gradients>(check_gradient);
        }
 
        {
            auto check_tdyn_force = [&tdfs = _behaviour.thermodynamic_forces,
                                     hyp = _behaviour.hypothesis,
                                     i = 0]<typename TDF>(TDF) mutable
            {
                if (tdfs[i].name != TDF::name)
                {
                    OGS_FATAL(
                        "OGS expects the {}th thermodynamic force to be {} but "
                        "MFront provides {}.",
                        i, TDF::name, tdfs[i].name);
                }
 
                if (tdfs[i].type != TDF::type)
                {
                    OGS_FATAL(
                        "The behaviour's {}th thermodynamic force ({}) must be "
                        "of type {}.",
                        i, tdfs[i].name, varTypeToString(TDF::type));
                }
 
                if (mgis::behaviour::getVariableSize(tdfs[i], hyp) !=
                    TDF::template size<DisplacementDim>())
                {
                    OGS_FATAL(
                        "The behaviour's {}th thermodynamic force ({}) must "
                        "have size {} instead of {}.",
                        i, tdfs[i].name, TDF::template size<DisplacementDim>(),
                        mgis::behaviour::getVariableSize(tdfs[i], hyp));
                }
 
                i++;
            };
 
            if (_behaviour.thermodynamic_forces.size() !=
                boost::mp11::mp_size<TDynForces>::value)
                OGS_FATAL(
                    "The behaviour must compute exactly {} thermodynamic "
                    "forces.",
                    boost::mp11::mp_size<TDynForces>::value);
 
            boost::mp11::mp_for_each<TDynForces>(check_tdyn_force);
        }
 
        auto const hypothesis = _behaviour.hypothesis;
 
        static_assert(
            std::is_same_v<ExtStateVars, boost::mp11::mp_list<Temperature>>,
            "Temperature is the only allowed external state variable.");
 
        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());
        }
    }

Member Function Documentation

computeFreeEnergyDensity()

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

double MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::computeFreeEnergyDensity ( double const , ParameterLib::SpatialPosition const & , double const , KelvinVector const & , KelvinVector const & , typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &  ) const

inline

Definition at line 716 of file MFrontGeneric.h.

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

createMaterialStateVariables()

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

std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables > MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::createMaterialStateVariables ( ) const

inline

Definition at line 411 of file MFrontGeneric.h.

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

createTangentOperatorBlocksView()

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

template<typename ForcesGradsCombinations = typename ForcesGradsCombinations<Gradients, TDynForces, ExtStateVars>::type>

OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations > MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::createTangentOperatorBlocksView ( ) const

inline

Definition at line 686 of file MFrontGeneric.h.

    {
        return OGSMFrontTangentOperatorBlocksView<DisplacementDim,
                                                  ForcesGradsCombinations>{
            _behaviour.to_blocks};
    }

createThermodynamicForcesView()

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

OGSMFrontThermodynamicForcesView< DisplacementDim, TDynForces > MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::createThermodynamicForcesView ( ) const

inline

Definition at line 694 of file MFrontGeneric.h.

    {
        return OGSMFrontThermodynamicForcesView<DisplacementDim, TDynForces>{};
    }

getBulkModulus()

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

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

inline

Definition at line 699 of file MFrontGeneric.h.

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

getInternalVariables()

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

std::vector< InternalVariable > MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::getInternalVariables ( ) const

inline

Definition at line 625 of file MFrontGeneric.h.

    {
        std::vector<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.
            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<MaterialStateVariablesMFront<
                               DisplacementDim> const*>(&state) != nullptr);
                    auto const& internal_state_variables =
                        static_cast<MaterialStateVariablesMFront<
                            DisplacementDim> 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)
                    -> std::span<double>
                {
                    assert(dynamic_cast<MaterialStateVariablesMFront<
                               DisplacementDim> const*>(&state) != nullptr);
                    auto& internal_state_variables =
                        static_cast<
                            MaterialStateVariablesMFront<DisplacementDim>&>(
                            state)
                            ._behaviour_data.s1.internal_state_variables;
 
                    return {internal_state_variables.data() + offset, size};
                }};
            internal_variables.push_back(new_variable);
        }
 
        return internal_variables;
    }

initializeInternalStateVariables()

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

void MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::initializeInternalStateVariables ( double const t, ParameterLib::SpatialPosition const & x, typename MechanicsBase< DisplacementDim >::MaterialStateVariables & material_state_variables ) const

inline

Definition at line 417 of file MFrontGeneric.h.

    {
        assert(dynamic_cast<MaterialStateVariablesMFront<DisplacementDim>*>(
            &material_state_variables));
 
        auto& state =
            static_cast<MaterialStateVariablesMFront<DisplacementDim>&>(
                material_state_variables);
 
        auto const& ivs = getInternalVariables();
 
        for (auto& [name, parameter] : _state_variables_initial_properties)
        {
            // find corresponding internal variable
            auto const& iv = BaseLib::findElementOrError(
                ivs,
                [name = name](InternalVariable const& iv)
                { return iv.name == name; },
                [name = name]()
                { OGS_FATAL("Internal variable `{:s}' not found.", name); });
 
            // evaluate parameter
            std::vector<double> values = (*parameter)(t, x);
 
            // copy parameter data into iv
            auto const values_span = iv.reference(state);
            assert(values.size() == values_span.size());
            std::copy_n(begin(values), values_span.size(), values_span.begin());
        }
 
        auto const& s1 = state._behaviour_data.s1.internal_state_variables;
        auto& s0 = state._behaviour_data.s0.internal_state_variables;
        std::copy(begin(s1), end(s1), begin(s0));
    }

integrateStress()

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

std::optional< std::tuple< OGSMFrontThermodynamicForcesData, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, OGSMFrontTangentOperatorData > > MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::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

inline

Definition at line 460 of file MFrontGeneric.h.

    {
        using namespace MathLib::KelvinVector;
 
        assert(
            dynamic_cast<MaterialStateVariablesMFront<DisplacementDim> const*>(
                &material_state_variables));
        // New state, copy of current one, packed in unique_ptr for return.
        auto state = std::make_unique<
            MaterialStateVariablesMFront<DisplacementDim>>(
            static_cast<MaterialStateVariablesMFront<DisplacementDim> const&>(
                material_state_variables));
        auto& behaviour_data = state->_behaviour_data;
 
        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.
        if (behaviour_data.s0.b.btype ==
            mgis::behaviour::Behaviour::STANDARDFINITESTRAINBEHAVIOUR)
        {
            behaviour_data.K[1] = 1.0;  // The second Piola-Kirchoff stress is
                                        // used for the stress measure
            behaviour_data.K[2] =
                1.0;  // The derivative of the second
                      // Piola-Kirchoff stress with respect to
                      // the Green-Lagrange strain is returned.
        }
 
        // evaluate parameters at (t, x)
        {
            {
                auto out = behaviour_data.s0.material_properties.begin();
                for (auto* param : _material_properties)
                {
                    auto const& vals = (*param)(t - dt, x);
                    out = std::copy(vals.begin(), vals.end(), out);
                }
                assert(out == behaviour_data.s0.material_properties.end());
            }
 
            {
                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());
            }
        }
 
        // TODO unify with gradient handling? Make gradient and external state
        // var input both optional?
        if (!behaviour_data.s0.external_state_variables.empty())
        {
            // assuming that there is only temperature
            // NOTE the temperature can be NaN, e.g., if OGS's process does not
            // have a temperature defined
            behaviour_data.s0.external_state_variables[0] =
                variable_array_prev.temperature;
        }
 
        if (!behaviour_data.s1.external_state_variables.empty())
        {
            // assuming that there is only temperature
            // NOTE the temperature can be NaN, e.g., if OGS's process does not
            // have a temperature defined
            behaviour_data.s1.external_state_variables[0] =
                variable_array.temperature;
        }
 
        // rotation tensor
        std::optional<KelvinMatrixType<DisplacementDim>> Q;
        if (_local_coordinate_system)
        {
            Q = fourthOrderRotationMatrix(
                _local_coordinate_system->transformation<DisplacementDim>(x));
        }
 
        boost::mp11::mp_for_each<Gradients>(
            detail::SetGradient<DisplacementDim>{
                variable_array_prev, Q, behaviour_data.s0.gradients.data()});
        boost::mp11::mp_for_each<Gradients>(
            detail::SetGradient<DisplacementDim>{
                variable_array, Q, behaviour_data.s1.gradients.data()});
 
        // previous and current state of thermodynamic forces are both set from
        // variable_array_prev. TODO optimization potential compute Q * grad_ogs
        // only once for both cases.
        boost::mp11::mp_for_each<TDynForces>(
            detail::SetGradient<DisplacementDim>{
                variable_array_prev, Q,
                behaviour_data.s0.thermodynamic_forces.data()});
        boost::mp11::mp_for_each<TDynForces>(
            detail::SetGradient<DisplacementDim>{
                variable_array_prev, Q,
                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) + ".");
        }
 
        OGSMFrontThermodynamicForcesData tdyn_forces_data;
        tdyn_forces_data.data.resize(  // TODO data stored on heap but size is
                                       // compile-time constant
            behaviour_data.s1.thermodynamic_forces.size());
 
        boost::mp11::mp_for_each<TDynForces>(
            [&out_data = tdyn_forces_data,
             &in_data = behaviour_data.s1.thermodynamic_forces,
             &Q]<typename TDF>(TDF tdf)
            {
                OGSMFrontThermodynamicForcesView<DisplacementDim, TDynForces>
                    view;
 
                if constexpr (TDF::type ==
                              mgis::behaviour::Variable::Type::STENSOR)
                {
                    if (Q)
                    {
                        view.block(tdf, out_data) =
                            *Q * eigenSwap45View(view.block(tdf, in_data));
                    }
                    else
                    {
                        view.block(tdf, out_data) =
                            eigenSwap45View(view.block(tdf, in_data));
                    }
                }
                else if constexpr (TDF::type ==
                                   mgis::behaviour::Variable::Type::SCALAR)
                {
                    view.block(tdf, out_data) = view.block(tdf, in_data);
                }
                else
                {
                    OGS_FATAL("Not yet implemented.");
                }
            });
 
        return std::make_optional(
            std::make_tuple<OGSMFrontThermodynamicForcesData,
                            std::unique_ptr<typename MechanicsBase<
                                DisplacementDim>::MaterialStateVariables>,
                            OGSMFrontTangentOperatorData>(
                std::move(tdyn_forces_data),
                std::move(state),
                tangentOperatorDataMFrontToOGS<DisplacementDim>(
                    behaviour_data.K, Q, _behaviour)));
    }

Member Data Documentation

_behaviour

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

mgis::behaviour::Behaviour MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::_behaviour

private

Definition at line 730 of file MFrontGeneric.h.

_local_coordinate_system

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

ParameterLib::CoordinateSystem const* const MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::_local_coordinate_system

private

Definition at line 735 of file MFrontGeneric.h.

_material_properties

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

std::vector<ParameterLib::Parameter<double> const*> MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::_material_properties

private

Definition at line 732 of file MFrontGeneric.h.

_state_variables_initial_properties

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

std::map<std::string, ParameterLib::Parameter<double> const*> MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::_state_variables_initial_properties

private

Definition at line 734 of file MFrontGeneric.h.

equivalent_plastic_strain_offset_

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

int const MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, Gradients, TDynForces, ExtStateVars >::equivalent_plastic_strain_offset_

private

Definition at line 731 of file MFrontGeneric.h.

---

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

• MFrontGeneric.h