StressDivergenceRZTensors Class Reference

StressDivergenceRZTensors is a modification of StressDivergenceTensors to accommodate the Axisymmetric material models that use cylindrical coordinates. More...

#include <StressDivergenceRZTensors.h>

Inheritance diagram for StressDivergenceRZTensors:

Public Member Functions
	StressDivergenceRZTensors (const InputParameters &parameters)
virtual void	computeJacobian () override
virtual void	computeOffDiagJacobian (MooseVariableFEBase &jvar) override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initialSetup () override
virtual Real	computeQpResidual () override
virtual Real	computeQpJacobian () override
virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override
virtual void	computeAverageGradientTest () override
virtual void	computeAverageGradientPhi () override
Real	calculateJacobian (unsigned int ivar, unsigned int jvar)
virtual void	computeResidual () override
virtual void	computeFiniteDeformJacobian ()

Protected Attributes
const std::string	_base_name
bool	_use_finite_deform_jacobian
const MaterialProperty< RankTwoTensor > &	_stress
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
unsigned int	_ndisp
	Coupled displacement variables. More...
std::vector< unsigned int >	_disp_var
const bool	_temp_coupled
const unsigned int	_temp_var
const MaterialProperty< RankTwoTensor > *const	_deigenstrain_dT
	d(strain)/d(temperature), if computed by ComputeThermalExpansionEigenstrain More...
const bool	_out_of_plane_strain_coupled
const VariableValue *	_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...
Assembly &	_assembly_undisplaced
	undisplaced problem More...
MooseVariable &	_var_undisplaced
	Reference to this Kernel's undisplaced MooseVariable object. More...
const VariablePhiGradient &	_grad_phi_undisplaced
	Shape and test functions on the undisplaced mesh. More...
const VariableTestGradient &	_grad_test_undisplaced

Detailed Description

StressDivergenceRZTensors is a modification of StressDivergenceTensors to accommodate the Axisymmetric material models that use cylindrical coordinates.

This kernel is for symmetrical loading only. The key modifications are a result of the circumferential stress' dependence on displacement in the axial direction. Reference: Cook et.al. Concepts and Applications of Finite Element Analysis, 4th Ed. 2002. p 510. Within this kernel, '_disp_x' refers to displacement in the radial direction, u_r, and '_disp_y' refers to displacement in the axial direction, u_z. The COORD_TYPE in the Problem block must be set to RZ.

Definition at line 31 of file StressDivergenceRZTensors.h.

Constructor & Destructor Documentation

StressDivergenceRZTensors()

StressDivergenceRZTensors::StressDivergenceRZTensors

(

const InputParameters &

parameters

)

Definition at line 34 of file StressDivergenceRZTensors.C.

  : StressDivergenceTensors(parameters)
{
}

Member Function Documentation

calculateJacobian()

Real StressDivergenceRZTensors::calculateJacobian ( unsigned int  ivar, unsigned int  jvar  )

protected

Definition at line 123 of file StressDivergenceRZTensors.C.

{
  // B^T_i * C * B_j
  RealGradient test, test_z, phi, phi_z;
  Real first_term = 0.0;
  if (ivar == 0) // Case grad_test for x, requires contributions from stress_xx, stress_xy, and
                 // stress_zz
  {
    test(0) = _grad_test[_i][_qp](0);
    test(1) = _grad_test[_i][_qp](1);
    test_z(2) = _test[_i][_qp] / _q_point[_qp](0);
  }
  else // Case grad_test for y
  {
    test(0) = _grad_test[_i][_qp](0);
    test(1) = _grad_test[_i][_qp](1);
  }
 
  if (jvar == 0)
  {
    phi(0) = _grad_phi[_j][_qp](0);
    phi(1) = _grad_phi[_j][_qp](1);
    phi_z(2) = _phi[_j][_qp] / _q_point[_qp](0);
  }
  else
  {
    phi(0) = _grad_phi[_j][_qp](0);
    phi(1) = _grad_phi[_j][_qp](1);
  }
 
  if (ivar == 0 &&
      jvar == 0) // Case when both phi and test are functions of x and z; requires four terms
  {
    const Real first_sum = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, jvar, test, phi); // test_x and phi_x
    const Real second_sum = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], 2, 2, test_z, phi_z); // test_z and phi_z
    const Real mixed_sum1 = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, 2, test, phi_z); // test_x and phi_z
    const Real mixed_sum2 = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], 2, jvar, test_z, phi); // test_z and phi_x
 
    first_term = first_sum + second_sum + mixed_sum1 + mixed_sum2;
  }
  else if (ivar == 0 && jvar == 1)
  {
    const Real first_sum = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, jvar, test, phi); // test_x and phi_y
    const Real mixed_sum2 = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], 2, jvar, test_z, phi); // test_z and phi_y
 
    first_term = first_sum + mixed_sum2;
  }
  else if (ivar == 1 && jvar == 0)
  {
    const Real second_sum = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, jvar, test, phi); // test_y and phi_x
    const Real mixed_sum1 = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, 2, test, phi_z); // test_y and phi_z
 
    first_term = second_sum + mixed_sum1;
  }
  else if (ivar == 1 && jvar == 1)
    first_term = ElasticityTensorTools::elasticJacobian(
        _Jacobian_mult[_qp], ivar, jvar, test, phi); // test_y and phi_y
  else
    mooseError("Invalid component in Jacobian Calculation");
 
  Real val = 0.0;
  // volumetric locking correction
  // K = Bbar^T_i * C * Bbar^T_j where Bbar = B + Bvol
  // K = B^T_i * C * B_j + Bvol^T_i * C * Bvol_j + B^T_i * C * Bvol_j + Bvol^T_i * C * B_j
  if (_volumetric_locking_correction)
  {
    RealGradient new_test(2, 0.0);
    RealGradient new_phi(2, 0.0);
 
    new_test(0) = _grad_test[_i][_qp](0) + _test[_i][_qp] / _q_point[_qp](0);
    new_test(1) = _grad_test[_i][_qp](1);
    new_phi(0) = _grad_phi[_j][_qp](0) + _phi[_j][_qp] / _q_point[_qp](0);
    new_phi(1) = _grad_phi[_j][_qp](1);
 
    // Bvol^T_i * C * Bvol_j
    val += _Jacobian_mult[_qp].sum3x3() * (_avg_grad_test[_i][ivar] - new_test(ivar)) *
           (_avg_grad_phi[_j][jvar] - new_phi(jvar)) / 3.0;
 
    // B^T_i * C * Bvol_j
    RealGradient sum_3x1 = _Jacobian_mult[_qp].sum3x1();
    if (ivar == 0 && jvar == 0)
      val += (sum_3x1(0) * test(0) + sum_3x1(2) * test_z(2)) * (_avg_grad_phi[_j][0] - new_phi(0));
    else if (ivar == 0 && jvar == 1)
      val += (sum_3x1(0) * test(0) + sum_3x1(2) * test_z(2)) * (_avg_grad_phi[_j][1] - new_phi(1));
    else if (ivar == 1 && jvar == 0)
      val += sum_3x1(1) * test(1) * (_avg_grad_phi[_j][0] - new_phi(0));
    else
      val += sum_3x1(1) * test(1) * (_avg_grad_phi[_j][1] - new_phi(1));
 
    // Bvol^T_i * C * B_j
    // val = trace (C * B_j) *(avg_grad_test[_i][ivar] - new_test(ivar))
    if (jvar == 0)
      for (unsigned int i = 0; i < 3; ++i)
        val +=
            (_Jacobian_mult[_qp](i, i, 0, 0) * phi(0) + _Jacobian_mult[_qp](i, i, 0, 1) * phi(1) +
             _Jacobian_mult[_qp](i, i, 2, 2) * phi_z(2)) *
            (_avg_grad_test[_i][ivar] - new_test(ivar));
    else if (jvar == 1)
      for (unsigned int i = 0; i < 3; ++i)
        val +=
            (_Jacobian_mult[_qp](i, i, 0, 1) * phi(0) + _Jacobian_mult[_qp](i, i, 1, 1) * phi(1)) *
            (_avg_grad_test[_i][ivar] - new_test(ivar));
  }
 
  return val / 3.0 + first_term;
}

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

computeAverageGradientPhi()

void StressDivergenceRZTensors::computeAverageGradientPhi ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 261 of file StressDivergenceRZTensors.C.

{
  _avg_grad_phi.resize(_phi.size());
  for (_i = 0; _i < _phi.size(); ++_i)
  {
    _avg_grad_phi[_i].resize(2);
    for (unsigned int component = 0; component < 2; ++component)
    {
      _avg_grad_phi[_i][component] = 0.0;
      for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      {
        if (component == 0)
          _avg_grad_phi[_i][component] +=
              (_grad_phi[_i][_qp](component) + _phi[_i][_qp] / _q_point[_qp](0)) * _JxW[_qp] *
              _coord[_qp];
        else
          _avg_grad_phi[_i][component] += _grad_phi[_i][_qp](component) * _JxW[_qp] * _coord[_qp];
      }
      _avg_grad_phi[_i][component] /= _current_elem_volume;
    }
  }
}

computeAverageGradientTest()

void StressDivergenceRZTensors::computeAverageGradientTest ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 239 of file StressDivergenceRZTensors.C.

{
  // calculate volume averaged value of shape function derivative
  _avg_grad_test.resize(_test.size());
  for (_i = 0; _i < _test.size(); ++_i)
  {
    _avg_grad_test[_i].resize(2);
    _avg_grad_test[_i][_component] = 0.0;
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
    {
      if (_component == 0)
        _avg_grad_test[_i][_component] +=
            (_grad_test[_i][_qp](_component) + _test[_i][_qp] / _q_point[_qp](0)) * _JxW[_qp] *
            _coord[_qp];
      else
        _avg_grad_test[_i][_component] += _grad_test[_i][_qp](_component) * _JxW[_qp] * _coord[_qp];
    }
    _avg_grad_test[_i][_component] /= _current_elem_volume;
  }
}

computeFiniteDeformJacobian()

void StressDivergenceTensors::computeFiniteDeformJacobian ( )

protectedvirtualinherited

Definition at line 350 of file StressDivergenceTensors.C.

{
  const RankTwoTensor I(RankTwoTensor::initIdentity);
  const RankFourTensor II_ijkl = I.mixedProductIkJl(I);
 
  // Bring back to unrotated config
  const RankTwoTensor unrotated_stress =
      (*_rotation_increment)[_qp].transpose() * _stress[_qp] * (*_rotation_increment)[_qp];
 
  // Incremental deformation gradient Fhat
  const RankTwoTensor Fhat =
      (*_deformation_gradient)[_qp] * (*_deformation_gradient_old)[_qp].inverse();
  const RankTwoTensor Fhatinv = Fhat.inverse();
 
  const RankTwoTensor rot_times_stress = (*_rotation_increment)[_qp] * unrotated_stress;
  const RankFourTensor dstress_drot =
      I.mixedProductIkJl(rot_times_stress) + I.mixedProductJkIl(rot_times_stress);
  const RankFourTensor rot_rank_four =
      (*_rotation_increment)[_qp].mixedProductIkJl((*_rotation_increment)[_qp]);
  const RankFourTensor drot_dUhatinv = Fhat.mixedProductIkJl(I);
 
  const RankTwoTensor A = I - Fhatinv;
 
  // Ctilde = Chat^-1 - I
  const RankTwoTensor Ctilde = A * A.transpose() - A - A.transpose();
  const RankFourTensor dCtilde_dFhatinv =
      -I.mixedProductIkJl(A) - I.mixedProductJkIl(A) + II_ijkl + I.mixedProductJkIl(I);
 
  // Second order approximation of Uhat - consistent with strain increment definition
  // const RankTwoTensor Uhat = I - 0.5 * Ctilde - 3.0/8.0 * Ctilde * Ctilde;
 
  RankFourTensor dUhatinv_dCtilde =
      0.5 * II_ijkl - 1.0 / 8.0 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
  RankFourTensor drot_dFhatinv = drot_dUhatinv * dUhatinv_dCtilde * dCtilde_dFhatinv;
 
  drot_dFhatinv -= Fhat.mixedProductIkJl((*_rotation_increment)[_qp].transpose());
  _finite_deform_Jacobian_mult[_qp] = dstress_drot * drot_dFhatinv;
 
  const RankFourTensor dstrain_increment_dCtilde =
      -0.5 * II_ijkl + 0.25 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
  _finite_deform_Jacobian_mult[_qp] +=
      rot_rank_four * _Jacobian_mult[_qp] * dstrain_increment_dCtilde * dCtilde_dFhatinv;
  _finite_deform_Jacobian_mult[_qp] += Fhat.mixedProductJkIl(_stress[_qp]);
 
  const RankFourTensor dFhat_dFhatinv = -Fhat.mixedProductIkJl(Fhat.transpose());
  const RankTwoTensor dJ_dFhatinv = dFhat_dFhatinv.innerProductTranspose(Fhat.ddet());
 
  // Component from Jacobian derivative
  _finite_deform_Jacobian_mult[_qp] += _stress[_qp].outerProduct(dJ_dFhatinv);
 
  // Derivative of Fhatinv w.r.t. undisplaced coordinates
  const RankTwoTensor Finv = (*_deformation_gradient)[_qp].inverse();
  const RankFourTensor dFhatinv_dGradu = -Fhatinv.mixedProductIkJl(Finv.transpose());
  _finite_deform_Jacobian_mult[_qp] = _finite_deform_Jacobian_mult[_qp] * dFhatinv_dGradu;
}

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

computeJacobian()

void StressDivergenceTensors::computeJacobian ( )

overridevirtualinherited

Reimplemented from ALEKernel.

Definition at line 168 of file StressDivergenceTensors.C.

{
  if (_volumetric_locking_correction)
  {
    computeAverageGradientTest();
    computeAverageGradientPhi();
  }
 
  if (_use_finite_deform_jacobian)
  {
    _finite_deform_Jacobian_mult.resize(_qrule->n_points());
 
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      computeFiniteDeformJacobian();
 
    ALEKernel::computeJacobian();
  }
  else
    Kernel::computeJacobian();
}

computeOffDiagJacobian()

void StressDivergenceTensors::computeOffDiagJacobian ( MooseVariableFEBase &  jvar )

overridevirtualinherited

Reimplemented from ALEKernel.

Definition at line 190 of file StressDivergenceTensors.C.

{
  if (_volumetric_locking_correction)
  {
    computeAverageGradientPhi();
    computeAverageGradientTest();
  }
 
  if (_use_finite_deform_jacobian)
  {
    _finite_deform_Jacobian_mult.resize(_qrule->n_points());
 
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      computeFiniteDeformJacobian();
 
    ALEKernel::computeOffDiagJacobian(jvar);
  }
  else
    Kernel::computeOffDiagJacobian(jvar);
}

computeQpJacobian()

Real StressDivergenceRZTensors::computeQpJacobian ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 81 of file StressDivergenceRZTensors.C.

{
  return calculateJacobian(_component, _component);
}

computeQpOffDiagJacobian()

Real StressDivergenceRZTensors::computeQpOffDiagJacobian ( unsigned int  jvar )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 87 of file StressDivergenceRZTensors.C.

{
  for (unsigned int i = 0; i < _ndisp; ++i)
  {
    if (jvar == _disp_var[i])
      return calculateJacobian(_component, i);
  }
 
  if (_temp_coupled && jvar == _temp_var)
  {
    Real jac = 0.0;
    if (_component == 0)
    {
      for (unsigned k = 0; k < LIBMESH_DIM; ++k)
        for (unsigned l = 0; l < LIBMESH_DIM; ++l)
          jac -= (_grad_test[_i][_qp](0) * _Jacobian_mult[_qp](0, 0, k, l) +
                  _test[_i][_qp] / _q_point[_qp](0) * _Jacobian_mult[_qp](2, 2, k, l) +
                  _grad_test[_i][_qp](1) * _Jacobian_mult[_qp](0, 1, k, l)) *
                 (*_deigenstrain_dT)[_qp](k, l);
      return jac * _phi[_j][_qp];
    }
    else if (_component == 1)
    {
      for (unsigned k = 0; k < LIBMESH_DIM; ++k)
        for (unsigned l = 0; l < LIBMESH_DIM; ++l)
          jac -= (_grad_test[_i][_qp](1) * _Jacobian_mult[_qp](1, 1, k, l) +
                  _grad_test[_i][_qp](0) * _Jacobian_mult[_qp](1, 0, k, l)) *
                 (*_deigenstrain_dT)[_qp](k, l);
      return jac * _phi[_j][_qp];
    }
  }
 
  return 0.0;
}

computeQpResidual()

Real StressDivergenceRZTensors::computeQpResidual ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 51 of file StressDivergenceRZTensors.C.

{
  Real div = 0.0;
  if (_component == 0)
  {
    div = _grad_test[_i][_qp](0) * _stress[_qp](0, 0) +
          +(_test[_i][_qp] / _q_point[_qp](0)) * _stress[_qp](2, 2) +
          +_grad_test[_i][_qp](1) * _stress[_qp](0, 1); // stress_{rz}
 
    // volumetric locking correction
    if (_volumetric_locking_correction)
      div += (_avg_grad_test[_i][0] - _grad_test[_i][_qp](0) - _test[_i][_qp] / _q_point[_qp](0)) *
             (_stress[_qp].trace()) / 3.0;
  }
  else if (_component == 1)
  {
    div = _grad_test[_i][_qp](1) * _stress[_qp](1, 1) +
          +_grad_test[_i][_qp](0) * _stress[_qp](1, 0); // stress_{zr}
 
    // volumetric locking correction
    if (_volumetric_locking_correction)
      div += (_avg_grad_test[_i][1] - _grad_test[_i][_qp](1)) * (_stress[_qp].trace()) / 3.0;
  }
  else
    mooseError("Invalid component for this AxisymmetricRZ problem.");
 
  return div;
}

computeResidual()

void StressDivergenceTensors::computeResidual ( )

overrideprotectedvirtualinherited

Definition at line 126 of file StressDivergenceTensors.C.

{
  prepareVectorTag(_assembly, _var.number());
 
  if (_volumetric_locking_correction)
    computeAverageGradientTest();
 
  precalculateResidual();
  for (_i = 0; _i < _test.size(); ++_i)
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      _local_re(_i) += _JxW[_qp] * _coord[_qp] * computeQpResidual();
 
  accumulateTaggedLocalResidual();
 
  if (_has_save_in)
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    for (const auto & var : _save_in)
      var->sys().solution().add_vector(_local_re, var->dofIndices());
  }
}

initialSetup()

void StressDivergenceRZTensors::initialSetup ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 40 of file StressDivergenceRZTensors.C.

{
  if (getBlockCoordSystem() != Moose::COORD_RZ)
    mooseError("The coordinate system in the Problem block must be set to RZ for axisymmetric "
               "geometries.");
 
  if (getBlockCoordSystem() == Moose::COORD_RZ && _fe_problem.getAxisymmetricRadialCoord() != 0)
    mooseError("rz_coord_axis=Y is the only supported option for StressDivergenceRZTensors");
}

validParams()

InputParameters StressDivergenceRZTensors::validParams ( )

static

Definition at line 20 of file StressDivergenceRZTensors.C.

{
  InputParameters params = StressDivergenceTensors::validParams();
  params.addClassDescription(
      "Calculate stress divergence for an axisymmetric problem in cylindrical coordinates.");
  params.addRequiredRangeCheckedParam<unsigned int>(
      "component",
      "component < 2",
      "An integer corresponding to the direction the variable this kernel acts in. (0 "
      "refers to the radial and 1 to the axial displacement.)");
  params.set<bool>("use_displaced_mesh") = true;
  return params;
}

Member Data Documentation

_assembly_undisplaced

Assembly& ALEKernel::_assembly_undisplaced

protectedinherited

undisplaced problem

Definition at line 34 of file ALEKernel.h.

_avg_grad_phi

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

protectedinherited

Gradient of phi function averaged over the element. Used in volumetric locking correction calculation.

Definition at line 86 of file StressDivergenceTensors.h.

Referenced by calculateJacobian(), computeAverageGradientPhi(), StressDivergenceTensors::computeAverageGradientPhi(), StressDivergenceTensors::computeQpJacobian(), and StressDivergenceTensors::computeQpOffDiagJacobian().

_avg_grad_test

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

protectedinherited

Gradient of test function averaged over the element. Used in volumetric locking correction calculation.

Definition at line 83 of file StressDivergenceTensors.h.

Referenced by calculateJacobian(), computeAverageGradientTest(), StressDivergenceTensors::computeAverageGradientTest(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), computeQpResidual(), and StressDivergenceTensors::computeQpResidual().

_base_name

const std::string StressDivergenceTensors::_base_name

protectedinherited

Definition at line 50 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

_component

const unsigned int StressDivergenceTensors::_component

protectedinherited

Definition at line 62 of file StressDivergenceTensors.h.

Referenced by computeAverageGradientTest(), StressDivergenceTensors::computeAverageGradientTest(), computeQpJacobian(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceRSphericalTensors::computeQpJacobian(), CosseratStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), computeQpResidual(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceRSphericalTensors::StressDivergenceRSphericalTensors().

_deformation_gradient

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient

protectedinherited

Definition at line 57 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

_deformation_gradient_old

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient_old

protectedinherited

Definition at line 58 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

_deigenstrain_dT

const MaterialProperty<RankTwoTensor>* const StressDivergenceTensors::_deigenstrain_dT

protectedinherited

d(strain)/d(temperature), if computed by ComputeThermalExpansionEigenstrain

Definition at line 72 of file StressDivergenceTensors.h.

_disp_var

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

protectedinherited

Definition at line 66 of file StressDivergenceTensors.h.

Referenced by DynamicStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), and StressDivergenceTensors::StressDivergenceTensors().

_finite_deform_Jacobian_mult

std::vector<RankFourTensor> StressDivergenceTensors::_finite_deform_Jacobian_mult

protectedinherited

Definition at line 56 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeFiniteDeformJacobian(), StressDivergenceTensors::computeJacobian(), StressDivergenceTensors::computeOffDiagJacobian(), StressDivergenceTensors::computeQpJacobian(), and StressDivergenceTensors::computeQpOffDiagJacobian().

_grad_phi_undisplaced

const VariablePhiGradient& ALEKernel::_grad_phi_undisplaced

protectedinherited

Shape and test functions on the undisplaced mesh.

Definition at line 40 of file ALEKernel.h.

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

_grad_test_undisplaced

const VariableTestGradient& ALEKernel::_grad_test_undisplaced

protectedinherited

Definition at line 41 of file ALEKernel.h.

_Jacobian_mult

const MaterialProperty<RankFourTensor>& StressDivergenceTensors::_Jacobian_mult

protectedinherited

Definition at line 54 of file StressDivergenceTensors.h.

Referenced by StressDivergenceRSphericalTensors::calculateJacobian(), calculateJacobian(), StressDivergenceTensors::computeFiniteDeformJacobian(), StressDivergenceTensors::computeQpJacobian(), CosseratStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), and StressDivergenceTensors::computeQpOffDiagJacobian().

_ndisp

unsigned int StressDivergenceTensors::_ndisp

protectedinherited

Coupled displacement variables.

Definition at line 65 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeQpJacobian(), DynamicStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceTensors::StressDivergenceTensors().

_out_of_plane_direction

const unsigned int StressDivergenceTensors::_out_of_plane_direction

protectedinherited

Definition at line 77 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeQpOffDiagJacobian(), and StressDivergenceTensors::StressDivergenceTensors().

_out_of_plane_strain

const VariableValue* StressDivergenceTensors::_out_of_plane_strain

protectedinherited

Definition at line 75 of file StressDivergenceTensors.h.

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

_out_of_plane_strain_coupled

const bool StressDivergenceTensors::_out_of_plane_strain_coupled

protectedinherited

Definition at line 74 of file StressDivergenceTensors.h.

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

_out_of_plane_strain_var

const unsigned int StressDivergenceTensors::_out_of_plane_strain_var

protectedinherited

Definition at line 76 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeQpOffDiagJacobian().

_rotation_increment

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_rotation_increment

protectedinherited

Definition at line 59 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeFiniteDeformJacobian(), and StressDivergenceTensors::StressDivergenceTensors().

_stress

const MaterialProperty<RankTwoTensor>& StressDivergenceTensors::_stress

protectedinherited

Definition at line 53 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeFiniteDeformJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), computeQpResidual(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceRSphericalTensors::computeQpResidual().

_temp_coupled

const bool StressDivergenceTensors::_temp_coupled

protectedinherited

Definition at line 68 of file StressDivergenceTensors.h.

Referenced by DynamicStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), and StressDivergenceRSphericalTensors::computeQpOffDiagJacobian().

_temp_var

const unsigned int StressDivergenceTensors::_temp_var

protectedinherited

Definition at line 69 of file StressDivergenceTensors.h.

Referenced by DynamicStressDivergenceTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), and StressDivergenceRSphericalTensors::computeQpOffDiagJacobian().

_use_displaced_mesh

const bool StressDivergenceTensors::_use_displaced_mesh

protectedinherited

Whether this object is acting on the displaced mesh.

Definition at line 80 of file StressDivergenceTensors.h.

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

_use_finite_deform_jacobian

bool StressDivergenceTensors::_use_finite_deform_jacobian

protectedinherited

Definition at line 51 of file StressDivergenceTensors.h.

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

_var_undisplaced

MooseVariable& ALEKernel::_var_undisplaced

protectedinherited

Reference to this Kernel's undisplaced MooseVariable object.

Definition at line 37 of file ALEKernel.h.

_volumetric_locking_correction

bool StressDivergenceTensors::_volumetric_locking_correction

protectedinherited

Flag for volumetric locking correction.

Definition at line 89 of file StressDivergenceTensors.h.

Referenced by calculateJacobian(), StressDivergenceTensors::computeJacobian(), StressDivergenceTensors::computeOffDiagJacobian(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), computeQpResidual(), StressDivergenceTensors::computeQpResidual(), StressDivergenceTensors::computeResidual(), and StressDivergenceTensors::StressDivergenceTensors().

---

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

• tensor_mechanics/include/kernels/StressDivergenceRZTensors.h
• tensor_mechanics/src/kernels/StressDivergenceRZTensors.C