https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
CosseratStressDivergenceTensors Class Reference

Computes grad_i(stress_{i component}) This is exactly the same as StressDivergenceTensors, only the Jacobian entries are correct for the Cosserat case. More...

#include <CosseratStressDivergenceTensors.h>

Inheritance diagram for CosseratStressDivergenceTensors:
[legend]

Public Types

typedef std::vector< intJvarMap
 

Public Member Functions

 CosseratStressDivergenceTensors (const InputParameters &parameters)
 
virtual void computeJacobian () override
 
virtual void computeOffDiagJacobian (unsigned int jvar) override
 
unsigned int mapJvarToCvar (unsigned int jvar)
 
int mapJvarToCvar (unsigned int jvar, const JvarMap &jvar_map)
 
bool mapJvarToCvar (unsigned int jvar, unsigned int &cvar)
 
const JvarMapgetJvarMap ()
 
const JvarMapgetParameterJvarMap (std::string parameter_name)
 

Static Public Member Functions

static InputParameters validParams ()
 

Protected Member Functions

virtual Real computeQpOffDiagJacobian (unsigned int jvar)
 
virtual void initialSetup () override
 
virtual void computeResidual () override
 
virtual Real computeQpResidual () override
 
virtual Real computeQpJacobian () override
 
virtual void computeFiniteDeformJacobian ()
 
virtual void computeAverageGradientTest ()
 
virtual void computeAverageGradientPhi ()
 

Protected Attributes

const unsigned int _nrots
 Number of Cosserat rotation variables supplied by user. More...
 
std::vector< unsigned int_wc_var
 The MOOSE variable numbers of the Cosserat rotation variables. More...
 
const std::string _base_name
 Base name of the material system that this kernel applies to. More...
 
bool _use_finite_deform_jacobian
 
const MaterialProperty< RankTwoTensor > & _stress
 The stress tensor that the divergence operator operates on. More...
 
const MaterialProperty< RankFourTensor > & _Jacobian_mult
 
std::vector< RankFourTensor_finite_deform_Jacobian_mult
 
const MaterialProperty< RankTwoTensor > * _deformation_gradient
 
const MaterialProperty< RankTwoTensor > * _deformation_gradient_old
 
const MaterialProperty< RankTwoTensor > * _rotation_increment
 
const unsigned int _component
 An integer corresponding to the direction this kernel acts in. More...
 
unsigned int _ndisp
 Coupled displacement variables. More...
 
std::vector< unsigned int_disp_var
 Displacement variables IDs. More...
 
std::vector< std::vector< const MaterialProperty< RankTwoTensor > * > > _deigenstrain_dargs
 eigen strain derivatives wrt coupled variables More...
 
const bool _out_of_plane_strain_coupled
 
const VariableValue *const _out_of_plane_strain
 
const unsigned int _out_of_plane_strain_var
 
const unsigned int _out_of_plane_direction
 
const bool _use_displaced_mesh
 Whether this object is acting on the displaced mesh. More...
 
std::vector< std::vector< Real > > _avg_grad_test
 Gradient of test function averaged over the element. Used in volumetric locking correction calculation. More...
 
std::vector< std::vector< Real > > _avg_grad_phi
 Gradient of phi function averaged over the element. Used in volumetric locking correction calculation. More...
 
bool _volumetric_locking_correction
 Flag for volumetric locking correction. More...
 
const unsigned int _n_args
 

Detailed Description

Computes grad_i(stress_{i component}) This is exactly the same as StressDivergenceTensors, only the Jacobian entries are correct for the Cosserat case.

Definition at line 21 of file CosseratStressDivergenceTensors.h.

Constructor & Destructor Documentation

◆ CosseratStressDivergenceTensors()

CosseratStressDivergenceTensors::CosseratStressDivergenceTensors ( const InputParameters parameters)

Definition at line 29 of file CosseratStressDivergenceTensors.C.

30  : StressDivergenceTensors(parameters),
31  _nrots(coupledComponents("Cosserat_rotations")),
33 {
34  for (unsigned i = 0; i < _nrots; ++i)
35  _wc_var[i] = coupled("Cosserat_rotations", i);
36 }
StressDivergenceTensors(const InputParameters &parameters)
const unsigned int _nrots
Number of Cosserat rotation variables supplied by user.
std::vector< unsigned int > _wc_var
The MOOSE variable numbers of the Cosserat rotation variables.

Member Function Documentation

◆ computeAverageGradientPhi()

void StressDivergenceTensors::computeAverageGradientPhi ( )
protectedvirtualinherited

Reimplemented in StressDivergenceRZTensors.

Definition at line 443 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeJacobian(), and StressDivergenceTensors::computeOffDiagJacobian().

444 {
445  // Calculate volume average derivatives for phi
446  _avg_grad_phi.resize(_phi.size());
447  for (_i = 0; _i < _phi.size(); ++_i)
448  {
449  _avg_grad_phi[_i].resize(3);
450  for (unsigned int component = 0; component < _mesh.dimension(); ++component)
451  {
452  _avg_grad_phi[_i][component] = 0.0;
453  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
454  _avg_grad_phi[_i][component] += _grad_phi[_i][_qp](component) * _JxW[_qp] * _coord[_qp];
455 
456  _avg_grad_phi[_i][component] /= _current_elem_volume;
457  }
458  }
459 }
std::vector< std::vector< Real > > _avg_grad_phi
Gradient of phi function averaged over the element. Used in volumetric locking correction calculation...
static const std::string component
Definition: NS.h:153

◆ computeAverageGradientTest()

void StressDivergenceTensors::computeAverageGradientTest ( )
protectedvirtualinherited

Reimplemented in StressDivergenceRZTensors.

Definition at line 427 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeJacobian(), StressDivergenceTensors::computeOffDiagJacobian(), and StressDivergenceTensors::computeResidual().

428 {
429  // Calculate volume averaged value of shape function derivative
430  _avg_grad_test.resize(_test.size());
431  for (_i = 0; _i < _test.size(); ++_i)
432  {
433  _avg_grad_test[_i].resize(3);
434  _avg_grad_test[_i][_component] = 0.0;
435  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
436  _avg_grad_test[_i][_component] += _grad_test[_i][_qp](_component) * _JxW[_qp] * _coord[_qp];
437 
438  _avg_grad_test[_i][_component] /= _current_elem_volume;
439  }
440 }
std::vector< std::vector< Real > > _avg_grad_test
Gradient of test function averaged over the element. Used in volumetric locking correction calculatio...
const unsigned int _component
An integer corresponding to the direction this kernel acts in.

◆ computeFiniteDeformJacobian()

void StressDivergenceTensors::computeFiniteDeformJacobian ( )
protectedvirtualinherited

Definition at line 369 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeJacobian(), and StressDivergenceTensors::computeOffDiagJacobian().

370 {
371  usingTensorIndices(i_, j_, k_, l_);
372  const auto I = RankTwoTensor::Identity();
373  const RankFourTensor I2 = I.times<i_, k_, j_, l_>(I);
374 
375  // Bring back to unrotated config
376  const RankTwoTensor unrotated_stress =
377  (*_rotation_increment)[_qp].transpose() * _stress[_qp] * (*_rotation_increment)[_qp];
378 
379  // Incremental deformation gradient Fhat
380  const RankTwoTensor Fhat =
381  (*_deformation_gradient)[_qp] * (*_deformation_gradient_old)[_qp].inverse();
382  const RankTwoTensor Fhatinv = Fhat.inverse();
383 
384  const RankTwoTensor rot_times_stress = (*_rotation_increment)[_qp] * unrotated_stress;
385  const RankFourTensor dstress_drot =
386  I.times<i_, k_, j_, l_>(rot_times_stress) + I.times<j_, k_, i_, l_>(rot_times_stress);
387  const RankFourTensor rot_rank_four =
388  (*_rotation_increment)[_qp].times<i_, k_, j_, l_>((*_rotation_increment)[_qp]);
389  const RankFourTensor drot_dUhatinv = Fhat.times<i_, k_, j_, l_>(I);
390 
391  const RankTwoTensor A = I - Fhatinv;
392 
393  // Ctilde = Chat^-1 - I
394  const RankTwoTensor Ctilde = A * A.transpose() - A - A.transpose();
395  const RankFourTensor dCtilde_dFhatinv =
396  -I.times<i_, k_, j_, l_>(A) - I.times<j_, k_, i_, l_>(A) + I2 + I.times<j_, k_, i_, l_>(I);
397 
398  // Second order approximation of Uhat - consistent with strain increment definition
399  // const RankTwoTensor Uhat = I - 0.5 * Ctilde - 3.0/8.0 * Ctilde * Ctilde;
400 
401  RankFourTensor dUhatinv_dCtilde =
402  0.5 * I2 - 1.0 / 8.0 * (I.times<i_, k_, j_, l_>(Ctilde) + Ctilde.times<i_, k_, j_, l_>(I));
403  RankFourTensor drot_dFhatinv = drot_dUhatinv * dUhatinv_dCtilde * dCtilde_dFhatinv;
404 
405  drot_dFhatinv -= Fhat.times<i_, k_, j_, l_>((*_rotation_increment)[_qp].transpose());
406  _finite_deform_Jacobian_mult[_qp] = dstress_drot * drot_dFhatinv;
407 
408  const RankFourTensor dstrain_increment_dCtilde =
409  -0.5 * I2 + 0.25 * (I.times<i_, k_, j_, l_>(Ctilde) + Ctilde.times<i_, k_, j_, l_>(I));
411  rot_rank_four * _Jacobian_mult[_qp] * dstrain_increment_dCtilde * dCtilde_dFhatinv;
412  _finite_deform_Jacobian_mult[_qp] += Fhat.times<j_, k_, i_, l_>(_stress[_qp]);
413 
414  const RankFourTensor dFhat_dFhatinv = -Fhat.times<i_, k_, j_, l_>(Fhat.transpose());
415  const RankTwoTensor dJ_dFhatinv = dFhat_dFhatinv.innerProductTranspose(Fhat.ddet());
416 
417  // Component from Jacobian derivative
418  _finite_deform_Jacobian_mult[_qp] += _stress[_qp].times<i_, j_, k_, l_>(dJ_dFhatinv);
419 
420  // Derivative of Fhatinv w.r.t. undisplaced coordinates
421  const RankTwoTensor Finv = (*_deformation_gradient)[_qp].inverse();
422  const RankFourTensor dFhatinv_dGradu = -Fhatinv.times<i_, k_, j_, l_>(Finv.transpose());
423  _finite_deform_Jacobian_mult[_qp] = _finite_deform_Jacobian_mult[_qp] * dFhatinv_dGradu;
424 }
RankTwoTensorTempl< Real > inverse() const
static RankTwoTensorTempl Identity()
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
const MaterialProperty< RankFourTensor > & _Jacobian_mult
RankTwoTensorTempl< Real > transpose() const
RankFourTensorTempl< Real > times(const RankTwoTensorTempl< Real > &b) const
RankTwoTensorTempl< Real > ddet() const
const MaterialProperty< RankTwoTensor > & _stress
The stress tensor that the divergence operator operates on.

◆ computeJacobian()

void StressDivergenceTensors::computeJacobian ( )
overridevirtualinherited

Definition at line 178 of file StressDivergenceTensors.C.

179 {
181  {
184  }
185 
187  {
188  _finite_deform_Jacobian_mult.resize(_qrule->n_points());
189 
190  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
192 
194  }
195  else
197 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
virtual void computeJacobian() override
virtual void computeFiniteDeformJacobian()
virtual void computeJacobian() override
Definition: ALEKernel.C:34

◆ computeOffDiagJacobian()

void StressDivergenceTensors::computeOffDiagJacobian ( unsigned int  jvar)
overridevirtualinherited

Reimplemented from JvarMapKernelInterface< ALEKernel >.

Definition at line 200 of file StressDivergenceTensors.C.

201 {
203  {
206  }
207 
209  {
210  _finite_deform_Jacobian_mult.resize(_qrule->n_points());
211 
212  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
214 
216  }
217  else
219 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
virtual void computeOffDiagJacobian(unsigned int jvar) override
Definition: ALEKernel.C:41
virtual void computeFiniteDeformJacobian()
virtual void computeOffDiagJacobian(unsigned int jvar) override

◆ computeQpJacobian()

Real StressDivergenceTensors::computeQpJacobian ( )
overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, StressDivergenceRZTensors, and DynamicStressDivergenceTensors.

Definition at line 222 of file StressDivergenceTensors.C.

Referenced by DynamicStressDivergenceTensors::computeQpJacobian().

223 {
226  _component,
227  _component,
228  _grad_test[_i][_qp],
229  _grad_phi_undisplaced[_j][_qp]);
230 
231  Real sum_C3x3 = _Jacobian_mult[_qp].sum3x3();
232  RealGradient sum_C3x1 = _Jacobian_mult[_qp].sum3x1();
233 
234  Real jacobian = 0.0;
235  // B^T_i * C * B_j
237  _Jacobian_mult[_qp], _component, _component, _grad_test[_i][_qp], _grad_phi[_j][_qp]);
238 
240  {
241  // jacobian = Bbar^T_i * C * Bbar_j where Bbar = B + Bvol
242  // jacobian = B^T_i * C * B_j + Bvol^T_i * C * Bvol_j + Bvol^T_i * C * B_j + B^T_i * C *
243  // Bvol_j
244 
245  // Bvol^T_i * C * Bvol_j
246  jacobian += sum_C3x3 * (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component)) *
247  (_avg_grad_phi[_j][_component] - _grad_phi[_j][_qp](_component)) / 9.0;
248 
249  // B^T_i * C * Bvol_j
250  jacobian += sum_C3x1(_component) * _grad_test[_i][_qp](_component) *
251  (_avg_grad_phi[_j][_component] - _grad_phi[_j][_qp](_component)) / 3.0;
252 
253  // Bvol^T_i * C * B_j
254  RankTwoTensor phi;
255  switch (_component)
256  {
257  case 0:
258  phi(0, 0) = _grad_phi[_j][_qp](0);
259  phi(0, 1) = phi(1, 0) = _grad_phi[_j][_qp](1);
260  phi(0, 2) = phi(2, 0) = _grad_phi[_j][_qp](2);
261  break;
262 
263  case 1:
264  phi(1, 1) = _grad_phi[_j][_qp](1);
265  phi(0, 1) = phi(1, 0) = _grad_phi[_j][_qp](0);
266  phi(1, 2) = phi(2, 1) = _grad_phi[_j][_qp](2);
267  break;
268 
269  case 2:
270  phi(2, 2) = _grad_phi[_j][_qp](2);
271  phi(0, 2) = phi(2, 0) = _grad_phi[_j][_qp](0);
272  phi(1, 2) = phi(2, 1) = _grad_phi[_j][_qp](1);
273  break;
274  }
275 
276  jacobian += (_Jacobian_mult[_qp] * phi).trace() *
277  (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component)) / 3.0;
278  }
279 
281  {
282  const Real out_of_plane_thickness = std::exp((*_out_of_plane_strain)[_qp]);
283  jacobian *= out_of_plane_thickness;
284  }
285 
286  return jacobian;
287 }
std::vector< std::vector< Real > > _avg_grad_phi
Gradient of phi function averaged over the element. Used in volumetric locking correction calculation...
const VariableValue *const _out_of_plane_strain
bool _volumetric_locking_correction
Flag for volumetric locking correction.
unsigned int _ndisp
Coupled displacement variables.
std::vector< std::vector< Real > > _avg_grad_test
Gradient of test function averaged over the element. Used in volumetric locking correction calculatio...
const unsigned int _component
An integer corresponding to the direction this kernel acts in.
Real elasticJacobian(const RankFourTensor &r4t, unsigned int i, unsigned int k, const RealGradient &grad_test, const RealGradient &grad_phi)
This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt u_k Jacobian entry: d(st...
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
const bool _use_displaced_mesh
Whether this object is acting on the displaced mesh.
const MaterialProperty< RankFourTensor > & _Jacobian_mult
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ computeQpOffDiagJacobian()

Real CosseratStressDivergenceTensors::computeQpOffDiagJacobian ( unsigned int  jvar)
protectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 39 of file CosseratStressDivergenceTensors.C.

40 {
41  for (unsigned int v = 0; v < _nrots; ++v)
42  if (jvar == _wc_var[v])
44  _Jacobian_mult[_qp], _component, v, _grad_test[_i][_qp], _phi[_j][_qp]);
45 
47 }
Real elasticJacobianWC(const RankFourTensor &r4t, unsigned int i, unsigned int k, const RealGradient &grad_test, Real phi)
This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt w_k (the cosserat rotati...
const unsigned int _component
An integer corresponding to the direction this kernel acts in.
virtual Real computeQpOffDiagJacobian(unsigned int jvar) override
const MaterialProperty< RankFourTensor > & _Jacobian_mult
static const std::string v
Definition: NS.h:84
const unsigned int _nrots
Number of Cosserat rotation variables supplied by user.
std::vector< unsigned int > _wc_var
The MOOSE variable numbers of the Cosserat rotation variables.

◆ computeQpResidual()

Real StressDivergenceTensors::computeQpResidual ( )
overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, StressDivergenceRZTensors, and DynamicStressDivergenceTensors.

Definition at line 160 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeResidual().

161 {
162  Real residual = _stress[_qp].row(_component) * _grad_test[_i][_qp];
163  // volumetric locking correction
165  residual += _stress[_qp].trace() / 3.0 *
166  (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component));
167 
169  {
170  const Real out_of_plane_thickness = std::exp((*_out_of_plane_strain)[_qp]);
171  residual *= out_of_plane_thickness;
172  }
173 
174  return residual;
175 }
const VariableValue *const _out_of_plane_strain
bool _volumetric_locking_correction
Flag for volumetric locking correction.
unsigned int _ndisp
Coupled displacement variables.
std::vector< std::vector< Real > > _avg_grad_test
Gradient of test function averaged over the element. Used in volumetric locking correction calculatio...
const unsigned int _component
An integer corresponding to the direction this kernel acts in.
const bool _use_displaced_mesh
Whether this object is acting on the displaced mesh.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const MaterialProperty< RankTwoTensor > & _stress
The stress tensor that the divergence operator operates on.

◆ computeResidual()

void StressDivergenceTensors::computeResidual ( )
overrideprotectedvirtualinherited

Definition at line 137 of file StressDivergenceTensors.C.

138 {
139  prepareVectorTag(_assembly, _var.number());
140 
143 
144  precalculateResidual();
145  for (_i = 0; _i < _test.size(); ++_i)
146  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
147  _local_re(_i) += _JxW[_qp] * _coord[_qp] * computeQpResidual();
148 
149  accumulateTaggedLocalResidual();
150 
151  if (_has_save_in)
152  {
153  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
154  for (const auto & var : _save_in)
155  var->sys().solution().add_vector(_local_re, var->dofIndices());
156  }
157 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
virtual Real computeQpResidual() override

◆ initialSetup()

void StressDivergenceTensors::initialSetup ( )
overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, and StressDivergenceRZTensors.

Definition at line 124 of file StressDivergenceTensors.C.

125 {
126  // check if any of the eigenstrains provide derivatives wrt variables that are not coupled
127  for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
128  validateNonlinearCoupling<RankTwoTensor>(eigenstrain_name);
129 
130  // make sure the coordinate system is cartesioan
131  if (getBlockCoordSystem() != Moose::COORD_XYZ)
132  mooseError("The coordinate system in the Problem block must be set to XYZ for cartesian "
133  "geometries.");
134 }
void mooseError(Args &&... args)

◆ validParams()

InputParameters CosseratStressDivergenceTensors::validParams ( )
static

Definition at line 20 of file CosseratStressDivergenceTensors.C.

21 {
23  params.addRequiredCoupledVar("Cosserat_rotations", "The 3 Cosserat rotation variables");
24  params.addClassDescription("Stress divergence tensor with the additional Jacobian terms for the "
25  "Cosserat rotation variables.");
26  return params;
27 }
void addRequiredCoupledVar(const std::string &name, const std::string &doc_string)
static InputParameters validParams()
void addClassDescription(const std::string &doc_string)

Member Data Documentation

◆ _avg_grad_phi

std::vector<std::vector<Real> > StressDivergenceTensors::_avg_grad_phi
protectedinherited

◆ _avg_grad_test

std::vector<std::vector<Real> > StressDivergenceTensors::_avg_grad_test
protectedinherited

◆ _base_name

const std::string StressDivergenceTensors::_base_name
protectedinherited

Base name of the material system that this kernel applies to.

Definition at line 47 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

◆ _component

const unsigned int StressDivergenceTensors::_component
protectedinherited

◆ _deformation_gradient

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient
protectedinherited

◆ _deformation_gradient_old

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient_old
protectedinherited

◆ _deigenstrain_dargs

std::vector<std::vector<const MaterialProperty<RankTwoTensor> *> > StressDivergenceTensors::_deigenstrain_dargs
protectedinherited

◆ _disp_var

std::vector<unsigned int> StressDivergenceTensors::_disp_var
protectedinherited

◆ _finite_deform_Jacobian_mult

std::vector<RankFourTensor> StressDivergenceTensors::_finite_deform_Jacobian_mult
protectedinherited

◆ _Jacobian_mult

const MaterialProperty<RankFourTensor>& StressDivergenceTensors::_Jacobian_mult
protectedinherited

◆ _ndisp

unsigned int StressDivergenceTensors::_ndisp
protectedinherited

◆ _nrots

const unsigned int CosseratStressDivergenceTensors::_nrots
protected

Number of Cosserat rotation variables supplied by user.

Definition at line 32 of file CosseratStressDivergenceTensors.h.

Referenced by computeQpOffDiagJacobian(), and CosseratStressDivergenceTensors().

◆ _out_of_plane_direction

const unsigned int StressDivergenceTensors::_out_of_plane_direction
protectedinherited

◆ _out_of_plane_strain

const VariableValue* const StressDivergenceTensors::_out_of_plane_strain
protectedinherited

◆ _out_of_plane_strain_coupled

const bool StressDivergenceTensors::_out_of_plane_strain_coupled
protectedinherited

◆ _out_of_plane_strain_var

const unsigned int StressDivergenceTensors::_out_of_plane_strain_var
protectedinherited

◆ _rotation_increment

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_rotation_increment
protectedinherited

◆ _stress

const MaterialProperty<RankTwoTensor>& StressDivergenceTensors::_stress
protectedinherited

◆ _use_displaced_mesh

const bool StressDivergenceTensors::_use_displaced_mesh
protectedinherited

Whether this object is acting on the displaced mesh.

Definition at line 79 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeQpJacobian(), and StressDivergenceTensors::computeQpResidual().

◆ _use_finite_deform_jacobian

bool StressDivergenceTensors::_use_finite_deform_jacobian
protectedinherited

◆ _volumetric_locking_correction

bool StressDivergenceTensors::_volumetric_locking_correction
protectedinherited

◆ _wc_var

std::vector<unsigned int> CosseratStressDivergenceTensors::_wc_var
protected

The MOOSE variable numbers of the Cosserat rotation variables.

Definition at line 35 of file CosseratStressDivergenceTensors.h.

Referenced by computeQpOffDiagJacobian(), and CosseratStressDivergenceTensors().


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