ComputePlaneFiniteStrain defines strain increment and rotation increment for finite strain under 2D planar assumptions. More...

#include <ComputePlaneFiniteStrain.h>

Inheritance diagram for ComputePlaneFiniteStrain:

[legend]

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	ComputePlaneFiniteStrain (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 Real	computeOutOfPlaneGradDisp () override
	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 () override
	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.

unsigned int	getCurrentSubblockIndex () const
	gets its subblock index for current element

virtual void	displacementIntegrityCheck () override

virtual void	computeQpStrain ()

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

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

Protected Attributes
const SubblockIndexProvider *const	_subblock_id_provider
	A Userobject that carries the subblock ID for all elements.

const bool	_scalar_out_of_plane_strain_coupled
	Whether out-of-plane strain scalar variables are coupled.

const bool	_out_of_plane_strain_coupled
	Whether an out-of-plane strain variable is coupled.

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


std::vector< const VariableValue * >	_scalar_out_of_plane_strain
	Current and old values of the out-of-plane strain scalar variable.

std::vector< const VariableValue * >	_scalar_out_of_plane_strain_old


const VariableValue &	_out_of_plane_strain
	Current and old values of the out-of-plane strain variable.

const VariableValue &	_out_of_plane_strain_old

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

ComputePlaneFiniteStrain defines strain increment and rotation increment for finite strain under 2D planar assumptions.

Definition at line 19 of file ComputePlaneFiniteStrain.h.

Constructor & Destructor Documentation

◆ ComputePlaneFiniteStrain()

ComputePlaneFiniteStrain::ComputePlaneFiniteStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputePlaneFiniteStrain.C.

  : Compute2DFiniteStrain(parameters),
    _subblock_id_provider(isParamValid("subblock_index_provider")
                              ? &getUserObject<SubblockIndexProvider>("subblock_index_provider")
                              : nullptr),
    _scalar_out_of_plane_strain_coupled(isCoupledScalar("scalar_out_of_plane_strain")),
    _out_of_plane_strain_coupled(isCoupled("out_of_plane_strain")),
    _out_of_plane_strain(_out_of_plane_strain_coupled ? coupledValue("out_of_plane_strain")
                                                      : _zero),
    _out_of_plane_strain_old(_out_of_plane_strain_coupled ? coupledValueOld("out_of_plane_strain")
                                                          : _zero)
{
  if (_out_of_plane_strain_coupled && _scalar_out_of_plane_strain_coupled)
    mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
 
  if (_scalar_out_of_plane_strain_coupled)
  {
    const auto nscalar_strains = coupledScalarComponents("scalar_out_of_plane_strain");
    _scalar_out_of_plane_strain.resize(nscalar_strains);
    _scalar_out_of_plane_strain_old.resize(nscalar_strains);
    for (unsigned int i = 0; i < nscalar_strains; ++i)
    {
      _scalar_out_of_plane_strain[i] = &coupledScalarValue("scalar_out_of_plane_strain", i);
      _scalar_out_of_plane_strain_old[i] = &coupledScalarValueOld("scalar_out_of_plane_strain", i);
    }
  }
}

Member Function Documentation

◆ computeOutOfPlaneGradDisp()

Real ComputePlaneFiniteStrain::computeOutOfPlaneGradDisp ( )

overrideprotectedvirtual

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.

This is consistent with the approximation of stretch rate tensor D = log(sqrt(Fhat^T * Fhat)) / dt

Implements Compute2DFiniteStrain.

Definition at line 59 of file ComputePlaneFiniteStrain.C.

{
  if (_scalar_out_of_plane_strain_coupled)
    return std::exp((*_scalar_out_of_plane_strain[getCurrentSubblockIndex()])[0]) - 1.0;
  else
    return std::exp(_out_of_plane_strain[_qp]) - 1.0;
}

◆ computeOutOfPlaneGradDispOld()

Real ComputePlaneFiniteStrain::computeOutOfPlaneGradDispOld ( )

overrideprotectedvirtual

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.

Implements Compute2DFiniteStrain.

Definition at line 72 of file ComputePlaneFiniteStrain.C.

{
  if (_scalar_out_of_plane_strain_coupled)
    return std::exp((*_scalar_out_of_plane_strain_old[getCurrentSubblockIndex()])[0]) - 1.0;
  else
    return std::exp(_out_of_plane_strain_old[_qp]) - 1.0;
}

◆ computeProperties()

void Compute2DFiniteStrain::computeProperties ( )

overridevirtualinherited

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(), Compute2DFiniteStrain::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 ( )

overrideprotectedvirtualinherited

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.");
}

◆ getCurrentSubblockIndex()

unsigned int ComputePlaneFiniteStrain::getCurrentSubblockIndex ( ) const

inlineprotected

gets its subblock index for current element

Definition at line 31 of file ComputePlaneFiniteStrain.h.

  {
    return _subblock_id_provider ? _subblock_id_provider->getSubblockIndex(*_current_elem) : 0;
  };

Referenced by computeOutOfPlaneGradDisp(), and computeOutOfPlaneGradDispOld().

◆ initialSetup()

void Compute2DFiniteStrain::initialSetup ( )

overrideinherited

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 ComputePlaneFiniteStrain::validParams ( )

static

Definition at line 16 of file ComputePlaneFiniteStrain.C.

{
  InputParameters params = Compute2DFiniteStrain::validParams();
  params.addClassDescription("Compute strain increment and rotation increment for finite strain "
                             "under 2D planar assumptions.");
  params.addParam<UserObjectName>("subblock_index_provider",
                                  "SubblockIndexProvider user object name");
  params.addCoupledVar("scalar_out_of_plane_strain",
                       "Scalar variable for generalized plane strain");
  params.addCoupledVar("out_of_plane_strain", "Nonlinear variable for plane stress condition");
 
  return params;
}