Detailed Description

template<int DisplacementDim>
class MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >

Definition at line 272 of file Ehlers.h.

#include <Ehlers.h>

Inheritance diagram for MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >:

Collaboration diagram for MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >:

Public Types
using	ResidualVectorType = Eigen::Matrix<double, JacobianResidualSize, 1>

using	JacobianMatrix

using	KelvinVector

using	KelvinMatrix

Public Types inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
using	KelvinVector

using	KelvinMatrix

Public Member Functions
std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >	createMaterialStateVariables () const override

	SolidEhlers (NumLib::NewtonRaphsonSolverParameters nonlinear_solver_parameters, MaterialPropertiesParameters material_properties, std::unique_ptr< DamagePropertiesParameters > &&damage_properties, TangentType tangent_type)

double	computeFreeEnergyDensity (double const, ParameterLib::SpatialPosition const &, double const, KelvinVector const &eps, KelvinVector const &sigma, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &material_state_variables) 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

MaterialProperties	evaluatedMaterialProperties (double const t, ParameterLib::SpatialPosition const &x) const

double	getBulkModulus (double const t, ParameterLib::SpatialPosition const &x, KelvinMatrix const *const) const override

DamageProperties	evaluatedDamageProperties (double const t, ParameterLib::SpatialPosition const &x) const

Public Member Functions inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
virtual void	initializeInternalStateVariables (double const, ParameterLib::SpatialPosition const &, typename MechanicsBase< DisplacementDim >::MaterialStateVariables &) const

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.

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

Static Public Attributes
static int const	KelvinVectorSize

static int const	JacobianResidualSize

Private Attributes
NumLib::NewtonRaphsonSolverParameters const	_nonlinear_solver_parameters

MaterialPropertiesParameters	_mp

std::unique_ptr< DamagePropertiesParameters >	_damage_properties

TangentType const	_tangent_type

Member Typedef Documentation

◆ JacobianMatrix

template<int DisplacementDim>

using MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::JacobianMatrix

Initial value:

Eigen::Matrix<double, JacobianResidualSize,

JacobianResidualSize, Eigen::RowMajor>

MaterialLib::Solids::Ehlers::SolidEhlers::JacobianResidualSize

static int const JacobianResidualSize

Definition Ehlers.h:277

Definition at line 283 of file Ehlers.h.

◆ KelvinMatrix

template<int DisplacementDim>

using MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::KelvinMatrix

Initial value:

MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>

MathLib::KelvinVector::KelvinMatrixType

Eigen::Matrix< double, kelvin_vector_dimensions(DisplacementDim), kelvin_vector_dimensions(DisplacementDim), Eigen::RowMajor > KelvinMatrixType

Definition KelvinVector.h:55

Definition at line 297 of file Ehlers.h.

◆ KelvinVector

template<int DisplacementDim>

using MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::KelvinVector

Initial value:

MathLib::KelvinVector::KelvinVectorType<DisplacementDim>

MathLib::KelvinVector::KelvinVectorType

Eigen::Matrix< double, kelvin_vector_dimensions(DisplacementDim), 1, Eigen::ColMajor > KelvinVectorType

Definition KelvinVector.h:47

Definition at line 295 of file Ehlers.h.

◆ ResidualVectorType

template<int DisplacementDim>

using MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::ResidualVectorType = Eigen::Matrix<double, JacobianResidualSize, 1>

Definition at line 282 of file Ehlers.h.

Constructor & Destructor Documentation

◆ SolidEhlers()

template<int DisplacementDim>

MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::SolidEhlers	(	NumLib::NewtonRaphsonSolverParameters	nonlinear_solver_parameters,
		MaterialPropertiesParameters	material_properties,
		std::unique_ptr< DamagePropertiesParameters > &&	damage_properties,
		TangentType	tangent_type )

Definition at line 503 of file Ehlers.cpp.

    : _nonlinear_solver_parameters(std::move(nonlinear_solver_parameters)),
      _mp(std::move(material_properties)),
      _damage_properties(std::move(damage_properties)),
      _tangent_type(tangent_type)
{
}

Member Function Documentation

◆ computeFreeEnergyDensity()

template<int DisplacementDim>

double MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::computeFreeEnergyDensity	(	double const	,
		ParameterLib::SpatialPosition const &	,
		double const	,
		KelvinVector const &	eps,
		KelvinVector const &	sigma,
		typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &	material_state_variables ) const

override

Definition at line 516 of file Ehlers.cpp.

{
    assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
               &material_state_variables) != nullptr);
 
    auto const& eps_p = static_cast<StateVariables<DisplacementDim> const&>(
                            material_state_variables)
                            .eps_p;
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    auto const& identity2 = Invariants::identity2;
    return (eps - eps_p.D - eps_p.V / 3 * identity2).dot(sigma) / 2;
}

◆ createMaterialStateVariables()

template<int DisplacementDim>

std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables > MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::createMaterialStateVariables ( ) const

inlineoverridevirtual

Polymorphic creator for MaterialStateVariables objects specific for a material model.

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

Definition at line 289 of file Ehlers.h.

    {
        return std::make_unique<StateVariables<DisplacementDim>>();
    }

◆ evaluatedDamageProperties()

template<int DisplacementDim>

DamageProperties MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::evaluatedDamageProperties	(	double const	t,
		ParameterLib::SpatialPosition const &	x ) const

inline

Definition at line 343 of file Ehlers.h.

    {
        return DamageProperties(t, x, *_damage_properties);
    }

References MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_damage_properties.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::preAssemble().

◆ evaluatedMaterialProperties()

template<int DisplacementDim>

MaterialProperties MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::evaluatedMaterialProperties	(	double const	t,
		ParameterLib::SpatialPosition const &	x ) const

inline

Definition at line 330 of file Ehlers.h.

    {
        return MaterialProperties(t, x, _mp);
    }

References MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_mp.

◆ getBulkModulus()

template<int DisplacementDim>

double MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::getBulkModulus	(	double const	t,
		ParameterLib::SpatialPosition const &	x,
		KelvinMatrix const * const	) const

inlineoverridevirtual

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

Definition at line 336 of file Ehlers.h.

    {
        return _mp.K(t, x)[0];
    }

References MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_mp, and MaterialLib::Solids::Ehlers::MaterialPropertiesParameters::K.

◆ getInternalVariables()

template<int DisplacementDim>

std::vector< typename MechanicsBase< DisplacementDim >::InternalVariable > MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::getInternalVariables ( ) const

overridevirtual

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

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

Definition at line 735 of file Ehlers.cpp.

{
    return {{"damage.kappa_d", 1,
             [](typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto const& ehlers_state =
                     static_cast<StateVariables<DisplacementDim> const&>(state);
 
                 cache.resize(1);
                 cache.front() = ehlers_state.damage.kappa_d();
                 return cache;
             },
             [](typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> std::span<double>
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto& ehlers_state =
                     static_cast<StateVariables<DisplacementDim>&>(state);
 
                 return {&ehlers_state.damage.kappa_d(), 1};
             }},
            {"damage.value", 1,
             [](typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto const& ehlers_state =
                     static_cast<StateVariables<DisplacementDim> const&>(state);
 
                 cache.resize(1);
                 cache.front() = ehlers_state.damage.value();
                 return cache;
             },
             [](typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> std::span<double>
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto& ehlers_state =
                     static_cast<StateVariables<DisplacementDim>&>(state);
 
                 return {&ehlers_state.damage.value(), 1};
             }},
            {"eps_p.D", KelvinVector::RowsAtCompileTime,
             [](typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto const& ehlers_state =
                     static_cast<StateVariables<DisplacementDim> const&>(state);
 
                 cache.resize(KelvinVector::RowsAtCompileTime);
                 MathLib::toVector<KelvinVector>(
                     cache, KelvinVector::RowsAtCompileTime) =
                     MathLib::KelvinVector::kelvinVectorToSymmetricTensor(
                         ehlers_state.eps_p.D);
 
                 return cache;
             },
             [](typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> std::span<double>
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto& ehlers_state =
                     static_cast<StateVariables<DisplacementDim>&>(state);
 
                 return {
                     ehlers_state.eps_p.D.data(),
                     static_cast<std::size_t>(KelvinVector::RowsAtCompileTime)};
             }},
            {"eps_p.V", 1,
             [](typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto const& ehlers_state =
                     static_cast<StateVariables<DisplacementDim> const&>(state);
 
                 cache.resize(1);
                 cache.front() = ehlers_state.eps_p.V;
                 return cache;
             },
             [](typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> std::span<double>
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto& ehlers_state =
                     static_cast<StateVariables<DisplacementDim>&>(state);
 
                 return {&ehlers_state.eps_p.V, 1};
             }},
            {"eps_p.eff", 1,
             [](typename MechanicsBase<
                    DisplacementDim>::MaterialStateVariables const& state,
                std::vector<double>& cache) -> std::vector<double> const&
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto const& ehlers_state =
                     static_cast<StateVariables<DisplacementDim> const&>(state);
 
                 cache.resize(1);
                 cache.front() = ehlers_state.eps_p.eff;
                 return cache;
             },
             [](typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
                    state) -> std::span<double>
             {
                 assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
                            &state) != nullptr);
                 auto& ehlers_state =
                     static_cast<StateVariables<DisplacementDim>&>(state);
 
                 return {&ehlers_state.eps_p.eff, 1};
             }}};
}

References MaterialLib::Solids::Ehlers::StateVariables< DisplacementDim >::damage, MaterialLib::Solids::Ehlers::StateVariables< DisplacementDim >::eps_p, MaterialLib::Solids::Ehlers::Damage::kappa_d(), MathLib::KelvinVector::kelvinVectorToSymmetricTensor(), and MaterialLib::Solids::Ehlers::Damage::value().

◆ integrateStress()

template<int DisplacementDim>

std::optional< std::tuple< typename SolidEhlers< DisplacementDim >::KelvinVector, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, typename SolidEhlers< DisplacementDim >::KelvinMatrix > > MaterialLib::Solids::Ehlers::SolidEhlers< 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 541 of file Ehlers.cpp.

{
    auto const& eps_m = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array.mechanical_strain);
    auto const& eps_m_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev.mechanical_strain);
    auto const& sigma_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev.stress);
 
    assert(dynamic_cast<StateVariables<DisplacementDim> const*>(
               &material_state_variables) != nullptr);
 
    StateVariables<DisplacementDim> state =
        static_cast<StateVariables<DisplacementDim> const&>(
            material_state_variables);
    state.setInitialConditions();
 
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
 
    // volumetric strain
    double const eps_V = Invariants::trace(eps_m);
 
    auto const& P_dev = Invariants::deviatoric_projection;
    // deviatoric strain
    KelvinVector const eps_D = P_dev * eps_m;
 
    // do the evaluation once per function call.
    MaterialProperties const mp(t, x, _mp);
 
    KelvinVector sigma = predict_sigma<DisplacementDim>(
        mp.G, mp.K, sigma_prev, eps_m, eps_m_prev, eps_V);
 
    KelvinMatrix tangentStiffness;
 
    PhysicalStressWithInvariants<DisplacementDim> s{mp.G * sigma};
    // Quit early if sigma is zero (nothing to do), or dt is zero, or if we are
    // still in elastic zone.
    // dt can be zero if we are in the initialization phase and the tangent
    // stiffness will no be necessary. Anyway the newton loop below would not
    // work because of division by zero.
    if ((sigma.squaredNorm() == 0. || dt == 0. ||
         yieldFunction(
             mp, s,
             calculateIsotropicHardening(mp.kappa, mp.hardening_coefficient,
                                         state.eps_p.eff)) < 0.))
    {
        tangentStiffness = elasticTangentStiffness<DisplacementDim>(
            mp.K - 2. / 3 * mp.G, mp.G);
    }
    else
    {
        // Linear solver for the newton loop is required after the loop with the
        // same matrix. This saves one decomposition.
        Eigen::FullPivLU<Eigen::Matrix<double, JacobianResidualSize,
                                       JacobianResidualSize, Eigen::RowMajor>>
            linear_solver;
 
        {
            using KelvinVector =
                MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
            using ResidualVectorType =
                Eigen::Matrix<double, JacobianResidualSize, 1>;
            using JacobianMatrix =
                Eigen::Matrix<double, JacobianResidualSize,
                              JacobianResidualSize, Eigen::RowMajor>;
 
            JacobianMatrix jacobian;
 
            // Agglomerated solution vector construction.  It is later split
            // into individual parts by splitSolutionVector().
            ResidualVectorType solution;
            solution << sigma, state.eps_p.D, state.eps_p.V, state.eps_p.eff, 0;
 
            auto const update_residual = [&](ResidualVectorType& residual)
            {
                auto const& eps_p_D =
                    solution.template segment<KelvinVectorSize>(
                        KelvinVectorSize);
                KelvinVector const eps_p_D_dot =
                    (eps_p_D - state.eps_p_prev.D) / dt;
 
                double const& eps_p_V = solution[KelvinVectorSize * 2];
                double const eps_p_V_dot = (eps_p_V - state.eps_p_prev.V) / dt;
 
                double const& eps_p_eff = solution[KelvinVectorSize * 2 + 1];
                double const eps_p_eff_dot =
                    (eps_p_eff - state.eps_p_prev.eff) / dt;
 
                double const k_hardening = calculateIsotropicHardening(
                    mp.kappa, mp.hardening_coefficient,
                    solution[KelvinVectorSize * 2 + 1]);
                residual = calculatePlasticResidual<DisplacementDim>(
                    eps_D, eps_V, s,
                    solution.template segment<KelvinVectorSize>(
                        KelvinVectorSize),
                    eps_p_D_dot, solution[KelvinVectorSize * 2], eps_p_V_dot,
                    eps_p_eff_dot, solution[KelvinVectorSize * 2 + 2],
                    k_hardening, mp);
            };
 
            auto const update_jacobian = [&](JacobianMatrix& jacobian)
            {
                jacobian = calculatePlasticJacobian<DisplacementDim>(
                    dt, s, solution[KelvinVectorSize * 2 + 2], mp);
            };
 
            auto const update_solution =
                [&](ResidualVectorType const& increment)
            {
                solution += increment;
                s = PhysicalStressWithInvariants<DisplacementDim>{
                    mp.G * solution.template segment<KelvinVectorSize>(0)};
            };
 
            auto newton_solver = NumLib::NewtonRaphson<
                decltype(linear_solver), JacobianMatrix,
                decltype(update_jacobian), ResidualVectorType,
                decltype(update_residual), decltype(update_solution)>(
                linear_solver, update_jacobian, update_residual,
                update_solution, _nonlinear_solver_parameters);
 
            auto const success_iterations = newton_solver.solve(jacobian);
 
            if (!success_iterations)
            {
                return {};
            }
 
            // If the Newton loop didn't run, the linear solver will not be
            // initialized.
            // This happens usually for the first iteration of the first
            // timestep.
            if (*success_iterations == 0)
            {
                linear_solver.compute(jacobian);
            }
 
            std::tie(sigma, state.eps_p, std::ignore) =
                splitSolutionVector<ResidualVectorType, KelvinVector>(solution);
        }
 
        // Calculate residual derivative w.r.t. strain
        Eigen::Matrix<double, JacobianResidualSize, KelvinVectorSize,
                      Eigen::RowMajor>
            dresidual_deps =
                Eigen::Matrix<double, JacobianResidualSize, KelvinVectorSize,
                              Eigen::RowMajor>::Zero();
        dresidual_deps.template block<KelvinVectorSize, KelvinVectorSize>(0, 0)
            .noalias() = calculateDResidualDEps<DisplacementDim>(mp.K, mp.G);
 
        if (_tangent_type == TangentType::Elastic)
        {
            tangentStiffness =
                elasticTangentStiffness<DisplacementDim>(mp.K, mp.G);
        }
        else if (_tangent_type == TangentType::Plastic ||
                 _tangent_type == TangentType::PlasticDamageSecant)
        {
            tangentStiffness =
                mp.G *
                linear_solver.solve(-dresidual_deps)
                    .template block<KelvinVectorSize, KelvinVectorSize>(0, 0);
            if (_tangent_type == TangentType::PlasticDamageSecant)
            {
                tangentStiffness *= 1 - state.damage.value();
            }
        }
        else
        {
            OGS_FATAL(
                "Unimplemented tangent type behaviour for the tangent type "
                "'{}'.",
                BaseLib::to_underlying(_tangent_type));
        }
    }
 
    KelvinVector sigma_final = mp.G * sigma;
 
    return {std::make_tuple(
        sigma_final,
        std::unique_ptr<
            typename MechanicsBase<DisplacementDim>::MaterialStateVariables>{
            new StateVariables<DisplacementDim>{
                static_cast<StateVariables<DisplacementDim> const&>(state)}},
        tangentStiffness)};
}

Member Data Documentation

◆ _damage_properties

template<int DisplacementDim>

std::unique_ptr<DamagePropertiesParameters> MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_damage_properties

private

Definition at line 353 of file Ehlers.h.

Referenced by MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::evaluatedDamageProperties().

◆ _mp

template<int DisplacementDim>

MaterialPropertiesParameters MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_mp

private

Definition at line 352 of file Ehlers.h.

Referenced by MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::evaluatedMaterialProperties(), and MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::getBulkModulus().

◆ _nonlinear_solver_parameters

template<int DisplacementDim>

NumLib::NewtonRaphsonSolverParameters const MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_nonlinear_solver_parameters

private

Definition at line 350 of file Ehlers.h.

◆ _tangent_type

template<int DisplacementDim>

TangentType const MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::_tangent_type

private

Definition at line 354 of file Ehlers.h.

◆ JacobianResidualSize

template<int DisplacementDim>

int const MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::JacobianResidualSize

static

Initial value:

=

2 * KelvinVectorSize + 3

Definition at line 277 of file Ehlers.h.

◆ KelvinVectorSize

template<int DisplacementDim>

int const MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::KelvinVectorSize

static

Initial value:

=

MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)

MathLib::KelvinVector::kelvin_vector_dimensions

constexpr int kelvin_vector_dimensions(int const displacement_dim)

Kelvin vector dimensions for given displacement dimension.

Definition KelvinVector.h:24

Definition at line 275 of file Ehlers.h.

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

MaterialLib/SolidModels/Ehlers.h
MaterialLib/SolidModels/Ehlers.cpp

Detailed Description

Public Types

Public Member Functions

Static Public Attributes

Private Attributes

Member Typedef Documentation

◆ JacobianMatrix

◆ KelvinMatrix

◆ KelvinVector

◆ ResidualVectorType

Constructor & Destructor Documentation

◆ SolidEhlers()

Member Function Documentation

◆ computeFreeEnergyDensity()

◆ createMaterialStateVariables()

◆ evaluatedDamageProperties()

◆ evaluatedMaterialProperties()

◆ getBulkModulus()

◆ getInternalVariables()

◆ integrateStress()

Member Data Documentation

◆ _damage_properties

◆ _mp

◆ _nonlinear_solver_parameters

◆ _tangent_type

◆ JacobianResidualSize

◆ KelvinVectorSize