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

#include <ComputePlaneFiniteStrain.h>

Inheritance diagram for ComputePlaneFiniteStrain:

[legend]

Public Member Functions
	ComputePlaneFiniteStrain (const InputParameters &parameters)

void	initialSetup () override

virtual void	computeProperties () override

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

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

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

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 *	_subblock_id_provider

const bool	_scalar_out_of_plane_strain_coupled

unsigned int	_nscalar_strains

std::vector< const VariableValue * >	_scalar_out_of_plane_strain

std::vector< const VariableValue * >	_scalar_out_of_plane_strain_old

const bool	_out_of_plane_strain_coupled

const VariableValue &	_out_of_plane_strain

const VariableValue &	_out_of_plane_strain_old

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

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

Definition at line 24 of file ComputePlaneFiniteStrain.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

◆ ComputePlaneFiniteStrain()

ComputePlaneFiniteStrain::ComputePlaneFiniteStrain ( const InputParameters & parameters )

Definition at line 31 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(isParamValid("scalar_out_of_plane_strain")),
     _nscalar_strains(coupledScalarComponents("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)
   {
     _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 60 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 73 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 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(), Compute2DFiniteStrain::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 ( )

overrideprotectedvirtualinherited

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

◆ getCurrentSubblockIndex()

unsigned int ComputePlaneFiniteStrain::getCurrentSubblockIndex ( ) const

inlineprotected

gets its subblock index for current element

Definition at line 36 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 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 ComputePlaneFiniteStrain::validParams ( )

static

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