Compute1DIncrementalStrain defines a strain increment only for incremental small strains in 1D problems, handling strains in other two directions. More...

#include <Compute1DIncrementalStrain.h>

Inheritance diagram for Compute1DIncrementalStrain:

[legend]

Public Member Functions
	Compute1DIncrementalStrain (const InputParameters &parameters)

virtual void	computeProperties () override

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
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 Real	computeGradDispYY ()=0
	Computes the current dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual Real	computeGradDispYYOld ()=0
	Computes the old dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual Real	computeGradDispZZ ()=0
	Computes the current dUz/dZ; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...

virtual Real	computeGradDispZZOld ()=0
	Computes the old dUz/dZ; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. 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

Compute1DIncrementalStrain defines a strain increment only for incremental small strains in 1D problems, handling strains in other two directions.

Compute1DIncrementalStrain contains virtual methods to define the displacement gradients as a general nonzero value.

Definition at line 25 of file Compute1DIncrementalStrain.h.

Constructor & Destructor Documentation

◆ Compute1DIncrementalStrain()

Compute1DIncrementalStrain::Compute1DIncrementalStrain ( const InputParameters & parameters )

Definition at line 25 of file Compute1DIncrementalStrain.C.

   : ComputeIncrementalSmallStrain(parameters)
 {
 }

Member Function Documentation

◆ computeGradDispYY()

virtual Real Compute1DIncrementalStrain::computeGradDispYY ( )

protectedpure virtual

Computes the current dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetric1DIncrementalStrain.

Referenced by computeTotalStrainIncrement().

◆ computeGradDispYYOld()

virtual Real Compute1DIncrementalStrain::computeGradDispYYOld ( )

protectedpure virtual

Computes the old dUy/dY; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetric1DIncrementalStrain.

Referenced by computeTotalStrainIncrement().

◆ computeGradDispZZ()

virtual Real Compute1DIncrementalStrain::computeGradDispZZ ( )

protectedpure virtual

Computes the current dUz/dZ; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetric1DIncrementalStrain.

Referenced by computeTotalStrainIncrement().

◆ computeGradDispZZOld()

virtual Real Compute1DIncrementalStrain::computeGradDispZZOld ( )

protectedpure virtual

Computes the old dUz/dZ; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implemented in ComputeAxisymmetric1DIncrementalStrain.

Referenced by computeTotalStrainIncrement().

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

overrideprotectedvirtual

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

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

◆ validParams()

InputParameters Compute1DIncrementalStrain::validParams ( )

static

Definition at line 17 of file Compute1DIncrementalStrain.C.

 {
   InputParameters params = ComputeIncrementalSmallStrain::validParams();
   params.addClassDescription("Compute strain increment for small strains in 1D problems.");
  
   return params;
 }