ADCompute1DFiniteStrain defines a strain increment for finite strains in 1D problems, handling strains in other two directions. More...

#include <ADCompute1DFiniteStrain.h>

Inheritance diagram for ADCompute1DFiniteStrain< compute_stage >:

[legend]

Public Member Functions
	ADCompute1DFiniteStrain (const InputParameters &parameters)

void	computeProperties () override

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	decompositionType ()

Protected Member Functions
virtual ADReal	computeGradDispYY ()=0
	Computes the current dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual Real	computeGradDispYYOld ()=0
	Computes the old dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual ADReal	computeGradDispZZ ()=0
	Computes the current dUz/dz; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual Real	computeGradDispZZOld ()=0
	Computes the old dUz/dz; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

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
	usingComputeFiniteStrainMembers

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 ADCompute1DFiniteStrain< compute_stage >

ADCompute1DFiniteStrain defines a strain increment for finite strains in 1D problems, handling strains in other two directions.

It contains virtual methods to define the displacement gradients as a general nonzero value.

Definition at line 22 of file ADCompute1DFiniteStrain.h.

Member Enumeration Documentation

◆ DecompMethod

template<ComputeStage compute_stage>

enum ADComputeFiniteStrain::DecompMethod

strongprivateinherited

Enumerator
TaylorExpansion
EigenSolution

Definition at line 47 of file ADComputeFiniteStrain.h.

   {
     TaylorExpansion,
     EigenSolution
   };

Constructor & Destructor Documentation

◆ ADCompute1DFiniteStrain()

template<ComputeStage compute_stage>

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

Definition at line 26 of file ADCompute1DFiniteStrain.C.

   : ADComputeFiniteStrain<compute_stage>(parameters)
 {
 }

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

◆ computeGradDispYY()

template<ComputeStage compute_stage>

virtual ADReal ADCompute1DFiniteStrain< compute_stage >::computeGradDispYY ( )

protectedpure virtual

Computes the current dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

◆ computeGradDispYYOld()

template<ComputeStage compute_stage>

virtual Real ADCompute1DFiniteStrain< compute_stage >::computeGradDispYYOld ( )

protectedpure virtual

Computes the old dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

◆ computeGradDispZZ()

template<ComputeStage compute_stage>

virtual ADReal ADCompute1DFiniteStrain< compute_stage >::computeGradDispZZ ( )

protectedpure virtual

Computes the current dUz/dz; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

◆ computeGradDispZZOld()

template<ComputeStage compute_stage>

virtual Real ADCompute1DFiniteStrain< compute_stage >::computeGradDispZZOld ( )

protectedpure virtual

Computes the old dUz/dz; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

◆ computeProperties()

template<ComputeStage compute_stage>

void ADCompute1DFiniteStrain< compute_stage >::computeProperties ( )

override

Definition at line 33 of file ADCompute1DFiniteStrain.C.

 {
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     ADRankTwoTensor A((*_grad_disp[0])[_qp],
                       (*_grad_disp[1])[_qp],
                       (*_grad_disp[2])[_qp]); // Deformation gradient
     RankTwoTensor Fbar((*_grad_disp_old[0])[_qp],
                        (*_grad_disp_old[1])[_qp],
                        (*_grad_disp_old[2])[_qp]); // Old Deformation gradient
  
     // Compute the displacement gradient dUy/dy and dUz/dz value for 1D problems
     A(1, 1) = computeGradDispYY();
     A(2, 2) = computeGradDispZZ();
  
     Fbar(1, 1) = computeGradDispYYOld();
     Fbar(2, 2) = computeGradDispZZOld();
  
     A -= Fbar; // very nearly A = gradU - gradUold, adapted to cylindrical coords
  
     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);
   }
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     computeQpStrain();
 }

◆ computeQpIncrements()

template<ComputeStage compute_stage>

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

protectedvirtualinherited

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

protectedvirtualinherited

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

staticinherited

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

static

Definition at line 18 of file ADCompute1DFiniteStrain.C.

 {
   InputParameters params = ADComputeFiniteStrain<compute_stage>::validParams();
   params.addClassDescription("Compute strain increment for finite strain in 1D problem");
   return params;
 }

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

privateinherited

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

protectedinherited

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

◆ usingComputeFiniteStrainMembers

template<ComputeStage compute_stage>

ADCompute1DFiniteStrain< compute_stage >::usingComputeFiniteStrainMembers

protected

Definition at line 58 of file ADCompute1DFiniteStrain.h.

◆ usingComputeIncrementalStrainBaseMembers

template<ComputeStage compute_stage>

ADComputeFiniteStrain< compute_stage >::usingComputeIncrementalStrainBaseMembers

protectedinherited

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/ADCompute1DFiniteStrain.h
tensor_mechanics/src/materials/ADCompute1DFiniteStrain.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Detailed Description

template<ComputeStage compute_stage> class ADCompute1DFiniteStrain< compute_stage >

Member Enumeration Documentation

◆ DecompMethod

Constructor & Destructor Documentation

◆ ADCompute1DFiniteStrain()

Member Function Documentation

◆ ADMaterialProperty() [1/4]

◆ ADMaterialProperty() [2/4]

◆ ADMaterialProperty() [3/4]

◆ ADMaterialProperty() [4/4]

◆ computeGradDispYY()

◆ computeGradDispYYOld()

◆ computeGradDispZZ()

◆ computeGradDispZZOld()

◆ 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

◆ usingComputeFiniteStrainMembers

◆ usingComputeIncrementalStrainBaseMembers

◆ usingComputeStrainBaseMembers

◆ usingMaterialMembers

template<ComputeStage compute_stage>
class ADCompute1DFiniteStrain< compute_stage >