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 Member Functions
	Compute2DFiniteStrain (const InputParameters &parameters)

void	initialSetup () override

virtual void	computeProperties () override

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. More...

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. More...

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

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. More...

std::vector< const VariableValue * >	_disp

std::vector< const VariableGradient * >	_grad_disp

const std::string	_base_name

MaterialProperty< RankTwoTensor > &	_mechanical_strain

MaterialProperty< RankTwoTensor > &	_total_strain

std::vector< MaterialPropertyName >	_eigenstrain_names

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

const MaterialProperty< RankTwoTensor > *	_global_strain

const bool	_volumetric_locking_correction

const Real &	_current_elem_volume

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

Private Attributes
const DecompMethod	_decomposition_method

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 26 of file Compute2DFiniteStrain.h.

Member Enumeration Documentation

◆ DecompMethod

enum ComputeFiniteStrain::DecompMethod

strongprivateinherited

Enumerator
TaylorExpansion
EigenSolution

Definition at line 40 of file ComputeFiniteStrain.h.

   {
     TaylorExpansion,
     EigenSolution
   };

Constructor & Destructor Documentation

◆ Compute2DFiniteStrain()

Compute2DFiniteStrain::Compute2DFiniteStrain ( const InputParameters & parameters )

Definition at line 29 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 59 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
     RankTwoTensor 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 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);
  
     A -= Fbar; // very nearly A = gradU - gradUold
  
     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

Definition at line 137 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);
       mooseAssert(C1_squared >= 0.0,
                   "Cannot take square root of a negative number. This may happen 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);
       mooseAssert(C3_test >= 0.0,
                   "Cannot take square root of a negative number. This may happen 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:
     {
       std::vector<Real> e_value(3);
       RankTwoTensor e_vector, N1, N2, N3;
  
       RankTwoTensor Chat = _Fhat[_qp].transpose() * _Fhat[_qp];
       Chat.symmetricEigenvaluesEigenvectors(e_value, e_vector);
  
       const Real lambda1 = std::sqrt(e_value[0]);
       const Real lambda2 = std::sqrt(e_value[1]);
       const Real 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 RankTwoTensor Uhat = N1 * lambda1 + N2 * lambda2 + N3 * lambda3;
       const RankTwoTensor 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("ComputeFiniteStrain Error: Pass valid decomposition type: TaylorExpansion or "
                  "EigenSolution.");
   }
 }

Referenced by ComputeFiniteStrain::computeQpStrain().

◆ computeQpStrain()

void ComputeFiniteStrain::computeQpStrain ( )

protectedvirtualinherited

Definition at line 105 of file ComputeFiniteStrain.C.

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

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

◆ decompositionType()

MooseEnum ComputeFiniteStrain::decompositionType ( )

staticinherited

Definition at line 17 of file ComputeFiniteStrain.C.

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

Referenced by TensorMechanicsActionBase::validParams(), and ComputeFiniteStrain::validParams().

◆ displacementIntegrityCheck()

void Compute2DFiniteStrain::displacementIntegrityCheck ( )

overrideprotectedvirtual

Reimplemented from ComputeStrainBase.

Definition at line 124 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 36 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 51 of file ComputeIncrementalStrainBase.C.

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

Referenced by ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties().

◆ subtractEigenstrainIncrementFromStrain()

void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor & strain )

protectedinherited

Definition at line 59 of file ComputeIncrementalStrainBase.C.

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

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

◆ validParams()

InputParameters Compute2DFiniteStrain::validParams ( )

static

Definition at line 17 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;
 }