Mohr-Coulomb plasticity, nonassociative with hardening/softening. More...

#include <TensorMechanicsPlasticMohrCoulomb.h>

Inheritance diagram for TensorMechanicsPlasticMohrCoulomb:

Public Member Functions
	TensorMechanicsPlasticMohrCoulomb (const InputParameters &parameters)

virtual std::string	modelName () const override

void	initialize ()

void	execute ()

void	finalize ()

virtual unsigned int	numberSurfaces () const
	The number of yield surfaces for this plasticity model. More...

virtual void	yieldFunctionV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &f) const
	Calculates the yield functions. More...

virtual void	dyieldFunction_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &df_dstress) const
	The derivative of yield functions with respect to stress. More...

virtual void	dyieldFunction_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &df_dintnl) const
	The derivative of yield functions with respect to the internal parameter. More...

virtual void	flowPotentialV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &r) const
	The flow potentials. More...

virtual void	dflowPotential_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankFourTensor > &dr_dstress) const
	The derivative of the flow potential with respect to stress. More...

virtual void	dflowPotential_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &dr_dintnl) const
	The derivative of the flow potential with respect to the internal parameter. More...

virtual void	hardPotentialV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &h) const
	The hardening potential. More...

virtual void	dhardPotential_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &dh_dstress) const
	The derivative of the hardening potential with respect to stress. More...

virtual void	dhardPotential_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &dh_dintnl) const
	The derivative of the hardening potential with respect to the internal parameter. More...

virtual void	activeConstraints (const std::vector< Real > &f, const RankTwoTensor &stress, Real intnl, const RankFourTensor &Eijkl, std::vector< bool > &act, RankTwoTensor &returned_stress) const
	The active yield surfaces, given a vector of yield functions. More...

virtual bool	useCustomReturnMap () const
	Returns false. You will want to override this in your derived class if you write a custom returnMap function. More...

virtual bool	useCustomCTO () const
	Returns false. You will want to override this in your derived class if you write a custom consistent tangent operator function. More...

virtual bool	returnMap (const RankTwoTensor &trial_stress, Real intnl_old, const RankFourTensor &E_ijkl, Real ep_plastic_tolerance, RankTwoTensor &returned_stress, Real &returned_intnl, std::vector< Real > &dpm, RankTwoTensor &delta_dp, std::vector< Real > &yf, bool &trial_stress_inadmissible) const
	Performs a custom return-map. More...

virtual RankFourTensor	consistentTangentOperator (const RankTwoTensor &trial_stress, Real intnl_old, const RankTwoTensor &stress, Real intnl, const RankFourTensor &E_ijkl, const std::vector< Real > &cumulative_pm) const
	Calculates a custom consistent tangent operator. More...

bool	KuhnTuckerSingleSurface (Real yf, Real dpm, Real dpm_tol) const
	Returns true if the Kuhn-Tucker conditions for the single surface are satisfied. More...

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const Real	_f_tol
	Tolerance on yield function. More...

const Real	_ic_tol
	Tolerance on internal constraint. More...

Protected Member Functions
Real	yieldFunction (const RankTwoTensor &stress, Real intnl) const override
	The following functions are what you should override when building single-plasticity models. More...

RankTwoTensor	dyieldFunction_dstress (const RankTwoTensor &stress, Real intnl) const override
	The derivative of yield function with respect to stress. More...

Real	dyieldFunction_dintnl (const RankTwoTensor &stress, Real intnl) const override
	The derivative of yield function with respect to the internal parameter. More...

RankTwoTensor	flowPotential (const RankTwoTensor &stress, Real intnl) const override
	The flow potential. More...

RankFourTensor	dflowPotential_dstress (const RankTwoTensor &stress, Real intnl) const override
	The derivative of the flow potential with respect to stress. More...

RankTwoTensor	dflowPotential_dintnl (const RankTwoTensor &stress, Real intnl) const override
	The derivative of the flow potential with respect to the internal parameter. More...

virtual Real	smooth (const RankTwoTensor &stress) const
	returns the 'a' parameter - see doco for _tip_scheme More...

virtual Real	dsmooth (const RankTwoTensor &stress) const
	returns the da/dstress_mean - see doco for _tip_scheme More...

virtual Real	d2smooth (const RankTwoTensor &stress) const
	returns the d^2a/dstress_mean^2 - see doco for _tip_scheme More...

virtual Real	cohesion (const Real internal_param) const
	cohesion as a function of internal parameter More...

virtual Real	dcohesion (const Real internal_param) const
	d(cohesion)/d(internal_param); More...

virtual Real	phi (const Real internal_param) const
	friction angle as a function of internal parameter More...

virtual Real	dphi (const Real internal_param) const
	d(phi)/d(internal_param); More...

virtual Real	psi (const Real internal_param) const
	dilation angle as a function of internal parameter More...

virtual Real	dpsi (const Real internal_param) const
	d(psi)/d(internal_param); More...

virtual Real	hardPotential (const RankTwoTensor &stress, Real intnl) const
	The hardening potential. More...

virtual RankTwoTensor	dhardPotential_dstress (const RankTwoTensor &stress, Real intnl) const
	The derivative of the hardening potential with respect to stress. More...

virtual Real	dhardPotential_dintnl (const RankTwoTensor &stress, Real intnl) const
	The derivative of the hardening potential with respect to the internal parameter. More...

Protected Attributes
const TensorMechanicsHardeningModel &	_cohesion
	Hardening model for cohesion. More...

const TensorMechanicsHardeningModel &	_phi
	Hardening model for phi. More...

const TensorMechanicsHardeningModel &	_psi
	Hardening model for psi. More...

MooseEnum	_tip_scheme
	The yield function is modified to f = s_msinphi + sqrt(a + s_bar^2 K^2) - Ccosphi where "a" depends on the tip_scheme. More...

Real	_small_smoother2
	Square of tip smoothing parameter to smooth the cone at mean_stress = T. More...

Real	_cap_start
	smoothing parameter dictating when the 'cap' will start - see doco for _tip_scheme More...

Real	_cap_rate
	dictates how quickly the 'cap' degenerates to a hemisphere - see doco for _tip_scheme More...

Real	_tt
	edge smoothing parameter, in radians More...

Real	_costt
	cos(_tt) More...

Real	_sintt
	sin(_tt) More...

Real	_cos3tt
	cos(3*_tt) More...

Real	_sin3tt
	sin(3*_tt) - useful for making comparisons with Lode angle More...

Real	_cos6tt
	cos(6*_tt) More...

Real	_sin6tt
	sin(6*_tt) More...

Real	_lode_cutoff
	if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-loss More...

Private Member Functions
void	abbo (const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
	Computes Abbo et al's A, B and C parameters. More...

void	dabbo (const Real sin3lode, const Real sin_angle, Real &daaa, Real &dbbb, Real &dccc) const
	Computes derivatives of Abbo et al's A, B and C parameters wrt sin_angle. More...

RankTwoTensor	df_dsig (const RankTwoTensor &stress, const Real sin_angle) const
	d(yieldFunction)/d(stress), but with the ability to put friction or dilation angle into the result More...

Detailed Description

Mohr-Coulomb plasticity, nonassociative with hardening/softening.

For 'hyperbolic' smoothing, the smoothing of the tip of the yield-surface cone is described in Zienkiewicz and Prande "Some useful forms of isotropic yield surfaces for soil and rock mechanics" (1977) In G Gudehus (editor) "Finite Elements in Geomechanics" Wile, Chichester, pp 179-190. For 'cap' smoothing, additional smoothing is performed. The smoothing of the edges of the cone is described in AJ Abbo, AV Lyamin, SW Sloan, JP Hambleton "A C2 continuous approximation to the Mohr-Coulomb yield surface" International Journal of Solids and Structures 48 (2011) 3001-3010

Definition at line 33 of file TensorMechanicsPlasticMohrCoulomb.h.

Constructor & Destructor Documentation

◆ TensorMechanicsPlasticMohrCoulomb()

TensorMechanicsPlasticMohrCoulomb::TensorMechanicsPlasticMohrCoulomb ( const InputParameters & parameters )

Definition at line 71 of file TensorMechanicsPlasticMohrCoulomb.C.

   : TensorMechanicsPlasticModel(parameters),
     _cohesion(getUserObject<TensorMechanicsHardeningModel>("cohesion")),
     _phi(getUserObject<TensorMechanicsHardeningModel>("friction_angle")),
     _psi(getUserObject<TensorMechanicsHardeningModel>("dilation_angle")),
     _tip_scheme(getParam<MooseEnum>("tip_scheme")),
     _small_smoother2(Utility::pow<2>(getParam<Real>("mc_tip_smoother"))),
     _cap_start(getParam<Real>("cap_start")),
     _cap_rate(getParam<Real>("cap_rate")),
     _tt(getParam<Real>("mc_edge_smoother") * libMesh::pi / 180.0),
     _costt(std::cos(_tt)),
     _sintt(std::sin(_tt)),
     _cos3tt(std::cos(3 * _tt)),
     _sin3tt(std::sin(3 * _tt)),
     _cos6tt(std::cos(6 * _tt)),
     _sin6tt(std::sin(6 * _tt)),
     _lode_cutoff(parameters.isParamValid("mc_lode_cutoff") ? getParam<Real>("mc_lode_cutoff")
                                                            : 1.0E-5 * Utility::pow<2>(_f_tol))
  
 {
   if (_lode_cutoff < 0)
     mooseError("mc_lode_cutoff must not be negative");
  
   // With arbitary UserObjects, it is impossible to check everything, and
   // I think this is the best I can do
   if (phi(0) < 0 || psi(0) < 0 || phi(0) > libMesh::pi / 2.0 || psi(0) > libMesh::pi / 2.0)
     mooseError("Mohr-Coulomb friction and dilation angles must lie in [0, Pi/2]");
   if (phi(0) < psi(0))
     mooseError("Mohr-Coulomb friction angle must not be less than Mohr-Coulomb dilation angle");
   if (cohesion(0) < 0)
     mooseError("Mohr-Coulomb cohesion must not be negative");
  
   // check Abbo et al's convexity constraint (Eqn c.18 in their paper)
   // With an arbitrary UserObject, it is impossible to check for all angles
   // I think the following is the best we can do
   Real sin_angle = std::sin(std::max(phi(0), psi(0)));
   sin_angle = std::max(sin_angle, std::sin(std::max(phi(1E6), psi(1E6))));
   Real rhs = std::sqrt(3) * (35 * std::sin(_tt) + 14 * std::sin(5 * _tt) - 5 * std::sin(7 * _tt)) /
              16 / Utility::pow<5>(std::cos(_tt)) / (11 - 10 * std::cos(2 * _tt));
   if (rhs <= sin_angle)
     mooseError("Mohr-Coulomb edge smoothing angle is too small and a non-convex yield surface will "
                "result.  Please choose a larger value");
 }

Member Function Documentation

◆ abbo()

void TensorMechanicsPlasticMohrCoulomb::abbo	(	const Real	sin3lode,
		const Real	sin_angle,
		Real &	aaa,
		Real &	bbb,
		Real &	ccc
	)		const

private

Computes Abbo et al's A, B and C parameters.

Parameters

	sin3lode	sin(3*(lode angle))
	sin_angle	sin(friction_angle) (for yield function), or sin(dilation_angle) (for potential function)
[out]	aaa	Abbo's A
[out]	bbb	Abbo's B
[out]	ccc	Abbo's C

Definition at line 411 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real tmp1 = (sin3lode >= 0 ? _costt - sin_angle * _sintt / std::sqrt(3.0)
                              : _costt + sin_angle * _sintt / std::sqrt(3.0));
   Real tmp2 = (sin3lode >= 0 ? _sintt + sin_angle * _costt / std::sqrt(3.0)
                              : -_sintt + sin_angle * _costt / std::sqrt(3.0));
  
   ccc = -_cos3tt * tmp1;
   ccc += (sin3lode >= 0 ? -3 * _sin3tt * tmp2 : 3 * _sin3tt * tmp2);
   ccc /= 18 * Utility::pow<3>(_cos3tt);
  
   bbb = (sin3lode >= 0 ? _sin6tt * tmp1 : -_sin6tt * tmp1);
   bbb -= 6 * _cos6tt * tmp2;
   bbb /= 18 * Utility::pow<3>(_cos3tt);
  
   aaa = (sin3lode >= 0 ? -sin_angle * _sintt / std::sqrt(3.0) - bbb * _sin3tt
                        : sin_angle * _sintt / std::sqrt(3.0) + bbb * _sin3tt);
   aaa += -ccc * Utility::pow<2>(_sin3tt) + _costt;
 }

Referenced by df_dsig(), dflowPotential_dintnl(), dflowPotential_dstress(), dyieldFunction_dintnl(), and yieldFunction().

◆ activeConstraints()

void TensorMechanicsPlasticModel::activeConstraints	(	const std::vector< Real > &	f,
		const RankTwoTensor &	stress,
		Real	intnl,
		const RankFourTensor &	Eijkl,
		std::vector< bool > &	act,
		RankTwoTensor &	returned_stress
	)		const

virtualinherited

The active yield surfaces, given a vector of yield functions.

This is used by FiniteStrainMultiPlasticity to determine the initial set of active constraints at the trial (stress, intnl) configuration. It is up to you (the coder) to determine how accurate you want the returned_stress to be. Currently it is only used by FiniteStrainMultiPlasticity to estimate a good starting value for the Newton-Rahson procedure, so currently it may not need to be super perfect.

Parameters

	f	values of the yield functions
	stress	stress tensor
	intnl	internal parameter
	Eijkl	elasticity tensor (stress = Eijkl*strain)
[out]	act	act[i] = true if the i_th yield function is active
[out]	returned_stress	Approximate value of the returned stress

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticMeanCapTC, TensorMechanicsPlasticWeakPlaneShear, and TensorMechanicsPlasticWeakPlaneTensile.

Definition at line 188 of file TensorMechanicsPlasticModel.C.

 {
   mooseAssert(f.size() == numberSurfaces(),
               "f incorrectly sized at " << f.size() << " in activeConstraints");
   act.resize(numberSurfaces());
   for (unsigned surface = 0; surface < numberSurfaces(); ++surface)
     act[surface] = (f[surface] > _f_tol);
 }

◆ cohesion()

Real TensorMechanicsPlasticMohrCoulomb::cohesion ( const Real internal_param ) const

protectedvirtual

cohesion as a function of internal parameter

Definition at line 375 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _cohesion.value(internal_param);
 }

Referenced by dyieldFunction_dintnl(), TensorMechanicsPlasticMohrCoulomb(), and yieldFunction().

◆ consistentTangentOperator()

RankFourTensor TensorMechanicsPlasticModel::consistentTangentOperator	(	const RankTwoTensor &	trial_stress,
		Real	intnl_old,
		const RankTwoTensor &	stress,
		Real	intnl,
		const RankFourTensor &	E_ijkl,
		const std::vector< Real > &	cumulative_pm
	)		const

virtualinherited

Calculates a custom consistent tangent operator.

You may choose to over-ride this in your derived TensorMechanicsPlasticXXXX class.

(Note, if you over-ride returnMap, you will probably want to override consistentTangentOpertor too, otherwise it will default to E_ijkl.)

Parameters

stress_old	trial stress before returning
intnl_old	internal parameter before returning
stress	current returned stress state
intnl	internal parameter
E_ijkl	elasticity tensor
cumulative_pm	the cumulative plastic multipliers

Returns: the consistent tangent operator: E_ijkl if not over-ridden

Reimplemented in TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticDruckerPragerHyperbolic, TensorMechanicsPlasticMeanCapTC, and TensorMechanicsPlasticJ2.

Definition at line 254 of file TensorMechanicsPlasticModel.C.

 {
   return E_ijkl;
 }

Referenced by TensorMechanicsPlasticJ2::consistentTangentOperator(), TensorMechanicsPlasticDruckerPragerHyperbolic::consistentTangentOperator(), TensorMechanicsPlasticMeanCapTC::consistentTangentOperator(), and TensorMechanicsPlasticTensileMulti::consistentTangentOperator().

◆ d2smooth()

Real TensorMechanicsPlasticMohrCoulomb::d2smooth ( const RankTwoTensor & stress ) const

protectedvirtual

returns the d^2a/dstress_mean^2 - see doco for _tip_scheme

Definition at line 487 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real d2smoother2 = 0;
   if (_tip_scheme == "cap")
   {
     Real x = stress.trace() / 3.0 - _cap_start;
     Real p = 0;
     Real dp_dx = 0;
     Real d2p_dx2 = 0;
     if (x > 0)
     {
       p = x * (1 - std::exp(-_cap_rate * x));
       dp_dx = (1 - std::exp(-_cap_rate * x)) + x * _cap_rate * std::exp(-_cap_rate * x);
       d2p_dx2 = 2 * _cap_rate * std::exp(-_cap_rate * x) -
                 x * Utility::pow<2>(_cap_rate) * std::exp(-_cap_rate * x);
     }
     d2smoother2 += 2 * Utility::pow<2>(dp_dx) + 2 * p * d2p_dx2;
   }
   return d2smoother2;
 }

Referenced by dflowPotential_dstress().

◆ dabbo()

void TensorMechanicsPlasticMohrCoulomb::dabbo	(	const Real	sin3lode,
		const Real	sin_angle,
		Real &	daaa,
		Real &	dbbb,
		Real &	dccc
	)		const

private

Computes derivatives of Abbo et al's A, B and C parameters wrt sin_angle.

Parameters

	sin3lode	sin(3*(lode angle))
	sin_angle	sin(friction_angle) (for yield function), or sin(dilation_angle) (for potential function)
[out]	daaa	d(Abbo's A)/d(sin_angle)
[out]	dbbb	d(Abbo's B)/d(sin_angle)
[out]	dccc	d(Abbo's C)/d(sin_angle)

Definition at line 433 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real dtmp1 = (sin3lode >= 0 ? -_sintt / std::sqrt(3.0) : _sintt / std::sqrt(3.0));
   Real dtmp2 = _costt / std::sqrt(3.0);
  
   dccc = -_cos3tt * dtmp1;
   dccc += (sin3lode >= 0 ? -3 * _sin3tt * dtmp2 : 3 * _sin3tt * dtmp2);
   dccc /= 18 * Utility::pow<3>(_cos3tt);
  
   dbbb = (sin3lode >= 0 ? _sin6tt * dtmp1 : -_sin6tt * dtmp1);
   dbbb -= 6 * _cos6tt * dtmp2;
   dbbb /= 18 * Utility::pow<3>(_cos3tt);
  
   daaa = (sin3lode >= 0 ? -_sintt / std::sqrt(3.0) - dbbb * _sin3tt
                         : _sintt / std::sqrt(3.0) + dbbb * _sin3tt);
   daaa += -dccc * Utility::pow<2>(_sin3tt);
 }

Referenced by dflowPotential_dintnl(), and dyieldFunction_dintnl().

◆ dcohesion()

Real TensorMechanicsPlasticMohrCoulomb::dcohesion ( const Real internal_param ) const

protectedvirtual

d(cohesion)/d(internal_param);

Definition at line 381 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _cohesion.derivative(internal_param);
 }

Referenced by dyieldFunction_dintnl().

◆ df_dsig()

RankTwoTensor TensorMechanicsPlasticMohrCoulomb::df_dsig	(	const RankTwoTensor &	stress,
		const Real	sin_angle
	)		const

private

d(yieldFunction)/d(stress), but with the ability to put friction or dilation angle into the result

Parameters

stress	the stress at which to calculate
sin_angle	either sin(friction angle) or sin(dilation angle)

Definition at line 147 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real mean_stress = stress.trace() / 3.0;
   RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
   Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
   if (std::abs(sin3Lode) <= _sin3tt)
   {
     // the non-edge-smoothed version
     std::vector<Real> eigvals;
     std::vector<RankTwoTensor> deigvals;
     stress.dsymmetricEigenvalues(eigvals, deigvals);
     Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
     RankTwoTensor dtmp =
         deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
     Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
     return dmean_stress * sin_angle +
            (0.5 * dsmooth(stress) * dmean_stress + 0.25 * tmp * dtmp) / denom;
   }
   else
   {
     // the edge-smoothed version
     Real aaa, bbb, ccc;
     abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
     Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
     RankTwoTensor dkk = (bbb + 2 * ccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff);
     Real sibar2 = stress.secondInvariant();
     RankTwoTensor dsibar2 = stress.dsecondInvariant();
     Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
     return dmean_stress * sin_angle + (0.5 * dsmooth(stress) * dmean_stress +
                                        0.5 * dsibar2 * Utility::pow<2>(kk) + sibar2 * kk * dkk) /
                                           denom;
   }
 }

Referenced by dyieldFunction_dstress(), and flowPotential().

◆ dflowPotential_dintnl()

RankTwoTensor TensorMechanicsPlasticMohrCoulomb::dflowPotential_dintnl	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The derivative of the flow potential with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns: dr_dintnl(i, j) = dr(i, j)/dintnl

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 318 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real sin_angle = std::sin(psi(intnl));
   Real dsin_angle = std::cos(psi(intnl)) * dpsi(intnl);
  
   Real mean_stress = stress.trace() / 3.0;
   RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
   Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
  
   if (std::abs(sin3Lode) <= _sin3tt)
   {
     // the non-edge-smoothed version
     std::vector<Real> eigvals;
     std::vector<RankTwoTensor> deigvals;
     stress.dsymmetricEigenvalues(eigvals, deigvals);
     Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
     Real dtmp_dintnl = (eigvals[2] + eigvals[0] - 2 * mean_stress) * dsin_angle;
     RankTwoTensor dtmp_dstress =
         deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
     RankTwoTensor d2tmp_dstress_dintnl =
         (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * dsin_angle;
     Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
     return dmean_stress * dsin_angle + 0.25 * dtmp_dintnl * dtmp_dstress / denom +
            0.25 * tmp * d2tmp_dstress_dintnl / denom -
            0.5 * (dsmooth(stress) * dmean_stress + 0.5 * tmp * dtmp_dstress) * 0.25 * tmp *
                dtmp_dintnl / Utility::pow<3>(denom);
   }
   else
   {
     // the edge-smoothed version
     Real aaa, bbb, ccc;
     abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
     Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
  
     Real daaa, dbbb, dccc;
     dabbo(sin3Lode, sin_angle, daaa, dbbb, dccc);
     Real dkk_dintnl = (daaa + dbbb * sin3Lode + dccc * Utility::pow<2>(sin3Lode)) * dsin_angle;
     RankTwoTensor dkk_dstress = (bbb + 2 * ccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff);
     RankTwoTensor d2kk_dstress_dintnl =
         (dbbb + 2 * dccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff) * dsin_angle;
  
     Real sibar2 = stress.secondInvariant();
     RankTwoTensor dsibar2 = stress.dsecondInvariant();
     Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
  
     return dmean_stress * dsin_angle +
            (dsibar2 * kk * dkk_dintnl + sibar2 * dkk_dintnl * dkk_dstress +
             sibar2 * kk * d2kk_dstress_dintnl) /
                denom -
            (0.5 * dsmooth(stress) * dmean_stress + 0.5 * dsibar2 * Utility::pow<2>(kk) +
             sibar2 * kk * dkk_dstress) *
                sibar2 * kk * dkk_dintnl / Utility::pow<3>(denom);
   }
 }

◆ dflowPotential_dintnlV()

void TensorMechanicsPlasticModel::dflowPotential_dintnlV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< RankTwoTensor > &	dr_dintnl
	)		const

virtualinherited

The derivative of the flow potential with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	dr_dintnl	dr_dintnl[alpha](i, j) = dr[alpha](i, j)/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 139 of file TensorMechanicsPlasticModel.C.

 {
   return dr_dintnl.assign(1, dflowPotential_dintnl(stress, intnl));
 }

◆ dflowPotential_dstress()

RankFourTensor TensorMechanicsPlasticMohrCoulomb::dflowPotential_dstress	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The derivative of the flow potential with respect to stress.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns: dr_dstress(i, j, k, l) = dr(i, j)/dstress(k, l)

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 235 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   RankFourTensor dr_dstress;
   Real sin_angle = std::sin(psi(intnl));
   Real mean_stress = stress.trace() / 3.0;
   RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
   Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
   if (std::abs(sin3Lode) <= _sin3tt)
   {
     // the non-edge-smoothed version
     std::vector<Real> eigvals;
     std::vector<RankTwoTensor> deigvals;
     std::vector<RankFourTensor> d2eigvals;
     stress.dsymmetricEigenvalues(eigvals, deigvals);
     stress.d2symmetricEigenvalues(d2eigvals);
  
     Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
     RankTwoTensor dtmp =
         deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
     Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
     Real denom3 = Utility::pow<3>(denom);
     Real d2smooth_over_denom = d2smooth(stress) / denom;
     RankTwoTensor numer = dsmooth(stress) * dmean_stress + 0.5 * tmp * dtmp;
  
     dr_dstress = 0.25 * tmp *
                  (d2eigvals[2] - d2eigvals[0] + (d2eigvals[2] + d2eigvals[0]) * sin_angle) / denom;
  
     for (unsigned i = 0; i < 3; ++i)
       for (unsigned j = 0; j < 3; ++j)
         for (unsigned k = 0; k < 3; ++k)
           for (unsigned l = 0; l < 3; ++l)
           {
             dr_dstress(i, j, k, l) +=
                 0.5 * d2smooth_over_denom * dmean_stress(i, j) * dmean_stress(k, l);
             dr_dstress(i, j, k, l) += 0.25 * dtmp(i, j) * dtmp(k, l) / denom;
             dr_dstress(i, j, k, l) -= 0.25 * numer(i, j) * numer(k, l) / denom3;
           }
   }
   else
   {
     // the edge-smoothed version
     Real aaa, bbb, ccc;
     abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
     RankTwoTensor dsin3Lode = stress.dsin3Lode(_lode_cutoff);
     Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
     RankTwoTensor dkk = (bbb + 2 * ccc * sin3Lode) * dsin3Lode;
     RankFourTensor d2kk = (bbb + 2 * ccc * sin3Lode) * stress.d2sin3Lode(_lode_cutoff);
     for (unsigned i = 0; i < 3; ++i)
       for (unsigned j = 0; j < 3; ++j)
         for (unsigned k = 0; k < 3; ++k)
           for (unsigned l = 0; l < 3; ++l)
             d2kk(i, j, k, l) += 2 * ccc * dsin3Lode(i, j) * dsin3Lode(k, l);
  
     Real sibar2 = stress.secondInvariant();
     RankTwoTensor dsibar2 = stress.dsecondInvariant();
     RankFourTensor d2sibar2 = stress.d2secondInvariant();
  
     Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
     Real denom3 = Utility::pow<3>(denom);
     Real d2smooth_over_denom = d2smooth(stress) / denom;
     RankTwoTensor numer_full =
         0.5 * dsmooth(stress) * dmean_stress + 0.5 * dsibar2 * kk * kk + sibar2 * kk * dkk;
  
     dr_dstress = (0.5 * d2sibar2 * Utility::pow<2>(kk) + sibar2 * kk * d2kk) / denom;
     for (unsigned i = 0; i < 3; ++i)
       for (unsigned j = 0; j < 3; ++j)
         for (unsigned k = 0; k < 3; ++k)
           for (unsigned l = 0; l < 3; ++l)
           {
             dr_dstress(i, j, k, l) +=
                 0.5 * d2smooth_over_denom * dmean_stress(i, j) * dmean_stress(k, l);
             dr_dstress(i, j, k, l) +=
                 (dsibar2(i, j) * dkk(k, l) * kk + dkk(i, j) * dsibar2(k, l) * kk +
                  sibar2 * dkk(i, j) * dkk(k, l)) /
                 denom;
             dr_dstress(i, j, k, l) -= numer_full(i, j) * numer_full(k, l) / denom3;
           }
   }
   return dr_dstress;
 }

◆ dflowPotential_dstressV()

void TensorMechanicsPlasticModel::dflowPotential_dstressV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< RankFourTensor > &	dr_dstress
	)		const

virtualinherited

The derivative of the flow potential with respect to stress.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	dr_dstress	dr_dstress[alpha](i, j, k, l) = dr[alpha](i, j)/dstress(k, l)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 125 of file TensorMechanicsPlasticModel.C.

 {
   return dr_dstress.assign(1, dflowPotential_dstress(stress, intnl));
 }

◆ dhardPotential_dintnl()

Real TensorMechanicsPlasticModel::dhardPotential_dintnl	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

protectedvirtualinherited

The derivative of the hardening potential with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the hardening potentials
intnl	internal parameter

Returns: the derivative

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 174 of file TensorMechanicsPlasticModel.C.

 {
   return 0.0;
 }

Referenced by TensorMechanicsPlasticModel::dhardPotential_dintnlV().

◆ dhardPotential_dintnlV()

void TensorMechanicsPlasticModel::dhardPotential_dintnlV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< Real > &	dh_dintnl
	)		const

virtualinherited

The derivative of the hardening potential with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	internal parameter
[out]	dh_dintnl	dh_dintnl[alpha] = dh[alpha]/dintnl

Definition at line 180 of file TensorMechanicsPlasticModel.C.

 {
   dh_dintnl.resize(numberSurfaces(), dhardPotential_dintnl(stress, intnl));
 }

◆ dhardPotential_dstress()

RankTwoTensor TensorMechanicsPlasticModel::dhardPotential_dstress	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

protectedvirtualinherited

The derivative of the hardening potential with respect to stress.

Parameters

stress	the stress at which to calculate the hardening potentials
intnl	internal parameter

Returns: dh_dstress(i, j) = dh/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 160 of file TensorMechanicsPlasticModel.C.

 {
   return RankTwoTensor();
 }

Referenced by TensorMechanicsPlasticModel::dhardPotential_dstressV().

◆ dhardPotential_dstressV()

void TensorMechanicsPlasticModel::dhardPotential_dstressV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< RankTwoTensor > &	dh_dstress
	)		const

virtualinherited

The derivative of the hardening potential with respect to stress.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	internal parameter
[out]	dh_dstress	dh_dstress[alpha](i, j) = dh[alpha]/dstress(i, j)

Definition at line 166 of file TensorMechanicsPlasticModel.C.

 {
   dh_dstress.assign(numberSurfaces(), dhardPotential_dstress(stress, intnl));
 }

◆ dphi()

Real TensorMechanicsPlasticMohrCoulomb::dphi ( const Real internal_param ) const

protectedvirtual

d(phi)/d(internal_param);

Definition at line 393 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _phi.derivative(internal_param);
 }

Referenced by dyieldFunction_dintnl().

◆ dpsi()

Real TensorMechanicsPlasticMohrCoulomb::dpsi ( const Real internal_param ) const

protectedvirtual

d(psi)/d(internal_param);

Definition at line 405 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _psi.derivative(internal_param);
 }

Referenced by dflowPotential_dintnl().

◆ dsmooth()

Real TensorMechanicsPlasticMohrCoulomb::dsmooth ( const RankTwoTensor & stress ) const

protectedvirtual

returns the da/dstress_mean - see doco for _tip_scheme

Definition at line 468 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real dsmoother2 = 0;
   if (_tip_scheme == "cap")
   {
     Real x = stress.trace() / 3.0 - _cap_start;
     Real p = 0;
     Real dp_dx = 0;
     if (x > 0)
     {
       p = x * (1 - std::exp(-_cap_rate * x));
       dp_dx = (1 - std::exp(-_cap_rate * x)) + x * _cap_rate * std::exp(-_cap_rate * x);
     }
     dsmoother2 += 2 * p * dp_dx;
   }
   return dsmoother2;
 }

Referenced by df_dsig(), dflowPotential_dintnl(), and dflowPotential_dstress().

◆ dyieldFunction_dintnl()

Real TensorMechanicsPlasticMohrCoulomb::dyieldFunction_dintnl	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The derivative of yield function with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns: the derivative

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 190 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real sin_angle = std::sin(phi(intnl));
   Real cos_angle = std::cos(phi(intnl));
   Real dsin_angle = cos_angle * dphi(intnl);
   Real dcos_angle = -sin_angle * dphi(intnl);
  
   Real mean_stress = stress.trace() / 3.0;
   Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
   if (std::abs(sin3Lode) <= _sin3tt)
   {
     // the non-edge-smoothed version
     std::vector<Real> eigvals;
     stress.symmetricEigenvalues(eigvals);
     Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2 * mean_stress) * sin_angle;
     Real dtmp = (eigvals[2] + eigvals[0] - 2 * mean_stress) * dsin_angle;
     Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
     return mean_stress * dsin_angle + 0.25 * tmp * dtmp / denom - dcohesion(intnl) * cos_angle -
            cohesion(intnl) * dcos_angle;
   }
   else
   {
     // the edge-smoothed version
     Real aaa, bbb, ccc;
     abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
     Real daaa, dbbb, dccc;
     dabbo(sin3Lode, sin_angle, daaa, dbbb, dccc);
     Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
     Real dkk = (daaa + dbbb * sin3Lode + dccc * Utility::pow<2>(sin3Lode)) * dsin_angle;
     Real sibar2 = stress.secondInvariant();
     Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
     return mean_stress * dsin_angle + sibar2 * kk * dkk / denom - dcohesion(intnl) * cos_angle -
            cohesion(intnl) * dcos_angle;
   }
 }

◆ dyieldFunction_dintnlV()

void TensorMechanicsPlasticModel::dyieldFunction_dintnlV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< Real > &	df_dintnl
	)		const

virtualinherited

The derivative of yield functions with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	df_dintnl	df_dintnl[alpha] = df[alpha]/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 98 of file TensorMechanicsPlasticModel.C.

 {
   return df_dintnl.assign(1, dyieldFunction_dintnl(stress, intnl));
 }

◆ dyieldFunction_dstress()

RankTwoTensor TensorMechanicsPlasticMohrCoulomb::dyieldFunction_dstress	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The derivative of yield function with respect to stress.

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns: df_dstress(i, j) = dyieldFunction/dstress(i, j)

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 182 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real sinphi = std::sin(phi(intnl));
   return df_dsig(stress, sinphi);
 }

◆ dyieldFunction_dstressV()

void TensorMechanicsPlasticModel::dyieldFunction_dstressV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< RankTwoTensor > &	df_dstress
	)		const

virtualinherited

The derivative of yield functions with respect to stress.

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	df_dstress	df_dstress[alpha](i, j) = dyieldFunction[alpha]/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 84 of file TensorMechanicsPlasticModel.C.

 {
   df_dstress.assign(1, dyieldFunction_dstress(stress, intnl));
 }

◆ execute()

void TensorMechanicsPlasticModel::execute ( )

inherited

Definition at line 47 of file TensorMechanicsPlasticModel.C.

48 {

49 }

◆ finalize()

void TensorMechanicsPlasticModel::finalize ( )

inherited

Definition at line 52 of file TensorMechanicsPlasticModel.C.

53 {

54 }

◆ flowPotential()

RankTwoTensor TensorMechanicsPlasticMohrCoulomb::flowPotential	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The flow potential.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns: the flow potential

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 228 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real sinpsi = std::sin(psi(intnl));
   return df_dsig(stress, sinpsi);
 }

◆ flowPotentialV()

void TensorMechanicsPlasticModel::flowPotentialV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< RankTwoTensor > &	r
	)		const

virtualinherited

The flow potentials.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	r	r[alpha] is the flow potential for the "alpha" yield function

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 111 of file TensorMechanicsPlasticModel.C.

 {
   return r.assign(1, flowPotential(stress, intnl));
 }

◆ hardPotential()

Real TensorMechanicsPlasticModel::hardPotential	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

protectedvirtualinherited

The hardening potential.

Parameters

stress	the stress at which to calculate the hardening potential
intnl	internal parameter

Returns: the hardening potential

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 147 of file TensorMechanicsPlasticModel.C.

 {
   return -1.0;
 }

Referenced by TensorMechanicsPlasticModel::hardPotentialV().

◆ hardPotentialV()

void TensorMechanicsPlasticModel::hardPotentialV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< Real > &	h
	)		const

virtualinherited

The hardening potential.

Parameters

	stress	the stress at which to calculate the hardening potential
	intnl	internal parameter
[out]	h	h[alpha] is the hardening potential for the "alpha" yield function

Definition at line 152 of file TensorMechanicsPlasticModel.C.

 {
   h.assign(numberSurfaces(), hardPotential(stress, intnl));
 }

◆ initialize()

void TensorMechanicsPlasticModel::initialize ( )

inherited

Definition at line 42 of file TensorMechanicsPlasticModel.C.

43 {

44 }

◆ KuhnTuckerSingleSurface()

bool TensorMechanicsPlasticModel::KuhnTuckerSingleSurface	(	Real	yf,
		Real	dpm,
		Real	dpm_tol
	)		const

inherited

Returns true if the Kuhn-Tucker conditions for the single surface are satisfied.

Parameters

yf	Yield function value
dpm	plastic multiplier
dpm_tol	tolerance on plastic multiplier: viz dpm>-dpm_tol means "dpm is non-negative"

Definition at line 248 of file TensorMechanicsPlasticModel.C.

 {
   return (dpm == 0 && yf <= _f_tol) || (dpm > -dpm_tol && yf <= _f_tol && yf >= -_f_tol);
 }

Referenced by TensorMechanicsPlasticMohrCoulombMulti::KuhnTuckerOK(), TensorMechanicsPlasticTensileMulti::KuhnTuckerOK(), and TensorMechanicsPlasticModel::returnMap().

◆ modelName()

std::string TensorMechanicsPlasticMohrCoulomb::modelName ( ) const

overridevirtual

Implements TensorMechanicsPlasticModel.

Definition at line 509 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return "MohrCoulomb";
 }

◆ numberSurfaces()

unsigned TensorMechanicsPlasticModel::numberSurfaces ( ) const

virtualinherited

The number of yield surfaces for this plasticity model.

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 57 of file TensorMechanicsPlasticModel.C.

 {
   return 1;
 }

Referenced by TensorMechanicsPlasticModel::activeConstraints(), TensorMechanicsPlasticModel::dhardPotential_dintnlV(), TensorMechanicsPlasticModel::dhardPotential_dstressV(), TensorMechanicsPlasticModel::hardPotentialV(), and TensorMechanicsPlasticModel::returnMap().

◆ phi()

Real TensorMechanicsPlasticMohrCoulomb::phi ( const Real internal_param ) const

protectedvirtual

friction angle as a function of internal parameter

Definition at line 387 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _phi.value(internal_param);
 }

Referenced by dyieldFunction_dintnl(), dyieldFunction_dstress(), TensorMechanicsPlasticMohrCoulomb(), and yieldFunction().

◆ psi()

Real TensorMechanicsPlasticMohrCoulomb::psi ( const Real internal_param ) const

protectedvirtual

dilation angle as a function of internal parameter

Definition at line 399 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   return _psi.value(internal_param);
 }

Referenced by dflowPotential_dintnl(), dflowPotential_dstress(), flowPotential(), and TensorMechanicsPlasticMohrCoulomb().

◆ returnMap()

bool TensorMechanicsPlasticModel::returnMap	(	const RankTwoTensor &	trial_stress,
		Real	intnl_old,
		const RankFourTensor &	E_ijkl,
		Real	ep_plastic_tolerance,
		RankTwoTensor &	returned_stress,
		Real &	returned_intnl,
		std::vector< Real > &	dpm,
		RankTwoTensor &	delta_dp,
		std::vector< Real > &	yf,
		bool &	trial_stress_inadmissible
	)		const

virtualinherited

Performs a custom return-map.

You may choose to over-ride this in your derived TensorMechanicsPlasticXXXX class, and you may implement the return-map algorithm in any way that suits you. Eg, using a Newton-Raphson approach, or a radial-return, etc. This may also be used as a quick way of ascertaining whether (trial_stress, intnl_old) is in fact admissible.

For over-riding this function, please note the following.

(1) Denoting the return value of the function by "successful_return", the only possible output values should be: (A) trial_stress_inadmissible=false, successful_return=true. That is, (trial_stress, intnl_old) is in fact admissible (in the elastic domain). (B) trial_stress_inadmissible=true, successful_return=false. That is (trial_stress, intnl_old) is inadmissible (outside the yield surface), and you didn't return to the yield surface. (C) trial_stress_inadmissible=true, successful_return=true. That is (trial_stress, intnl_old) is inadmissible (outside the yield surface), but you did return to the yield surface. The default implementation only handles case (A) and (B): it does not attempt to do a return-map algorithm.

(2) you must correctly signal "successful_return" using the return value of this function. Don't assume the calling function will do Kuhn-Tucker checking and so forth!

(3) In cases (A) and (B) you needn't set returned_stress, returned_intnl, delta_dp, or dpm. This is for computational efficiency.

(4) In cases (A) and (B), you MUST place the yield function values at (trial_stress, intnl_old) into yf so the calling function can use this information optimally. You will have already calculated these yield function values, which can be quite expensive, and it's not very optimal for the calling function to have to re-calculate them.

(5) In case (C), you need to set: returned_stress (the returned value of stress) returned_intnl (the returned value of the internal variable) delta_dp (the change in plastic strain) dpm (the plastic multipliers needed to bring about the return) yf (yield function values at the returned configuration)

(Note, if you over-ride returnMap, you will probably want to override consistentTangentOpertor too, otherwise it will default to E_ijkl.)

Parameters

	trial_stress	The trial stress
	intnl_old	Value of the internal parameter
	E_ijkl	Elasticity tensor
	ep_plastic_tolerance	Tolerance defined by the user for the plastic strain
[out]	returned_stress	In case (C): lies on the yield surface after returning and produces the correct plastic strain (normality condition). Otherwise: not defined
[out]	returned_intnl	In case (C): the value of the internal parameter after returning. Otherwise: not defined
[out]	dpm	In case (C): the plastic multipliers needed to bring about the return. Otherwise: not defined
[out]	delta_dp	In case (C): The change in plastic strain induced by the return process. Otherwise: not defined
[out]	yf	In case (C): the yield function at (returned_stress, returned_intnl). Otherwise: the yield function at (trial_stress, intnl_old)
[out]	trial_stress_inadmissible	Should be set to false if the trial_stress is admissible, and true if the trial_stress is inadmissible. This can be used by the calling prorgram

Returns: true if a successful return (or a return-map not needed), false if the trial_stress is inadmissible but the return process failed

Reimplemented in TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticMohrCoulombMulti, TensorMechanicsPlasticDruckerPragerHyperbolic, TensorMechanicsPlasticMeanCapTC, and TensorMechanicsPlasticJ2.

Definition at line 221 of file TensorMechanicsPlasticModel.C.

 {
   trial_stress_inadmissible = false;
   yieldFunctionV(trial_stress, intnl_old, yf);
  
   for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
     if (yf[sf] > _f_tol)
       trial_stress_inadmissible = true;
  
   // example of checking Kuhn-Tucker
   std::vector<Real> dpm(numberSurfaces(), 0);
   for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
     if (!KuhnTuckerSingleSurface(yf[sf], dpm[sf], 0))
       return false;
   return true;
 }

Referenced by TensorMechanicsPlasticJ2::returnMap(), TensorMechanicsPlasticDruckerPragerHyperbolic::returnMap(), TensorMechanicsPlasticMeanCapTC::returnMap(), TensorMechanicsPlasticMohrCoulombMulti::returnMap(), and TensorMechanicsPlasticTensileMulti::returnMap().

◆ smooth()

Real TensorMechanicsPlasticMohrCoulomb::smooth ( const RankTwoTensor & stress ) const

protectedvirtual

returns the 'a' parameter - see doco for _tip_scheme

Definition at line 453 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real smoother2 = _small_smoother2;
   if (_tip_scheme == "cap")
   {
     Real x = stress.trace() / 3.0 - _cap_start;
     Real p = 0;
     if (x > 0)
       p = x * (1 - std::exp(-_cap_rate * x));
     smoother2 += Utility::pow<2>(p);
   }
   return smoother2;
 }

Referenced by df_dsig(), dflowPotential_dintnl(), dflowPotential_dstress(), dyieldFunction_dintnl(), and yieldFunction().

◆ useCustomCTO()

bool TensorMechanicsPlasticModel::useCustomCTO ( ) const

virtualinherited

Returns false. You will want to override this in your derived class if you write a custom consistent tangent operator function.

Reimplemented in TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticMeanCapTC, TensorMechanicsPlasticDruckerPragerHyperbolic, and TensorMechanicsPlasticJ2.

Definition at line 215 of file TensorMechanicsPlasticModel.C.

 {
   return false;
 }

◆ useCustomReturnMap()

bool TensorMechanicsPlasticModel::useCustomReturnMap ( ) const

virtualinherited

Returns false. You will want to override this in your derived class if you write a custom returnMap function.

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticMeanCapTC, TensorMechanicsPlasticDruckerPragerHyperbolic, and TensorMechanicsPlasticJ2.

Definition at line 209 of file TensorMechanicsPlasticModel.C.

 {
   return false;
 }

◆ validParams()

InputParameters TensorMechanicsPlasticMohrCoulomb::validParams ( )

static

Definition at line 19 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   InputParameters params = TensorMechanicsPlasticModel::validParams();
   params.addRequiredParam<UserObjectName>(
       "cohesion",
       "A TensorMechanicsHardening UserObject that defines hardening of the cohesion.  "
       "Physically the cohesion should not be negative.");
   params.addRequiredParam<UserObjectName>(
       "friction_angle",
       "A TensorMechanicsHardening UserObject that defines hardening of the "
       "friction angle (in radians).  Physically the friction angle should be "
       "between 0 and 90deg.");
   params.addRequiredParam<UserObjectName>(
       "dilation_angle",
       "A TensorMechanicsHardening UserObject that defines hardening of the "
       "dilation angle (in radians).  Usually the dilation angle is not greater "
       "than the friction angle, and it is between 0 and 90deg.");
   params.addRangeCheckedParam<Real>(
       "mc_edge_smoother",
       25.0,
       "mc_edge_smoother>=0 & mc_edge_smoother<=30",
       "Smoothing parameter: the edges of the cone are smoothed by the given amount.");
   MooseEnum tip_scheme("hyperbolic cap", "hyperbolic");
   params.addParam<MooseEnum>(
       "tip_scheme", tip_scheme, "Scheme by which the pyramid's tip will be smoothed.");
   params.addRequiredRangeCheckedParam<Real>("mc_tip_smoother",
                                             "mc_tip_smoother>=0",
                                             "Smoothing parameter: the cone vertex at mean = "
                                             "cohesion*cot(friction_angle), will be smoothed by "
                                             "the given amount.  Typical value is 0.1*cohesion");
   params.addParam<Real>(
       "cap_start",
       0.0,
       "For the 'cap' tip_scheme, smoothing is performed in the stress_mean > cap_start region");
   params.addRangeCheckedParam<Real>("cap_rate",
                                     0.0,
                                     "cap_rate>=0",
                                     "For the 'cap' tip_scheme, this controls how quickly the cap "
                                     "degenerates to a hemisphere: small values mean a slow "
                                     "degeneration to a hemisphere (and zero means the 'cap' will "
                                     "be totally inactive).  Typical value is 1/tensile_strength");
   params.addParam<Real>("mc_lode_cutoff",
                         "If the second invariant of stress is less than this "
                         "amount, the Lode angle is assumed to be zero.  This is "
                         "to gaurd against precision-loss problems, and this "
                         "parameter should be set small.  Default = "
                         "0.00001*((yield_Function_tolerance)^2)");
   params.addClassDescription("Non-associative Mohr-Coulomb plasticity with hardening/softening");
  
   return params;
 }

◆ yieldFunction()

Real TensorMechanicsPlasticMohrCoulomb::yieldFunction	(	const RankTwoTensor &	stress,
		Real	intnl
	)		const

overrideprotectedvirtual

The following functions are what you should override when building single-plasticity models.

The yield function

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns: the yield function

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 117 of file TensorMechanicsPlasticMohrCoulomb.C.

 {
   Real mean_stress = stress.trace() / 3.0;
   Real sinphi = std::sin(phi(intnl));
   Real cosphi = std::cos(phi(intnl));
   Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
   if (std::abs(sin3Lode) <= _sin3tt)
   {
     // the non-edge-smoothed version
     std::vector<Real> eigvals;
     stress.symmetricEigenvalues(eigvals);
     return mean_stress * sinphi +
            std::sqrt(smooth(stress) +
                      0.25 * Utility::pow<2>(eigvals[2] - eigvals[0] +
                                             (eigvals[2] + eigvals[0] - 2 * mean_stress) * sinphi)) -
            cohesion(intnl) * cosphi;
   }
   else
   {
     // the edge-smoothed version
     Real aaa, bbb, ccc;
     abbo(sin3Lode, sinphi, aaa, bbb, ccc);
     Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
     Real sibar2 = stress.secondInvariant();
     return mean_stress * sinphi + std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk)) -
            cohesion(intnl) * cosphi;
   }
 }

◆ yieldFunctionV()

void TensorMechanicsPlasticModel::yieldFunctionV	(	const RankTwoTensor &	stress,
		Real	intnl,
		std::vector< Real > &	f
	)		const

virtualinherited

Calculates the yield functions.

Note that for single-surface plasticity you don't want to override this - override the private yieldFunction below

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	f	the yield functions

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 69 of file TensorMechanicsPlasticModel.C.

 {
   f.assign(1, yieldFunction(stress, intnl));
 }

Referenced by TensorMechanicsPlasticModel::returnMap().

Member Data Documentation

◆ _cap_rate

Real TensorMechanicsPlasticMohrCoulomb::_cap_rate

protected

dictates how quickly the 'cap' degenerates to a hemisphere - see doco for _tip_scheme

Definition at line 81 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by d2smooth(), dsmooth(), and smooth().

◆ _cap_start

Real TensorMechanicsPlasticMohrCoulomb::_cap_start

protected

smoothing parameter dictating when the 'cap' will start - see doco for _tip_scheme

Definition at line 78 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by d2smooth(), dsmooth(), and smooth().

◆ _cohesion

const TensorMechanicsHardeningModel& TensorMechanicsPlasticMohrCoulomb::_cohesion

protected

Hardening model for cohesion.

Definition at line 56 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by cohesion(), and dcohesion().

◆ _cos3tt

Real TensorMechanicsPlasticMohrCoulomb::_cos3tt

protected

cos(3*_tt)

Definition at line 93 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _cos6tt

Real TensorMechanicsPlasticMohrCoulomb::_cos6tt

protected

cos(6*_tt)

Definition at line 99 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _costt

Real TensorMechanicsPlasticMohrCoulomb::_costt

protected

cos(_tt)

Definition at line 87 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _f_tol

const Real TensorMechanicsPlasticModel::_f_tol

inherited

Tolerance on yield function.

Definition at line 175 of file TensorMechanicsPlasticModel.h.

◆ _ic_tol

const Real TensorMechanicsPlasticModel::_ic_tol

inherited

Tolerance on internal constraint.

Definition at line 178 of file TensorMechanicsPlasticModel.h.

◆ _lode_cutoff

Real TensorMechanicsPlasticMohrCoulomb::_lode_cutoff

protected

if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-loss

Definition at line 105 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by df_dsig(), dflowPotential_dintnl(), dflowPotential_dstress(), dyieldFunction_dintnl(), TensorMechanicsPlasticMohrCoulomb(), and yieldFunction().

◆ _phi

const TensorMechanicsHardeningModel& TensorMechanicsPlasticMohrCoulomb::_phi

protected

Hardening model for phi.

Definition at line 59 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by dphi(), and phi().

◆ _psi

const TensorMechanicsHardeningModel& TensorMechanicsPlasticMohrCoulomb::_psi

protected

Hardening model for psi.

Definition at line 62 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by dpsi(), and psi().

◆ _sin3tt

Real TensorMechanicsPlasticMohrCoulomb::_sin3tt

protected

sin(3*_tt) - useful for making comparisons with Lode angle

Definition at line 96 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), dabbo(), df_dsig(), dflowPotential_dintnl(), dflowPotential_dstress(), dyieldFunction_dintnl(), and yieldFunction().

◆ _sin6tt

Real TensorMechanicsPlasticMohrCoulomb::_sin6tt

protected

sin(6*_tt)

Definition at line 102 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _sintt

Real TensorMechanicsPlasticMohrCoulomb::_sintt

protected

sin(_tt)

Definition at line 90 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _small_smoother2

Real TensorMechanicsPlasticMohrCoulomb::_small_smoother2

protected

Square of tip smoothing parameter to smooth the cone at mean_stress = T.

Definition at line 75 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by smooth().

◆ _tip_scheme

MooseEnum TensorMechanicsPlasticMohrCoulomb::_tip_scheme

protected

The yield function is modified to f = s_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi where "a" depends on the tip_scheme.

Currently _tip_scheme is 'hyperbolic', where a = _small_smoother2 'cap' where a = _small_smoother2 + (p(stress_mean - _cap_start))^2 with the function p(x)=x(1-exp(-_cap_rate*x)) for x>0, and p=0 otherwise

Definition at line 72 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by d2smooth(), dsmooth(), and smooth().

◆ _tt

Real TensorMechanicsPlasticMohrCoulomb::_tt

protected

edge smoothing parameter, in radians

Definition at line 84 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by TensorMechanicsPlasticMohrCoulomb().

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

tensor_mechanics/include/userobjects/TensorMechanicsPlasticMohrCoulomb.h
tensor_mechanics/src/userobjects/TensorMechanicsPlasticMohrCoulomb.C

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ TensorMechanicsPlasticMohrCoulomb()

Member Function Documentation

◆ abbo()

◆ activeConstraints()

◆ cohesion()

◆ consistentTangentOperator()

◆ d2smooth()

◆ dabbo()

◆ dcohesion()

◆ df_dsig()

◆ dflowPotential_dintnl()

◆ dflowPotential_dintnlV()

◆ dflowPotential_dstress()

◆ dflowPotential_dstressV()

◆ dhardPotential_dintnl()

◆ dhardPotential_dintnlV()

◆ dhardPotential_dstress()

◆ dhardPotential_dstressV()

◆ dphi()

◆ dpsi()

◆ dsmooth()

◆ dyieldFunction_dintnl()

◆ dyieldFunction_dintnlV()

◆ dyieldFunction_dstress()

◆ dyieldFunction_dstressV()

◆ execute()

◆ finalize()

◆ flowPotential()

◆ flowPotentialV()

◆ hardPotential()

◆ hardPotentialV()

◆ initialize()

◆ KuhnTuckerSingleSurface()

◆ modelName()

◆ numberSurfaces()

◆ phi()

◆ psi()

◆ returnMap()

◆ smooth()

◆ useCustomCTO()

◆ useCustomReturnMap()

◆ validParams()

◆ yieldFunction()

◆ yieldFunctionV()

Member Data Documentation

◆ _cap_rate

◆ _cap_start

◆ _cohesion

◆ _cos3tt

◆ _cos6tt

◆ _costt

◆ _f_tol

◆ _ic_tol

◆ _lode_cutoff

◆ _phi

◆ _psi

◆ _sin3tt

◆ _sin6tt

◆ _sintt

◆ _small_smoother2

◆ _tip_scheme

◆ _tt