ComputeAxisymmetric1DIncrementalStrain defines a strain increment only for incremental small strains in an Axisymmetric 1D problem. More...

#include <ComputeAxisymmetric1DIncrementalStrain.h>

Inheritance diagram for ComputeAxisymmetric1DIncrementalStrain:

[legend]

Public Member Functions
	ComputeAxisymmetric1DIncrementalStrain (const InputParameters &parameters)

void	initialSetup () override

virtual void	computeProperties () override

Static Public Member Functions
static InputParameters	validParams ()

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

void	computeTotalStrainIncrement (RankTwoTensor &total_strain_increment) override
	Computes the current and old deformation gradients with the assumptions for axisymmetric 1D problems, and returns the total strain increment tensor. 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...

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

ComputeAxisymmetric1DIncrementalStrain defines a strain increment only for incremental small strains in an Axisymmetric 1D problem.

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

Definition at line 25 of file ComputeAxisymmetric1DIncrementalStrain.h.

Constructor & Destructor Documentation

◆ ComputeAxisymmetric1DIncrementalStrain()

ComputeAxisymmetric1DIncrementalStrain::ComputeAxisymmetric1DIncrementalStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeAxisymmetric1DIncrementalStrain.C.

   : Compute1DIncrementalStrain(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 ComputeAxisymmetric1DIncrementalStrain::computeGradDispYY ( )

overrideprotectedvirtual

Computes the current dUy/dy for axisymmetric problems.

Implements Compute1DIncrementalStrain.

Definition at line 69 of file ComputeAxisymmetric1DIncrementalStrain.C.

 {
   if (_has_scalar_out_of_plane_strain)
     return (*_scalar_out_of_plane_strain[getCurrentSubblockIndex()])[0];
   else
     return _out_of_plane_strain[_qp];
 }

◆ computeGradDispYYOld()

Real ComputeAxisymmetric1DIncrementalStrain::computeGradDispYYOld ( )

overrideprotectedvirtual

Computes the old dUy/dy for axisymmetric problems.

Implements Compute1DIncrementalStrain.

Definition at line 78 of file ComputeAxisymmetric1DIncrementalStrain.C.

 {
   if (_has_scalar_out_of_plane_strain)
     return (*_scalar_out_of_plane_strain_old[getCurrentSubblockIndex()])[0];
   else
     return _out_of_plane_strain_old[_qp];
 }

◆ computeGradDispZZ()

Real ComputeAxisymmetric1DIncrementalStrain::computeGradDispZZ ( )

overrideprotectedvirtual

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

Implements Compute1DIncrementalStrain.

Definition at line 87 of file ComputeAxisymmetric1DIncrementalStrain.C.

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

◆ computeGradDispZZOld()

Real ComputeAxisymmetric1DIncrementalStrain::computeGradDispZZOld ( )

overrideprotectedvirtual

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

Implements Compute1DIncrementalStrain.

Definition at line 96 of file ComputeAxisymmetric1DIncrementalStrain.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 Compute1DIncrementalStrain::computeTotalStrainIncrement ( RankTwoTensor & total_strain_increment )

overrideprotectedvirtualinherited

Computes the current and old deformation gradients with the assumptions for axisymmetric 1D problems, and returns the total strain increment tensor.

Reimplemented from ComputeIncrementalSmallStrain.

Definition at line 31 of file Compute1DIncrementalStrain.C.

 {
   // Deformation gradient calculation for 1D 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 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
  
   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().

◆ getCurrentSubblockIndex()

unsigned int ComputeAxisymmetric1DIncrementalStrain::getCurrentSubblockIndex ( ) const

inlineprotected

gets its subblock index for current element

Definition at line 50 of file ComputeAxisymmetric1DIncrementalStrain.h.

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

Referenced by computeGradDispYY(), and computeGradDispYYOld().

◆ initialSetup()

void ComputeAxisymmetric1DIncrementalStrain::initialSetup ( )

override

Definition at line 60 of file ComputeAxisymmetric1DIncrementalStrain.C.

 {
   ComputeIncrementalStrainBase::initialSetup();
  
   if (getBlockCoordSystem() != Moose::COORD_RZ)
     mooseError("The coordinate system must be set to RZ for Axisymmetric 1D 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 ComputeAxisymmetric1DIncrementalStrain::validParams ( )

static

Definition at line 17 of file ComputeAxisymmetric1DIncrementalStrain.C.

 {
   InputParameters params = Compute1DIncrementalStrain::validParams();
   params.addClassDescription(
       "Compute strain increment for small 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;
 }