ComputeAxisymmetricRZIncrementalStrain defines a strain increment only for incremental strains in an Axisymmetric simulation. More...

#include <ComputeAxisymmetricRZIncrementalStrain.h>

Inheritance diagram for ComputeAxisymmetricRZIncrementalStrain:

[legend]

Public Member Functions
	ComputeAxisymmetricRZIncrementalStrain (const InputParameters &parameters)

void	initialSetup () override

virtual void	computeProperties () override

Static Public Member Functions
static InputParameters	validParams ()

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

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

virtual void	displacementIntegrityCheck () override

virtual void	computeTotalStrainIncrement (RankTwoTensor &total_strain_increment) override
	Computes the current and old deformation gradients with the assumptions for 2D geometries, including plane strain, generalized plane strain, and axisymmetric, and returns the total strain increment tensor. More...

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

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

const unsigned int	_out_of_plane_direction

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

ComputeAxisymmetricRZIncrementalStrain defines a strain increment only for incremental strains in an Axisymmetric simulation.

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

Definition at line 24 of file ComputeAxisymmetricRZIncrementalStrain.h.

Constructor & Destructor Documentation

◆ ComputeAxisymmetricRZIncrementalStrain()

ComputeAxisymmetricRZIncrementalStrain::ComputeAxisymmetricRZIncrementalStrain ( const InputParameters & parameters )

Definition at line 28 of file ComputeAxisymmetricRZIncrementalStrain.C.

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

Member Function Documentation

◆ computeOutOfPlaneGradDisp()

Real ComputeAxisymmetricRZIncrementalStrain::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.

Implements Compute2DIncrementalStrain.

Definition at line 48 of file ComputeAxisymmetricRZIncrementalStrain.C.

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

◆ computeOutOfPlaneGradDispOld()

Real ComputeAxisymmetricRZIncrementalStrain::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 Compute2DIncrementalStrain.

Definition at line 57 of file ComputeAxisymmetricRZIncrementalStrain.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 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 Compute2DIncrementalStrain::computeTotalStrainIncrement ( RankTwoTensor & total_strain_increment )

overrideprotectedvirtualinherited

Computes the current and old deformation gradients with the assumptions for 2D geometries, including plane strain, generalized plane strain, and axisymmetric, and returns the total strain increment tensor.

Reimplemented from ComputeIncrementalSmallStrain.

Definition at line 58 of file Compute2DIncrementalStrain.C.

 {
   // 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 of 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();
  
   _deformation_gradient[_qp] = A;
   _deformation_gradient[_qp].addIa(1.0);
  
   A -= Fbar; // very nearly A = gradU - gradUold
  
   total_strain_increment = 0.5 * (A + A.transpose());
 }

◆ displacementIntegrityCheck()

void Compute2DIncrementalStrain::displacementIntegrityCheck ( )

overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Definition at line 81 of file Compute2DIncrementalStrain.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 ComputeAxisymmetricRZIncrementalStrain::initialSetup ( )

override

Definition at line 35 of file ComputeAxisymmetricRZIncrementalStrain.C.

 {
   ComputeIncrementalStrainBase::initialSetup();
  
   if (getBlockCoordSystem() != Moose::COORD_RZ)
     mooseError("The coordinate system must be set to RZ for Axisymmetric geometries.");
  
   if (_out_of_plane_direction != 2)
     paramError("out_of_plane_direction",
                "The out-of-plane direction for axisymmetric systems is currently restricted to z");
 }

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

static

Definition at line 20 of file ComputeAxisymmetricRZIncrementalStrain.C.

 {
   InputParameters params = Compute2DIncrementalStrain::validParams();
   params.addClassDescription("Compute a strain increment and rotation increment for small strains "
                              "under axisymmetric assumptions.");
   return params;
 }