Compute2DSmallStrain defines a strain tensor, assuming small strains, in 2D geometries / simulations. More...

#include <Compute2DSmallStrain.h>

Inheritance diagram for Compute2DSmallStrain:

Public Member Functions
	Compute2DSmallStrain (const InputParameters &parameters)

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeProperties () override

virtual void	displacementIntegrityCheck () override

virtual Real	computeOutOfPlaneStrain ()=0

virtual void	initQpStatefulProperties () override

Protected Attributes
const unsigned int	_out_of_plane_direction

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

Compute2DSmallStrain defines a strain tensor, assuming small strains, in 2D geometries / simulations.

ComputePlaneSmallStrain acts as a base class for ComputePlaneSmallStrain and ComputeAxisymmetricRZSmallStrain through the computeOutOfPlaneStrain method.

Definition at line 25 of file Compute2DSmallStrain.h.

Constructor & Destructor Documentation

◆ Compute2DSmallStrain()

Compute2DSmallStrain::Compute2DSmallStrain ( const InputParameters & parameters )

Definition at line 28 of file Compute2DSmallStrain.C.

   : ComputeSmallStrain(parameters),
     _out_of_plane_direction(getParam<MooseEnum>("out_of_plane_direction"))
 {
 }

Member Function Documentation

◆ computeOutOfPlaneStrain()

virtual Real Compute2DSmallStrain::computeOutOfPlaneStrain ( )

protectedpure virtual

Implemented in ComputeAxisymmetricRZSmallStrain, and ComputePlaneSmallStrain.

Referenced by computeProperties().

◆ computeProperties()

void Compute2DSmallStrain::computeProperties ( )

overrideprotectedvirtual

Reimplemented from ComputeSmallStrain.

Definition at line 54 of file Compute2DSmallStrain.C.

 {
   const auto o0 = _out_of_plane_direction;
   const auto o1 = (_out_of_plane_direction + 1) % 3;
   const auto o2 = (_out_of_plane_direction + 2) % 3;
  
   Real volumetric_strain = 0.0;
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     _total_strain[_qp](o0, o0) = computeOutOfPlaneStrain();
     _total_strain[_qp](o1, o1) = (*_grad_disp[o1])[_qp](o1);
     _total_strain[_qp](o2, o2) = (*_grad_disp[o2])[_qp](o2);
     _total_strain[_qp](o1, o2) = ((*_grad_disp[o1])[_qp](o2) + (*_grad_disp[o2])[_qp](o1)) / 2.0;
     _total_strain[_qp](o2, o1) = _total_strain[_qp](o1, o2); // force the symmetrical strain tensor
  
     if (_volumetric_locking_correction)
       volumetric_strain += _total_strain[_qp].trace() * _JxW[_qp] * _coord[_qp];
   }
  
   if (_volumetric_locking_correction)
     volumetric_strain /= _current_elem_volume;
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     if (_volumetric_locking_correction)
     {
       const Real correction = (volumetric_strain - _total_strain[_qp].trace()) / 3.0;
       _total_strain[_qp](0, 0) += correction;
       _total_strain[_qp](1, 1) += correction;
       _total_strain[_qp](2, 2) += correction;
     }
  
     _mechanical_strain[_qp] = _total_strain[_qp];
  
     // Remove the eigenstrains
     for (const auto es : _eigenstrains)
       _mechanical_strain[_qp] -= (*es)[_qp];
   }
 }

◆ displacementIntegrityCheck()

void Compute2DSmallStrain::displacementIntegrityCheck ( )

overrideprotectedvirtual

Reimplemented from ComputeStrainBase.

Definition at line 95 of file Compute2DSmallStrain.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.");
 }

Referenced by initialSetup().

◆ initialSetup()

void Compute2DSmallStrain::initialSetup ( )

override

Definition at line 35 of file Compute2DSmallStrain.C.

 {
   displacementIntegrityCheck();
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (_out_of_plane_direction == i)
     {
       _disp[i] = &_zero;
       _grad_disp[i] = &_grad_zero;
     }
     else
     {
       _disp[i] = &coupledValue("displacements", i);
       _grad_disp[i] = &coupledGradient("displacements", i);
     }
   }
 }

Referenced by ComputeAxisymmetricRZSmallStrain::initialSetup().

◆ initQpStatefulProperties()

void ComputeStrainBase::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented in ComputeIncrementalStrainBase, and ComputeCosseratIncrementalSmallStrain.

Definition at line 104 of file ComputeStrainBase.C.

 {
   _mechanical_strain[_qp].zero();
   _total_strain[_qp].zero();
 }

◆ validParams()

InputParameters Compute2DSmallStrain::validParams ( )

static

Definition at line 17 of file Compute2DSmallStrain.C.

 {
   InputParameters params = ComputeSmallStrain::validParams();
   params.addClassDescription("Compute a small strain in a plane strain configuration.");
  
   MooseEnum outOfPlaneDirection("x y z", "z");
   params.addParam<MooseEnum>(
       "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
   return params;
 }