Detailed Description

Common convenitions for naming: x_D - deviatoric part of tensor x x_V - volumetric part of tensor x x_p - a variable related to plastic potential x_prev - value of x in previous time step

Variables used in the code: eps_D - deviatoric strain eps_p_D_dot - deviatoric increment of plastic strain eps_p_eff_dot - increment of effective plastic strain eps_p_V_dot - volumetric increment of plastic strain sigma_D_inverse_D - deviatoric part of sigma_D_inverse

derivation of the flow rule theta - J3 / J2^(3 / 2) from yield function dtheta_dsigma - derivative of theta sqrtPhi - square root of Phi from plastic potential flow_D - deviatoric part of flow flow_V - volumetric part of flow lambda_flow_D - deviatoric increment of plastic strain

Classes
class	Damage
struct	DamageProperties
struct	DamagePropertiesParameters
struct	MaterialProperties
struct	MaterialPropertiesParameters
struct	OnePlusGamma_pTheta
	Holds powers of 1 + gamma_p*theta to base 0, m_p, and m_p-1. More...
struct	PhysicalStressWithInvariants
struct	PlasticStrain
class	SolidEhlers
struct	StateVariables

Enumerations
enum class	TangentType { Elastic , PlasticDamageSecant , Plastic }

Functions
std::unique_ptr< DamagePropertiesParameters >	createDamageProperties (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
std::unique_ptr< SolidEhlers< DisplacementDim > >	createEhlers (std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, BaseLib::ConfigTree const &config)
template<int DisplacementDim>
MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >	sOdotS (MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &v)
template<int DisplacementDim>
double	plasticFlowVolumetricPart (PhysicalStressWithInvariants< DisplacementDim > const &s, double const sqrtPhi, double const alpha_p, double const beta_p, double const delta_p, double const epsilon_p)
template<int DisplacementDim>
SolidEhlers< DisplacementDim >::KelvinVector	plasticFlowDeviatoricPart (PhysicalStressWithInvariants< DisplacementDim > const &s, OnePlusGamma_pTheta const &one_gt, double const sqrtPhi, typename SolidEhlers< DisplacementDim >::KelvinVector const &dtheta_dsigma, double const gamma_p, double const m_p)
template<int DisplacementDim>
double	yieldFunction (MaterialProperties const &mp, PhysicalStressWithInvariants< DisplacementDim > const &s, double const k)
template<int DisplacementDim>
std::pair< MathLib::KelvinVector::KelvinVectorType< DisplacementDim >, MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > >	thetaSigmaDerivatives (double theta, PhysicalStressWithInvariants< DisplacementDim > const &s)
template<int DisplacementDim>
SolidEhlers< DisplacementDim >::ResidualVectorType	calculatePlasticResidual (MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &eps_D, double const eps_V, PhysicalStressWithInvariants< DisplacementDim > const &s, MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &eps_p_D, MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &eps_p_D_dot, double const eps_p_V, double const eps_p_V_dot, double const eps_p_eff_dot, double const lambda, double const k, MaterialProperties const &mp)
template<int DisplacementDim>
SolidEhlers< DisplacementDim >::JacobianMatrix	calculatePlasticJacobian (double const dt, PhysicalStressWithInvariants< DisplacementDim > const &s, double const lambda, MaterialProperties const &mp)
template<int DisplacementDim>
MathLib::KelvinVector::KelvinMatrixType< DisplacementDim >	calculateDResidualDEps (double const K, double const G)
double	calculateIsotropicHardening (double const kappa, double const hardening_coefficient, double const eps_p_eff)
template<int DisplacementDim>
SolidEhlers< DisplacementDim >::KelvinVector	predict_sigma (double const G, double const K, typename SolidEhlers< DisplacementDim >::KelvinVector const &sigma_prev, typename SolidEhlers< DisplacementDim >::KelvinVector const &eps, typename SolidEhlers< DisplacementDim >::KelvinVector const &eps_prev, double const eps_V)
template<typename ResidualVector, typename KelvinVector>
std::tuple< KelvinVector, PlasticStrain< KelvinVector >, double >	splitSolutionVector (ResidualVector const &solution)
template<>
MathLib::KelvinVector::KelvinMatrixType< 3 >	sOdotS< 3 > (MathLib::KelvinVector::KelvinVectorType< 3 > const &v)
template<>
MathLib::KelvinVector::KelvinMatrixType< 2 >	sOdotS< 2 > (MathLib::KelvinVector::KelvinVectorType< 2 > const &v)
TangentType	makeTangentType (std::string const &s)

Enumeration Type Documentation

◆ TangentType

enum class MaterialLib::Solids::Ehlers::TangentType

strong

Enumerator
Elastic
PlasticDamageSecant
Plastic

Definition at line 33 of file Ehlers.h.

{
    Elastic,
    PlasticDamageSecant,
    Plastic
};

Function Documentation

◆ calculateDResidualDEps()

template<int DisplacementDim>

MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > MaterialLib::Solids::Ehlers::calculateDResidualDEps	(	double const	K,
		double const	G )

Calculates the derivative of the residuals with respect to total strain. Implementation fully implicit only.

Definition at line 431 of file Ehlers.cpp.

{
    static int const KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
 
    auto const& P_dev = Invariants::deviatoric_projection;
    auto const& P_sph = Invariants::spherical_projection;
    auto const& I =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>::Identity();
 
    return -2. * I * P_dev - 3. * K / G * I * P_sph;
}

References MathLib::KelvinVector::kelvin_vector_dimensions().

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

◆ calculateIsotropicHardening()

double MaterialLib::Solids::Ehlers::calculateIsotropicHardening	(	double const	kappa,
		double const	hardening_coefficient,
		double const	eps_p_eff )

inline

Definition at line 446 of file Ehlers.cpp.

{
    return kappa * (1. + eps_p_eff * hardening_coefficient);
}

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

◆ calculatePlasticJacobian()

template<int DisplacementDim>

SolidEhlers< DisplacementDim >::JacobianMatrix MaterialLib::Solids::Ehlers::calculatePlasticJacobian	(	double const	dt,
		PhysicalStressWithInvariants< DisplacementDim > const &	s,
		double const	lambda,
		MaterialProperties const &	mp )

Definition at line 250 of file Ehlers.cpp.

{
    static int const KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    using KelvinVector =
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
    using KelvinMatrix =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;
 
    auto const& P_dev = Invariants::deviatoric_projection;
    auto const& identity2 = Invariants::identity2;
 
    double const theta = s.J_3 / (s.J_2 * std::sqrt(s.J_2));
    OnePlusGamma_pTheta const one_gt{mp.gamma_p, theta, mp.m_p};
 
    auto const [dtheta_dsigma, d2theta_dsigma2] =
        thetaSigmaDerivatives(theta, s);
 
    // deviatoric flow
    double const sqrtPhi = std::sqrt(
        s.J_2 * one_gt.pow_m_p + mp.alpha_p / 2. * boost::math::pow<2>(s.I_1) +
        boost::math::pow<2>(mp.delta_p) * boost::math::pow<4>(s.I_1));
    KelvinVector const flow_D = plasticFlowDeviatoricPart(
        s, one_gt, sqrtPhi, dtheta_dsigma, mp.gamma_p, mp.m_p);
    KelvinVector const lambda_flow_D = lambda * flow_D;
 
    typename SolidEhlers<DisplacementDim>::JacobianMatrix jacobian =
        SolidEhlers<DisplacementDim>::JacobianMatrix::Zero();
 
    // G_11
    jacobian.template block<KelvinVectorSize, KelvinVectorSize>(0, 0)
        .noalias() = KelvinMatrix::Identity();
 
    // G_12
    jacobian
        .template block<KelvinVectorSize, KelvinVectorSize>(0, KelvinVectorSize)
        .noalias() = 2 * KelvinMatrix::Identity();
 
    // G_13
    jacobian.template block<KelvinVectorSize, 1>(0, 2 * KelvinVectorSize)
        .noalias() = mp.K / mp.G * identity2;
 
    // G_14 and G_15 are zero
 
    // G_21 -- derivative of deviatoric flow
 
    double const gm_p = mp.gamma_p * mp.m_p;
    // intermediate variable for derivative of deviatoric flow
    KelvinVector const M0 = s.J_2 / one_gt.value * dtheta_dsigma;
    // derivative of Phi w.r.t. sigma
    KelvinVector const dPhi_dsigma =
        one_gt.pow_m_p * (s.D + gm_p * M0) +
        (mp.alpha_p * s.I_1 +
         4 * boost::math::pow<2>(mp.delta_p) * boost::math::pow<3>(s.I_1)) *
            identity2;
 
    // intermediate variable for derivative of deviatoric flow
    KelvinMatrix const M1 =
        one_gt.pow_m_p *
        (s.D * dPhi_dsigma.transpose() + gm_p * M0 * dPhi_dsigma.transpose());
    // intermediate variable for derivative of deviatoric flow
    KelvinMatrix const M2 =
        one_gt.pow_m_p * (P_dev + s.D * gm_p * M0.transpose());
 
    // intermediate variable for derivative of deviatoric flow
    KelvinMatrix const M3 =
        gm_p * one_gt.pow_m_p1 *
        ((s.D + (gm_p - mp.gamma_p) * M0) * dtheta_dsigma.transpose() +
         s.J_2 * d2theta_dsigma2);
 
    // derivative of flow_D w.r.t. sigma
    KelvinMatrix const dflow_D_dsigma =
        (-M1 / (4 * boost::math::pow<3>(sqrtPhi)) + (M2 + M3) / (2 * sqrtPhi)) *
        mp.G;
    jacobian
        .template block<KelvinVectorSize, KelvinVectorSize>(KelvinVectorSize, 0)
        .noalias() = -lambda * dflow_D_dsigma;
 
    // G_22
    jacobian
        .template block<KelvinVectorSize, KelvinVectorSize>(KelvinVectorSize,
                                                            KelvinVectorSize)
        .noalias() = KelvinMatrix::Identity() / dt;
 
    // G_23 and G_24 are zero
 
    // G_25
    jacobian
        .template block<KelvinVectorSize, 1>(KelvinVectorSize,
                                             2 * KelvinVectorSize + 2)
        .noalias() = -flow_D;
 
    // G_31
    {
        // derivative of flow_V w.r.t. sigma
        KelvinVector const dflow_V_dsigma =
            3 * mp.G *
            (-(mp.alpha_p * s.I_1 + 4 * boost::math::pow<2>(mp.delta_p) *
                                        boost::math::pow<3>(s.I_1)) /
                 (4 * boost::math::pow<3>(sqrtPhi)) * dPhi_dsigma +
             (mp.alpha_p * identity2 +
              12 * boost::math::pow<2>(mp.delta_p * s.I_1) * identity2) /
                 (2 * sqrtPhi) +
             2 * mp.epsilon_p * identity2);
 
        jacobian.template block<1, KelvinVectorSize>(2 * KelvinVectorSize, 0)
            .noalias() = -lambda * dflow_V_dsigma.transpose();
    }
 
    // G_32 is zero
 
    // G_33
    jacobian(2 * KelvinVectorSize, 2 * KelvinVectorSize) = 1. / dt;
 
    // G_34 is zero
 
    // G_35
    {
        double const flow_V = plasticFlowVolumetricPart<DisplacementDim>(
            s, sqrtPhi, mp.alpha_p, mp.beta_p, mp.delta_p, mp.epsilon_p);
        jacobian(2 * KelvinVectorSize, 2 * KelvinVectorSize + 2) = -flow_V;
    }
 
    // increment of effectiv plastic strain
    double const eff_flow =
        std::sqrt(2. / 3. * lambda_flow_D.transpose() * lambda_flow_D);
 
    if (eff_flow > 0)
    {
        // intermediate variable for derivative of plastic jacobian
        KelvinVector const eff_flow23_lambda_flow_D =
            -2 / 3. / eff_flow * lambda_flow_D;
        // G_41
        jacobian
            .template block<1, KelvinVectorSize>(2 * KelvinVectorSize + 1, 0)
            .noalias() = lambda * dflow_D_dsigma * eff_flow23_lambda_flow_D;
        // G_45
        jacobian(2 * KelvinVectorSize + 1, 2 * KelvinVectorSize + 2) =
            eff_flow23_lambda_flow_D.transpose() * flow_D;
    }
 
    // G_42 and G_43 are zero
 
    // G_44
    jacobian(2 * KelvinVectorSize + 1, 2 * KelvinVectorSize + 1) = 1. / dt;
 
    // G_51
    {
        double const one_gt_pow_m = std::pow(one_gt.value, mp.m);
        double const gm = mp.gamma * mp.m;
        // derivative of yield function w.r.t. sigma
        KelvinVector const dF_dsigma =
            mp.G *
                (one_gt_pow_m * (s.D + gm * M0) +
                 (mp.alpha * s.I_1 + 4 * boost::math::pow<2>(mp.delta) *
                                         boost::math::pow<3>(s.I_1)) *
                     identity2) /
                (2. * sqrtPhi) +
            mp.G * (mp.beta + 2 * mp.epsilon_p * s.I_1) * identity2;
 
        jacobian
            .template block<1, KelvinVectorSize>(2 * KelvinVectorSize + 2, 0)
            .noalias() = dF_dsigma.transpose() / mp.G;
    }
 
    // G_54
    jacobian(2 * KelvinVectorSize + 2, 2 * KelvinVectorSize + 1) =
        -mp.kappa * mp.hardening_coefficient / mp.G;
 
    // G_52, G_53, G_55 are zero
    return jacobian;
}

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

◆ calculatePlasticResidual()

template<int DisplacementDim>

SolidEhlers< DisplacementDim >::ResidualVectorType MaterialLib::Solids::Ehlers::calculatePlasticResidual	(	MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &	eps_D,
		double const	eps_V,
		PhysicalStressWithInvariants< DisplacementDim > const &	s,
		MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &	eps_p_D,
		MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &	eps_p_D_dot,
		double const	eps_p_V,
		double const	eps_p_V_dot,
		double const	eps_p_eff_dot,
		double const	lambda,
		double const	k,
		MaterialProperties const &	mp )

Definition at line 189 of file Ehlers.cpp.

{
    static int const KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    using KelvinVector =
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
 
    auto const& identity2 = Invariants::identity2;
 
    double const theta = s.J_3 / (s.J_2 * std::sqrt(s.J_2));
 
    typename SolidEhlers<DisplacementDim>::ResidualVectorType residual;
    // calculate stress residual
    residual.template segment<KelvinVectorSize>(0).noalias() =
        s.value / mp.G - 2 * (eps_D - eps_p_D) -
        mp.K / mp.G * (eps_V - eps_p_V) * identity2;
 
    auto const [dtheta_dsigma, d2theta_dsigma2] =
        thetaSigmaDerivatives(theta, s);
 
    OnePlusGamma_pTheta const one_gt{mp.gamma_p, theta, mp.m_p};
    double const sqrtPhi = std::sqrt(
        s.J_2 * one_gt.pow_m_p + mp.alpha_p / 2. * boost::math::pow<2>(s.I_1) +
        boost::math::pow<2>(mp.delta_p) * boost::math::pow<4>(s.I_1));
    KelvinVector const flow_D = plasticFlowDeviatoricPart(
        s, one_gt, sqrtPhi, dtheta_dsigma, mp.gamma_p, mp.m_p);
    KelvinVector const lambda_flow_D = lambda * flow_D;
 
    residual.template segment<KelvinVectorSize>(KelvinVectorSize).noalias() =
        eps_p_D_dot - lambda_flow_D;
 
    // plastic volume strain
    {
        double const flow_V = plasticFlowVolumetricPart<DisplacementDim>(
            s, sqrtPhi, mp.alpha_p, mp.beta_p, mp.delta_p, mp.epsilon_p);
        residual(2 * KelvinVectorSize, 0) = eps_p_V_dot - lambda * flow_V;
    }
 
    // evolution of plastic equivalent strain
    residual(2 * KelvinVectorSize + 1) =
        eps_p_eff_dot -
        std::sqrt(2. / 3. * lambda_flow_D.transpose() * lambda_flow_D);
 
    // yield function (for plastic multiplier)
    residual(2 * KelvinVectorSize + 2) = yieldFunction(mp, s, k) / mp.G;
    return residual;
}

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

◆ createDamageProperties()

std::unique_ptr< DamagePropertiesParameters > MaterialLib::Solids::Ehlers::createDamageProperties	(	std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		BaseLib::ConfigTree const &	config )

inline

Input File Parameter: material__solid__constitutive_relation__Ehlers__damage_properties__alpha_d

Input File Parameter: material__solid__constitutive_relation__Ehlers__damage_properties__beta_d

Input File Parameter: material__solid__constitutive_relation__Ehlers__damage_properties__h_d

Definition at line 16 of file CreateEhlers.h.

{
    auto& alpha_d =
        ParameterLib::findParameter<double>(config, "alpha_d", parameters, 1);
 
    DBUG("Use '{:s}' as alpha_d.", alpha_d.name);
    auto& beta_d =
        ParameterLib::findParameter<double>(config, "beta_d", parameters, 1);
 
    DBUG("Use '{:s}' as beta_d.", beta_d.name);
    auto& h_d =
        ParameterLib::findParameter<double>(config, "h_d", parameters, 1);
 
    DBUG("Use '{:s}' as h_d.", h_d.name);
 
    return std::make_unique<DamagePropertiesParameters>(
        DamagePropertiesParameters{alpha_d, beta_d, h_d});
}

References DBUG(), and ParameterLib::findParameter().

Referenced by createEhlers().

◆ createEhlers()

template<int DisplacementDim>

std::unique_ptr< SolidEhlers< DisplacementDim > > MaterialLib::Solids::Ehlers::createEhlers	(	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__Ehlers__shear_modulus

Input File Parameter: material__solid__constitutive_relation__Ehlers__bulk_modulus

Input File Parameter: material__solid__constitutive_relation__Ehlers__kappa

Input File Parameter: material__solid__constitutive_relation__Ehlers__beta

Input File Parameter: material__solid__constitutive_relation__Ehlers__gamma

Input File Parameter: material__solid__constitutive_relation__Ehlers__hardening_modulus

Input File Parameter: material__solid__constitutive_relation__Ehlers__alpha

Input File Parameter: material__solid__constitutive_relation__Ehlers__delta

Input File Parameter: material__solid__constitutive_relation__Ehlers__eps

Input File Parameter: material__solid__constitutive_relation__Ehlers__m

Input File Parameter: material__solid__constitutive_relation__Ehlers__alphap

Input File Parameter: material__solid__constitutive_relation__Ehlers__deltap

Input File Parameter: material__solid__constitutive_relation__Ehlers__epsp

Input File Parameter: material__solid__constitutive_relation__Ehlers__mp

Input File Parameter: material__solid__constitutive_relation__Ehlers__betap

Input File Parameter: material__solid__constitutive_relation__Ehlers__gammap

Input File Parameter: material__solid__constitutive_relation__Ehlers__tangent_type

Input File Parameter: material__solid__constitutive_relation__Ehlers__damage_properties

Input File Parameter: material__solid__constitutive_relation__Ehlers__nonlinear_solver

Definition at line 43 of file CreateEhlers.h.

{
    config.checkConfigParameter("type", "Ehlers");
    DBUG("Create Ehlers material");
    auto& shear_modulus = ParameterLib::findParameter<double>(
        config, "shear_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as shear modulus parameter.", shear_modulus.name);
    auto& bulk_modulus = ParameterLib::findParameter<double>(
        config, "bulk_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as bulk modulus parameter.", bulk_modulus.name);
    auto& kappa =
        ParameterLib::findParameter<double>(config, "kappa", parameters, 1);
 
    DBUG("Use '{:s}' as kappa.", kappa.name);
    auto& beta =
        ParameterLib::findParameter<double>(config, "beta", parameters, 1);
 
    DBUG("Use '{:s}' as beta.", beta.name);
    auto& gamma =
        ParameterLib::findParameter<double>(config, "gamma", parameters, 1);
 
    DBUG("Use '{:s}' as gamma.", gamma.name);
    auto& hardening_modulus = ParameterLib::findParameter<double>(
        config, "hardening_modulus", parameters, 1);
 
    DBUG("Use '{:s}' as hardening modulus parameter.", hardening_modulus.name);
    auto& alpha =
        ParameterLib::findParameter<double>(config, "alpha", parameters, 1);
 
    DBUG("Use '{:s}' as alpha.", alpha.name);
    auto& delta =
        ParameterLib::findParameter<double>(config, "delta", parameters, 1);
 
    DBUG("Use '{:s}' as delta.", delta.name);
    auto& eps =
        ParameterLib::findParameter<double>(config, "eps", parameters, 1);
 
    DBUG("Use '{:s}' as eps.", eps.name);
    auto& m = ParameterLib::findParameter<double>(config, "m", parameters, 1);
 
    DBUG("Use '{:s}' as m.", m.name);
    auto& alphap =
        ParameterLib::findParameter<double>(config, "alphap", parameters, 1);
 
    DBUG("Use '{:s}' as alphap.", alphap.name);
    auto& deltap =
        ParameterLib::findParameter<double>(config, "deltap", parameters, 1);
 
    DBUG("Use '{:s}' as deltap.", deltap.name);
    auto& epsp =
        ParameterLib::findParameter<double>(config, "epsp", parameters, 1);
 
    DBUG("Use '{:s}' as epsp.", epsp.name);
    auto& paremeter_mp =
        ParameterLib::findParameter<double>(config, "mp", parameters, 1);
 
    DBUG("Use '{:s}' as mp.", paremeter_mp.name);
    auto& betap =
        ParameterLib::findParameter<double>(config, "betap", parameters, 1);
 
    DBUG("Use '{:s}' as betap.", betap.name);
    auto& gammap =
        ParameterLib::findParameter<double>(config, "gammap", parameters, 1);
 
    DBUG("Use '{:s}' as gammap.", gammap.name);
 
    auto tangent_type =
        makeTangentType(config.getConfigParameter<std::string>("tangent_type"));
 
    MaterialPropertiesParameters mp{
        shear_modulus, bulk_modulus, alpha,  beta,
        gamma,         delta,        eps,    m,
        alphap,        betap,        gammap, deltap,
        epsp,          paremeter_mp, kappa,  hardening_modulus};
 
    // Damage properties.
    std::unique_ptr<DamagePropertiesParameters> ehlers_damage_properties;
 
    auto const& ehlers_damage_config =
        config.getConfigSubtreeOptional("damage_properties");
    if (ehlers_damage_config)
    {
        ehlers_damage_properties =
            createDamageProperties(parameters, *ehlers_damage_config);
    }
 
    auto const& nonlinear_solver_config =
        config.getConfigSubtree("nonlinear_solver");
    auto const nonlinear_solver_parameters =
        NumLib::createNewtonRaphsonSolverParameters(nonlinear_solver_config);
 
    return std::make_unique<SolidEhlers<DisplacementDim>>(
        nonlinear_solver_parameters,
        mp,
        std::move(ehlers_damage_properties),
        tangent_type);
}

References BaseLib::ConfigTree::checkConfigParameter(), createDamageProperties(), NumLib::createNewtonRaphsonSolverParameters(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and makeTangentType().

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

◆ makeTangentType()

TangentType MaterialLib::Solids::Ehlers::makeTangentType ( std::string const & s )

inline

Definition at line 39 of file Ehlers.h.

{
    if (s == "Elastic")
    {
        return TangentType::Elastic;
    }
    if (s == "PlasticDamageSecant")
    {
        return TangentType::PlasticDamageSecant;
    }
    if (s == "Plastic")
    {
        return TangentType::Plastic;
    }
    OGS_FATAL("Not valid string '{:s}' to create a tangent type from.", s);
}

References Elastic, OGS_FATAL, Plastic, and PlasticDamageSecant.

Referenced by createEhlers().

◆ plasticFlowDeviatoricPart()

template<int DisplacementDim>

SolidEhlers< DisplacementDim >::KelvinVector MaterialLib::Solids::Ehlers::plasticFlowDeviatoricPart	(	PhysicalStressWithInvariants< DisplacementDim > const &	s,
		OnePlusGamma_pTheta const &	one_gt,
		double const	sqrtPhi,
		typename SolidEhlers< DisplacementDim >::KelvinVector const &	dtheta_dsigma,
		double const	gamma_p,
		double const	m_p )

Definition at line 117 of file Ehlers.cpp.

{
    return (one_gt.pow_m_p *
            (s.D + s.J_2 * m_p * gamma_p * dtheta_dsigma / one_gt.value)) /
           (2 * sqrtPhi);
}

References MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::D, MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::J_2, MaterialLib::Solids::Ehlers::OnePlusGamma_pTheta::pow_m_p, and MaterialLib::Solids::Ehlers::OnePlusGamma_pTheta::value.

Referenced by calculatePlasticJacobian(), and calculatePlasticResidual().

◆ plasticFlowVolumetricPart()

template<int DisplacementDim>

double MaterialLib::Solids::Ehlers::plasticFlowVolumetricPart	(	PhysicalStressWithInvariants< DisplacementDim > const &	s,
		double const	sqrtPhi,
		double const	alpha_p,
		double const	beta_p,
		double const	delta_p,
		double const	epsilon_p )

Definition at line 104 of file Ehlers.cpp.

{
    return 3 *
               (alpha_p * s.I_1 +
                4 * boost::math::pow<2>(delta_p) * boost::math::pow<3>(s.I_1)) /
               (2 * sqrtPhi) +
           3 * beta_p + 6 * epsilon_p * s.I_1;
}

References MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::I_1.

Referenced by calculatePlasticJacobian(), and calculatePlasticResidual().

◆ predict_sigma()

template<int DisplacementDim>

SolidEhlers< DisplacementDim >::KelvinVector MaterialLib::Solids::Ehlers::predict_sigma	(	double const	G,
		double const	K,
		typename SolidEhlers< DisplacementDim >::KelvinVector const &	sigma_prev,
		typename SolidEhlers< DisplacementDim >::KelvinVector const &	eps,
		typename SolidEhlers< DisplacementDim >::KelvinVector const &	eps_prev,
		double const	eps_V )

Definition at line 454 of file Ehlers.cpp.

{
    static int const KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    auto const& P_dev = Invariants::deviatoric_projection;
 
    // dimensionless initial hydrostatic pressure
    double const pressure_prev = Invariants::trace(sigma_prev) / (-3. * G);
    // initial strain invariant
    double const e_prev = Invariants::trace(eps_prev);
    // dimensioness hydrostatic stress increment
    double const pressure = pressure_prev - K / G * (eps_V - e_prev);
    // dimensionless deviatoric initial stress
    typename SolidEhlers<DisplacementDim>::KelvinVector const sigma_D_prev =
        P_dev * sigma_prev / G;
    // dimensionless deviatoric stress
    typename SolidEhlers<DisplacementDim>::KelvinVector const sigma_D =
        sigma_D_prev + 2 * P_dev * (eps - eps_prev);
    return sigma_D - pressure * Invariants::identity2;
}

References MathLib::KelvinVector::kelvin_vector_dimensions().

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

◆ sOdotS()

template<int DisplacementDim>

MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > MaterialLib::Solids::Ehlers::sOdotS ( MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const & v )

Special product of v with itself: \(v \odot v\). The tensor v is given in Kelvin mapping.

Note: Implementation only for 2 and 3 dimensions.

Attention: Pay attention to the sign of the result, which normally would be negative, but the returned value is not negated. This has to do with \(d(A^{-1})/dA = -A^{-1} \odot A^{-1} \).

Referenced by thetaSigmaDerivatives().

◆ sOdotS< 2 >()

template<>

MathLib::KelvinVector::KelvinMatrixType< 2 > MaterialLib::Solids::Ehlers::sOdotS< 2 > ( MathLib::KelvinVector::KelvinVectorType< 2 > const & v )

Definition at line 859 of file Ehlers.cpp.

{
    MathLib::KelvinVector::KelvinMatrixType<2> result;
 
    result(0, 0) = v(0) * v(0);
    result(0, 1) = result(1, 0) = v(3) * v(3) / 2.;
    result(0, 2) = result(2, 0) = 0;
    result(0, 3) = result(3, 0) = v(0) * v(3);
 
    result(1, 1) = v(1) * v(1);
    result(1, 2) = result(2, 1) = 0;
    result(1, 3) = result(3, 1) = v(3) * v(1);
 
    result(2, 2) = v(2) * v(2);
    result(2, 3) = result(3, 2) = 0;
 
    result(3, 3) = v(0) * v(1) + v(3) * v(3) / 2.;
 
    return result;
}

◆ sOdotS< 3 >()

template<>

MathLib::KelvinVector::KelvinMatrixType< 3 > MaterialLib::Solids::Ehlers::sOdotS< 3 > ( MathLib::KelvinVector::KelvinVectorType< 3 > const & v )

Definition at line 859 of file Ehlers.cpp.

{
    MathLib::KelvinVector::KelvinMatrixType<3> result;
 
    result(0, 0) = v(0) * v(0);
    result(0, 1) = result(1, 0) = v(3) * v(3) / 2.;
    result(0, 2) = result(2, 0) = v(5) * v(5) / 2.;
    result(0, 3) = result(3, 0) = v(0) * v(3);
    result(0, 4) = result(4, 0) = v(3) * v(5) / std::sqrt(2.);
    result(0, 5) = result(5, 0) = v(0) * v(5);
 
    result(1, 1) = v(1) * v(1);
    result(1, 2) = result(2, 1) = v(4) * v(4) / 2.;
    result(1, 3) = result(3, 1) = v(3) * v(1);
    result(1, 4) = result(4, 1) = v(1) * v(4);
    result(1, 5) = result(5, 1) = v(3) * v(4) / std::sqrt(2.);
 
    result(2, 2) = v(2) * v(2);
    result(2, 3) = result(3, 2) = v(5) * v(4) / std::sqrt(2.);
    result(2, 4) = result(4, 2) = v(4) * v(2);
    result(2, 5) = result(5, 2) = v(5) * v(2);
 
    result(3, 3) = v(0) * v(1) + v(3) * v(3) / 2.;
    result(3, 4) = result(4, 3) =
        v(3) * v(4) / 2. + v(5) * v(1) / std::sqrt(2.);
    result(3, 5) = result(5, 3) =
        v(0) * v(4) / std::sqrt(2.) + v(3) * v(5) / 2.;
 
    result(4, 4) = v(1) * v(2) + v(4) * v(4) / 2.;
    result(4, 5) = result(5, 4) =
        v(3) * v(2) / std::sqrt(2.) + v(5) * v(4) / 2.;
 
    result(5, 5) = v(0) * v(2) + v(5) * v(5) / 2.;
    return result;
}

◆ splitSolutionVector()

template<typename ResidualVector, typename KelvinVector>

std::tuple< KelvinVector, PlasticStrain< KelvinVector >, double > MaterialLib::Solids::Ehlers::splitSolutionVector ( ResidualVector const & solution )

Split the agglomerated solution vector in separate items. The arrangement must be the same as in the newton() function.

Definition at line 485 of file Ehlers.cpp.

{
    static auto const size = KelvinVector::SizeAtCompileTime;
    return std::forward_as_tuple(
        solution.template segment<size>(size * 0),
        PlasticStrain<KelvinVector>{solution.template segment<size>(size * 1),
                                    solution[size * 2], solution[size * 2 + 1]},
        solution[size * 2 + 2]);
}

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

◆ thetaSigmaDerivatives()

template<int DisplacementDim>

std::pair< MathLib::KelvinVector::KelvinVectorType< DisplacementDim >, MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > > MaterialLib::Solids::Ehlers::thetaSigmaDerivatives	(	double	theta,
		PhysicalStressWithInvariants< DisplacementDim > const &	s )

Definition at line 148 of file Ehlers.cpp.

{
    constexpr int KelvinVectorSize =
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim);
    using Invariants = MathLib::KelvinVector::Invariants<KelvinVectorSize>;
    using KelvinVector =
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
    using KelvinMatrix =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;
 
    if (theta == 0)
    {
        return {KelvinVector::Zero(), KelvinMatrix::Zero()};
    }
 
    auto const& P_dev = Invariants::deviatoric_projection;
 
    // inverse of deviatoric stress tensor
    if (Invariants::determinant(s.D) == 0)
    {
        OGS_FATAL("Determinant is zero. Matrix is non-invertable.");
    }
    // inverse of sigma_D
    KelvinVector const sigma_D_inverse = MathLib::KelvinVector::inverse(s.D);
    KelvinVector const sigma_D_inverse_D = P_dev * sigma_D_inverse;
 
    KelvinVector const dtheta_dsigma =
        theta * sigma_D_inverse_D - 3. / 2. * theta / s.J_2 * s.D;
    KelvinMatrix const d2theta_dsigma2 =
        theta * P_dev * sOdotS<DisplacementDim>(sigma_D_inverse) * P_dev +
        sigma_D_inverse_D * dtheta_dsigma.transpose() -
        3. / 2. * theta / s.J_2 * P_dev -
        3. / 2. * dtheta_dsigma / s.J_2 * s.D.transpose() +
        3. / 2. * theta / boost::math::pow<2>(s.J_2) * s.D * s.D.transpose();
 
    return {dtheta_dsigma, d2theta_dsigma2};
}

References MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::D, MathLib::KelvinVector::inverse(), MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::J_2, MathLib::KelvinVector::kelvin_vector_dimensions(), OGS_FATAL, and sOdotS().

Referenced by calculatePlasticJacobian(), and calculatePlasticResidual().

◆ yieldFunction()

template<int DisplacementDim>

double MaterialLib::Solids::Ehlers::yieldFunction	(	MaterialProperties const &	mp,
		PhysicalStressWithInvariants< DisplacementDim > const &	s,
		double const	k )

Definition at line 129 of file Ehlers.cpp.

{
    double const I_1_squared = boost::math::pow<2>(s.I_1);
    assert(s.J_2 != 0);
 
    return std::sqrt(s.J_2 * std::pow(1 + mp.gamma * s.J_3 /
                                              (s.J_2 * std::sqrt(s.J_2)),
                                      mp.m) +
                     mp.alpha / 2. * I_1_squared +
                     boost::math::pow<2>(mp.delta) *
                         boost::math::pow<2>(I_1_squared)) +
           mp.beta * s.I_1 + mp.epsilon * I_1_squared - k;
}

References MaterialLib::Solids::Ehlers::MaterialProperties::alpha, MaterialLib::Solids::Ehlers::MaterialProperties::beta, MaterialLib::Solids::Ehlers::MaterialProperties::delta, MaterialLib::Solids::Ehlers::MaterialProperties::epsilon, MaterialLib::Solids::Ehlers::MaterialProperties::gamma, MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::I_1, MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::J_2, MaterialLib::Solids::Ehlers::PhysicalStressWithInvariants< DisplacementDim >::J_3, and MaterialLib::Solids::Ehlers::MaterialProperties::m.

Referenced by calculatePlasticResidual(), and MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::integrateStress().

Detailed Description

Classes

Enumerations

Functions

Enumeration Type Documentation

◆ TangentType

Function Documentation

◆ calculateDResidualDEps()

◆ calculateIsotropicHardening()

◆ calculatePlasticJacobian()

◆ calculatePlasticResidual()

◆ createDamageProperties()

◆ createEhlers()

◆ makeTangentType()

◆ plasticFlowDeviatoricPart()

◆ plasticFlowVolumetricPart()

◆ predict_sigma()

◆ sOdotS()

◆ sOdotS< 2 >()

◆ sOdotS< 3 >()

◆ splitSolutionVector()

◆ thetaSigmaDerivatives()

◆ yieldFunction()