ComputeIncrementalSmallStrain defines a strain increment and rotation increment (=1), for small strains. More...

#include <ComputeIncrementalSmallStrain.h>

Inheritance diagram for ComputeIncrementalSmallStrain:

Public Member Functions
	ComputeIncrementalSmallStrain (const InputParameters &parameters)

virtual void	computeProperties () override

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeTotalStrainIncrement (RankTwoTensor &total_strain_increment)
	Computes the current and old deformation gradients and passes back the total strain increment tensor. More...

virtual void	initQpStatefulProperties () override

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

virtual void	displacementIntegrityCheck ()

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

ComputeIncrementalSmallStrain defines a strain increment and rotation increment (=1), for small strains.

Definition at line 23 of file ComputeIncrementalSmallStrain.h.

Constructor & Destructor Documentation

◆ ComputeIncrementalSmallStrain()

ComputeIncrementalSmallStrain::ComputeIncrementalSmallStrain ( const InputParameters & parameters )

Definition at line 27 of file ComputeIncrementalSmallStrain.C.

   : ComputeIncrementalStrainBase(parameters)
 {
 }

Member Function Documentation

◆ computeProperties()

void ComputeIncrementalSmallStrain::computeProperties ( )

overridevirtual

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 ComputeIncrementalSmallStrain::computeTotalStrainIncrement ( RankTwoTensor & total_strain_increment )

protectedvirtual

Computes the current and old deformation gradients and passes back the total strain increment tensor.

Reimplemented in Compute2DIncrementalStrain, Compute1DIncrementalStrain, and ComputeRSphericalIncrementalStrain.

Definition at line 79 of file ComputeIncrementalSmallStrain.C.

 {
   // Deformation gradient
   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
  
   _deformation_gradient[_qp] = A;
   _deformation_gradient[_qp].addIa(1.0);
  
   A -= Fbar; // A = grad_disp - grad_disp_old
  
   total_strain_increment = 0.5 * (A + A.transpose());
 }

Referenced by computeProperties().

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

overrideinherited

Definition at line 38 of file ComputeIncrementalStrainBase.C.

 {
   ComputeStrainBase::initialSetup();
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (_fe_problem.isTransient() && i < _ndisp)
       _grad_disp_old[i] = &coupledGradientOld("displacements", i);
     else
       _grad_disp_old[i] = &_grad_zero;
   }
 }

Referenced by ComputeAxisymmetric1DFiniteStrain::initialSetup(), ComputeAxisymmetricRZIncrementalStrain::initialSetup(), ComputeRSphericalFiniteStrain::initialSetup(), ComputeRSphericalIncrementalStrain::initialSetup(), and ComputeAxisymmetric1DIncrementalStrain::initialSetup().

◆ 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 computeProperties(), ComputeCosseratIncrementalSmallStrain::computeQpProperties(), and ComputeFiniteStrain::computeQpStrain().

◆ validParams()

InputParameters ComputeIncrementalSmallStrain::validParams ( )

static

Definition at line 19 of file ComputeIncrementalSmallStrain.C.

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