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)

Protected Member Functions
virtual void	computeProperties () override

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

void	initialSetup () override

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

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

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 24 of file ComputeIncrementalSmallStrain.h.

Constructor & Destructor Documentation

◆ ComputeIncrementalSmallStrain()

ComputeIncrementalSmallStrain::ComputeIncrementalSmallStrain ( const InputParameters & parameters )

Definition at line 26 of file ComputeIncrementalSmallStrain.C.

   : ComputeIncrementalStrainBase(parameters)
 {
 }

Member Function Documentation

◆ computeProperties()

void ComputeIncrementalSmallStrain::computeProperties ( )

overrideprotectedvirtual

Definition at line 32 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];
   }
 }

◆ 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, ComputeRSphericalIncrementalStrain, and Compute1DIncrementalStrain.

Definition at line 75 of file ComputeIncrementalSmallStrain.C.

Referenced by computeProperties().

 {
   // 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());
 }

◆ displacementIntegrityCheck()

void ComputeStrainBase::displacementIntegrityCheck ( )

protectedvirtualinherited

Reimplemented in Compute2DFiniteStrain, Compute2DIncrementalStrain, and Compute2DSmallStrain.

Definition at line 86 of file ComputeStrainBase.C.

Referenced by ComputeStrainBase::initialSetup().

 {
   // 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.");
 }

◆ initialSetup()

void ComputeIncrementalStrainBase::initialSetup ( )

overrideprotectedinherited

Definition at line 37 of file ComputeIncrementalStrainBase.C.

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

 {
   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;
   }
 }

◆ initQpStatefulProperties()

void ComputeIncrementalStrainBase::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Reimplemented in ComputeCosseratIncrementalSmallStrain.

Definition at line 50 of file ComputeIncrementalStrainBase.C.

Referenced by ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties().

 {
   _mechanical_strain[_qp].zero();
   _total_strain[_qp].zero();
   _deformation_gradient[_qp].zero();
   _deformation_gradient[_qp].addIa(1.0);
 
   // Note that for some models (small strain), the rotation increment is
   // never updated. Because we always have stateful properties, this method
   // always gets called, so we can rely on this getting set here without
   // setting it again when properties get computed.
   _rotation_increment[_qp].zero();
   _rotation_increment[_qp].addIa(1.0);
 }

◆ subtractEigenstrainIncrementFromStrain()

void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor & strain )

protectedinherited

Definition at line 66 of file ComputeIncrementalStrainBase.C.

Referenced by computeProperties(), ComputeCosseratIncrementalSmallStrain::computeQpProperties(), and ComputeFiniteStrain::computeQpStrain().

 {
   for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
   {
     strain -= (*_eigenstrains[i])[_qp];
     strain += (*_eigenstrains_old[i])[_qp];
   }
 }