ComputeRSphericalFiniteStrain defines a strain increment and a rotation increment for finite strains in 1D spherical symmetry geometries. More...

#include <ComputeRSphericalFiniteStrain.h>

Inheritance diagram for ComputeRSphericalFiniteStrain:

[legend]

Public Member Functions
	ComputeRSphericalFiniteStrain (const InputParameters &parameters)

virtual void	initialSetup ()

virtual void	computeProperties ()
	Computes the current and old deformation gradients with the assumptions for 1D spherical symmetry geometries: \( \epsilon_{\theta} = \epsilon_{\phi} = \frac{u_r}{r} \). More...

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	decompositionType ()

Protected Member Functions
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...

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

ComputeRSphericalFiniteStrain defines a strain increment and a rotation increment for finite strains in 1D spherical symmetry geometries.

The strains in the polar and azimuthal directions are functions of the radial displacement.

Definition at line 25 of file ComputeRSphericalFiniteStrain.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

◆ ComputeRSphericalFiniteStrain()

ComputeRSphericalFiniteStrain::ComputeRSphericalFiniteStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeRSphericalFiniteStrain.C.

   : ComputeFiniteStrain(parameters), _disp_old_0(coupledValueOld("displacements", 0))
 {
 }

Member Function Documentation

◆ computeProperties()

void ComputeRSphericalFiniteStrain::computeProperties ( )

virtual

Computes the current and old deformation gradients with the assumptions for 1D spherical symmetry geometries: \( \epsilon_{\theta} = \epsilon_{\phi} = \frac{u_r}{r} \).

Definition at line 47 of file ComputeRSphericalFiniteStrain.C.

 {
   // Method from Rashid, 1993
   RankTwoTensor ave_Fhat;
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     // Deformation gradient calculation in cylindrical coordinates
     RankTwoTensor A;    // Deformation gradient
     RankTwoTensor Fbar; // Old Deformation gradient
  
     // Step through calculating the current and old deformation gradients
     // Only diagonal components are nonzero because this is a 1D material
     // Note: x_disp is the radial displacement
     A(0, 0) = (*_grad_disp[0])[_qp](0);
     Fbar(0, 0) = (*_grad_disp_old[0])[_qp](0);
  
     // The polar and azimuthal strains are functions of radial displacement
     if (!MooseUtils::relativeFuzzyEqual(_q_point[_qp](0), 0.0))
     {
       A(1, 1) = (*_disp[0])[_qp] / _q_point[_qp](0);
       Fbar(1, 1) = _disp_old_0[_qp] / _q_point[_qp](0);
     }
  
     // The polar and azimuthal strains are equivalent in this 1D problem
     A(2, 2) = A(1, 1);
     Fbar(2, 2) = Fbar(1, 1);
  
     // Gauss point deformation gradient
     _deformation_gradient[_qp] = A;
     _deformation_gradient[_qp].addIa(1.0);
  
     // very nearly A = gradU - gradUold, adapted to cylindrical coords
     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);
  
     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 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().

◆ initialSetup()

void ComputeRSphericalFiniteStrain::initialSetup ( )

virtual

Definition at line 36 of file ComputeRSphericalFiniteStrain.C.

 {
   ComputeIncrementalStrainBase::initialSetup();
  
   const auto & subdomainIDs = _mesh.meshSubdomains();
   for (auto subdomainID : subdomainIDs)
     if (_fe_problem.getCoordSystem(subdomainID) != Moose::COORD_RSPHERICAL)
       mooseError("The coordinate system must be set to RSPHERICAL for 1D R spherical simulations.");
 }

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

static

Definition at line 22 of file ComputeRSphericalFiniteStrain.C.

 {
   InputParameters params = ComputeFiniteStrain::validParams();
   params.addClassDescription("Compute a strain increment and rotation increment for finite strains "
                              "in 1D spherical symmetry problems.");
   return params;
 }