ComputeAxisymmetric1DFiniteStrain defines a strain increment for finite strains in an Axisymmetric 1D problem. More...

#include <ComputeAxisymmetric1DFiniteStrain.h>

Inheritance diagram for ComputeAxisymmetric1DFiniteStrain:

Public Member Functions
	ComputeAxisymmetric1DFiniteStrain (const InputParameters &parameters)

void	initialSetup () override

void	computeProperties () override

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	decompositionType ()

Protected Member Functions
Real	computeGradDispYY () override
	Computes the current dUy/dy for axisymmetric problems. More...

Real	computeGradDispYYOld () override
	Computes the old dUy/dy for axisymmetric problems. More...

Real	computeGradDispZZ () override
	Computes the current dUz/dz for axisymmetric problems, where \( \epsilon_{\theta} = \frac{u_r}{r} \). More...

Real	computeGradDispZZOld () override
	Computes the old dUz/dz for axisymmetric problems, where \( \epsilon_{\theta-old} = \frac{u_{r-old}}{r_{old}} \). More...

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

virtual void	computeQpStrain ()

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

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

virtual void	displacementIntegrityCheck ()

Protected Attributes
const VariableValue &	_disp_old_0
	the old value of the first component of the displacements vector More...

const SubblockIndexProvider *	_subblock_id_provider

bool	_has_out_of_plane_strain

const VariableValue &	_out_of_plane_strain

const VariableValue &	_out_of_plane_strain_old

bool	_has_scalar_out_of_plane_strain

unsigned int	_nscalar_strains

std::vector< const VariableValue * >	_scalar_out_of_plane_strain

std::vector< const VariableValue * >	_scalar_out_of_plane_strain_old

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

ComputeAxisymmetric1DFiniteStrain defines a strain increment for finite strains in an Axisymmetric 1D problem.

The COORD_TYPE in the Problem block must be set to RZ.

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

◆ ComputeAxisymmetric1DFiniteStrain()

ComputeAxisymmetric1DFiniteStrain::ComputeAxisymmetric1DFiniteStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeAxisymmetric1DFiniteStrain.C.

   : Compute1DFiniteStrain(parameters),
     _disp_old_0(coupledValueOld("displacements", 0)),
     _subblock_id_provider(isParamValid("subblock_index_provider")
                               ? &getUserObject<SubblockIndexProvider>("subblock_index_provider")
                               : nullptr),
     _has_out_of_plane_strain(isParamValid("out_of_plane_strain")),
     _out_of_plane_strain(_has_out_of_plane_strain ? coupledValue("out_of_plane_strain") : _zero),
     _out_of_plane_strain_old(_has_out_of_plane_strain ? coupledValueOld("out_of_plane_strain")
                                                       : _zero),
     _has_scalar_out_of_plane_strain(isParamValid("scalar_out_of_plane_strain")),
     _nscalar_strains(coupledScalarComponents("scalar_out_of_plane_strain"))
 {
   if (_has_out_of_plane_strain && _has_scalar_out_of_plane_strain)
     mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
  
   if (_has_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

◆ computeGradDispYY()

Real ComputeAxisymmetric1DFiniteStrain::computeGradDispYY ( )

overrideprotectedvirtual

Computes the current dUy/dy for axisymmetric problems.

Implements Compute1DFiniteStrain.

Definition at line 69 of file ComputeAxisymmetric1DFiniteStrain.C.

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

◆ computeGradDispYYOld()

Real ComputeAxisymmetric1DFiniteStrain::computeGradDispYYOld ( )

overrideprotectedvirtual

Computes the old dUy/dy for axisymmetric problems.

Implements Compute1DFiniteStrain.

Definition at line 78 of file ComputeAxisymmetric1DFiniteStrain.C.

 {
   if (_has_scalar_out_of_plane_strain)
     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;
 }

◆ computeGradDispZZ()

Real ComputeAxisymmetric1DFiniteStrain::computeGradDispZZ ( )

overrideprotectedvirtual

Computes the current dUz/dz for axisymmetric problems, where \( \epsilon_{\theta} = \frac{u_r}{r} \).

Implements Compute1DFiniteStrain.

Definition at line 87 of file ComputeAxisymmetric1DFiniteStrain.C.

 {
   if (!MooseUtils::absoluteFuzzyEqual(_q_point[_qp](0), 0.0))
     return (*_disp[0])[_qp] / _q_point[_qp](0);
   else
     return 0.0;
 }

◆ computeGradDispZZOld()

Real ComputeAxisymmetric1DFiniteStrain::computeGradDispZZOld ( )

overrideprotectedvirtual

Computes the old dUz/dz for axisymmetric problems, where \( \epsilon_{\theta-old} = \frac{u_{r-old}}{r_{old}} \).

Implements Compute1DFiniteStrain.

Definition at line 96 of file ComputeAxisymmetric1DFiniteStrain.C.

 {
   if (!MooseUtils::absoluteFuzzyEqual(_q_point[_qp](0), 0.0))
     return _disp_old_0[_qp] / _q_point[_qp](0);
   else
     return 0.0;
 }

◆ computeProperties()

void Compute1DFiniteStrain::computeProperties ( )

overrideinherited

Definition at line 31 of file Compute1DFiniteStrain.C.

 {
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     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 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();
  
     // Gauss point deformation gradient
     _deformation_gradient[_qp] = A;
     _deformation_gradient[_qp].addIa(1.0);
  
     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()

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 ComputeStrainBase::displacementIntegrityCheck ( )

protectedvirtualinherited

Reimplemented in Compute2DFiniteStrain, Compute2DIncrementalStrain, and Compute2DSmallStrain.

Definition at line 94 of file ComputeStrainBase.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.");
 }

Referenced by ComputeStrainBase::initialSetup().

◆ getCurrentSubblockIndex()

unsigned int ComputeAxisymmetric1DFiniteStrain::getCurrentSubblockIndex ( ) const

inlineprotected

gets its subblock index for current element

Definition at line 49 of file ComputeAxisymmetric1DFiniteStrain.h.

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

Referenced by computeGradDispYY(), and computeGradDispYYOld().

◆ initialSetup()

void ComputeAxisymmetric1DFiniteStrain::initialSetup ( )

override

Definition at line 60 of file ComputeAxisymmetric1DFiniteStrain.C.

 {
   ComputeIncrementalStrainBase::initialSetup();
  
   if (getBlockCoordSystem() != Moose::COORD_RZ)
     mooseError("The coordinate system must be set to RZ for Axisymmetric geometries.");
 }

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

static

Definition at line 17 of file ComputeAxisymmetric1DFiniteStrain.C.

 {
   InputParameters params = Compute1DFiniteStrain::validParams();
   params.addClassDescription("Compute a strain increment and rotation increment for finite strains "
                              "in an axisymmetric 1D problem");
   params.addParam<UserObjectName>("subblock_index_provider",
                                   "SubblockIndexProvider user object name");
   params.addCoupledVar("scalar_out_of_plane_strain", "Scalar variable for axisymmetric 1D problem");
   params.addCoupledVar("out_of_plane_strain", "Nonlinear variable for axisymmetric 1D problem");
  
   return params;
 }