ADComputeFiniteStrain defines a strain increment and rotation increment, for finite strains. More...

#include <ADComputeFiniteStrain.h>

Inheritance diagram for ADComputeFiniteStrain< compute_stage >:

Public Member Functions
	ADComputeFiniteStrain (const InputParameters &parameters)

void	computeProperties () override

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	decompositionType ()

Protected Member Functions
virtual void	computeQpStrain ()

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

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (ADRankTwoTensor &strain)

	ADMaterialProperty (RankTwoTensor) &_strain_rate

	ADMaterialProperty (RankTwoTensor) &_strain_increment

	ADMaterialProperty (RankTwoTensor) &_rotation_increment

const	ADMaterialProperty (RankTwoTensor) *_global_strain

virtual void	displacementIntegrityCheck ()

Protected Attributes
std::vector< ADRankTwoTensor >	_Fhat

	usingComputeIncrementalStrainBaseMembers

std::vector< const VariableGradient * >	_grad_disp_old

const MaterialProperty< RankTwoTensor > &	_mechanical_strain_old

const MaterialProperty< RankTwoTensor > &	_total_strain_old

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

	usingComputeStrainBaseMembers

const unsigned int	_ndisp
	Coupled displacement variables. More...

std::vector< const ADVariableValue * >	_disp

std::vector< const ADVariableGradient * >	_grad_disp

const std::string	_base_name

std::vector< MaterialPropertyName >	_eigenstrain_names

std::vector< const ADMaterialProperty(RankTwoTensor) * >	_eigenstrains

const bool	_volumetric_locking_correction

const Real &	_current_elem_volume

	usingMaterialMembers

Private Types
enum	DecompMethod { DecompMethod::TaylorExpansion, DecompMethod::EigenSolution }

Private Attributes
const DecompMethod	_decomposition_method

Detailed Description

template<ComputeStage compute_stage>
class ADComputeFiniteStrain< compute_stage >

ADComputeFiniteStrain defines a strain increment and rotation increment, for finite strains.

Definition at line 21 of file ADComputeFiniteStrain.h.

Member Enumeration Documentation

◆ DecompMethod

template<ComputeStage compute_stage>

enum ADComputeFiniteStrain::DecompMethod

strongprivate

Enumerator
TaylorExpansion
EigenSolution

Definition at line 47 of file ADComputeFiniteStrain.h.

   {
     TaylorExpansion,
     EigenSolution
   };

Constructor & Destructor Documentation

◆ ADComputeFiniteStrain()

template<ComputeStage compute_stage>

ADComputeFiniteStrain< compute_stage >::ADComputeFiniteStrain ( const InputParameters & parameters )

Definition at line 40 of file ADComputeFiniteStrain.C.

   : ADComputeIncrementalStrainBase<compute_stage>(parameters),
     _Fhat(_fe_problem.getMaxQps()),
     _decomposition_method(
         getParam<MooseEnum>("decomposition_method").template getEnum<DecompMethod>())
 {
 }

Member Function Documentation

◆ ADMaterialProperty() [1/4]

template<ComputeStage compute_stage>

ADComputeIncrementalStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor ) &

protectedinherited

◆ ADMaterialProperty() [2/4]

template<ComputeStage compute_stage>

ADComputeIncrementalStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor ) &

protectedinherited

◆ ADMaterialProperty() [3/4]

template<ComputeStage compute_stage>

ADComputeIncrementalStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor ) &

protectedinherited

◆ ADMaterialProperty() [4/4]

template<ComputeStage compute_stage>

const ADComputeStrainBase< compute_stage >::ADMaterialProperty ( RankTwoTensor )

protectedinherited

◆ computeProperties()

template<ComputeStage compute_stage>

void ADComputeFiniteStrain< compute_stage >::computeProperties ( )

override

Definition at line 50 of file ADComputeFiniteStrain.C.

 {
   ADRankTwoTensor ave_Fhat;
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     // Deformation gradient
     ADRankTwoTensor A((*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]);
  
     // Old Deformation gradient
     ADRankTwoTensor Fbar(
         (*_grad_disp_old[0])[_qp], (*_grad_disp_old[1])[_qp], (*_grad_disp_old[2])[_qp]);
  
     // A = gradU - gradUold
     A -= Fbar;
  
     // Fbar = ( I + gradUold)
     Fbar.addIa(1.0);
  
     // Incremental deformation gradient _Fhat = I + A Fbar^-1
     _Fhat[_qp] = A * Fbar.inverse();
     _Fhat[_qp].addIa(1.0);
  
     // Calculate average _Fhat for volumetric locking correction
     if (_volumetric_locking_correction)
       ave_Fhat += _Fhat[_qp] * _JxW[_qp] * _coord[_qp];
   }
  
   if (_volumetric_locking_correction)
     ave_Fhat /= _current_elem_volume;
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     // Finalize volumetric locking correction
     if (_volumetric_locking_correction)
       // std::cbrt is not yet supported for dual numbers (MetaPhysicL/issues/36)
       _Fhat[_qp] *= std::pow(ave_Fhat.det() / _Fhat[_qp].det(), 1.0 / 3.0);
  
     computeQpStrain();
   }
  
   copyDualNumbersToValues();
 }

◆ computeQpIncrements()

template<ComputeStage compute_stage>

void ADComputeFiniteStrain< compute_stage >::computeQpIncrements	(	ADRankTwoTensor &	e,
		ADRankTwoTensor &	r
	)

protectedvirtual

Definition at line 128 of file ADComputeFiniteStrain.C.

 {
   switch (_decomposition_method)
   {
     case DecompMethod::TaylorExpansion:
     {
       // inverse of _Fhat
       const ADRankTwoTensor invFhat = _Fhat[_qp].inverse();
  
       // A = I - _Fhat^-1
       ADRankTwoTensor A(RankTwoTensorType<compute_stage>::type::initIdentity);
       A -= invFhat;
  
       // Cinv - I = A A^T - A - A^T;
       ADRankTwoTensor 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 ADReal a[3] = {invFhat(1, 2) - invFhat(2, 1),
                            invFhat(2, 0) - invFhat(0, 2),
                            invFhat(0, 1) - invFhat(1, 0)};
  
       const auto q = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]) / 4.0;
       const auto trFhatinv_1 = invFhat.trace() - 1.0;
       const auto p = trFhatinv_1 * trFhatinv_1 / 4.0;
  
       // cos theta_a
       const ADReal 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);
       mooseAssert(C1_squared >= 0.0,
                   "Cannot take square root of a negative number. This may happen when elements "
                   "become heavily distorted.");
       const ADReal C1 = std::sqrt(C1_squared);
  
       ADReal 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 ADReal C3_test =
           (p * q * (3.0 - q) + Utility::pow<3>(p) + Utility::pow<2>(q)) / Utility::pow<3>(p + q);
       mooseAssert(C3_test >= 0.0,
                   "Cannot take square root of a negative number. This may happen when elements "
                   "become heavily distorted.");
       const ADReal 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
       ADRankTwoTensor 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:
     {
       std::vector<ADReal> e_value(3);
       ADRankTwoTensor e_vector, N1, N2, N3;
  
       const auto Chat = _Fhat[_qp].transpose() * _Fhat[_qp];
       Chat.symmetricEigenvaluesEigenvectors(e_value, e_vector);
  
       const auto lambda1 = std::sqrt(e_value[0]);
       const auto lambda2 = std::sqrt(e_value[1]);
       const auto lambda3 = std::sqrt(e_value[2]);
  
       N1.vectorOuterProduct(e_vector.column(0), e_vector.column(0));
       N2.vectorOuterProduct(e_vector.column(1), e_vector.column(1));
       N3.vectorOuterProduct(e_vector.column(2), e_vector.column(2));
  
       const auto Uhat = N1 * lambda1 + N2 * lambda2 + N3 * lambda3;
       const ADRankTwoTensor invUhat(Uhat.inverse());
  
       rotation_increment = _Fhat[_qp] * invUhat;
  
       total_strain_increment =
           N1 * std::log(lambda1) + N2 * std::log(lambda2) + N3 * std::log(lambda3);
       break;
     }
  
     default:
       mooseError("ADComputeFiniteStrain Error: Pass valid decomposition type: TaylorExpansion or "
                  "EigenSolution.");
   }
 }

◆ computeQpStrain()

template<ComputeStage compute_stage>

void ADComputeFiniteStrain< compute_stage >::computeQpStrain ( )

protectedvirtual

Definition at line 95 of file ADComputeFiniteStrain.C.

 {
   ADRankTwoTensor total_strain_increment;
  
   // two ways to calculate these increments: TaylorExpansion(default) or EigenSolution
   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();
  
   // Update strain in intermediate configuration
   _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
   _total_strain[_qp] = _total_strain_old[_qp] + total_strain_increment;
  
   // Rotate strain to current configuration
   _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];
 }

◆ decompositionType()

template<ComputeStage compute_stage>

MooseEnum ADComputeFiniteStrain< compute_stage >::decompositionType ( )

static

Definition at line 21 of file ADComputeFiniteStrain.C.

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

Referenced by ADComputeFiniteStrain< compute_stage >::validParams().

◆ displacementIntegrityCheck()

template<ComputeStage compute_stage>

void ADComputeStrainBase< compute_stage >::displacementIntegrityCheck ( )

protectedvirtualinherited

Reimplemented in ADCompute2DFiniteStrain< compute_stage >, ADCompute2DIncrementalStrain< compute_stage >, and ADCompute2DSmallStrain< compute_stage >.

Definition at line 93 of file ADComputeStrainBase.C.

 {
   // Checking for consistency between mesh size and length of the provided displacements vector
   if (_ndisp != _mesh.dimension())
     paramError(
         "displacements",
         "The number of variables supplied in 'displacements' must match the mesh dimension.");
 }

◆ initialSetup()

template<ComputeStage compute_stage>

void ADComputeIncrementalStrainBase< compute_stage >::initialSetup ( )

overrideinherited

Definition at line 41 of file ADComputeIncrementalStrainBase.C.

 {
   ADComputeStrainBase<compute_stage>::initialSetup();
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (_fe_problem.isTransient() && i < _ndisp)
       _grad_disp_old[i] = &coupledGradientOld("displacements", i);
     else
       _grad_disp_old[i] = &_grad_zero;
   }
 }

Referenced by ADComputeAxisymmetricRZIncrementalStrain< compute_stage >::initialSetup(), ADComputeRSphericalIncrementalStrain< compute_stage >::initialSetup(), and ADComputeRSphericalFiniteStrain< compute_stage >::initialSetup().

◆ initQpStatefulProperties()

template<ComputeStage compute_stage>

void ADComputeIncrementalStrainBase< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented from ADComputeStrainBase< compute_stage >.

Definition at line 55 of file ADComputeIncrementalStrainBase.C.

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

◆ subtractEigenstrainIncrementFromStrain()

template<ComputeStage compute_stage>

void ADComputeIncrementalStrainBase< compute_stage >::subtractEigenstrainIncrementFromStrain ( ADRankTwoTensor & strain )

protectedinherited

Definition at line 63 of file ADComputeIncrementalStrainBase.C.

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

◆ validParams()

template<ComputeStage compute_stage>

InputParameters ADComputeFiniteStrain< compute_stage >::validParams ( )

static

Definition at line 28 of file ADComputeFiniteStrain.C.

 {
   InputParameters params = ADComputeIncrementalStrainBase<compute_stage>::validParams();
   params.addClassDescription(
       "Compute a strain increment and rotation increment for finite strains.");
   params.addParam<MooseEnum>("decomposition_method",
                              ADComputeFiniteStrain<compute_stage>::decompositionType(),
                              "Methods to calculate the strain and rotation increments");
   return params;
 }

Referenced by ADComputeRSphericalFiniteStrain< compute_stage >::validParams(), ADCompute1DFiniteStrain< compute_stage >::validParams(), and ADCompute2DFiniteStrain< compute_stage >::validParams().

Member Data Documentation

◆ _base_name

template<ComputeStage compute_stage>

const std::string ADComputeStrainBase< compute_stage >::_base_name

protectedinherited

Definition at line 60 of file ADComputeStrainBase.h.

Referenced by ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

◆ _current_elem_volume

template<ComputeStage compute_stage>

const Real& ADComputeStrainBase< compute_stage >::_current_elem_volume

protectedinherited

Definition at line 71 of file ADComputeStrainBase.h.

◆ _decomposition_method

template<ComputeStage compute_stage>

const DecompMethod ADComputeFiniteStrain< compute_stage >::_decomposition_method

private

Definition at line 53 of file ADComputeFiniteStrain.h.

◆ _disp

template<ComputeStage compute_stage>

std::vector<const ADVariableValue *> ADComputeStrainBase< compute_stage >::_disp

protectedinherited

Definition at line 57 of file ADComputeStrainBase.h.

◆ _eigenstrain_names

template<ComputeStage compute_stage>

std::vector<MaterialPropertyName> ADComputeStrainBase< compute_stage >::_eigenstrain_names

protectedinherited

Definition at line 65 of file ADComputeStrainBase.h.

Referenced by ADComputeIncrementalStrainBase< compute_stage >::ADComputeIncrementalStrainBase(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

◆ _eigenstrains

template<ComputeStage compute_stage>

std::vector<const ADMaterialProperty(RankTwoTensor) *> ADComputeStrainBase< compute_stage >::_eigenstrains

protectedinherited

Definition at line 66 of file ADComputeStrainBase.h.

Referenced by ADComputeGreenLagrangeStrain< compute_stage >::ADComputeGreenLagrangeStrain(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

◆ _eigenstrains_old

template<ComputeStage compute_stage>

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

protectedinherited

Definition at line 58 of file ADComputeIncrementalStrainBase.h.

Referenced by ADComputeIncrementalStrainBase< compute_stage >::ADComputeIncrementalStrainBase().

◆ _Fhat

template<ComputeStage compute_stage>

std::vector<ADRankTwoTensor> ADComputeFiniteStrain< compute_stage >::_Fhat

protected

Definition at line 44 of file ADComputeFiniteStrain.h.

◆ _grad_disp

template<ComputeStage compute_stage>

std::vector<const ADVariableGradient *> ADComputeStrainBase< compute_stage >::_grad_disp

protectedinherited

Definition at line 58 of file ADComputeStrainBase.h.

◆ _grad_disp_old

template<ComputeStage compute_stage>

std::vector<const VariableGradient *> ADComputeIncrementalStrainBase< compute_stage >::_grad_disp_old

protectedinherited

Definition at line 49 of file ADComputeIncrementalStrainBase.h.

◆ _mechanical_strain_old

template<ComputeStage compute_stage>

const MaterialProperty<RankTwoTensor>& ADComputeIncrementalStrainBase< compute_stage >::_mechanical_strain_old

protectedinherited

Definition at line 55 of file ADComputeIncrementalStrainBase.h.

◆ _ndisp

template<ComputeStage compute_stage>

const unsigned int ADComputeStrainBase< compute_stage >::_ndisp

protectedinherited

Coupled displacement variables.

Definition at line 56 of file ADComputeStrainBase.h.

Referenced by ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

◆ _total_strain_old

template<ComputeStage compute_stage>

const MaterialProperty<RankTwoTensor>& ADComputeIncrementalStrainBase< compute_stage >::_total_strain_old

protectedinherited

Definition at line 56 of file ADComputeIncrementalStrainBase.h.

◆ _volumetric_locking_correction

template<ComputeStage compute_stage>

const bool ADComputeStrainBase< compute_stage >::_volumetric_locking_correction

protectedinherited

Definition at line 70 of file ADComputeStrainBase.h.

Referenced by ADComputeGreenLagrangeStrain< compute_stage >::ADComputeGreenLagrangeStrain(), and ADComputeStrainBase< compute_stage >::ADComputeStrainBase().

◆ usingComputeIncrementalStrainBaseMembers

template<ComputeStage compute_stage>

ADComputeFiniteStrain< compute_stage >::usingComputeIncrementalStrainBaseMembers

protected

Definition at line 56 of file ADComputeFiniteStrain.h.

◆ usingComputeStrainBaseMembers

template<ComputeStage compute_stage>

ADComputeIncrementalStrainBase< compute_stage >::usingComputeStrainBaseMembers

protectedinherited

Definition at line 60 of file ADComputeIncrementalStrainBase.h.

◆ usingMaterialMembers

template<ComputeStage compute_stage>

ADComputeStrainBase< compute_stage >::usingMaterialMembers

protectedinherited

Definition at line 73 of file ADComputeStrainBase.h.

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

tensor_mechanics/include/materials/ADComputeFiniteStrain.h
tensor_mechanics/src/materials/ADComputeFiniteStrain.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Detailed Description

template<ComputeStage compute_stage> class ADComputeFiniteStrain< compute_stage >

Member Enumeration Documentation

◆ DecompMethod

Constructor & Destructor Documentation

◆ ADComputeFiniteStrain()

Member Function Documentation

◆ ADMaterialProperty() [1/4]

◆ ADMaterialProperty() [2/4]

◆ ADMaterialProperty() [3/4]

◆ ADMaterialProperty() [4/4]

◆ computeProperties()

◆ computeQpIncrements()

◆ computeQpStrain()

◆ decompositionType()

◆ displacementIntegrityCheck()

◆ initialSetup()

◆ initQpStatefulProperties()

◆ subtractEigenstrainIncrementFromStrain()

◆ validParams()

Member Data Documentation

◆ _base_name

◆ _current_elem_volume

◆ _decomposition_method

◆ _disp

◆ _eigenstrain_names

◆ _eigenstrains

◆ _eigenstrains_old

◆ _Fhat

◆ _grad_disp

◆ _grad_disp_old

◆ _mechanical_strain_old

◆ _ndisp

◆ _total_strain_old

◆ _volumetric_locking_correction

◆ usingComputeIncrementalStrainBaseMembers

◆ usingComputeStrainBaseMembers

◆ usingMaterialMembers

template<ComputeStage compute_stage>
class ADComputeFiniteStrain< compute_stage >