Compute2DFiniteStrain defines a strain increment and a rotation increment for finite strains in 2D geometries, handling the out of plane strains. More...

#include <Compute2DFiniteStrain.h>

Inheritance diagram for Compute2DFiniteStrain:

[legend]

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	Compute2DFiniteStrain (const InputParameters &parameters)

void	initialSetup () override

virtual void	computeProperties () override

	CreateMooseEnumClass (DecompMethod, TaylorExpansion, EigenSolution, HughesWinget)

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)

void	validateDerivativeMaterialPropertyBase (const std::string &base)

const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	decompositionType ()

Protected Member Functions
virtual void	displacementIntegrityCheck () override

virtual Real	computeOutOfPlaneGradDisp ()=0
	Computes the current out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

virtual Real	computeOutOfPlaneGradDispOld ()=0
	Computes the old out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

virtual void	computeQpStrain ()

virtual void	computeQpIncrements (RankTwoTensor &e, RankTwoTensor &r)

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

Protected Attributes
const unsigned int	_out_of_plane_direction

std::vector< RankTwoTensor >	_Fhat
	Incremental deformation gradient.

const DecompMethod	_decomposition_method
	Method for determining rotation and strain increments.

const bool	_use_hw
	Flag if using HughesWinget method.

MaterialProperty< RankTwoTensor > *	_def_grad_mid
	For HughesWinget kinematics.

MaterialProperty< RankTwoTensor > *	_f_bar

std::vector< const VariableGradient * >	_grad_disp_old

MaterialProperty< RankTwoTensor > &	_strain_rate

MaterialProperty< RankTwoTensor > &	_strain_increment

MaterialProperty< RankTwoTensor > &	_rotation_increment

MaterialProperty< RankTwoTensor > &	_deformation_gradient

const MaterialProperty< RankTwoTensor > &	_mechanical_strain_old

const MaterialProperty< RankTwoTensor > &	_total_strain_old

std::vector< const MaterialProperty< RankTwoTensor > * >	_eigenstrains_old

unsigned int	_ndisp
	Coupled displacement variables.

std::vector< const VariableValue * >	_disp
	Displacement variables.

std::vector< const VariableGradient * >	_grad_disp
	Gradient of displacements.

const std::string	_base_name
	Base name of the material system.

MaterialProperty< RankTwoTensor > &	_mechanical_strain

MaterialProperty< RankTwoTensor > &	_total_strain

std::vector< MaterialPropertyName >	_eigenstrain_names

std::vector< const MaterialProperty< RankTwoTensor > * >	_eigenstrains

const MaterialProperty< RankTwoTensor > *const	_global_strain

const bool	_volumetric_locking_correction

const Real &	_current_elem_volume

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)

std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)

void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)

bool	isNotObjectVariable (const VariableName &name)

Private Attributes
FEProblemBase &	_dmi_fe_problem

Detailed Description

Compute2DFiniteStrain defines a strain increment and a rotation increment for finite strains in 2D geometries, handling the out of plane strains.

Compute2DFiniteStrain contains a virtual method to define the out-of-plane strain as a general nonzero value in the inherited classes ComputePlaneFiniteStrain and ComputeAxisymmetricRZFiniteStrain.

Definition at line 21 of file Compute2DFiniteStrain.h.

Constructor & Destructor Documentation

◆ Compute2DFiniteStrain()

Compute2DFiniteStrain::Compute2DFiniteStrain ( const InputParameters & parameters )

Definition at line 27 of file Compute2DFiniteStrain.C.

  : ComputeFiniteStrain(parameters),
    _out_of_plane_direction(getParam<MooseEnum>("out_of_plane_direction"))
{
}

Member Function Documentation

◆ computeOutOfPlaneGradDisp()

virtual Real Compute2DFiniteStrain::computeOutOfPlaneGradDisp ( )

protectedpure virtual

Computes the current out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetricRZFiniteStrain, and ComputePlaneFiniteStrain.

Referenced by computeProperties().

◆ computeOutOfPlaneGradDispOld()

virtual Real Compute2DFiniteStrain::computeOutOfPlaneGradDispOld ( )

protectedpure virtual

Computes the old out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetricRZFiniteStrain, and ComputePlaneFiniteStrain.

Referenced by computeProperties().

◆ computeProperties()

void Compute2DFiniteStrain::computeProperties ( )

overridevirtual

Definition at line 57 of file Compute2DFiniteStrain.C.

{
  RankTwoTensor ave_Fhat;
  Real ave_dfgrd_det = 0.0;
 
  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
  {
    // Deformation gradient calculation for 2D problems
    auto A = RankTwoTensor::initializeFromRows(
        (*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]);
 
    // Old Deformation gradient
    auto Fbar = RankTwoTensor::initializeFromRows(
        (*_grad_disp_old[0])[_qp], (*_grad_disp_old[1])[_qp], (*_grad_disp_old[2])[_qp]);
 
    // Compute the displacement gradient for the out of plane direction for plane strain,
    // generalized plane strain, or axisymmetric problems
 
    A(_out_of_plane_direction, _out_of_plane_direction) = computeOutOfPlaneGradDisp();
    Fbar(_out_of_plane_direction, _out_of_plane_direction) = computeOutOfPlaneGradDispOld();
 
    // Gauss point deformation gradient
    _deformation_gradient[_qp] = A;
    _deformation_gradient[_qp].addIa(1.0);
 
    // deformation gradient midpoint
    if (_use_hw)
    {
      (*_def_grad_mid)[_qp].setToIdentity();
      (*_def_grad_mid)[_qp] += 0.5 * (A + Fbar);
    }
 
    A -= Fbar; // very nearly A = gradU - gradUold
 
    // _f_bar = dDU/dX_o
    if (_use_hw)
      (*_f_bar)[_qp] = A;
 
    Fbar.addIa(1.0); // Fbar = ( I + gradUold)
 
    // Incremental deformation gradient _Fhat = I + A Fbar^-1
    _Fhat[_qp] = A * Fbar.inverse();
    _Fhat[_qp].addIa(1.0);
 
    if (_volumetric_locking_correction)
    {
      // Calculate average _Fhat for volumetric locking correction
      ave_Fhat += _Fhat[_qp] * _JxW[_qp] * _coord[_qp];
 
      // Average deformation gradient
      ave_dfgrd_det += _deformation_gradient[_qp].det() * _JxW[_qp] * _coord[_qp];
    }
  }
  if (_volumetric_locking_correction)
  {
    // needed for volumetric locking correction
    ave_Fhat /= _current_elem_volume;
    // average deformation gradient
    ave_dfgrd_det /= _current_elem_volume;
  }
  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
  {
    if (_volumetric_locking_correction)
    {
      // Finalize volumetric locking correction
      _Fhat[_qp] *= std::cbrt(ave_Fhat.det() / _Fhat[_qp].det());
      // Volumetric locking correction
      _deformation_gradient[_qp] *= std::cbrt(ave_dfgrd_det / _deformation_gradient[_qp].det());
    }
 
    computeQpStrain();
  }
}

◆ computeQpIncrements()

void ComputeFiniteStrain::computeQpIncrements	(	RankTwoTensor &	e,
		RankTwoTensor &	r
	)

protectedvirtualinherited

Reimplemented in ComputeRSphericalFiniteStrain.

Definition at line 165 of file ComputeFiniteStrain.C.

{
  switch (_decomposition_method)
  {
    case DecompMethod::TaylorExpansion:
    {
      // inverse of _Fhat
      const RankTwoTensor invFhat = _Fhat[_qp].inverse();
 
      // A = I - _Fhat^-1
      RankTwoTensor A(RankTwoTensor::initIdentity);
      A -= invFhat;
 
      // Cinv - I = A A^T - A - A^T;
      RankTwoTensor Cinv_I = A * A.transpose() - A - A.transpose();
 
      // strain rate D from Taylor expansion, Chat = (-1/2(Chat^-1 - I) + 1/4*(Chat^-1 - I)^2 + ...
      total_strain_increment = -Cinv_I * 0.5 + Cinv_I * Cinv_I * 0.25;
 
      const Real a[3] = {invFhat(1, 2) - invFhat(2, 1),
                         invFhat(2, 0) - invFhat(0, 2),
                         invFhat(0, 1) - invFhat(1, 0)};
 
      Real q = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]) / 4.0;
      Real trFhatinv_1 = invFhat.trace() - 1.0;
      const Real p = trFhatinv_1 * trFhatinv_1 / 4.0;
 
      // cos theta_a
      const Real C1_squared = p +
                              3.0 * Utility::pow<2>(p) * (1.0 - (p + q)) / Utility::pow<2>(p + q) -
                              2.0 * Utility::pow<3>(p) * (1.0 - (p + q)) / Utility::pow<3>(p + q);
      if (C1_squared <= 0.0)
        mooseException(
            "Cannot take square root of a number less than or equal to zero in the calculation of "
            "C1 for the Rashid approximation for the rotation tensor. This zero or negative number "
            "may occur when elements become heavily distorted.");
 
      const Real C1 = std::sqrt(C1_squared);
 
      Real C2;
      if (q > 0.01)
        // (1-cos theta_a)/4q
        C2 = (1.0 - C1) / (4.0 * q);
      else
        // alternate form for small q
        C2 = 0.125 + q * 0.03125 * (Utility::pow<2>(p) - 12.0 * (p - 1.0)) / Utility::pow<2>(p) +
             Utility::pow<2>(q) * (p - 2.0) * (Utility::pow<2>(p) - 10.0 * p + 32.0) /
                 Utility::pow<3>(p) +
             Utility::pow<3>(q) *
                 (1104.0 - 992.0 * p + 376.0 * Utility::pow<2>(p) - 72.0 * Utility::pow<3>(p) +
                  5.0 * Utility::pow<4>(p)) /
                 (512.0 * Utility::pow<4>(p));
 
      const Real C3_test =
          (p * q * (3.0 - q) + Utility::pow<3>(p) + Utility::pow<2>(q)) / Utility::pow<3>(p + q);
 
      if (C3_test <= 0.0)
        mooseException(
            "Cannot take square root of a number less than or equal to zero in the calculation of "
            "C3_test for the Rashid approximation for the rotation tensor. This zero or negative "
            "number may occur when elements become heavily distorted.");
 
      const Real C3 = 0.5 * std::sqrt(C3_test); // sin theta_a/(2 sqrt(q))
 
      // Calculate incremental rotation. Note that this value is the transpose of that from Rashid,
      // 93, so we transpose it before storing
      RankTwoTensor R_incr;
      R_incr.addIa(C1);
      for (unsigned int i = 0; i < 3; ++i)
        for (unsigned int j = 0; j < 3; ++j)
          R_incr(i, j) += C2 * a[i] * a[j];
 
      R_incr(0, 1) += C3 * a[2];
      R_incr(0, 2) -= C3 * a[1];
      R_incr(1, 0) -= C3 * a[2];
      R_incr(1, 2) += C3 * a[0];
      R_incr(2, 0) += C3 * a[1];
      R_incr(2, 1) -= C3 * a[0];
 
      rotation_increment = R_incr.transpose();
      break;
    }
 
    case DecompMethod::EigenSolution:
    {
      FactorizedRankTwoTensor Chat = RankTwoTensor::transposeTimes(_Fhat[_qp]);
      FactorizedRankTwoTensor Uhat = MathUtils::sqrt(Chat);
      rotation_increment = _Fhat[_qp] * Uhat.inverse().get();
      total_strain_increment = MathUtils::log(Uhat).get();
      break;
    }
 
    case DecompMethod::HughesWinget:
    {
      const RankTwoTensor G = (*_f_bar)[_qp] * (*_def_grad_mid)[_qp].inverse();
 
      total_strain_increment = 0.5 * (G + G.transpose());
      const RankTwoTensor W = 0.5 * (G - G.transpose());
 
      RankTwoTensor Q_1(RankTwoTensor::initIdentity);
      RankTwoTensor Q_2(RankTwoTensor::initIdentity);
 
      Q_1 -= 0.5 * W;
      Q_2 += 0.5 * W;
 
      rotation_increment = Q_1.inverse() * Q_2;
 
      break;
    }
 
    default:
      mooseError("ComputeFiniteStrain Error: Pass valid decomposition type: TaylorExpansion, "
                 "EigenSolution, or HughesWinget.");
  }
}

Referenced by ComputeFiniteStrain::computeQpStrain().

◆ computeQpStrain()

void ComputeFiniteStrain::computeQpStrain ( )

protectedvirtualinherited

Definition at line 118 of file ComputeFiniteStrain.C.

{
  RankTwoTensor total_strain_increment;
 
  // three ways to calculate these increments: TaylorExpansion(default), EigenSolution, or
  // HughesWinget
  computeQpIncrements(total_strain_increment, _rotation_increment[_qp]);
 
  _strain_increment[_qp] = total_strain_increment;
 
  // Remove the eigenstrain increment
  subtractEigenstrainIncrementFromStrain(_strain_increment[_qp]);
 
  if (_dt > 0)
    _strain_rate[_qp] = _strain_increment[_qp] / _dt;
  else
    _strain_rate[_qp].zero();
 
  // if HughesWinget, rotate old strains here
  RankTwoTensor mechanical_strain_old = _mechanical_strain_old[_qp];
  RankTwoTensor total_strain_old = _total_strain_old[_qp];
  if (_use_hw)
  {
    mechanical_strain_old = _rotation_increment[_qp] * _mechanical_strain_old[_qp] *
                            _rotation_increment[_qp].transpose();
    total_strain_old =
        _rotation_increment[_qp] * _total_strain_old[_qp] * _rotation_increment[_qp].transpose();
  }
 
  // Update strain in intermediate configuration
  _mechanical_strain[_qp] = mechanical_strain_old + _strain_increment[_qp];
  _total_strain[_qp] = total_strain_old + total_strain_increment;
 
  // Rotate strain to current configuration, unless HughesWinget
  if (!_use_hw)
  {
    _mechanical_strain[_qp] =
        _rotation_increment[_qp] * _mechanical_strain[_qp] * _rotation_increment[_qp].transpose();
    _total_strain[_qp] =
        _rotation_increment[_qp] * _total_strain[_qp] * _rotation_increment[_qp].transpose();
  }
 
  if (_global_strain)
    _total_strain[_qp] += (*_global_strain)[_qp];
}

Referenced by Compute1DFiniteStrain::computeProperties(), computeProperties(), ComputeFiniteStrain::computeProperties(), and ComputeRSphericalFiniteStrain::computeProperties().

◆ CreateMooseEnumClass()

ComputeFiniteStrain::CreateMooseEnumClass	(	DecompMethod	,
		TaylorExpansion	,
		EigenSolution	,
		HughesWinget
	)

inherited

◆ decompositionType()

MooseEnum ComputeFiniteStrain::decompositionType ( )

staticinherited

Definition at line 17 of file ComputeFiniteStrain.C.

{
  return MooseEnum(getDecompMethodOptions(), "TaylorExpansion");
}

Referenced by AbaqusUMATStress::validParams(), ComputeFiniteStrain::validParams(), and QuasiStaticSolidMechanicsPhysicsBase::validParams().

◆ displacementIntegrityCheck()

void Compute2DFiniteStrain::displacementIntegrityCheck ( )

overrideprotectedvirtual

Reimplemented from ComputeStrainBase.

Definition at line 132 of file Compute2DFiniteStrain.C.

{
  if (_out_of_plane_direction != 2 && _ndisp != 3)
    mooseError("For 2D simulations where the out-of-plane direction is x or y the number of "
               "supplied displacements must be three.");
  else if (_out_of_plane_direction == 2 && _ndisp != 2)
    mooseError("For 2D simulations where the out-of-plane direction is z the number of supplied "
               "displacements must be two.");
}

◆ initialSetup()

void Compute2DFiniteStrain::initialSetup ( )

override

Definition at line 34 of file Compute2DFiniteStrain.C.

{
  for (unsigned int i = 0; i < 3; ++i)
  {
    if (_out_of_plane_direction == i)
    {
      _disp[i] = &_zero;
      _grad_disp[i] = &_grad_zero;
    }
    else
    {
      _disp[i] = &coupledValue("displacements", i);
      _grad_disp[i] = &coupledGradient("displacements", i);
    }
 
    if (_fe_problem.isTransient() && i != _out_of_plane_direction)
      _grad_disp_old[i] = &coupledGradientOld("displacements", i);
    else
      _grad_disp_old[i] = &_grad_zero;
  }
}

Referenced by ComputeAxisymmetricRZFiniteStrain::initialSetup().

◆ initQpStatefulProperties()

void ComputeIncrementalStrainBase::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Reimplemented in ComputeCosseratIncrementalSmallStrain.

Definition at line 49 of file ComputeIncrementalStrainBase.C.

{
  _mechanical_strain[_qp].zero();
  _total_strain[_qp].zero();
  _deformation_gradient[_qp].setToIdentity();
  _rotation_increment[_qp].setToIdentity();
}

Referenced by ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties().

◆ subtractEigenstrainIncrementFromStrain()

void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor & strain )

protectedinherited

Definition at line 58 of file ComputeIncrementalStrainBase.C.

{
  for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
  {
    strain -= (*_eigenstrains[i])[_qp];
    strain += (*_eigenstrains_old[i])[_qp];
  }
}

Referenced by ComputeIncrementalStrain::computeProperties(), ComputeCosseratIncrementalSmallStrain::computeQpProperties(), and ComputeFiniteStrain::computeQpStrain().

◆ validParams()

InputParameters Compute2DFiniteStrain::validParams ( )

static

Definition at line 15 of file Compute2DFiniteStrain.C.

{
  InputParameters params = ComputeFiniteStrain::validParams();
  params.addClassDescription(
      "Compute a strain increment and rotation increment for finite strains in 2D geometries.");
 
  MooseEnum outOfPlaneDirection("x y z", "z");
  params.addParam<MooseEnum>(
      "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
  return params;
}