Classes
struct	PhysicalStressWithInvariants

struct	OnePlusGamma_pTheta
	Holds powers of 1 + gamma_p*theta to base 0, m_p, and m_p-1. More...

struct	MaterialPropertiesParameters

struct	DamagePropertiesParameters

struct	MaterialProperties

struct	DamageProperties

struct	PlasticStrain

class	Damage

struct	StateVariables

class	SolidEhlers

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>
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 MaterialLib::Solids::Ehlers::TangentType

strong

Enumerator
Elastic
PlasticDamageSecant
Plastic

Definition at line 38 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 414 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().

◆ calculateIsotropicHardening()

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

inline

Definition at line 429 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 217 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};
  
     // 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;
  
     // 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());
     // second derivative of theta
     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();
  
     // 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;
 }

◆ 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 152 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& P_dev = Invariants::deviatoric_projection;
     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;
  
     // deviatoric plastic strain
     KelvinVector const sigma_D_inverse_D =
         P_dev * MathLib::KelvinVector::inverse(s.D);
     KelvinVector const dtheta_dsigma =
         theta * sigma_D_inverse_D - 3. / 2. * theta / s.J_2 * s.D;
  
     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;
 }

◆ 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 23 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().

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 50 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 MaterialPropertyLib::alpha, MaterialPropertyLib::beta, MaterialPropertyLib::bulk_modulus, BaseLib::ConfigTree::checkConfigParameter(), createDamageProperties(), NumLib::createNewtonRaphsonSolverParameters(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and makeTangentType().

◆ makeTangentType()

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

inline

Definition at line 44 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 122 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 109 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.

◆ 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 437 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().

◆ 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} \).

◆ sOdotS< 2 >()

template<>

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

Definition at line 843 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 843 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 468 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]);
 }

◆ yieldFunction()

template<int DisplacementDim>

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

Definition at line 134 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().

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()

◆ yieldFunction()