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

#include <StressDivergenceRZTensors.h>

Inheritance diagram for StressDivergenceRZTensors:

[legend]

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	StressDivergenceRZTensors (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 JvarMap &	getJvarMap ()

const JvarMap &	getParameterJvarMap (std::string parameter_name)

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
	Base name of the material system that this kernel applies to.

bool	_use_finite_deform_jacobian

const MaterialProperty< RankTwoTensor > &	_stress
	The stress tensor that the divergence operator operates on.

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.

unsigned int	_ndisp
	Coupled displacement variables.

std::vector< unsigned int >	_disp_var
	Displacement variables IDs.

std::vector< std::vector< const MaterialProperty< RankTwoTensor > * > >	_deigenstrain_dargs
	eigen strain derivatives wrt coupled variables

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.

std::vector< std::vector< Real > >	_avg_grad_test
	Gradient of test function averaged over the element. Used in volumetric locking correction calculation.

std::vector< std::vector< Real > >	_avg_grad_phi
	Gradient of phi function averaged over the element. Used in volumetric locking correction calculation.

bool	_volumetric_locking_correction
	Flag for volumetric locking correction.

const unsigned int	_n_args

Private Attributes
const std::size_t	_jvar_max_size

JvarMap	_jvar_map

std::map< std::string, JvarMap >	_jvar_local_map

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 27 of file StressDivergenceRZTensors.h.

Constructor & Destructor Documentation

◆ StressDivergenceRZTensors()

StressDivergenceRZTensors::StressDivergenceRZTensors ( const InputParameters & parameters )

Definition at line 32 of file StressDivergenceRZTensors.C.

  : StressDivergenceTensors(parameters)
{
}

Member Function Documentation

◆ calculateJacobian()

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

protected

Definition at line 130 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 268 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 246 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 369 of file StressDivergenceTensors.C.

{
  usingTensorIndices(i_, j_, k_, l_);
  const auto I = RankTwoTensor::Identity();
  const RankFourTensor I2 = I.times<i_, k_, j_, l_>(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.times<i_, k_, j_, l_>(rot_times_stress) + I.times<j_, k_, i_, l_>(rot_times_stress);
  const RankFourTensor rot_rank_four =
      (*_rotation_increment)[_qp].times<i_, k_, j_, l_>((*_rotation_increment)[_qp]);
  const RankFourTensor drot_dUhatinv = Fhat.times<i_, k_, j_, l_>(I);
 
  const RankTwoTensor A = I - Fhatinv;
 
  // Ctilde = Chat^-1 - I
  const RankTwoTensor Ctilde = A * A.transpose() - A - A.transpose();
  const RankFourTensor dCtilde_dFhatinv =
      -I.times<i_, k_, j_, l_>(A) - I.times<j_, k_, i_, l_>(A) + I2 + I.times<j_, k_, i_, l_>(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 * I2 - 1.0 / 8.0 * (I.times<i_, k_, j_, l_>(Ctilde) + Ctilde.times<i_, k_, j_, l_>(I));
  RankFourTensor drot_dFhatinv = drot_dUhatinv * dUhatinv_dCtilde * dCtilde_dFhatinv;
 
  drot_dFhatinv -= Fhat.times<i_, k_, j_, l_>((*_rotation_increment)[_qp].transpose());
  _finite_deform_Jacobian_mult[_qp] = dstress_drot * drot_dFhatinv;
 
  const RankFourTensor dstrain_increment_dCtilde =
      -0.5 * I2 + 0.25 * (I.times<i_, k_, j_, l_>(Ctilde) + Ctilde.times<i_, k_, j_, l_>(I));
  _finite_deform_Jacobian_mult[_qp] +=
      rot_rank_four * _Jacobian_mult[_qp] * dstrain_increment_dCtilde * dCtilde_dFhatinv;
  _finite_deform_Jacobian_mult[_qp] += Fhat.times<j_, k_, i_, l_>(_stress[_qp]);
 
  const RankFourTensor dFhat_dFhatinv = -Fhat.times<i_, k_, j_, l_>(Fhat.transpose());
  const RankTwoTensor dJ_dFhatinv = dFhat_dFhatinv.innerProductTranspose(Fhat.ddet());
 
  // Component from Jacobian derivative
  _finite_deform_Jacobian_mult[_qp] += _stress[_qp].times<i_, j_, k_, l_>(dJ_dFhatinv);
 
  // Derivative of Fhatinv w.r.t. undisplaced coordinates
  const RankTwoTensor Finv = (*_deformation_gradient)[_qp].inverse();
  const RankFourTensor dFhatinv_dGradu = -Fhatinv.times<i_, k_, j_, l_>(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

Definition at line 178 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 ( unsigned int jvar )

overridevirtualinherited

Reimplemented from JvarMapKernelInterface< ALEKernel >.

Definition at line 200 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 83 of file StressDivergenceRZTensors.C.

{
  return calculateJacobian(_component, _component);
}

◆ computeQpOffDiagJacobian()

Real StressDivergenceRZTensors::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 89 of file StressDivergenceRZTensors.C.

{
  for (unsigned int i = 0; i < _ndisp; ++i)
    if (jvar == _disp_var[i])
      return calculateJacobian(_component, i);
 
  // bail out if jvar is not coupled
  if (getJvarMap()[jvar] < 0)
    return 0.0;
 
  // off-diagonal Jacobian with respect to any other coupled variable
  const unsigned int cvar = mapJvarToCvar(jvar);
  RankTwoTensor total_deigenstrain;
  for (const auto deigenstrain_darg : _deigenstrain_dargs[cvar])
    total_deigenstrain += (*deigenstrain_darg)[_qp];
 
  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)) *
               total_deigenstrain(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)) *
               total_deigenstrain(k, l);
    return jac * _phi[_j][_qp];
  }
 
  return 0.0;
}

◆ computeQpResidual()

Real StressDivergenceRZTensors::computeQpResidual ( )

overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 53 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 137 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 38 of file StressDivergenceRZTensors.C.

{
  // check if any of the eigenstrains provide derivatives wrt variables that are not coupled
  for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
    validateNonlinearCoupling<RankTwoTensor>(eigenstrain_name);
 
  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 18 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

◆ _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 85 of file StressDivergenceTensors.h.

Referenced by calculateJacobian(), StressDivergenceTensors::computeAverageGradientPhi(), 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 82 of file StressDivergenceTensors.h.

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

◆ _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

An integer corresponding to the direction this kernel acts in.

Definition at line 62 of file StressDivergenceTensors.h.

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

◆ _deformation_gradient

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient

protectedinherited

Definition at line 56 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

◆ _deformation_gradient_old

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient_old

protectedinherited

Definition at line 57 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

◆ _deigenstrain_dargs

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

protectedinherited

eigen strain derivatives wrt coupled variables

Definition at line 71 of file StressDivergenceTensors.h.

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

◆ _disp_var

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

protectedinherited

Displacement variables IDs.

Definition at line 68 of file StressDivergenceTensors.h.

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

◆ _finite_deform_Jacobian_mult

std::vector<RankFourTensor> StressDivergenceTensors::_finite_deform_Jacobian_mult

protectedinherited

Definition at line 55 of file StressDivergenceTensors.h.

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

◆ _Jacobian_mult

const MaterialProperty<RankFourTensor>& StressDivergenceTensors::_Jacobian_mult

protectedinherited

Definition at line 53 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(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceTensors::StressDivergenceTensors().

◆ _out_of_plane_direction

const unsigned int StressDivergenceTensors::_out_of_plane_direction

protectedinherited

Definition at line 76 of file StressDivergenceTensors.h.

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

◆ _out_of_plane_strain

const VariableValue* const StressDivergenceTensors::_out_of_plane_strain

protectedinherited

Definition at line 74 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 73 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 75 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::computeQpOffDiagJacobian().

◆ _rotation_increment

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_rotation_increment

protectedinherited

Definition at line 58 of file StressDivergenceTensors.h.

Referenced by StressDivergenceTensors::StressDivergenceTensors().

◆ _stress

const MaterialProperty<RankTwoTensor>& StressDivergenceTensors::_stress

protectedinherited

The stress tensor that the divergence operator operates on.

Definition at line 52 of file StressDivergenceTensors.h.

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

◆ _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

Definition at line 49 of file StressDivergenceTensors.h.

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

◆ _volumetric_locking_correction

bool StressDivergenceTensors::_volumetric_locking_correction

protectedinherited

Flag for volumetric locking correction.

Definition at line 88 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:

solid_mechanics/include/kernels/StressDivergenceRZTensors.h
solid_mechanics/src/kernels/StressDivergenceRZTensors.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StressDivergenceRZTensors()

Member Function Documentation

◆ calculateJacobian()

◆ computeAverageGradientPhi()

◆ computeAverageGradientTest()

◆ computeFiniteDeformJacobian()

◆ computeJacobian()

◆ computeOffDiagJacobian()

◆ computeQpJacobian()

◆ computeQpOffDiagJacobian()

◆ computeQpResidual()

◆ computeResidual()

◆ initialSetup()

◆ validParams()

Member Data Documentation

◆ _avg_grad_phi

◆ _avg_grad_test

◆ _base_name

◆ _component

◆ _deformation_gradient

◆ _deformation_gradient_old

◆ _deigenstrain_dargs

◆ _disp_var

◆ _finite_deform_Jacobian_mult

◆ _Jacobian_mult

◆ _ndisp

◆ _out_of_plane_direction

◆ _out_of_plane_strain

◆ _out_of_plane_strain_coupled

◆ _out_of_plane_strain_var

◆ _rotation_increment

◆ _stress

◆ _use_displaced_mesh

◆ _use_finite_deform_jacobian

◆ _volumetric_locking_correction