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:

Public Types
typedef std::vector< int >	JvarMap

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 JvarMap &	getJvarMap ()
const JvarMap &	getParameterJvarMap (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.

  : StressDivergenceTensors(parameters),
    _nrots(coupledComponents("Cosserat_rotations")),
    _wc_var(_nrots)
{
  for (unsigned i = 0; i < _nrots; ++i)
    _wc_var[i] = coupled("Cosserat_rotations", i);
}

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().

{
  // Calculate volume average derivatives for phi
  _avg_grad_phi.resize(_phi.size());
  for (_i = 0; _i < _phi.size(); ++_i)
  {
    _avg_grad_phi[_i].resize(3);
    for (unsigned int component = 0; component < _mesh.dimension(); ++component)
    {
      _avg_grad_phi[_i][component] = 0.0;
      for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
        _avg_grad_phi[_i][component] += _grad_phi[_i][_qp](component) * _JxW[_qp] * _coord[_qp];

      _avg_grad_phi[_i][component] /= _current_elem_volume;
    }
  }
}

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().

{
  // 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(3);
    _avg_grad_test[_i][_component] = 0.0;
    for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      _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.

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

{
  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;
}

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 StressDivergenceTensors::computeQpJacobian ( )

overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, StressDivergenceRZTensors, and DynamicStressDivergenceTensors.

Definition at line 222 of file StressDivergenceTensors.C.

Referenced by DynamicStressDivergenceTensors::computeQpJacobian().

{
  if (_use_finite_deform_jacobian)
    return ElasticityTensorTools::elasticJacobian(_finite_deform_Jacobian_mult[_qp],
                                                  _component,
                                                  _component,
                                                  _grad_test[_i][_qp],
                                                  _grad_phi_undisplaced[_j][_qp]);

  Real sum_C3x3 = _Jacobian_mult[_qp].sum3x3();
  RealGradient sum_C3x1 = _Jacobian_mult[_qp].sum3x1();

  Real jacobian = 0.0;
  // B^T_i * C * B_j
  jacobian += ElasticityTensorTools::elasticJacobian(
      _Jacobian_mult[_qp], _component, _component, _grad_test[_i][_qp], _grad_phi[_j][_qp]);

  if (_volumetric_locking_correction)
  {
    // jacobian = Bbar^T_i * C * Bbar_j where Bbar = B + Bvol
    // jacobian = B^T_i * C * B_j + Bvol^T_i * C * Bvol_j +  Bvol^T_i * C * B_j + B^T_i * C *
    // Bvol_j

    // Bvol^T_i * C * Bvol_j
    jacobian += sum_C3x3 * (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component)) *
                (_avg_grad_phi[_j][_component] - _grad_phi[_j][_qp](_component)) / 9.0;

    // B^T_i * C * Bvol_j
    jacobian += sum_C3x1(_component) * _grad_test[_i][_qp](_component) *
                (_avg_grad_phi[_j][_component] - _grad_phi[_j][_qp](_component)) / 3.0;

    // Bvol^T_i * C * B_j
    RankTwoTensor phi;
    switch (_component)
    {
      case 0:
        phi(0, 0) = _grad_phi[_j][_qp](0);
        phi(0, 1) = phi(1, 0) = _grad_phi[_j][_qp](1);
        phi(0, 2) = phi(2, 0) = _grad_phi[_j][_qp](2);
        break;

      case 1:
        phi(1, 1) = _grad_phi[_j][_qp](1);
        phi(0, 1) = phi(1, 0) = _grad_phi[_j][_qp](0);
        phi(1, 2) = phi(2, 1) = _grad_phi[_j][_qp](2);
        break;

      case 2:
        phi(2, 2) = _grad_phi[_j][_qp](2);
        phi(0, 2) = phi(2, 0) = _grad_phi[_j][_qp](0);
        phi(1, 2) = phi(2, 1) = _grad_phi[_j][_qp](1);
        break;
    }

    jacobian += (_Jacobian_mult[_qp] * phi).trace() *
                (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component)) / 3.0;
  }

  if (_ndisp != 3 && _out_of_plane_strain_coupled && _use_displaced_mesh)
  {
    const Real out_of_plane_thickness = std::exp((*_out_of_plane_strain)[_qp]);
    jacobian *= out_of_plane_thickness;
  }

  return jacobian;
}

computeQpOffDiagJacobian()

Real CosseratStressDivergenceTensors::computeQpOffDiagJacobian ( unsigned int  jvar )

protectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 39 of file CosseratStressDivergenceTensors.C.

{
  for (unsigned int v = 0; v < _nrots; ++v)
    if (jvar == _wc_var[v])
      return ElasticityTensorTools::elasticJacobianWC(
          _Jacobian_mult[_qp], _component, v, _grad_test[_i][_qp], _phi[_j][_qp]);

  return StressDivergenceTensors::computeQpOffDiagJacobian(jvar);
}

computeQpResidual()

Real StressDivergenceTensors::computeQpResidual ( )

overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, StressDivergenceRZTensors, and DynamicStressDivergenceTensors.

Definition at line 160 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeResidual().

{
  Real residual = _stress[_qp].row(_component) * _grad_test[_i][_qp];
  // volumetric locking correction
  if (_volumetric_locking_correction)
    residual += _stress[_qp].trace() / 3.0 *
                (_avg_grad_test[_i][_component] - _grad_test[_i][_qp](_component));

  if (_ndisp != 3 && _out_of_plane_strain_coupled && _use_displaced_mesh)
  {
    const Real out_of_plane_thickness = std::exp((*_out_of_plane_strain)[_qp]);
    residual *= out_of_plane_thickness;
  }

  return residual;
}

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 StressDivergenceTensors::initialSetup ( )

overrideprotectedvirtualinherited

Reimplemented in StressDivergenceRSphericalTensors, and StressDivergenceRZTensors.

Definition at line 124 of file StressDivergenceTensors.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);

  // make sure the coordinate system is cartesioan
  if (getBlockCoordSystem() != Moose::COORD_XYZ)
    mooseError("The coordinate system in the Problem block must be set to XYZ for cartesian "
               "geometries.");
}

validParams()

InputParameters CosseratStressDivergenceTensors::validParams ( )

static

Definition at line 20 of file CosseratStressDivergenceTensors.C.

{
  InputParameters params = StressDivergenceTensors::validParams();
  params.addRequiredCoupledVar("Cosserat_rotations", "The 3 Cosserat rotation variables");
  params.addClassDescription("Stress divergence tensor with the additional Jacobian terms for the "
                             "Cosserat rotation variables.");
  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 StressDivergenceRZTensors::calculateJacobian(), StressDivergenceRZTensors::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 82 of file StressDivergenceTensors.h.

Referenced by StressDivergenceRZTensors::calculateJacobian(), StressDivergenceRZTensors::computeAverageGradientTest(), StressDivergenceTensors::computeAverageGradientTest(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), StressDivergenceRZTensors::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 StressDivergenceRZTensors::computeAverageGradientTest(), StressDivergenceTensors::computeAverageGradientTest(), StressDivergenceRZTensors::computeQpJacobian(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceRSphericalTensors::computeQpJacobian(), computeQpOffDiagJacobian(), StressDivergenceRZTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), StressDivergenceRZTensors::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 StressDivergenceRZTensors::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(), StressDivergenceRZTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::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(), StressDivergenceRZTensors::calculateJacobian(), StressDivergenceTensors::computeFiniteDeformJacobian(), StressDivergenceTensors::computeQpJacobian(), computeQpOffDiagJacobian(), StressDivergenceRZTensors::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(), StressDivergenceRZTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), StressDivergenceRSphericalTensors::computeQpOffDiagJacobian(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceTensors::StressDivergenceTensors().

_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

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(), StressDivergenceRZTensors::computeQpResidual(), StressDivergenceTensors::computeQpResidual(), and StressDivergenceRSphericalTensors::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 StressDivergenceRZTensors::calculateJacobian(), StressDivergenceTensors::computeJacobian(), StressDivergenceTensors::computeOffDiagJacobian(), StressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), DynamicStressDivergenceTensors::computeQpResidual(), StressDivergenceRZTensors::computeQpResidual(), StressDivergenceTensors::computeQpResidual(), StressDivergenceTensors::computeResidual(), and StressDivergenceTensors::StressDivergenceTensors().

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

• solid_mechanics/include/kernels/CosseratStressDivergenceTensors.h
• solid_mechanics/src/kernels/CosseratStressDivergenceTensors.C