ComputeRSphericalIncrementalStrain defines a strain increment only for small strains in 1D spherical symmetry geometries. More...

#include <ComputeRSphericalIncrementalStrain.h>

Inheritance diagram for ComputeRSphericalIncrementalStrain:

[legend]

Public Member Functions
	ComputeRSphericalIncrementalStrain (const InputParameters &parameters)

virtual void	initialSetup () override

virtual void	computeProperties () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeTotalStrainIncrement (RankTwoTensor &total_strain_increment) override
	Computes the current and old deformation gradients with the assumptions for 1D spherical symmetry geometries: \( \epsilon_{\theta} = \epsilon_{\phi} = \frac{u_r}{r} \). More...

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

Detailed Description

ComputeRSphericalIncrementalStrain defines a strain increment only for small 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 ComputeRSphericalIncrementalStrain.h.

Constructor & Destructor Documentation

◆ ComputeRSphericalIncrementalStrain()

ComputeRSphericalIncrementalStrain::ComputeRSphericalIncrementalStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeRSphericalIncrementalStrain.C.

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

Member Function Documentation

◆ computeProperties()

void ComputeIncrementalSmallStrain::computeProperties ( )

overridevirtualinherited

Definition at line 33 of file ComputeIncrementalSmallStrain.C.

 {
   Real volumetric_strain = 0.0;
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     RankTwoTensor total_strain_increment;
     computeTotalStrainIncrement(total_strain_increment);
  
     _strain_increment[_qp] = total_strain_increment;
  
     if (_volumetric_locking_correction)
       volumetric_strain += total_strain_increment.trace() * _JxW[_qp] * _coord[_qp];
   }
   if (_volumetric_locking_correction)
     volumetric_strain /= _current_elem_volume;
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     Real trace = _strain_increment[_qp].trace();
     if (_volumetric_locking_correction)
     {
       _strain_increment[_qp](0, 0) += (volumetric_strain - trace) / 3.0;
       _strain_increment[_qp](1, 1) += (volumetric_strain - trace) / 3.0;
       _strain_increment[_qp](2, 2) += (volumetric_strain - trace) / 3.0;
     }
  
     _total_strain[_qp] = _total_strain_old[_qp] + _strain_increment[_qp];
  
     // Remove the Eigen strain increment
     subtractEigenstrainIncrementFromStrain(_strain_increment[_qp]);
  
     // strain rate
     if (_dt > 0)
       _strain_rate[_qp] = _strain_increment[_qp] / _dt;
     else
       _strain_rate[_qp].zero();
  
     // Update strain in intermediate configuration: rotations are not needed
     _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
  
     // incremental small strain does not include rotation
     _rotation_increment[_qp].setToIdentity();
   }
 }

◆ computeTotalStrainIncrement()

void ComputeRSphericalIncrementalStrain::computeTotalStrainIncrement ( RankTwoTensor & total_strain_increment )

overrideprotectedvirtual

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

Reimplemented from ComputeIncrementalSmallStrain.

Definition at line 48 of file ComputeRSphericalIncrementalStrain.C.

 {
   // 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;
  
   total_strain_increment = 0.5 * (A + A.transpose());
 }

◆ 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 ComputeRSphericalIncrementalStrain::initialSetup ( )

overridevirtual

Definition at line 37 of file ComputeRSphericalIncrementalStrain.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 ComputeRSphericalIncrementalStrain::validParams ( )

static

Definition at line 22 of file ComputeRSphericalIncrementalStrain.C.

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