www.mooseframework.org
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
TensorMechanicsPlasticMohrCoulomb Class Reference

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

#include <TensorMechanicsPlasticMohrCoulomb.h>

Inheritance diagram for TensorMechanicsPlasticMohrCoulomb:
[legend]

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...
 

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_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi 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 34 of file TensorMechanicsPlasticMohrCoulomb.h.

Constructor & Destructor Documentation

◆ TensorMechanicsPlasticMohrCoulomb()

TensorMechanicsPlasticMohrCoulomb::TensorMechanicsPlasticMohrCoulomb ( const InputParameters &  parameters)

Definition at line 70 of file TensorMechanicsPlasticMohrCoulomb.C.

72  : TensorMechanicsPlasticModel(parameters),
73  _cohesion(getUserObject<TensorMechanicsHardeningModel>("cohesion")),
74  _phi(getUserObject<TensorMechanicsHardeningModel>("friction_angle")),
75  _psi(getUserObject<TensorMechanicsHardeningModel>("dilation_angle")),
76  _tip_scheme(getParam<MooseEnum>("tip_scheme")),
77  _small_smoother2(Utility::pow<2>(getParam<Real>("mc_tip_smoother"))),
78  _cap_start(getParam<Real>("cap_start")),
79  _cap_rate(getParam<Real>("cap_rate")),
80  _tt(getParam<Real>("mc_edge_smoother") * libMesh::pi / 180.0),
81  _costt(std::cos(_tt)),
82  _sintt(std::sin(_tt)),
83  _cos3tt(std::cos(3 * _tt)),
84  _sin3tt(std::sin(3 * _tt)),
85  _cos6tt(std::cos(6 * _tt)),
86  _sin6tt(std::sin(6 * _tt)),
87  _lode_cutoff(parameters.isParamValid("mc_lode_cutoff") ? getParam<Real>("mc_lode_cutoff")
88  : 1.0E-5 * Utility::pow<2>(_f_tol))
89 
90 {
91  if (_lode_cutoff < 0)
92  mooseError("mc_lode_cutoff must not be negative");
93 
94  // With arbitary UserObjects, it is impossible to check everything, and
95  // I think this is the best I can do
96  if (phi(0) < 0 || psi(0) < 0 || phi(0) > libMesh::pi / 2.0 || psi(0) > libMesh::pi / 2.0)
97  mooseError("Mohr-Coulomb friction and dilation angles must lie in [0, Pi/2]");
98  if (phi(0) < psi(0))
99  mooseError("Mohr-Coulomb friction angle must not be less than Mohr-Coulomb dilation angle");
100  if (cohesion(0) < 0)
101  mooseError("Mohr-Coulomb cohesion must not be negative");
102 
103  // check Abbo et al's convexity constraint (Eqn c.18 in their paper)
104  // With an arbitrary UserObject, it is impossible to check for all angles
105  // I think the following is the best we can do
106  Real sin_angle = std::sin(std::max(phi(0), psi(0)));
107  sin_angle = std::max(sin_angle, std::sin(std::max(phi(1E6), psi(1E6))));
108  Real rhs = std::sqrt(3) * (35 * std::sin(_tt) + 14 * std::sin(5 * _tt) - 5 * std::sin(7 * _tt)) /
109  16 / Utility::pow<5>(std::cos(_tt)) / (11 - 10 * std::cos(2 * _tt));
110  if (rhs <= sin_angle)
111  mooseError("Mohr-Coulomb edge smoothing angle is too small and a non-convex yield surface will "
112  "result. Please choose a larger value");
113 }
const TensorMechanicsHardeningModel & _cohesion
Hardening model for cohesion.
TensorMechanicsPlasticModel(const InputParameters &parameters)
Real _cap_start
smoothing parameter dictating when the &#39;cap&#39; will start - see doco for _tip_scheme ...
const TensorMechanicsHardeningModel & _phi
Hardening model for phi.
Real _cap_rate
dictates how quickly the &#39;cap&#39; degenerates to a hemisphere - see doco for _tip_scheme ...
Real _tt
edge smoothing parameter, in radians
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
const Real _f_tol
Tolerance on yield function.
virtual Real phi(const Real internal_param) const
friction angle as a function of internal parameter
MooseEnum _tip_scheme
The yield function is modified to f = s_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi where "a" depends...
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
virtual Real psi(const Real internal_param) const
dilation angle as a function of internal parameter
virtual Real cohesion(const Real internal_param) const
cohesion as a function of internal parameter
Real _small_smoother2
Square of tip smoothing parameter to smooth the cone at mean_stress = T.
const TensorMechanicsHardeningModel & _psi
Hardening model for psi.

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
sin3lodesin(3*(lode angle))
sin_anglesin(friction_angle) (for yield function), or sin(dilation_angle) (for potential function)
[out]aaaAbbo's A
[out]bbbAbbo's B
[out]cccAbbo's C

Definition at line 410 of file TensorMechanicsPlasticMohrCoulomb.C.

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

412 {
413  Real tmp1 = (sin3lode >= 0 ? _costt - sin_angle * _sintt / std::sqrt(3.0)
414  : _costt + sin_angle * _sintt / std::sqrt(3.0));
415  Real tmp2 = (sin3lode >= 0 ? _sintt + sin_angle * _costt / std::sqrt(3.0)
416  : -_sintt + sin_angle * _costt / std::sqrt(3.0));
417 
418  ccc = -_cos3tt * tmp1;
419  ccc += (sin3lode >= 0 ? -3 * _sin3tt * tmp2 : 3 * _sin3tt * tmp2);
420  ccc /= 18 * Utility::pow<3>(_cos3tt);
421 
422  bbb = (sin3lode >= 0 ? _sin6tt * tmp1 : -_sin6tt * tmp1);
423  bbb -= 6 * _cos6tt * tmp2;
424  bbb /= 18 * Utility::pow<3>(_cos3tt);
425 
426  aaa = (sin3lode >= 0 ? -sin_angle * _sintt / std::sqrt(3.0) - bbb * _sin3tt
427  : sin_angle * _sintt / std::sqrt(3.0) + bbb * _sin3tt);
428  aaa += -ccc * Utility::pow<2>(_sin3tt) + _costt;
429 }
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle

◆ 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
fvalues of the yield functions
stressstress tensor
intnlinternal parameter
Eijklelasticity tensor (stress = Eijkl*strain)
[out]actact[i] = true if the i_th yield function is active
[out]returned_stressApproximate value of the returned stress

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

Definition at line 187 of file TensorMechanicsPlasticModel.C.

193 {
194  mooseAssert(f.size() == numberSurfaces(),
195  "f incorrectly sized at " << f.size() << " in activeConstraints");
196  act.resize(numberSurfaces());
197  for (unsigned surface = 0; surface < numberSurfaces(); ++surface)
198  act[surface] = (f[surface] > _f_tol);
199 }
virtual unsigned int numberSurfaces() const
The number of yield surfaces for this plasticity model.
const Real _f_tol
Tolerance on yield function.

◆ cohesion()

Real TensorMechanicsPlasticMohrCoulomb::cohesion ( const Real  internal_param) const
protectedvirtual

cohesion as a function of internal parameter

Definition at line 374 of file TensorMechanicsPlasticMohrCoulomb.C.

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

375 {
376  return _cohesion.value(internal_param);
377 }
const TensorMechanicsHardeningModel & _cohesion
Hardening model for cohesion.
virtual Real value(Real intnl) const

◆ 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_oldtrial stress before returning
intnl_oldinternal parameter before returning
stresscurrent returned stress state
intnlinternal parameter
E_ijklelasticity tensor
cumulative_pmthe cumulative plastic multipliers
Returns
the consistent tangent operator: E_ijkl if not over-ridden

Reimplemented in TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticDruckerPragerHyperbolic, TensorMechanicsPlasticMeanCapTC, and TensorMechanicsPlasticJ2.

Definition at line 253 of file TensorMechanicsPlasticModel.C.

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

260 {
261  return E_ijkl;
262 }

◆ d2smooth()

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

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

Definition at line 486 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dflowPotential_dstress().

487 {
488  Real d2smoother2 = 0;
489  if (_tip_scheme == "cap")
490  {
491  Real x = stress.trace() / 3.0 - _cap_start;
492  Real p = 0;
493  Real dp_dx = 0;
494  Real d2p_dx2 = 0;
495  if (x > 0)
496  {
497  p = x * (1 - std::exp(-_cap_rate * x));
498  dp_dx = (1 - std::exp(-_cap_rate * x)) + x * _cap_rate * std::exp(-_cap_rate * x);
499  d2p_dx2 = 2 * _cap_rate * std::exp(-_cap_rate * x) -
500  x * Utility::pow<2>(_cap_rate) * std::exp(-_cap_rate * x);
501  }
502  d2smoother2 += 2 * Utility::pow<2>(dp_dx) + 2 * p * d2p_dx2;
503  }
504  return d2smoother2;
505 }
Real _cap_start
smoothing parameter dictating when the &#39;cap&#39; will start - see doco for _tip_scheme ...
Real _cap_rate
dictates how quickly the &#39;cap&#39; degenerates to a hemisphere - see doco for _tip_scheme ...
MooseEnum _tip_scheme
The yield function is modified to f = s_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi where "a" depends...

◆ 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
sin3lodesin(3*(lode angle))
sin_anglesin(friction_angle) (for yield function), or sin(dilation_angle) (for potential function)
[out]daaad(Abbo's A)/d(sin_angle)
[out]dbbbd(Abbo's B)/d(sin_angle)
[out]dcccd(Abbo's C)/d(sin_angle)

Definition at line 432 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dflowPotential_dintnl(), and dyieldFunction_dintnl().

434 {
435  Real dtmp1 = (sin3lode >= 0 ? -_sintt / std::sqrt(3.0) : _sintt / std::sqrt(3.0));
436  Real dtmp2 = _costt / std::sqrt(3.0);
437 
438  dccc = -_cos3tt * dtmp1;
439  dccc += (sin3lode >= 0 ? -3 * _sin3tt * dtmp2 : 3 * _sin3tt * dtmp2);
440  dccc /= 18 * Utility::pow<3>(_cos3tt);
441 
442  dbbb = (sin3lode >= 0 ? _sin6tt * dtmp1 : -_sin6tt * dtmp1);
443  dbbb -= 6 * _cos6tt * dtmp2;
444  dbbb /= 18 * Utility::pow<3>(_cos3tt);
445 
446  daaa = (sin3lode >= 0 ? -_sintt / std::sqrt(3.0) - dbbb * _sin3tt
447  : _sintt / std::sqrt(3.0) + dbbb * _sin3tt);
448  daaa += -dccc * Utility::pow<2>(_sin3tt);
449 }
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle

◆ dcohesion()

Real TensorMechanicsPlasticMohrCoulomb::dcohesion ( const Real  internal_param) const
protectedvirtual

d(cohesion)/d(internal_param);

Definition at line 380 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dyieldFunction_dintnl().

381 {
382  return _cohesion.derivative(internal_param);
383 }
const TensorMechanicsHardeningModel & _cohesion
Hardening model for cohesion.
virtual Real derivative(Real intnl) const

◆ 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
stressthe stress at which to calculate
sin_angleeither sin(friction angle) or sin(dilation angle)

Definition at line 146 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dyieldFunction_dstress(), and flowPotential().

147 {
148  Real mean_stress = stress.trace() / 3.0;
149  RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
150  Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
151  if (std::abs(sin3Lode) <= _sin3tt)
152  {
153  // the non-edge-smoothed version
154  std::vector<Real> eigvals;
155  std::vector<RankTwoTensor> deigvals;
156  stress.dsymmetricEigenvalues(eigvals, deigvals);
157  Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
158  RankTwoTensor dtmp =
159  deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
160  Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
161  return dmean_stress * sin_angle +
162  (0.5 * dsmooth(stress) * dmean_stress + 0.25 * tmp * dtmp) / denom;
163  }
164  else
165  {
166  // the edge-smoothed version
167  Real aaa, bbb, ccc;
168  abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
169  Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
170  RankTwoTensor dkk = (bbb + 2 * ccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff);
171  Real sibar2 = stress.secondInvariant();
172  RankTwoTensor dsibar2 = stress.dsecondInvariant();
173  Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
174  return dmean_stress * sin_angle + (0.5 * dsmooth(stress) * dmean_stress +
175  0.5 * dsibar2 * Utility::pow<2>(kk) + sibar2 * kk * dkk) /
176  denom;
177  }
178 }
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
virtual Real smooth(const RankTwoTensor &stress) const
returns the &#39;a&#39; parameter - see doco for _tip_scheme
void abbo(const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
Computes Abbo et al&#39;s A, B and C parameters.
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
virtual Real dsmooth(const RankTwoTensor &stress) const
returns the da/dstress_mean - see doco for _tip_scheme

◆ 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
stressthe stress at which to calculate the flow potential
intnlinternal parameter
Returns
dr_dintnl(i, j) = dr(i, j)/dintnl

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 317 of file TensorMechanicsPlasticMohrCoulomb.C.

319 {
320  Real sin_angle = std::sin(psi(intnl));
321  Real dsin_angle = std::cos(psi(intnl)) * dpsi(intnl);
322 
323  Real mean_stress = stress.trace() / 3.0;
324  RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
325  Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
326 
327  if (std::abs(sin3Lode) <= _sin3tt)
328  {
329  // the non-edge-smoothed version
330  std::vector<Real> eigvals;
331  std::vector<RankTwoTensor> deigvals;
332  stress.dsymmetricEigenvalues(eigvals, deigvals);
333  Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
334  Real dtmp_dintnl = (eigvals[2] + eigvals[0] - 2 * mean_stress) * dsin_angle;
335  RankTwoTensor dtmp_dstress =
336  deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
337  RankTwoTensor d2tmp_dstress_dintnl =
338  (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * dsin_angle;
339  Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
340  return dmean_stress * dsin_angle + 0.25 * dtmp_dintnl * dtmp_dstress / denom +
341  0.25 * tmp * d2tmp_dstress_dintnl / denom -
342  0.5 * (dsmooth(stress) * dmean_stress + 0.5 * tmp * dtmp_dstress) * 0.25 * tmp *
343  dtmp_dintnl / Utility::pow<3>(denom);
344  }
345  else
346  {
347  // the edge-smoothed version
348  Real aaa, bbb, ccc;
349  abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
350  Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
351 
352  Real daaa, dbbb, dccc;
353  dabbo(sin3Lode, sin_angle, daaa, dbbb, dccc);
354  Real dkk_dintnl = (daaa + dbbb * sin3Lode + dccc * Utility::pow<2>(sin3Lode)) * dsin_angle;
355  RankTwoTensor dkk_dstress = (bbb + 2 * ccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff);
356  RankTwoTensor d2kk_dstress_dintnl =
357  (dbbb + 2 * dccc * sin3Lode) * stress.dsin3Lode(_lode_cutoff) * dsin_angle;
358 
359  Real sibar2 = stress.secondInvariant();
360  RankTwoTensor dsibar2 = stress.dsecondInvariant();
361  Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
362 
363  return dmean_stress * dsin_angle +
364  (dsibar2 * kk * dkk_dintnl + sibar2 * dkk_dintnl * dkk_dstress +
365  sibar2 * kk * d2kk_dstress_dintnl) /
366  denom -
367  (0.5 * dsmooth(stress) * dmean_stress + 0.5 * dsibar2 * Utility::pow<2>(kk) +
368  sibar2 * kk * dkk_dstress) *
369  sibar2 * kk * dkk_dintnl / Utility::pow<3>(denom);
370  }
371 }
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
virtual Real smooth(const RankTwoTensor &stress) const
returns the &#39;a&#39; parameter - see doco for _tip_scheme
void abbo(const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
Computes Abbo et al&#39;s A, B and C parameters.
virtual Real dpsi(const Real internal_param) const
d(psi)/d(internal_param);
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
void dabbo(const Real sin3lode, const Real sin_angle, Real &daaa, Real &dbbb, Real &dccc) const
Computes derivatives of Abbo et al&#39;s A, B and C parameters wrt sin_angle.
virtual Real psi(const Real internal_param) const
dilation angle as a function of internal parameter
virtual Real dsmooth(const RankTwoTensor &stress) const
returns the da/dstress_mean - see doco for _tip_scheme

◆ 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
stressthe stress at which to calculate the flow potential
intnlinternal parameter
[out]dr_dintnldr_dintnl[alpha](i, j) = dr[alpha](i, j)/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 138 of file TensorMechanicsPlasticModel.C.

141 {
142  return dr_dintnl.assign(1, dflowPotential_dintnl(stress, intnl));
143 }
virtual RankTwoTensor dflowPotential_dintnl(const RankTwoTensor &stress, Real intnl) const
The derivative of the flow potential with respect to the internal parameter.

◆ dflowPotential_dstress()

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

The derivative of the flow potential with respect to stress.

Parameters
stressthe stress at which to calculate the flow potential
intnlinternal parameter
Returns
dr_dstress(i, j, k, l) = dr(i, j)/dstress(k, l)

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 234 of file TensorMechanicsPlasticMohrCoulomb.C.

236 {
237  RankFourTensor dr_dstress;
238  Real sin_angle = std::sin(psi(intnl));
239  Real mean_stress = stress.trace() / 3.0;
240  RankTwoTensor dmean_stress = stress.dtrace() / 3.0;
241  Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
242  if (std::abs(sin3Lode) <= _sin3tt)
243  {
244  // the non-edge-smoothed version
245  std::vector<Real> eigvals;
246  std::vector<RankTwoTensor> deigvals;
247  std::vector<RankFourTensor> d2eigvals;
248  stress.dsymmetricEigenvalues(eigvals, deigvals);
249  stress.d2symmetricEigenvalues(d2eigvals);
250 
251  Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2.0 * mean_stress) * sin_angle;
252  RankTwoTensor dtmp =
253  deigvals[2] - deigvals[0] + (deigvals[2] + deigvals[0] - 2.0 * dmean_stress) * sin_angle;
254  Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
255  Real denom3 = Utility::pow<3>(denom);
256  Real d2smooth_over_denom = d2smooth(stress) / denom;
257  RankTwoTensor numer = dsmooth(stress) * dmean_stress + 0.5 * tmp * dtmp;
258 
259  dr_dstress = 0.25 * tmp *
260  (d2eigvals[2] - d2eigvals[0] + (d2eigvals[2] + d2eigvals[0]) * sin_angle) / denom;
261 
262  for (unsigned i = 0; i < 3; ++i)
263  for (unsigned j = 0; j < 3; ++j)
264  for (unsigned k = 0; k < 3; ++k)
265  for (unsigned l = 0; l < 3; ++l)
266  {
267  dr_dstress(i, j, k, l) +=
268  0.5 * d2smooth_over_denom * dmean_stress(i, j) * dmean_stress(k, l);
269  dr_dstress(i, j, k, l) += 0.25 * dtmp(i, j) * dtmp(k, l) / denom;
270  dr_dstress(i, j, k, l) -= 0.25 * numer(i, j) * numer(k, l) / denom3;
271  }
272  }
273  else
274  {
275  // the edge-smoothed version
276  Real aaa, bbb, ccc;
277  abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
278  RankTwoTensor dsin3Lode = stress.dsin3Lode(_lode_cutoff);
279  Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
280  RankTwoTensor dkk = (bbb + 2 * ccc * sin3Lode) * dsin3Lode;
281  RankFourTensor d2kk = (bbb + 2 * ccc * sin3Lode) * stress.d2sin3Lode(_lode_cutoff);
282  for (unsigned i = 0; i < 3; ++i)
283  for (unsigned j = 0; j < 3; ++j)
284  for (unsigned k = 0; k < 3; ++k)
285  for (unsigned l = 0; l < 3; ++l)
286  d2kk(i, j, k, l) += 2 * ccc * dsin3Lode(i, j) * dsin3Lode(k, l);
287 
288  Real sibar2 = stress.secondInvariant();
289  RankTwoTensor dsibar2 = stress.dsecondInvariant();
290  RankFourTensor d2sibar2 = stress.d2secondInvariant();
291 
292  Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
293  Real denom3 = Utility::pow<3>(denom);
294  Real d2smooth_over_denom = d2smooth(stress) / denom;
295  RankTwoTensor numer_full =
296  0.5 * dsmooth(stress) * dmean_stress + 0.5 * dsibar2 * kk * kk + sibar2 * kk * dkk;
297 
298  dr_dstress = (0.5 * d2sibar2 * Utility::pow<2>(kk) + sibar2 * kk * d2kk) / denom;
299  for (unsigned i = 0; i < 3; ++i)
300  for (unsigned j = 0; j < 3; ++j)
301  for (unsigned k = 0; k < 3; ++k)
302  for (unsigned l = 0; l < 3; ++l)
303  {
304  dr_dstress(i, j, k, l) +=
305  0.5 * d2smooth_over_denom * dmean_stress(i, j) * dmean_stress(k, l);
306  dr_dstress(i, j, k, l) +=
307  (dsibar2(i, j) * dkk(k, l) * kk + dkk(i, j) * dsibar2(k, l) * kk +
308  sibar2 * dkk(i, j) * dkk(k, l)) /
309  denom;
310  dr_dstress(i, j, k, l) -= numer_full(i, j) * numer_full(k, l) / denom3;
311  }
312  }
313  return dr_dstress;
314 }
virtual Real d2smooth(const RankTwoTensor &stress) const
returns the d^2a/dstress_mean^2 - see doco for _tip_scheme
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
virtual Real smooth(const RankTwoTensor &stress) const
returns the &#39;a&#39; parameter - see doco for _tip_scheme
void abbo(const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
Computes Abbo et al&#39;s A, B and C parameters.
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
virtual Real psi(const Real internal_param) const
dilation angle as a function of internal parameter
virtual Real dsmooth(const RankTwoTensor &stress) const
returns the da/dstress_mean - see doco for _tip_scheme

◆ 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
stressthe stress at which to calculate the flow potential
intnlinternal parameter
[out]dr_dstressdr_dstress[alpha](i, j, k, l) = dr[alpha](i, j)/dstress(k, l)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 124 of file TensorMechanicsPlasticModel.C.

127 {
128  return dr_dstress.assign(1, dflowPotential_dstress(stress, intnl));
129 }
virtual RankFourTensor dflowPotential_dstress(const RankTwoTensor &stress, Real intnl) const
The derivative of the flow potential with respect to stress.

◆ 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
stressthe stress at which to calculate the hardening potentials
intnlinternal parameter
Returns
the derivative

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 173 of file TensorMechanicsPlasticModel.C.

Referenced by TensorMechanicsPlasticModel::dhardPotential_dintnlV().

175 {
176  return 0.0;
177 }

◆ 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
stressthe stress at which to calculate the hardening potentials
intnlinternal parameter
[out]dh_dintnldh_dintnl[alpha] = dh[alpha]/dintnl

Definition at line 179 of file TensorMechanicsPlasticModel.C.

182 {
183  dh_dintnl.resize(numberSurfaces(), dhardPotential_dintnl(stress, intnl));
184 }
virtual unsigned int numberSurfaces() const
The number of yield surfaces for this plasticity model.
virtual Real dhardPotential_dintnl(const RankTwoTensor &stress, Real intnl) const
The derivative of the hardening potential with respect to the internal parameter. ...

◆ dhardPotential_dstress()

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

The derivative of the hardening potential with respect to stress.

Parameters
stressthe stress at which to calculate the hardening potentials
intnlinternal parameter
Returns
dh_dstress(i, j) = dh/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 159 of file TensorMechanicsPlasticModel.C.

Referenced by TensorMechanicsPlasticModel::dhardPotential_dstressV().

161 {
162  return RankTwoTensor();
163 }

◆ 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
stressthe stress at which to calculate the hardening potentials
intnlinternal parameter
[out]dh_dstressdh_dstress[alpha](i, j) = dh[alpha]/dstress(i, j)

Definition at line 165 of file TensorMechanicsPlasticModel.C.

168 {
169  dh_dstress.assign(numberSurfaces(), dhardPotential_dstress(stress, intnl));
170 }
virtual unsigned int numberSurfaces() const
The number of yield surfaces for this plasticity model.
virtual RankTwoTensor dhardPotential_dstress(const RankTwoTensor &stress, Real intnl) const
The derivative of the hardening potential with respect to stress.

◆ dphi()

Real TensorMechanicsPlasticMohrCoulomb::dphi ( const Real  internal_param) const
protectedvirtual

d(phi)/d(internal_param);

Definition at line 392 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dyieldFunction_dintnl().

393 {
394  return _phi.derivative(internal_param);
395 }
const TensorMechanicsHardeningModel & _phi
Hardening model for phi.
virtual Real derivative(Real intnl) const

◆ dpsi()

Real TensorMechanicsPlasticMohrCoulomb::dpsi ( const Real  internal_param) const
protectedvirtual

d(psi)/d(internal_param);

Definition at line 404 of file TensorMechanicsPlasticMohrCoulomb.C.

Referenced by dflowPotential_dintnl().

405 {
406  return _psi.derivative(internal_param);
407 }
virtual Real derivative(Real intnl) const
const TensorMechanicsHardeningModel & _psi
Hardening model for psi.

◆ dsmooth()

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

returns the da/dstress_mean - see doco for _tip_scheme

Definition at line 467 of file TensorMechanicsPlasticMohrCoulomb.C.

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

468 {
469  Real dsmoother2 = 0;
470  if (_tip_scheme == "cap")
471  {
472  Real x = stress.trace() / 3.0 - _cap_start;
473  Real p = 0;
474  Real dp_dx = 0;
475  if (x > 0)
476  {
477  p = x * (1 - std::exp(-_cap_rate * x));
478  dp_dx = (1 - std::exp(-_cap_rate * x)) + x * _cap_rate * std::exp(-_cap_rate * x);
479  }
480  dsmoother2 += 2 * p * dp_dx;
481  }
482  return dsmoother2;
483 }
Real _cap_start
smoothing parameter dictating when the &#39;cap&#39; will start - see doco for _tip_scheme ...
Real _cap_rate
dictates how quickly the &#39;cap&#39; degenerates to a hemisphere - see doco for _tip_scheme ...
MooseEnum _tip_scheme
The yield function is modified to f = s_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi where "a" depends...

◆ 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
stressthe stress at which to calculate the yield function
intnlinternal parameter
Returns
the derivative

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 189 of file TensorMechanicsPlasticMohrCoulomb.C.

191 {
192  Real sin_angle = std::sin(phi(intnl));
193  Real cos_angle = std::cos(phi(intnl));
194  Real dsin_angle = cos_angle * dphi(intnl);
195  Real dcos_angle = -sin_angle * dphi(intnl);
196 
197  Real mean_stress = stress.trace() / 3.0;
198  Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
199  if (std::abs(sin3Lode) <= _sin3tt)
200  {
201  // the non-edge-smoothed version
202  std::vector<Real> eigvals;
203  stress.symmetricEigenvalues(eigvals);
204  Real tmp = eigvals[2] - eigvals[0] + (eigvals[2] + eigvals[0] - 2 * mean_stress) * sin_angle;
205  Real dtmp = (eigvals[2] + eigvals[0] - 2 * mean_stress) * dsin_angle;
206  Real denom = std::sqrt(smooth(stress) + 0.25 * Utility::pow<2>(tmp));
207  return mean_stress * dsin_angle + 0.25 * tmp * dtmp / denom - dcohesion(intnl) * cos_angle -
208  cohesion(intnl) * dcos_angle;
209  }
210  else
211  {
212  // the edge-smoothed version
213  Real aaa, bbb, ccc;
214  abbo(sin3Lode, sin_angle, aaa, bbb, ccc);
215  Real daaa, dbbb, dccc;
216  dabbo(sin3Lode, sin_angle, daaa, dbbb, dccc);
217  Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
218  Real dkk = (daaa + dbbb * sin3Lode + dccc * Utility::pow<2>(sin3Lode)) * dsin_angle;
219  Real sibar2 = stress.secondInvariant();
220  Real denom = std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk));
221  return mean_stress * dsin_angle + sibar2 * kk * dkk / denom - dcohesion(intnl) * cos_angle -
222  cohesion(intnl) * dcos_angle;
223  }
224 }
virtual Real dcohesion(const Real internal_param) const
d(cohesion)/d(internal_param);
virtual Real dphi(const Real internal_param) const
d(phi)/d(internal_param);
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
virtual Real smooth(const RankTwoTensor &stress) const
returns the &#39;a&#39; parameter - see doco for _tip_scheme
void abbo(const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
Computes Abbo et al&#39;s A, B and C parameters.
virtual Real phi(const Real internal_param) const
friction angle as a function of internal parameter
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
void dabbo(const Real sin3lode, const Real sin_angle, Real &daaa, Real &dbbb, Real &dccc) const
Computes derivatives of Abbo et al&#39;s A, B and C parameters wrt sin_angle.
virtual Real cohesion(const Real internal_param) const
cohesion as a function of internal parameter

◆ 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
stressthe stress at which to calculate the yield function
intnlinternal parameter
[out]df_dintnldf_dintnl[alpha] = df[alpha]/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 97 of file TensorMechanicsPlasticModel.C.

100 {
101  return df_dintnl.assign(1, dyieldFunction_dintnl(stress, intnl));
102 }
virtual Real dyieldFunction_dintnl(const RankTwoTensor &stress, Real intnl) const
The derivative of yield function with respect to the internal parameter.

◆ dyieldFunction_dstress()

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

The derivative of yield function with respect to stress.

Parameters
stressthe stress at which to calculate the yield function
intnlinternal parameter
Returns
df_dstress(i, j) = dyieldFunction/dstress(i, j)

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 181 of file TensorMechanicsPlasticMohrCoulomb.C.

183 {
184  Real sinphi = std::sin(phi(intnl));
185  return df_dsig(stress, sinphi);
186 }
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 ...
virtual Real phi(const Real internal_param) const
friction angle as a function of internal parameter

◆ 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
stressthe stress at which to calculate the yield function
intnlinternal parameter
[out]df_dstressdf_dstress[alpha](i, j) = dyieldFunction[alpha]/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 83 of file TensorMechanicsPlasticModel.C.

86 {
87  df_dstress.assign(1, dyieldFunction_dstress(stress, intnl));
88 }
virtual RankTwoTensor dyieldFunction_dstress(const RankTwoTensor &stress, Real intnl) const
The derivative of yield function with respect to stress.

◆ execute()

void TensorMechanicsPlasticModel::execute ( )
inherited

Definition at line 46 of file TensorMechanicsPlasticModel.C.

47 {
48 }

◆ finalize()

void TensorMechanicsPlasticModel::finalize ( )
inherited

Definition at line 51 of file TensorMechanicsPlasticModel.C.

52 {
53 }

◆ flowPotential()

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

The flow potential.

Parameters
stressthe stress at which to calculate the flow potential
intnlinternal parameter
Returns
the flow potential

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 227 of file TensorMechanicsPlasticMohrCoulomb.C.

228 {
229  Real sinpsi = std::sin(psi(intnl));
230  return df_dsig(stress, sinpsi);
231 }
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 ...
virtual Real psi(const Real internal_param) const
dilation angle as a function of internal parameter

◆ flowPotentialV()

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

The flow potentials.

Parameters
stressthe stress at which to calculate the flow potential
intnlinternal parameter
[out]rr[alpha] is the flow potential for the "alpha" yield function

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 110 of file TensorMechanicsPlasticModel.C.

113 {
114  return r.assign(1, flowPotential(stress, intnl));
115 }
virtual RankTwoTensor flowPotential(const RankTwoTensor &stress, Real intnl) const
The flow potential.

◆ hardPotential()

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

The hardening potential.

Parameters
stressthe stress at which to calculate the hardening potential
intnlinternal parameter
Returns
the hardening potential

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 146 of file TensorMechanicsPlasticModel.C.

Referenced by TensorMechanicsPlasticModel::hardPotentialV().

147 {
148  return -1.0;
149 }

◆ hardPotentialV()

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

The hardening potential.

Parameters
stressthe stress at which to calculate the hardening potential
intnlinternal parameter
[out]hh[alpha] is the hardening potential for the "alpha" yield function

Definition at line 151 of file TensorMechanicsPlasticModel.C.

154 {
155  h.assign(numberSurfaces(), hardPotential(stress, intnl));
156 }
virtual Real hardPotential(const RankTwoTensor &stress, Real intnl) const
The hardening potential.
virtual unsigned int numberSurfaces() const
The number of yield surfaces for this plasticity model.

◆ initialize()

void TensorMechanicsPlasticModel::initialize ( )
inherited

Definition at line 41 of file TensorMechanicsPlasticModel.C.

42 {
43 }

◆ 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
yfYield function value
dpmplastic multiplier
dpm_toltolerance on plastic multiplier: viz dpm>-dpm_tol means "dpm is non-negative"

Definition at line 247 of file TensorMechanicsPlasticModel.C.

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

248 {
249  return (dpm == 0 && yf <= _f_tol) || (dpm > -dpm_tol && yf <= _f_tol && yf >= -_f_tol);
250 }
const Real _f_tol
Tolerance on yield function.

◆ modelName()

std::string TensorMechanicsPlasticMohrCoulomb::modelName ( ) const
overridevirtual

Implements TensorMechanicsPlasticModel.

Definition at line 508 of file TensorMechanicsPlasticMohrCoulomb.C.

509 {
510  return "MohrCoulomb";
511 }

◆ numberSurfaces()

unsigned TensorMechanicsPlasticModel::numberSurfaces ( ) const
virtualinherited

◆ phi()

Real TensorMechanicsPlasticMohrCoulomb::phi ( const Real  internal_param) const
protectedvirtual

friction angle as a function of internal parameter

Definition at line 386 of file TensorMechanicsPlasticMohrCoulomb.C.

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

387 {
388  return _phi.value(internal_param);
389 }
const TensorMechanicsHardeningModel & _phi
Hardening model for phi.
virtual Real value(Real intnl) const

◆ psi()

Real TensorMechanicsPlasticMohrCoulomb::psi ( const Real  internal_param) const
protectedvirtual

dilation angle as a function of internal parameter

Definition at line 398 of file TensorMechanicsPlasticMohrCoulomb.C.

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

399 {
400  return _psi.value(internal_param);
401 }
virtual Real value(Real intnl) const
const TensorMechanicsHardeningModel & _psi
Hardening model for psi.

◆ 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_stressThe trial stress
intnl_oldValue of the internal parameter
E_ijklElasticity tensor
ep_plastic_toleranceTolerance defined by the user for the plastic strain
[out]returned_stressIn case (C): lies on the yield surface after returning and produces the correct plastic strain (normality condition). Otherwise: not defined
[out]returned_intnlIn case (C): the value of the internal parameter after returning. Otherwise: not defined
[out]dpmIn case (C): the plastic multipliers needed to bring about the return. Otherwise: not defined
[out]delta_dpIn case (C): The change in plastic strain induced by the return process. Otherwise: not defined
[out]yfIn case (C): the yield function at (returned_stress, returned_intnl). Otherwise: the yield function at (trial_stress, intnl_old)
[out]trial_stress_inadmissibleShould 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 220 of file TensorMechanicsPlasticModel.C.

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

230 {
231  trial_stress_inadmissible = false;
232  yieldFunctionV(trial_stress, intnl_old, yf);
233 
234  for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
235  if (yf[sf] > _f_tol)
236  trial_stress_inadmissible = true;
237 
238  // example of checking Kuhn-Tucker
239  std::vector<Real> dpm(numberSurfaces(), 0);
240  for (unsigned sf = 0; sf < numberSurfaces(); ++sf)
241  if (!KuhnTuckerSingleSurface(yf[sf], dpm[sf], 0))
242  return false;
243  return true;
244 }
bool KuhnTuckerSingleSurface(Real yf, Real dpm, Real dpm_tol) const
Returns true if the Kuhn-Tucker conditions for the single surface are satisfied.
virtual unsigned int numberSurfaces() const
The number of yield surfaces for this plasticity model.
virtual void yieldFunctionV(const RankTwoTensor &stress, Real intnl, std::vector< Real > &f) const
Calculates the yield functions.
const Real _f_tol
Tolerance on yield function.

◆ smooth()

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

returns the 'a' parameter - see doco for _tip_scheme

Definition at line 452 of file TensorMechanicsPlasticMohrCoulomb.C.

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

453 {
454  Real smoother2 = _small_smoother2;
455  if (_tip_scheme == "cap")
456  {
457  Real x = stress.trace() / 3.0 - _cap_start;
458  Real p = 0;
459  if (x > 0)
460  p = x * (1 - std::exp(-_cap_rate * x));
461  smoother2 += Utility::pow<2>(p);
462  }
463  return smoother2;
464 }
Real _cap_start
smoothing parameter dictating when the &#39;cap&#39; will start - see doco for _tip_scheme ...
Real _cap_rate
dictates how quickly the &#39;cap&#39; degenerates to a hemisphere - see doco for _tip_scheme ...
MooseEnum _tip_scheme
The yield function is modified to f = s_m*sinphi + sqrt(a + s_bar^2 K^2) - C*cosphi where "a" depends...
Real _small_smoother2
Square of tip smoothing parameter to smooth the cone at mean_stress = T.

◆ 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 214 of file TensorMechanicsPlasticModel.C.

215 {
216  return false;
217 }

◆ 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 208 of file TensorMechanicsPlasticModel.C.

209 {
210  return false;
211 }

◆ 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
stressthe stress at which to calculate the yield function
intnlinternal parameter
Returns
the yield function

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 116 of file TensorMechanicsPlasticMohrCoulomb.C.

117 {
118  Real mean_stress = stress.trace() / 3.0;
119  Real sinphi = std::sin(phi(intnl));
120  Real cosphi = std::cos(phi(intnl));
121  Real sin3Lode = stress.sin3Lode(_lode_cutoff, 0);
122  if (std::abs(sin3Lode) <= _sin3tt)
123  {
124  // the non-edge-smoothed version
125  std::vector<Real> eigvals;
126  stress.symmetricEigenvalues(eigvals);
127  return mean_stress * sinphi +
128  std::sqrt(smooth(stress) +
129  0.25 * Utility::pow<2>(eigvals[2] - eigvals[0] +
130  (eigvals[2] + eigvals[0] - 2 * mean_stress) * sinphi)) -
131  cohesion(intnl) * cosphi;
132  }
133  else
134  {
135  // the edge-smoothed version
136  Real aaa, bbb, ccc;
137  abbo(sin3Lode, sinphi, aaa, bbb, ccc);
138  Real kk = aaa + bbb * sin3Lode + ccc * Utility::pow<2>(sin3Lode);
139  Real sibar2 = stress.secondInvariant();
140  return mean_stress * sinphi + std::sqrt(smooth(stress) + sibar2 * Utility::pow<2>(kk)) -
141  cohesion(intnl) * cosphi;
142  }
143 }
Real _lode_cutoff
if secondInvariant < _lode_cutoff then set Lode angle to zero. This is to guard against precision-los...
virtual Real smooth(const RankTwoTensor &stress) const
returns the &#39;a&#39; parameter - see doco for _tip_scheme
void abbo(const Real sin3lode, const Real sin_angle, Real &aaa, Real &bbb, Real &ccc) const
Computes Abbo et al&#39;s A, B and C parameters.
virtual Real phi(const Real internal_param) const
friction angle as a function of internal parameter
Real _sin3tt
sin(3*_tt) - useful for making comparisons with Lode angle
virtual Real cohesion(const Real internal_param) const
cohesion as a function of internal parameter

◆ 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
stressthe stress at which to calculate the yield function
intnlinternal parameter
[out]fthe yield functions

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 68 of file TensorMechanicsPlasticModel.C.

Referenced by TensorMechanicsPlasticModel::returnMap().

71 {
72  f.assign(1, yieldFunction(stress, intnl));
73 }
virtual Real yieldFunction(const RankTwoTensor &stress, Real intnl) const
The following functions are what you should override when building single-plasticity models...

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 80 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 77 of file TensorMechanicsPlasticMohrCoulomb.h.

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

◆ _cohesion

const TensorMechanicsHardeningModel& TensorMechanicsPlasticMohrCoulomb::_cohesion
protected

Hardening model for cohesion.

Definition at line 55 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by cohesion(), and dcohesion().

◆ _cos3tt

Real TensorMechanicsPlasticMohrCoulomb::_cos3tt
protected

cos(3*_tt)

Definition at line 92 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _cos6tt

Real TensorMechanicsPlasticMohrCoulomb::_cos6tt
protected

cos(6*_tt)

Definition at line 98 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _costt

Real TensorMechanicsPlasticMohrCoulomb::_costt
protected

cos(_tt)

Definition at line 86 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _f_tol

const Real TensorMechanicsPlasticModel::_f_tol
inherited

◆ _ic_tol

const Real TensorMechanicsPlasticModel::_ic_tol
inherited

Tolerance on internal constraint.

Definition at line 177 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 104 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 58 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by dphi(), and phi().

◆ _psi

const TensorMechanicsHardeningModel& TensorMechanicsPlasticMohrCoulomb::_psi
protected

Hardening model for psi.

Definition at line 61 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 95 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 101 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by abbo(), and dabbo().

◆ _sintt

Real TensorMechanicsPlasticMohrCoulomb::_sintt
protected

sin(_tt)

Definition at line 89 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 74 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 71 of file TensorMechanicsPlasticMohrCoulomb.h.

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

◆ _tt

Real TensorMechanicsPlasticMohrCoulomb::_tt
protected

edge smoothing parameter, in radians

Definition at line 83 of file TensorMechanicsPlasticMohrCoulomb.h.

Referenced by TensorMechanicsPlasticMohrCoulomb().


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