www.mooseframework.org
FiniteStrainHyperElasticViscoPlastic.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
3 /* */
4 /* All contents are licensed under LGPL V2.1 */
5 /* See LICENSE for full restrictions */
6 /****************************************************************/
8 #include "libmesh/utility.h"
9 
10 template <>
11 InputParameters
13 {
14  InputParameters params = validParams<ComputeStressBase>();
15  params.addParam<Real>(
16  "resid_abs_tol", 1e-10, "Absolute Tolerance for flow rate residual equation");
17  params.addParam<Real>(
18  "resid_rel_tol", 1e-6, "Relative Tolerance for flow rate residual equation");
19  params.addParam<unsigned int>("maxiters", 50, "Maximum iteration for flow rate update");
20  params.addParam<unsigned int>("max_substep_iteration", 1, "Maximum number of substep iteration");
21  params.addParam<std::vector<UserObjectName>>(
22  "flow_rate_user_objects",
23  "List of User object names that computes flow rate and derivatives");
24  params.addParam<std::vector<UserObjectName>>(
25  "strength_user_objects",
26  "List of User object names that computes strength variables and derivatives");
27  params.addParam<std::vector<UserObjectName>>(
28  "internal_var_user_objects",
29  "List of User object names that integrates internal variables and computes derivatives");
30  params.addParam<std::vector<UserObjectName>>(
31  "internal_var_rate_user_objects",
32  "List of User object names that computes internal variable rates and derivatives");
33  params.addClassDescription("Material class for hyper-elastic visco-platic flow: Can handle "
34  "multiple flow models defined by flowratemodel type user objects");
35 
36  return params;
37 }
38 
40  const InputParameters & parameters)
41  : ComputeStressBase(parameters),
42  _resid_abs_tol(getParam<Real>("resid_abs_tol")),
43  _resid_rel_tol(getParam<Real>("resid_rel_tol")),
44  _maxiters(getParam<unsigned int>("maxiters")),
45  _max_substep_iter(getParam<unsigned int>("max_substep_iteration")),
46  _flow_rate_uo_names(isParamValid("flow_rate_user_objects")
47  ? getParam<std::vector<UserObjectName>>("flow_rate_user_objects")
48  : std::vector<UserObjectName>(0)),
49  _strength_uo_names(isParamValid("strength_user_objects")
50  ? getParam<std::vector<UserObjectName>>("strength_user_objects")
51  : std::vector<UserObjectName>(0)),
52  _int_var_uo_names(isParamValid("internal_var_user_objects")
53  ? getParam<std::vector<UserObjectName>>("internal_var_user_objects")
54  : std::vector<UserObjectName>(0)),
55  _int_var_rate_uo_names(
56  isParamValid("internal_var_rate_user_objects")
57  ? getParam<std::vector<UserObjectName>>("internal_var_rate_user_objects")
58  : std::vector<UserObjectName>(0)),
59  _pk2_prop_name(_base_name + "pk2"),
60  _pk2(declareProperty<RankTwoTensor>(_pk2_prop_name)),
61  _fp(declareProperty<RankTwoTensor>(_base_name + "fp")),
62  _fp_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "fp")),
63  _ce(declareProperty<RankTwoTensor>(_base_name + "ce")),
64  _deformation_gradient(getMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
65  _deformation_gradient_old(
66  getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
67  _rotation_increment(getMaterialProperty<RankTwoTensor>(_base_name + "rotation_increment"))
68 {
70 
72 
75  _resid.resize(_num_flow_rate_uos);
76 
78 }
79 
80 void
82 {
87 
92 
94 
99 
100  _int_var_old.resize(_num_int_var_uos, 0.0);
101 }
102 
103 void
105  const std::vector<UserObjectName> & uo_names, unsigned int & uo_num)
106 {
107  uo_num = uo_names.size();
108 }
109 
110 template <typename T>
111 void
112 FiniteStrainHyperElasticViscoPlastic::initProp(const std::vector<UserObjectName> & uo_names,
113  unsigned int uo_num,
114  std::vector<MaterialProperty<T> *> & uo_prop)
115 {
116  uo_prop.resize(uo_num);
117  for (unsigned int i = 0; i < uo_num; ++i)
118  uo_prop[i] = &declareProperty<T>(uo_names[i]);
119 }
120 
121 template <typename T>
122 void
124  const std::vector<UserObjectName> & uo_names,
125  unsigned int uo_num,
126  std::vector<const MaterialProperty<T> *> & uo_prop_old)
127 {
128  uo_prop_old.resize(uo_num);
129  for (unsigned int i = 0; i < uo_num; ++i)
130  uo_prop_old[i] = &getMaterialPropertyOld<T>(uo_names[i]);
131 }
132 
133 template <typename T>
134 void
135 FiniteStrainHyperElasticViscoPlastic::initUserObjects(const std::vector<UserObjectName> & uo_names,
136  unsigned int uo_num,
137  std::vector<const T *> & uo)
138 {
139  uo.resize(uo_num);
140 
141  if (uo_num == 0)
142  mooseError("Specify atleast one user object of type", typeid(T).name());
143 
144  for (unsigned int i = 0; i < uo_num; ++i)
145  uo[i] = &getUserObjectByName<T>(uo_names[i]);
146 }
147 
148 void
150 {
152  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
154 
155  _dintvar_dflowrate_tmp.resize(_num_flow_rate_uos);
156  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
158 
161  _dintvar_dflowrate.resize(_num_int_var_uos, _num_flow_rate_uos);
164  _dflowrate_dstrength.resize(_num_flow_rate_uos, _num_strength_uos);
166 
167  _dpk2_dflowrate.resize(_num_flow_rate_uos);
168  _dflowrate_dpk2.resize(_num_flow_rate_uos);
169  _dfpinv_dflowrate.resize(_num_flow_rate_uos);
170 
171  _jac.resize(_num_flow_rate_uos, _num_flow_rate_uos);
172 
173  computeDeeDce();
174 }
175 
176 void
178 {
179  _stress[_qp].zero();
180 
181  _fp[_qp].zero();
182  _fp[_qp].addIa(1.0);
183  _ce[_qp].zero();
184 
185  _pk2[_qp].zero();
186 
187  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
188  (*_flow_rate_prop[i])[_qp] = 0.0;
189 
190  for (unsigned int i = 0; i < _num_strength_uos; ++i)
191  (*_strength_prop[i])[_qp] = 0.0;
192 
193  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
194  {
195  (*_int_var_stateful_prop[i])[_qp] = 0.0;
196  // TODO: remove this nasty const_cast if you can figure out how
197  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = 0.0;
198  }
199 
200  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
201  (*_int_var_rate_prop[i])[_qp] = 0.0;
202 }
203 
204 void
206 {
207  bool converge;
208  RankTwoTensor delta_dfgrd = _deformation_gradient[_qp] - _deformation_gradient_old[_qp];
209  unsigned int num_substep = 1;
210  unsigned int substep_iter = 1;
211 
212  saveOldState();
213 
214  do
215  {
216  preSolveQp();
217 
218  converge = true;
219  _dt_substep = _dt / num_substep;
220 
221  for (unsigned int istep = 0; istep < num_substep; ++istep)
222  {
223  _dfgrd_tmp = (istep + 1) * delta_dfgrd / num_substep + _deformation_gradient_old[_qp];
224  if (!solveQp())
225  {
226  converge = false;
227  substep_iter++;
228  num_substep *= 2;
229  break;
230  }
231  }
232 
233  if (substep_iter > _max_substep_iter)
234  mooseError("Constitutive failure with substepping at quadrature point ",
235  _q_point[_qp](0),
236  " ",
237  _q_point[_qp](1),
238  " ",
239  _q_point[_qp](2));
240  } while (!converge);
241 
242  postSolveQp();
243 }
244 
245 void
247 {
248  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
250 }
251 
252 void
254 {
255  _fp_tmp_old_inv = _fp_old[_qp].inverse();
256 
257  // TODO: remove this nasty const_cast if you can figure out how
258  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
259  (*_int_var_stateful_prop[i])[_qp] =
260  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = _int_var_old[i];
261 
263 }
264 
265 bool
267 {
269  if (!solveFlowrate())
270  return false;
272 
273  return true;
274 }
275 
276 void
278 {
279  recoverOldState();
280 
281  _stress[_qp] = _fe * _pk2[_qp] * _fe.transpose() / _fe.det();
282  _fp[_qp] = _fp_tmp_inv.inverse();
283 
285 }
286 
287 void
289 {
290  // TODO: remove this nasty const_cast if you can figure out how
291  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
292  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = _int_var_old[i];
293 }
294 
295 void
297 {
298  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
299  {
300  _flow_rate(i) = 0.0;
301  (*_flow_rate_prop[i])[_qp] = 0.0;
302  }
303 
304  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
305  (*_int_var_stateful_prop[i])[_qp] = (*_int_var_stateful_prop_old[i])[_qp];
306 
309 }
310 
311 bool
313 {
314  Real resid0, rnorm;
315  unsigned int iter = 0;
316 
317 #ifdef DEBUG
318  std::vector<Real> rnormst(_maxiters + 1), flowratest(_maxiters + 1);
319 #endif
320 
322  return false;
323 
324  rnorm = computeNorm(_resid.get_values());
325  resid0 = rnorm;
326 
327 #ifdef DEBUG
328  rnormst[iter] = rnorm;
329  flowratest[iter] = computeNorm(_flow_rate.get_values());
330 #endif
331 
332  while (rnorm > _resid_abs_tol && rnorm > _resid_rel_tol * resid0 && iter < _maxiters)
333  {
335 
336  updateFlowRate();
337 
339 
341  return false;
342 
343  rnorm = computeNorm(_resid.get_values());
344  iter++;
345 
346 #ifdef DEBUG
347  rnormst[iter] = rnorm;
348  flowratest[iter] = computeNorm(_flow_rate.get_values());
349 #endif
350  }
351 
352  if (iter == _maxiters && rnorm > _resid_abs_tol && rnorm > _resid_rel_tol * resid0)
353  return false;
354 
355  return true;
356 }
357 
358 void
360 {
362 
363  // TODO: remove this nasty const_cast if you can figure out how
364  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
365  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] =
366  (*_int_var_stateful_prop[i])[_qp];
367 }
368 
369 bool
371 {
372  if (!computeIntVarRates())
373  return false;
374 
375  if (!computeIntVar())
376  return false;
377 
378  if (!computeStrength())
379  return false;
380 
383 
385  return false;
386 
387  if (!computeFlowDirection())
388  return false;
389 
390  _resid += _flow_rate;
391 
392  return true;
393 }
394 
395 void
397 {
401 
402  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
403  for (unsigned int j = 0; j < _num_strength_uos; ++j)
404  _flow_rate_uo[i]->computeDerivative(_qp, _strength_uo_names[j], _dflowrate_dstrength(i, j));
405 
406  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
407  _flow_rate_uo[i]->computeTensorDerivative(_qp, _pk2_prop_name, _dflowrate_dpk2[i]);
408 
410 
411  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
412  {
415  }
416 
417  DenseMatrix<Real> dflowrate_dflowrate;
418  dflowrate_dflowrate = _dflowrate_dstrength;
419  dflowrate_dflowrate.right_multiply(_dstrength_dintvar);
420  dflowrate_dflowrate.right_multiply(_dintvar_dflowrate);
421 
422  _jac.zero();
423  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
424  for (unsigned int j = 0; j < _num_flow_rate_uos; ++j)
425  {
426  if (i == j)
427  _jac(i, j) = 1;
428  _jac(i, j) -= dflowrate_dflowrate(i, j);
429  _jac(i, j) -= _dflowrate_dpk2[i].doubleContraction(_dpk2_dflowrate[j]);
430  }
431 }
432 
433 bool
435 {
436  for (unsigned i = 0; i < _num_flow_rate_uos; ++i)
437  {
438  if (!_flow_rate_uo[i]->computeDirection(_qp, _flow_dirn[i]))
439  return false;
440  }
441  return true;
442 }
443 
444 bool
446 {
447  Real val = 0;
448  for (unsigned i = 0; i < _num_flow_rate_uos; ++i)
449  {
450  if (_flow_rate_uo[i]->computeValue(_qp, val))
451  _resid(i) = -val;
452  else
453  return false;
454  }
455  return true;
456 }
457 
458 void
460 {
462  _pk2[_qp] = _elasticity_tensor[_qp] * _ee;
463 
464  _dce_dfe.zero();
465  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
466  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
467  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
468  {
469  _dce_dfe(i, j, k, i) = _dce_dfe(i, j, k, i) + _fe(k, j);
470  _dce_dfe(i, j, k, j) = _dce_dfe(i, j, k, j) + _fe(k, i);
471  }
472 
474 }
475 
476 void
478 {
479  RankTwoTensor iden;
480  iden.addIa(1.0);
481  _ee = 0.5 * (_ce[_qp] - iden);
482 }
483 
484 void
486 {
487  _dee_dce.zero();
488 
489  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
490  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
491  _dee_dce(i, j, i, j) = 0.5;
492 }
493 
494 void
496 {
497  _ce[_qp] = _fe.transpose() * _fe;
498 }
499 
500 void
502 {
503  RankTwoTensor iden;
504  iden.addIa(1.0);
505 
506  RankTwoTensor val;
507  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
508  val += _flow_rate(i) * _flow_dirn[i] * _dt_substep;
509 
510  _fp_tmp_inv = _fp_tmp_old_inv * (iden - val);
511  _fp_tmp_inv = std::pow(_fp_tmp_inv.det(), -1.0 / 3.0) * _fp_tmp_inv;
513 }
514 
515 void
517 {
518  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
519  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
520  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
521  _dfe_dfpinv(i, j, k, j) = _dfgrd_tmp(i, k);
522 
524 }
525 
526 Real
528 {
529  Real val = 0.0;
530  for (unsigned int i = 0; i < var.size(); ++i)
531  val += Utility::pow<2>(var[i]);
532  return std::sqrt(val);
533 }
534 
535 void
537 {
538  _jac.lu_solve(_resid, _dflow_rate);
540 
541  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
542  (*_flow_rate_prop[i])[_qp] = _flow_rate(i);
543 }
544 
545 void
547 {
548  _tan_mod = _fe.mixedProductIkJl(_fe) * _dpk2_dfe;
549  _pk2_fet = _pk2[_qp] * _fe.transpose();
550  _fe_pk2 = _fe * _pk2[_qp];
551 
552  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
553  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
554  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
555  {
556  _tan_mod(i, j, i, l) += _pk2_fet(l, j);
557  _tan_mod(i, j, j, l) += _fe_pk2(i, l);
558  }
559 
560  _tan_mod /= _fe.det();
561 
562  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
563  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
564  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
565  _dfe_df(i, j, i, l) = _fp_tmp_inv(l, j);
566 
567  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
568  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
569  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
570  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
571  _df_dstretch_inc(i, j, k, l) =
572  _rotation_increment[_qp](i, k) * _deformation_gradient_old[_qp](l, j);
573 
575 }
576 
577 bool
579 {
580  Real val = 0;
581  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
582  {
583  if (_int_var_rate_uo[i]->computeValue(_qp, val))
584  (*_int_var_rate_prop[i])[_qp] = val;
585  else
586  return false;
587  }
588  return true;
589 }
590 
591 bool
593 {
594  Real val = 0;
595  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
596  {
597  if (_int_var_uo[i]->computeValue(_qp, _dt_substep, val))
598  (*_int_var_stateful_prop[i])[_qp] = val;
599  else
600  return false;
601  }
602  return true;
603 }
604 
605 bool
607 {
608  Real val = 0;
609  for (unsigned int i = 0; i < _num_strength_uos; ++i)
610  {
611  if (_strength_uo[i]->computeValue(_qp, val))
612  (*_strength_prop[i])[_qp] = val;
613  else
614  return false;
615  }
616  return true;
617 }
618 
619 void
621 {
622  Real val = 0;
623 
624  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
625  for (unsigned int j = 0; j < _num_flow_rate_uos; ++j)
626  {
627  _int_var_rate_uo[i]->computeDerivative(_qp, _flow_rate_uo_names[j], val);
628  _dintvarrate_dflowrate[j](i) = val;
629  }
630 }
631 
632 void
634 {
635  Real val = 0;
636 
637  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
638  for (unsigned int j = 0; j < _num_int_var_rate_uos; ++j)
639  {
640  _int_var_uo[i]->computeDerivative(_qp, _dt_substep, _int_var_rate_uo_names[j], val);
641  _dintvar_dintvarrate(i, j) = val;
642  }
643 
644  _dintvar_dintvar.zero();
645 
646  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
647  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
648  {
649  if (i == j)
650  _dintvar_dintvar(i, j) = 1;
651  for (unsigned int k = 0; k < _num_int_var_rate_uos; ++k)
653  }
654 
655  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
657 
658  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
659  {
660  _dintvar_dintvar_x.zero();
662  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
664  }
665 }
666 
667 void
669 {
670  Real val = 0;
671 
672  for (unsigned int i = 0; i < _num_strength_uos; ++i)
673  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
674  {
675  _strength_uo[i]->computeDerivative(_qp, _int_var_uo_names[j], val);
676  _dstrength_dintvar(i, j) = val;
677  }
678 }
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
unsigned int _num_flow_rate_uos
Number of flow rate user objects.
unsigned int _maxiters
Maximum number of iterations.
virtual void recoverOldState()
This function restores the the old stateful properties after a successful solve.
const MaterialProperty< RankTwoTensor > & _deformation_gradient_old
ComputeStressBase is the base class for stress tensors.
std::vector< MaterialProperty< Real > * > _flow_rate_prop
void initUserObjects(const std::vector< UserObjectName > &, unsigned int, std::vector< const T * > &)
This function initializes user objects.
unsigned int _num_int_var_rate_uos
Number of internal variable rate user objects.
std::vector< DenseVector< Real > > _dintvar_dflowrate_tmp
virtual void computeElasticStrain()
Computes elastic Lagrangian strain.
void initNumUserObjects(const std::vector< UserObjectName > &, unsigned int &)
This function calculates the number of each user object type.
unsigned int _max_substep_iter
Maximum number of substep iterations.
std::vector< UserObjectName > _strength_uo_names
Names of strength user objects.
virtual void initUOVariables()
This function initializes the properties, stateful properties and user objects The properties and sta...
virtual void computeDpk2Dfpinv()
Computes derivative of PK2 stress wrt inverse of plastic deformation gradient.
const MaterialProperty< RankTwoTensor > & _fp_old
MaterialProperty< RankTwoTensor > & _stress
virtual void computeDeeDce()
Computes derivative of elastic strain w.r.t elastic Right Cauchy Green Tensor.
unsigned int _num_int_var_uos
Number of internal variable user objects.
std::vector< DenseVector< Real > > _dintvarrate_dflowrate
Jacobian variables.
Real _resid_abs_tol
Absolute tolerance for residual convergence check.
virtual bool solveFlowrate()
Solve for flow rate and state.
virtual void computeQpJacobian()
This function computes the Jacobian.
InputParameters validParams< FiniteStrainHyperElasticViscoPlastic >()
virtual void postSolveQp()
Update state for output (Outside substepping)
std::vector< UserObjectName > _flow_rate_uo_names
Names of flow rate user objects.
void computeStrengthDerivatives()
This function call user objects to compute dstrength/dintvar.
virtual void computeIntVarRateDerivatives()
This function call user objects to compute dintvar_rate/dintvar and dintvarrate/dflowrate.
virtual void initJacobianVariables()
This function initialize variables required for Jacobian calculation.
std::vector< const MaterialProperty< Real > * > _int_var_stateful_prop_old
std::vector< UserObjectName > _int_var_uo_names
Names of internal variable user objects.
virtual bool computeFlowRateResidual()
Computes flow rate residual vector.
virtual void computeFlowRateJacobian()
Computes flow rate Jacobian matrix.
std::vector< const HEVPInternalVarUOBase * > _int_var_uo
Internal variable user objects.
virtual void preSolveFlowrate()
Sets state for solve (Inside substepping)
virtual void computeIntVarDerivatives()
This function call user objects to compute dintvar/dintvar_rate and dintvar/dflowrate.
std::vector< const HEVPStrengthUOBase * > _strength_uo
Strength user objects.
virtual Real computeNorm(const std::vector< Real > &)
Computes norm of residual vector.
virtual void computeElasticPlasticDeformGrad()
Computes elastic and plastic deformation gradients.
virtual void computeQpStress()
This function computes the Cauchy stress.
unsigned int _num_strength_uos
Number of strength user objects.
std::vector< UserObjectName > _int_var_rate_uo_names
Names of internal variable rate user objects.
std::vector< const HEVPInternalVarRateUOBase * > _int_var_rate_uo
Internal variable rate user objects.
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
virtual bool computeFlowDirection()
Calls user objects to compute flow directions.
virtual void postSolveFlowrate()
Update state for output (Inside substepping)
InputParameters validParams< ComputeStressBase >()
const MaterialProperty< RankTwoTensor > & _rotation_increment
std::vector< MaterialProperty< Real > * > _int_var_stateful_prop
void initProp(const std::vector< UserObjectName > &, unsigned int, std::vector< MaterialProperty< T > * > &)
This function initializes properties for each user object.
std::vector< const HEVPFlowRateUOBase * > _flow_rate_uo
Flow rate user objects.
virtual void saveOldState()
This function saves the old stateful properties that is modified during sub stepping.
const MaterialProperty< RankFourTensor > & _elasticity_tensor
const MaterialProperty< RankTwoTensor > & _deformation_gradient
virtual void computeElasticRightCauchyGreenTensor()
Computes elastic Right Cauchy Green Tensor.
virtual void computePK2StressAndDerivative()
Computes PK2 stress and derivative w.r.t elastic Right Cauchy Green Tensor.
virtual bool computeFlowRateFunction()
Calls user objects to compute flow rates.
virtual bool computeIntVar()
This function call user objects to integrate internal variables.
std::vector< MaterialProperty< Real > * > _int_var_rate_prop
void initPropOld(const std::vector< UserObjectName > &, unsigned int, std::vector< const MaterialProperty< T > * > &)
This function initializes old for stateful properties associated with user object Only user objects t...
Real _resid_rel_tol
Relative tolerance for residual convergence check.
FiniteStrainHyperElasticViscoPlastic(const InputParameters &parameters)
virtual bool computeStrength()
This function call user objects to compute strength.
virtual void initQpStatefulProperties()
Initializes state.
virtual bool computeIntVarRates()
This function call user objects to calculate rate of internal variables.
std::vector< MaterialProperty< Real > * > _strength_prop