www.mooseframework.org
FiniteStrainHyperElasticViscoPlastic.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 #include "libmesh/utility.h"
12 
14 
15 template <>
16 InputParameters
18 {
19  InputParameters params = validParams<ComputeStressBase>();
20  params.addParam<Real>(
21  "resid_abs_tol", 1e-10, "Absolute Tolerance for flow rate residual equation");
22  params.addParam<Real>(
23  "resid_rel_tol", 1e-6, "Relative Tolerance for flow rate residual equation");
24  params.addParam<unsigned int>("maxiters", 50, "Maximum iteration for flow rate update");
25  params.addParam<unsigned int>("max_substep_iteration", 1, "Maximum number of substep iteration");
26  params.addParam<std::vector<UserObjectName>>(
27  "flow_rate_user_objects",
28  "List of User object names that computes flow rate and derivatives");
29  params.addParam<std::vector<UserObjectName>>(
30  "strength_user_objects",
31  "List of User object names that computes strength variables and derivatives");
32  params.addParam<std::vector<UserObjectName>>(
33  "internal_var_user_objects",
34  "List of User object names that integrates internal variables and computes derivatives");
35  params.addParam<std::vector<UserObjectName>>(
36  "internal_var_rate_user_objects",
37  "List of User object names that computes internal variable rates and derivatives");
38  params.addClassDescription("Material class for hyper-elastic visco-platic flow: Can handle "
39  "multiple flow models defined by flowratemodel type user objects");
40 
41  return params;
42 }
43 
45  const InputParameters & parameters)
46  : ComputeStressBase(parameters),
47  _resid_abs_tol(getParam<Real>("resid_abs_tol")),
48  _resid_rel_tol(getParam<Real>("resid_rel_tol")),
49  _maxiters(getParam<unsigned int>("maxiters")),
50  _max_substep_iter(getParam<unsigned int>("max_substep_iteration")),
51  _flow_rate_uo_names(isParamValid("flow_rate_user_objects")
52  ? getParam<std::vector<UserObjectName>>("flow_rate_user_objects")
53  : std::vector<UserObjectName>(0)),
54  _strength_uo_names(isParamValid("strength_user_objects")
55  ? getParam<std::vector<UserObjectName>>("strength_user_objects")
56  : std::vector<UserObjectName>(0)),
57  _int_var_uo_names(isParamValid("internal_var_user_objects")
58  ? getParam<std::vector<UserObjectName>>("internal_var_user_objects")
59  : std::vector<UserObjectName>(0)),
60  _int_var_rate_uo_names(
61  isParamValid("internal_var_rate_user_objects")
62  ? getParam<std::vector<UserObjectName>>("internal_var_rate_user_objects")
63  : std::vector<UserObjectName>(0)),
64  _pk2_prop_name(_base_name + "pk2"),
65  _pk2(declareProperty<RankTwoTensor>(_pk2_prop_name)),
66  _fp(declareProperty<RankTwoTensor>(_base_name + "fp")),
67  _fp_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "fp")),
68  _ce(declareProperty<RankTwoTensor>(_base_name + "ce")),
69  _elasticity_tensor_name(_base_name + "elasticity_tensor"),
70  _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_elasticity_tensor_name)),
71  _deformation_gradient(getMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
72  _deformation_gradient_old(
73  getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
74  _rotation_increment(getMaterialProperty<RankTwoTensor>(_base_name + "rotation_increment"))
75 {
77 
79 
82  _resid.resize(_num_flow_rate_uos);
83 
85 }
86 
87 void
89 {
94 
99 
101 
106 
107  _int_var_old.resize(_num_int_var_uos, 0.0);
108 }
109 
110 void
112  const std::vector<UserObjectName> & uo_names, unsigned int & uo_num)
113 {
114  uo_num = uo_names.size();
115 }
116 
117 template <typename T>
118 void
119 FiniteStrainHyperElasticViscoPlastic::initProp(const std::vector<UserObjectName> & uo_names,
120  unsigned int uo_num,
121  std::vector<MaterialProperty<T> *> & uo_prop)
122 {
123  uo_prop.resize(uo_num);
124  for (unsigned int i = 0; i < uo_num; ++i)
125  uo_prop[i] = &declareProperty<T>(uo_names[i]);
126 }
127 
128 template <typename T>
129 void
131  const std::vector<UserObjectName> & uo_names,
132  unsigned int uo_num,
133  std::vector<const MaterialProperty<T> *> & uo_prop_old)
134 {
135  uo_prop_old.resize(uo_num);
136  for (unsigned int i = 0; i < uo_num; ++i)
137  uo_prop_old[i] = &getMaterialPropertyOld<T>(uo_names[i]);
138 }
139 
140 template <typename T>
141 void
142 FiniteStrainHyperElasticViscoPlastic::initUserObjects(const std::vector<UserObjectName> & uo_names,
143  unsigned int uo_num,
144  std::vector<const T *> & uo)
145 {
146  uo.resize(uo_num);
147 
148  if (uo_num == 0)
149  mooseError("Specify atleast one user object of type", typeid(T).name());
150 
151  for (unsigned int i = 0; i < uo_num; ++i)
152  uo[i] = &getUserObjectByName<T>(uo_names[i]);
153 }
154 
155 void
157 {
159  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
161 
163  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
165 
173 
177 
179 
180  computeDeeDce();
181 }
182 
183 void
185 {
186  _stress[_qp].zero();
187  _ce[_qp].zero();
188  _pk2[_qp].zero();
189  _fp[_qp].setToIdentity();
190 
191  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
192  (*_flow_rate_prop[i])[_qp] = 0.0;
193 
194  for (unsigned int i = 0; i < _num_strength_uos; ++i)
195  (*_strength_prop[i])[_qp] = 0.0;
196 
197  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
198  {
199  (*_int_var_stateful_prop[i])[_qp] = 0.0;
200  // TODO: remove this nasty const_cast if you can figure out how
201  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = 0.0;
202  }
203 
204  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
205  (*_int_var_rate_prop[i])[_qp] = 0.0;
206 }
207 
208 void
210 {
211  bool converge;
213  unsigned int num_substep = 1;
214  unsigned int substep_iter = 1;
215 
216  saveOldState();
217 
218  do
219  {
220  preSolveQp();
221 
222  converge = true;
223  _dt_substep = _dt / num_substep;
224 
225  for (unsigned int istep = 0; istep < num_substep; ++istep)
226  {
227  _dfgrd_tmp = (istep + 1.0) * delta_dfgrd / num_substep + _deformation_gradient_old[_qp];
228  if (!solveQp())
229  {
230  converge = false;
231  substep_iter++;
232  num_substep *= 2;
233  break;
234  }
235  }
236 
237  if (substep_iter > _max_substep_iter)
238  mooseError("Constitutive failure with substepping at quadrature point ",
239  _q_point[_qp](0),
240  " ",
241  _q_point[_qp](1),
242  " ",
243  _q_point[_qp](2));
244  } while (!converge);
245 
246  postSolveQp();
247 }
248 
249 void
251 {
252  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
254 }
255 
256 void
258 {
259  _fp_tmp_old_inv = _fp_old[_qp].inverse();
260 
261  // TODO: remove this nasty const_cast if you can figure out how
262  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
263  (*_int_var_stateful_prop[i])[_qp] =
264  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = _int_var_old[i];
265 
267 }
268 
269 bool
271 {
273  if (!solveFlowrate())
274  return false;
276 
277  return true;
278 }
279 
280 void
282 {
283  recoverOldState();
284 
285  _stress[_qp] = _fe * _pk2[_qp] * _fe.transpose() / _fe.det();
286  _fp[_qp] = _fp_tmp_inv.inverse();
287 
289 }
290 
291 void
293 {
294  // TODO: remove this nasty const_cast if you can figure out how
295  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
296  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] = _int_var_old[i];
297 }
298 
299 void
301 {
302  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
303  {
304  _flow_rate(i) = 0.0;
305  (*_flow_rate_prop[i])[_qp] = 0.0;
306  }
307 
308  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
309  (*_int_var_stateful_prop[i])[_qp] = (*_int_var_stateful_prop_old[i])[_qp];
310 
313 }
314 
315 bool
317 {
318  Real resid0, rnorm;
319  unsigned int iter = 0;
320 
321 #ifdef DEBUG
322  std::vector<Real> rnormst(_maxiters + 1), flowratest(_maxiters + 1);
323 #endif
324 
326  return false;
327 
328  rnorm = computeNorm(_resid.get_values());
329  resid0 = rnorm;
330 
331 #ifdef DEBUG
332  rnormst[iter] = rnorm;
333  flowratest[iter] = computeNorm(_flow_rate.get_values());
334 #endif
335 
336  while (rnorm > _resid_abs_tol && rnorm > _resid_rel_tol * resid0 && iter < _maxiters)
337  {
339 
340  updateFlowRate();
341 
343 
345  return false;
346 
347  rnorm = computeNorm(_resid.get_values());
348  iter++;
349 
350 #ifdef DEBUG
351  rnormst[iter] = rnorm;
352  flowratest[iter] = computeNorm(_flow_rate.get_values());
353 #endif
354  }
355 
356  if (iter == _maxiters && rnorm > _resid_abs_tol && rnorm > _resid_rel_tol * resid0)
357  return false;
358 
359  return true;
360 }
361 
362 void
364 {
366 
367  // TODO: remove this nasty const_cast if you can figure out how
368  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
369  const_cast<MaterialProperty<Real> &>(*_int_var_stateful_prop_old[i])[_qp] =
370  (*_int_var_stateful_prop[i])[_qp];
371 }
372 
373 bool
375 {
376  if (!computeIntVarRates())
377  return false;
378 
379  if (!computeIntVar())
380  return false;
381 
382  if (!computeStrength())
383  return false;
384 
387 
389  return false;
390 
391  if (!computeFlowDirection())
392  return false;
393 
394  _resid += _flow_rate;
395 
396  return true;
397 }
398 
399 void
401 {
405 
406  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
407  for (unsigned int j = 0; j < _num_strength_uos; ++j)
408  _flow_rate_uo[i]->computeDerivative(_qp, _strength_uo_names[j], _dflowrate_dstrength(i, j));
409 
410  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
411  _flow_rate_uo[i]->computeTensorDerivative(_qp, _pk2_prop_name, _dflowrate_dpk2[i]);
412 
414 
415  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
416  {
419  }
420 
421  DenseMatrix<Real> dflowrate_dflowrate;
422  dflowrate_dflowrate = _dflowrate_dstrength;
423  dflowrate_dflowrate.right_multiply(_dstrength_dintvar);
424  dflowrate_dflowrate.right_multiply(_dintvar_dflowrate);
425 
426  _jac.zero();
427  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
428  for (unsigned int j = 0; j < _num_flow_rate_uos; ++j)
429  {
430  if (i == j)
431  _jac(i, j) = 1;
432  _jac(i, j) -= dflowrate_dflowrate(i, j);
433  _jac(i, j) -= _dflowrate_dpk2[i].doubleContraction(_dpk2_dflowrate[j]);
434  }
435 }
436 
437 bool
439 {
440  for (unsigned i = 0; i < _num_flow_rate_uos; ++i)
441  {
442  if (!_flow_rate_uo[i]->computeDirection(_qp, _flow_dirn[i]))
443  return false;
444  }
445  return true;
446 }
447 
448 bool
450 {
451  Real val = 0;
452  for (unsigned i = 0; i < _num_flow_rate_uos; ++i)
453  {
454  if (_flow_rate_uo[i]->computeValue(_qp, val))
455  _resid(i) = -val;
456  else
457  return false;
458  }
459  return true;
460 }
461 
462 void
464 {
466  _pk2[_qp] = _elasticity_tensor[_qp] * _ee;
467 
468  _dce_dfe.zero();
469  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
470  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
471  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
472  {
473  _dce_dfe(i, j, k, i) = _dce_dfe(i, j, k, i) + _fe(k, j);
474  _dce_dfe(i, j, k, j) = _dce_dfe(i, j, k, j) + _fe(k, i);
475  }
476 
478 }
479 
480 void
482 {
483  RankTwoTensor iden(RankTwoTensor::initIdentity);
484  _ee = 0.5 * (_ce[_qp] - iden);
485 }
486 
487 void
489 {
490  _dee_dce.zero();
491 
492  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
493  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
494  _dee_dce(i, j, i, j) = 0.5;
495 }
496 
497 void
499 {
500  _ce[_qp] = _fe.transpose() * _fe;
501 }
502 
503 void
505 {
506  RankTwoTensor iden(RankTwoTensor::initIdentity);
507 
508  RankTwoTensor val;
509  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
510  val += _flow_rate(i) * _flow_dirn[i] * _dt_substep;
511 
512  _fp_tmp_inv = _fp_tmp_old_inv * (iden - val);
513  _fp_tmp_inv = std::pow(_fp_tmp_inv.det(), -1.0 / 3.0) * _fp_tmp_inv;
515 }
516 
517 void
519 {
520  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
521  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
522  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
523  _dfe_dfpinv(i, j, k, j) = _dfgrd_tmp(i, k);
524 
526 }
527 
528 Real
530 {
531  Real val = 0.0;
532  for (unsigned int i = 0; i < var.size(); ++i)
533  val += Utility::pow<2>(var[i]);
534  return std::sqrt(val);
535 }
536 
537 void
539 {
540  _jac.lu_solve(_resid, _dflow_rate);
542 
543  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
544  (*_flow_rate_prop[i])[_qp] = _flow_rate(i);
545 }
546 
547 void
549 {
550  _tan_mod = _fe.mixedProductIkJl(_fe) * _dpk2_dfe;
551  _pk2_fet = _pk2[_qp] * _fe.transpose();
552  _fe_pk2 = _fe * _pk2[_qp];
553 
554  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
555  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
556  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
557  {
558  _tan_mod(i, j, i, l) += _pk2_fet(l, j);
559  _tan_mod(i, j, j, l) += _fe_pk2(i, l);
560  }
561 
562  _tan_mod /= _fe.det();
563 
564  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
565  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
566  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
567  _dfe_df(i, j, i, l) = _fp_tmp_inv(l, j);
568 
569  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
570  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
571  for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
572  for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
573  _df_dstretch_inc(i, j, k, l) =
574  _rotation_increment[_qp](i, k) * _deformation_gradient_old[_qp](l, j);
575 
577 }
578 
579 bool
581 {
582  Real val = 0;
583  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
584  {
585  if (_int_var_rate_uo[i]->computeValue(_qp, val))
586  (*_int_var_rate_prop[i])[_qp] = val;
587  else
588  return false;
589  }
590  return true;
591 }
592 
593 bool
595 {
596  Real val = 0;
597  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
598  {
599  if (_int_var_uo[i]->computeValue(_qp, _dt_substep, val))
600  (*_int_var_stateful_prop[i])[_qp] = val;
601  else
602  return false;
603  }
604  return true;
605 }
606 
607 bool
609 {
610  Real val = 0;
611  for (unsigned int i = 0; i < _num_strength_uos; ++i)
612  {
613  if (_strength_uo[i]->computeValue(_qp, val))
614  (*_strength_prop[i])[_qp] = val;
615  else
616  return false;
617  }
618  return true;
619 }
620 
621 void
623 {
624  Real val = 0;
625 
626  for (unsigned int i = 0; i < _num_int_var_rate_uos; ++i)
627  for (unsigned int j = 0; j < _num_flow_rate_uos; ++j)
628  {
629  _int_var_rate_uo[i]->computeDerivative(_qp, _flow_rate_uo_names[j], val);
630  _dintvarrate_dflowrate[j](i) = val;
631  }
632 }
633 
634 void
636 {
637  Real val = 0;
638 
639  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
640  for (unsigned int j = 0; j < _num_int_var_rate_uos; ++j)
641  {
642  _int_var_uo[i]->computeDerivative(_qp, _dt_substep, _int_var_rate_uo_names[j], val);
643  _dintvar_dintvarrate(i, j) = val;
644  }
645 
646  _dintvar_dintvar.zero();
647 
648  for (unsigned int i = 0; i < _num_int_var_uos; ++i)
649  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
650  {
651  if (i == j)
652  _dintvar_dintvar(i, j) = 1;
653  for (unsigned int k = 0; k < _num_int_var_rate_uos; ++k)
655  }
656 
657  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
659 
660  for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
661  {
662  _dintvar_dintvar_x.zero();
664  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
666  }
667 }
668 
669 void
671 {
672  Real val = 0;
673 
674  for (unsigned int i = 0; i < _num_strength_uos; ++i)
675  for (unsigned int j = 0; j < _num_int_var_uos; ++j)
676  {
677  _strength_uo[i]->computeDerivative(_qp, _int_var_uo_names[j], val);
678  _dstrength_dintvar(i, j) = val;
679  }
680 }
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
This class solves the viscoplastic flow rate equations in the total form Involves 4 different types o...
ComputeStressBase is the base class for stress tensors.
std::vector< MaterialProperty< Real > * > _flow_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...
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
Stress material property.
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.
registerMooseObject("TensorMechanicsApp", FiniteStrainHyperElasticViscoPlastic)
std::vector< const HEVPStrengthUOBase * > _strength_uo
Strength user objects.
const std::string name
Definition: Setup.h:21
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.
void initProp(const std::vector< UserObjectName > &, unsigned int, std::vector< MaterialProperty< T > *> &)
This function initializes properties for each user object.
virtual void postSolveFlowrate()
Update state for output (Inside substepping)
const MaterialProperty< RankTwoTensor > & _rotation_increment
std::vector< MaterialProperty< Real > * > _int_var_stateful_prop
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< RankTwoTensor > & _deformation_gradient
virtual void computeElasticRightCauchyGreenTensor()
Computes elastic Right Cauchy Green Tensor.
void initUserObjects(const std::vector< UserObjectName > &, unsigned int, std::vector< const T *> &)
This function initializes user objects.
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
Real _resid_rel_tol
Relative tolerance for residual convergence check.
FiniteStrainHyperElasticViscoPlastic(const InputParameters &parameters)
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Elasticity tensor material property.
InputParameters validParams< ComputeStressBase >()
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