www.mooseframework.org
CappedDruckerPragerStressUpdate.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
11 
12 #include "libmesh/utility.h"
13 
15 
17 
18 InputParameters
20 {
21  InputParameters params = TwoParameterPlasticityStressUpdate::validParams();
22  params.addClassDescription("Capped Drucker-Prager plasticity stress calculator");
23  params.addRequiredParam<UserObjectName>(
24  "DP_model",
25  "A TensorMechanicsPlasticDruckerPrager UserObject that defines the "
26  "Drucker-Prager parameters (cohesion, friction angle and dilation angle)");
27  params.addRequiredParam<UserObjectName>(
28  "tensile_strength",
29  "A TensorMechanicsHardening UserObject that defines hardening of the "
30  "tensile strength. In physical situations this is positive (and always "
31  "must be greater than negative compressive-strength.");
32  params.addRequiredParam<UserObjectName>(
33  "compressive_strength",
34  "A TensorMechanicsHardening UserObject that defines hardening of the "
35  "compressive strength. In physical situations this is positive.");
36  params.addRequiredRangeCheckedParam<Real>(
37  "tip_smoother",
38  "tip_smoother>=0",
39  "The cone vertex at J2 = 0 will be smoothed by the given "
40  "amount. Typical value is 0.1*cohesion");
41  params.addParam<bool>("perfect_guess",
42  true,
43  "Provide a guess to the Newton-Raphson procedure "
44  "that is the result from perfect plasticity. With "
45  "severe hardening/softening this may be "
46  "suboptimal.");
47  params.addParam<bool>("small_dilation",
48  true,
49  "If true, and if the trial stress exceeds the "
50  "tensile strength, then the user guarantees that "
51  "the returned stress will be independent of the "
52  "compressive strength.");
53  return params;
54 }
55 
57  : TwoParameterPlasticityStressUpdate(parameters, 3, 2),
58  _dp(getUserObject<TensorMechanicsPlasticDruckerPrager>("DP_model")),
59  _tstrength(getUserObject<TensorMechanicsHardeningModel>("tensile_strength")),
60  _cstrength(getUserObject<TensorMechanicsHardeningModel>("compressive_strength")),
61  _small_smoother2(Utility::pow<2>(getParam<Real>("tip_smoother"))),
62  _perfect_guess(getParam<bool>("perfect_guess")),
63  _stress_return_type(StressReturnType::nothing_special),
64  _small_dilation(getParam<bool>("small_dilation")),
65  _in_q_trial(0.0)
66 {
67  // With arbitary UserObjects, it is impossible to check everything,
68  // but this will catch the common errors
70  mooseError("CappedDruckerPragerStressUpdate: Tensile strength plus compressive strength must "
71  "be greater than smoothing_tol");
72 }
73 
74 void
76 {
78 }
79 
80 void
82 {
84 }
85 
86 void
88  Real q_trial,
89  const RankTwoTensor & /*stress_trial*/,
90  const std::vector<Real> & /*intnl_old*/,
91  const std::vector<Real> & yf,
92  const RankFourTensor & /*Eijkl*/)
93 {
94  // If it's obvious, then simplify the return-type
95  if (yf[2] >= 0)
97  else if (_small_dilation && yf[1] >= 0)
99 
100  _in_q_trial = q_trial;
101 }
102 
103 void
104 CappedDruckerPragerStressUpdate::computePQ(const RankTwoTensor & stress, Real & p, Real & q) const
105 {
106  p = stress.trace();
107  q = std::sqrt(stress.secondInvariant());
108 }
109 
110 void
112  Real & Epp,
113  Real & Eqq) const
114 {
115  Epp = Eijkl.sum3x3();
116  Eqq = Eijkl(0, 1, 0, 1);
117 }
118 
119 void
121  Real q_trial,
122  Real /*p*/,
123  Real q,
124  const std::vector<Real> & intnl,
125  std::vector<std::vector<Real>> & dintnl) const
126 {
127  Real tanpsi;
128  _dp.onlyB(intnl[0], _dp.dilation, tanpsi);
129  Real dtanpsi;
130  _dp.donlyB(intnl[0], _dp.dilation, dtanpsi);
131  dintnl[0][0] = 0.0;
132  dintnl[0][1] = -1.0 / _Eqq;
133  dintnl[1][0] = -1.0 / _Epp;
134  dintnl[1][1] = tanpsi / _Eqq - (q_trial - q) * dtanpsi * dintnl[0][1] / _Eqq;
135 }
136 
137 void
139  Real q,
140  const std::vector<Real> & intnl,
141  std::vector<Real> & yf) const
142 {
143  Real aaa;
144  Real bbb;
145  _dp.bothAB(intnl[0], aaa, bbb);
146  yf[0] = std::sqrt(Utility::pow<2>(q) + _small_smoother2) + p * bbb - aaa;
147 
149  yf[1] = std::numeric_limits<Real>::lowest();
150  else
151  yf[1] = p - _tstrength.value(intnl[1]);
152 
154  yf[2] = std::numeric_limits<Real>::lowest();
155  else
156  yf[2] = -p - _cstrength.value(intnl[1]);
157 }
158 
159 void
161  Real q,
162  const std::vector<Real> & intnl,
163  std::vector<yieldAndFlow> & all_q) const
164 {
165  Real aaa;
166  Real bbb;
167  _dp.bothAB(intnl[0], aaa, bbb);
168  Real daaa;
169  Real dbbb;
170  _dp.dbothAB(intnl[0], daaa, dbbb);
171  Real tanpsi;
172  _dp.onlyB(intnl[0], _dp.dilation, tanpsi);
173  Real dtanpsi;
174  _dp.donlyB(intnl[0], _dp.dilation, dtanpsi);
175 
176  // yield function values
177  all_q[0].f = std::sqrt(Utility::pow<2>(q) + _small_smoother2) + p * bbb - aaa;
179  all_q[1].f = std::numeric_limits<Real>::lowest();
180  else
181  all_q[1].f = p - _tstrength.value(intnl[1]);
183  all_q[2].f = std::numeric_limits<Real>::lowest();
184  else
185  all_q[2].f = -p - _cstrength.value(intnl[1]);
186 
187  // d(yield Function)/d(p, q)
188  // derivatives wrt p
189  all_q[0].df[0] = bbb;
190  all_q[1].df[0] = 1.0;
191  all_q[2].df[0] = -1.0;
192 
193  // derivatives wrt q
194  if (_small_smoother2 == 0.0)
195  all_q[0].df[1] = 1.0;
196  else
197  all_q[0].df[1] = q / std::sqrt(Utility::pow<2>(q) + _small_smoother2);
198  all_q[1].df[1] = 0.0;
199  all_q[2].df[1] = 0.0;
200 
201  // d(yield Function)/d(intnl)
202  // derivatives wrt intnl[0] (shear plastic strain)
203  all_q[0].df_di[0] = p * dbbb - daaa;
204  all_q[1].df_di[0] = 0.0;
205  all_q[2].df_di[0] = 0.0;
206  // derivatives wrt intnl[q] (tensile plastic strain)
207  all_q[0].df_di[1] = 0.0;
208  all_q[1].df_di[1] = -_tstrength.derivative(intnl[1]);
209  all_q[2].df_di[1] = -_cstrength.derivative(intnl[1]);
210 
211  // d(flowPotential)/d(p, q)
212  // derivatives wrt p
213  all_q[0].dg[0] = tanpsi;
214  all_q[1].dg[0] = 1.0;
215  all_q[2].dg[0] = -1.0;
216  // derivatives wrt q
217  if (_small_smoother2 == 0.0)
218  all_q[0].dg[1] = 1.0;
219  else
220  all_q[0].dg[1] = q / std::sqrt(Utility::pow<2>(q) + _small_smoother2);
221  all_q[1].dg[1] = 0.0;
222  all_q[2].dg[1] = 0.0;
223 
224  // d2(flowPotential)/d(p, q)/d(intnl)
225  // d(dg/dp)/dintnl[0]
226  all_q[0].d2g_di[0][0] = dtanpsi;
227  all_q[1].d2g_di[0][0] = 0.0;
228  all_q[2].d2g_di[0][0] = 0.0;
229  // d(dg/dp)/dintnl[1]
230  all_q[0].d2g_di[0][1] = 0.0;
231  all_q[1].d2g_di[0][1] = 0.0;
232  all_q[2].d2g_di[0][1] = 0.0;
233  // d(dg/dq)/dintnl[0]
234  all_q[0].d2g_di[1][0] = 0.0;
235  all_q[1].d2g_di[1][0] = 0.0;
236  all_q[2].d2g_di[1][0] = 0.0;
237  // d(dg/dq)/dintnl[1]
238  all_q[0].d2g_di[1][1] = 0.0;
239  all_q[1].d2g_di[1][1] = 0.0;
240  all_q[2].d2g_di[1][1] = 0.0;
241 
242  // d2(flowPotential)/d(p, q)/d(p, q)
243  // d(dg/dp)/dp
244  all_q[0].d2g[0][0] = 0.0;
245  all_q[1].d2g[0][0] = 0.0;
246  all_q[2].d2g[0][0] = 0.0;
247  // d(dg/dp)/dq
248  all_q[0].d2g[0][1] = 0.0;
249  all_q[1].d2g[0][1] = 0.0;
250  all_q[2].d2g[0][1] = 0.0;
251  // d(dg/dq)/dp
252  all_q[0].d2g[1][0] = 0.0;
253  all_q[1].d2g[1][0] = 0.0;
254  all_q[2].d2g[1][0] = 0.0;
255  // d(dg/dq)/dq
256  if (_small_smoother2 == 0.0)
257  all_q[0].d2g[1][1] = 0.0;
258  else
259  all_q[0].d2g[1][1] = _small_smoother2 / std::pow(Utility::pow<2>(q) + _small_smoother2, 1.5);
260  all_q[1].d2g[1][1] = 0.0;
261  all_q[2].d2g[1][1] = 0.0;
262 }
263 
264 void
266  Real q_trial,
267  const std::vector<Real> & intnl_old,
268  Real & p,
269  Real & q,
270  Real & gaE,
271  std::vector<Real> & intnl) const
272 {
273  if (!_perfect_guess)
274  {
275  p = p_trial;
276  q = q_trial;
277  gaE = 0.0;
278  }
279  else
280  {
281  Real coh;
282  Real tanphi;
283  _dp.bothAB(intnl[0], coh, tanphi);
284  Real tanpsi;
285  _dp.onlyB(intnl_old[0], _dp.dilation, tanpsi);
286  const Real tens = _tstrength.value(intnl_old[1]);
287  const Real comp = _cstrength.value(intnl_old[1]);
288  const Real q_at_T = coh - tens * tanphi;
289  const Real q_at_C = coh + comp * tanphi;
290 
291  if ((p_trial >= tens) && (q_trial <= q_at_T))
292  {
293  // pure tensile failure
294  p = tens;
295  q = q_trial;
296  gaE = p_trial - p;
297  }
298  else if ((p_trial <= -comp) && (q_trial <= q_at_C))
299  {
300  // pure compressive failure
301  p = -comp;
302  q = q_trial;
303  gaE = p - p_trial;
304  }
305  else
306  {
307  // shear failure or a mixture
308  // Calculate ga assuming a pure shear failure
309  const Real ga = (q_trial + p_trial * tanphi - coh) / (_Eqq + _Epp * tanphi * tanpsi);
310  if (ga <= 0 && p_trial <= tens && p_trial >= -comp)
311  {
312  // very close to one of the rounded corners: there is no advantage to guessing the
313  // solution, so:
314  p = p_trial;
315  q = q_trial;
316  gaE = 0.0;
317  }
318  else
319  {
320  q = q_trial - _Eqq * ga;
321  if (q <= 0.0 && q_at_T <= 0.0)
322  {
323  // user has set tensile strength so large that it is irrelevant: return to the tip of the
324  // shear cone
325  q = 0.0;
326  p = coh / tanphi;
327  gaE = (p_trial - p) / tanpsi; // just a guess, based on the angle to the corner
328  }
329  else if (q <= q_at_T)
330  {
331  // pure shear is incorrect: mixture of tension and shear is correct
332  q = q_at_T;
333  p = tens;
334  gaE = (p_trial - p) / tanpsi; // just a guess, based on the angle to the corner
335  }
336  else if (q >= q_at_C)
337  {
338  // pure shear is incorrect: mixture of compression and shear is correct
339  q = q_at_C;
340  p = -comp;
341  if (p - p_trial < _Epp * tanpsi * (q_trial - q) / _Eqq)
342  // trial point is sitting almost directly above corner
343  gaE = (q_trial - q) * _Epp / _Eqq;
344  else
345  // trial point is sitting to the left of the corner
346  gaE = (p - p_trial) / tanpsi;
347  }
348  else
349  {
350  // pure shear was correct
351  p = p_trial - _Epp * ga * tanpsi;
352  gaE = ga * _Epp;
353  }
354  }
355  }
356  }
357  setIntnlValues(p_trial, q_trial, p, q, intnl_old, intnl);
358 }
359 
360 void
362  Real q_trial,
363  Real p,
364  Real q,
365  const std::vector<Real> & intnl_old,
366  std::vector<Real> & intnl) const
367 {
368  intnl[0] = intnl_old[0] + (q_trial - q) / _Eqq;
369  Real tanpsi;
370  _dp.onlyB(intnl[0], _dp.dilation, tanpsi);
371  intnl[1] = intnl_old[1] + (p_trial - p) / _Epp - (q_trial - q) * tanpsi / _Eqq;
372 }
373 
374 void
376  Real p_ok,
377  Real q_ok,
378  Real /*gaE*/,
379  const std::vector<Real> & /*intnl*/,
380  const yieldAndFlow & /*smoothed_q*/,
381  const RankFourTensor & /*Eijkl*/,
382  RankTwoTensor & stress) const
383 {
384  // stress = s_ij + de_ij tr(stress) / 3 = q / q_trial * s_ij^trial + de_ij p / 3 = q / q_trial *
385  // (stress_ij^trial - de_ij tr(stress^trial) / 3) + de_ij p / 3
386  const Real p_trial = stress_trial.trace();
387  stress = RankTwoTensor(RankTwoTensor::initIdentity) / 3.0 *
388  (p_ok - (_in_q_trial == 0.0 ? 0.0 : p_trial * q_ok / _in_q_trial));
389  if (_in_q_trial > 0)
390  stress += q_ok / _in_q_trial * stress_trial;
391 }
392 
395 {
396  return stress.dtrace();
397 }
398 
401 {
402  return RankFourTensor();
403 }
404 
407 {
408  const Real j2 = stress.secondInvariant();
409  if (j2 == 0.0)
410  return RankTwoTensor();
411  return 0.5 * stress.dsecondInvariant() / std::sqrt(j2);
412 }
413 
416 {
417  const Real j2 = stress.secondInvariant();
418  if (j2 == 0.0)
419  return RankFourTensor();
420 
421  const RankTwoTensor dj2 = stress.dsecondInvariant();
422  return -0.25 * dj2.outerProduct(dj2) / std::pow(j2, 1.5) +
423  0.5 * stress.d2secondInvariant() / std::sqrt(j2);
424 }
425 
426 void
428  Real /*p_trial*/,
429  Real /*q_trial*/,
430  const RankTwoTensor & stress,
431  Real /*p*/,
432  Real q,
433  Real gaE,
434  const yieldAndFlow & smoothed_q,
435  const RankFourTensor & Eijkl,
436  bool compute_full_tangent_operator,
437  RankFourTensor & cto) const
438 {
439  cto = Eijkl;
440  if (!compute_full_tangent_operator)
441  return;
442 
443  const RankTwoTensor s_over_q =
444  (q == 0.0 ? RankTwoTensor()
445  : (stress - stress.trace() * RankTwoTensor(RankTwoTensor::initIdentity) / 3.0) / q);
446 
447  for (unsigned i = 0; i < _tensor_dimensionality; ++i)
448  for (unsigned j = 0; j < _tensor_dimensionality; ++j)
449  for (unsigned k = 0; k < _tensor_dimensionality; ++k)
450  for (unsigned l = 0; l < _tensor_dimensionality; ++l)
451  {
452  cto(i, j, k, l) -=
453  (i == j) * (1.0 / 3.0) *
454  (_Epp * (1.0 - _dp_dpt) / 3.0 * (k == l) + s_over_q(k, l) * _Eqq * (-_dp_dqt));
455  cto(i, j, k, l) -= s_over_q(i, j) * (_Epp * (-_dq_dpt) / 3.0 * (k == l) +
456  s_over_q(k, l) * _Eqq * (1.0 - _dq_dqt));
457  }
458 
459  if (smoothed_q.dg[1] != 0.0)
460  {
461  const RankFourTensor Tijab = Eijkl * (gaE / _Epp) * smoothed_q.dg[1] * d2qdstress2(stress);
462  RankFourTensor inv = RankFourTensor(RankFourTensor::initIdentityFour) + Tijab;
463  try
464  {
465  inv = inv.transposeMajor().invSymm();
466  }
467  catch (const MooseException & e)
468  {
469  // Cannot form the inverse, so probably at some degenerate place in stress space.
470  // Just return with the "best estimate" of the cto.
471  mooseWarning("CappedDruckerPragerStressUpdate: Cannot invert 1+T in consistent tangent "
472  "operator computation at quadpoint ",
473  _qp,
474  " of element ",
475  _current_elem->id());
476  return;
477  }
478  cto = (cto.transposeMajor() * inv).transposeMajor();
479  }
480 }
CappedDruckerPragerStressUpdate::consistentTangentOperator
virtual void consistentTangentOperator(const RankTwoTensor &stress_trial, Real p_trial, Real q_trial, const RankTwoTensor &stress, Real p, Real q, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, RankFourTensor &cto) const override
Calculates the consistent tangent operator.
Definition: CappedDruckerPragerStressUpdate.C:427
CappedDruckerPragerStressUpdate::_cstrength
const TensorMechanicsHardeningModel & _cstrength
Hardening model for compressive strength.
Definition: CappedDruckerPragerStressUpdate.h:82
CappedDruckerPragerStressUpdate::preReturnMap
virtual void preReturnMap(Real p_trial, Real q_trial, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl) override
Derived classes may employ this function to record stuff or do other computations prior to the return...
Definition: CappedDruckerPragerStressUpdate.C:87
CappedDruckerPragerStressUpdate::StressReturnType::no_compression
CappedDruckerPragerStressUpdate::setStressAfterReturn
virtual void setStressAfterReturn(const RankTwoTensor &stress_trial, Real p_ok, Real q_ok, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const override
Sets stress from the admissible parameters.
Definition: CappedDruckerPragerStressUpdate.C:375
CappedDruckerPragerStressUpdate::finalizeReturnProcess
virtual void finalizeReturnProcess(const RankTwoTensor &rotation_increment) override
Derived classes may use this to perform calculations after the return-map process has completed succe...
Definition: CappedDruckerPragerStressUpdate.C:81
CappedDruckerPragerStressUpdate::validParams
static InputParameters validParams()
Definition: CappedDruckerPragerStressUpdate.C:19
CappedDruckerPragerStressUpdate::StressReturnType
StressReturnType
This allows some simplification in the return-map process.
Definition: CappedDruckerPragerStressUpdate.h:103
MultiParameterPlasticityStressUpdate::yieldAndFlow
Struct designed to hold info about a single yield function and its derivatives, as well as the flow d...
Definition: MultiParameterPlasticityStressUpdate.h:214
CappedDruckerPragerStressUpdate::d2qdstress2
virtual RankFourTensor d2qdstress2(const RankTwoTensor &stress) const override
d2(q)/d(stress)/d(stress) Derived classes must override this
Definition: CappedDruckerPragerStressUpdate.C:415
MultiParameterPlasticityStressUpdate::_smoothing_tol
const Real _smoothing_tol
Smoothing tolerance: edges of the yield surface get smoothed by this amount.
Definition: MultiParameterPlasticityStressUpdate.h:159
MultiParameterPlasticityStressUpdate::yieldAndFlow::dg
std::vector< Real > dg
Definition: MultiParameterPlasticityStressUpdate.h:219
TensorMechanicsPlasticDruckerPrager::onlyB
void onlyB(Real intnl, int fd, Real &bbb) const
Calculate bbb or bbb_flow.
Definition: TensorMechanicsPlasticDruckerPrager.C:161
pow
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Definition: ExpressionBuilder.h:673
TensorMechanicsPlasticDruckerPrager::donlyB
void donlyB(Real intnl, int fd, Real &dbbb) const
Calculate d(bbb)/d(intnl) or d(bbb_flow)/d(intnl)
Definition: TensorMechanicsPlasticDruckerPrager.C:177
TensorMechanicsPlasticDruckerPrager
Rate-independent non-associative Drucker Prager with hardening/softening.
Definition: TensorMechanicsPlasticDruckerPrager.h:27
CappedDruckerPragerStressUpdate::d2pdstress2
virtual RankFourTensor d2pdstress2(const RankTwoTensor &stress) const override
d2(p)/d(stress)/d(stress) Derived classes must override this
Definition: CappedDruckerPragerStressUpdate.C:400
TwoParameterPlasticityStressUpdate::validParams
static InputParameters validParams()
Definition: TwoParameterPlasticityStressUpdate.C:18
TwoParameterPlasticityStressUpdate::_dp_dqt
Real _dp_dqt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:63
TwoParameterPlasticityStressUpdate::_Epp
Real _Epp
elasticity tensor in p direction
Definition: TwoParameterPlasticityStressUpdate.h:49
CappedDruckerPragerStressUpdate
CappedDruckerPragerStressUpdate performs the return-map algorithm and associated stress updates for p...
Definition: CappedDruckerPragerStressUpdate.h:60
CappedDruckerPragerStressUpdate::initializeReturnProcess
virtual void initializeReturnProcess() override
Derived classes may use this to perform calculations before any return-map process is performed,...
Definition: CappedDruckerPragerStressUpdate.C:75
TensorMechanicsPlasticDruckerPrager::dilation
Definition: TensorMechanicsPlasticDruckerPrager.h:49
TwoParameterPlasticityStressUpdate::_dq_dqt
Real _dq_dqt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:65
CappedDruckerPragerStressUpdate::_small_dilation
const bool _small_dilation
If true, and if the trial stress exceeds the tensile strength, then the user gaurantees that the retu...
Definition: CappedDruckerPragerStressUpdate.h:115
TwoParameterPlasticityStressUpdate
TwoParameterPlasticityStressUpdate performs the return-map algorithm and associated stress updates fo...
Definition: TwoParameterPlasticityStressUpdate.h:29
CappedDruckerPragerStressUpdate::computeAllQ
virtual void computeAllQ(Real p, Real q, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const override
Completely fills all_q with correct values.
Definition: CappedDruckerPragerStressUpdate.C:160
CappedDruckerPragerStressUpdate::_stress_return_type
enum CappedDruckerPragerStressUpdate::StressReturnType _stress_return_type
CappedDruckerPragerStressUpdate::setEppEqq
virtual void setEppEqq(const RankFourTensor &Eijkl, Real &Epp, Real &Eqq) const override
Set Epp and Eqq based on the elasticity tensor Derived classes must override this.
Definition: CappedDruckerPragerStressUpdate.C:111
CappedDruckerPragerStressUpdate::_dp
const TensorMechanicsPlasticDruckerPrager & _dp
Hardening model for cohesion, friction and dilation angles.
Definition: CappedDruckerPragerStressUpdate.h:72
CappedDruckerPragerStressUpdate.h
CappedDruckerPragerStressUpdate::initializeVars
virtual void initializeVars(Real p_trial, Real q_trial, const std::vector< Real > &intnl_old, Real &p, Real &q, Real &gaE, std::vector< Real > &intnl) const override
Sets (p, q, gaE, intnl) at "good guesses" of the solution to the Return-Map algorithm.
Definition: CappedDruckerPragerStressUpdate.C:265
defineLegacyParams
defineLegacyParams(CappedDruckerPragerStressUpdate)
CappedDruckerPragerStressUpdate::dqdstress
virtual RankTwoTensor dqdstress(const RankTwoTensor &stress) const override
d(q)/d(stress) Derived classes must override this
Definition: CappedDruckerPragerStressUpdate.C:406
CappedDruckerPragerStressUpdate::setIntnlValues
virtual void setIntnlValues(Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const override
Sets the internal parameters based on the trial values of p and q, their current values,...
Definition: CappedDruckerPragerStressUpdate.C:361
CappedDruckerPragerStressUpdate::yieldFunctionValues
virtual void yieldFunctionValues(Real p, Real q, const std::vector< Real > &intnl, std::vector< Real > &yf) const override
Computes the values of the yield functions, given p, q and intnl parameters.
Definition: CappedDruckerPragerStressUpdate.C:138
TwoParameterPlasticityStressUpdate::_dp_dpt
Real _dp_dpt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:59
CappedDruckerPragerStressUpdate::_in_q_trial
Real _in_q_trial
trial value of q
Definition: CappedDruckerPragerStressUpdate.h:118
TensorMechanicsHardeningModel::derivative
virtual Real derivative(Real intnl) const
Definition: TensorMechanicsHardeningModel.C:47
CappedDruckerPragerStressUpdate::computePQ
virtual void computePQ(const RankTwoTensor &stress, Real &p, Real &q) const override
Computes p and q, given stress.
Definition: CappedDruckerPragerStressUpdate.C:104
CappedDruckerPragerStressUpdate::dpdstress
virtual RankTwoTensor dpdstress(const RankTwoTensor &stress) const override
d(p)/d(stress) Derived classes must override this
Definition: CappedDruckerPragerStressUpdate.C:394
CappedDruckerPragerStressUpdate::setIntnlDerivatives
virtual void setIntnlDerivatives(Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl, std::vector< std::vector< Real >> &dintnl) const override
Sets the derivatives of internal parameters, based on the trial values of p and q,...
Definition: CappedDruckerPragerStressUpdate.C:120
CappedDruckerPragerStressUpdate::_small_smoother2
const Real _small_smoother2
The cone vertex is smoothed by this amount.
Definition: CappedDruckerPragerStressUpdate.h:85
CappedDruckerPragerStressUpdate::StressReturnType::nothing_special
TensorMechanicsHardeningModel::value
virtual Real value(Real intnl) const
Definition: TensorMechanicsHardeningModel.C:45
RankTwoTensor
RankTwoTensorTempl< Real > RankTwoTensor
Definition: ACGrGrElasticDrivingForce.h:17
CappedDruckerPragerStressUpdate::_perfect_guess
const bool _perfect_guess
Initialize the NR proceedure from a guess coming from perfect plasticity.
Definition: CappedDruckerPragerStressUpdate.h:88
RankFourTensorTempl< Real >
CappedDruckerPragerStressUpdate::_tstrength
const TensorMechanicsHardeningModel & _tstrength
Hardening model for tensile strength.
Definition: CappedDruckerPragerStressUpdate.h:79
TwoParameterPlasticityStressUpdate::_dq_dpt
Real _dq_dpt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:61
RankTwoTensorTempl< Real >
TwoParameterPlasticityStressUpdate::_Eqq
Real _Eqq
elasticity tensor in q direction
Definition: TwoParameterPlasticityStressUpdate.h:52
registerMooseObject
registerMooseObject("TensorMechanicsApp", CappedDruckerPragerStressUpdate)
TensorMechanicsPlasticDruckerPrager::dbothAB
void dbothAB(Real intnl, Real &daaa, Real &dbbb) const
Calculates d(aaa)/d(intnl) and d(bbb)/d(intnl) as a function of the internal parameter intnl.
Definition: TensorMechanicsPlasticDruckerPrager.C:219
CappedDruckerPragerStressUpdate::CappedDruckerPragerStressUpdate
CappedDruckerPragerStressUpdate(const InputParameters &parameters)
Definition: CappedDruckerPragerStressUpdate.C:56
TensorMechanicsPlasticDruckerPrager::bothAB
void bothAB(Real intnl, Real &aaa, Real &bbb) const
Calculates aaa and bbb as a function of the internal parameter intnl.
Definition: TensorMechanicsPlasticDruckerPrager.C:149
CappedDruckerPragerStressUpdate::StressReturnType::no_tension
RankFourTensor
RankFourTensorTempl< Real > RankFourTensor
Definition: ACGrGrElasticDrivingForce.h:20
MultiParameterPlasticityStressUpdate::_tensor_dimensionality
constexpr static unsigned _tensor_dimensionality
Internal dimensionality of tensors (currently this is 3 throughout tensor_mechanics)
Definition: MultiParameterPlasticityStressUpdate.h:129
TensorMechanicsHardeningModel
Hardening Model base class.
Definition: TensorMechanicsHardeningModel.h:27