ComputeCosseratIncrementalSmallStrain defines various incremental versions of the Cossserat strain tensor, assuming small strains. More...

#include <ComputeCosseratIncrementalSmallStrain.h>

Inheritance diagram for ComputeCosseratIncrementalSmallStrain:

[legend]

Public Member Functions
	ComputeCosseratIncrementalSmallStrain (const InputParameters &parameters)

void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpProperties ()

virtual void	initQpStatefulProperties ()

void	subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)

virtual void	displacementIntegrityCheck ()

Protected Attributes
MaterialProperty< RankTwoTensor > &	_curvature
	the Cosserat curvature strain: curvature_ij = nabla_j CosseratRotation_i More...

const unsigned int	_nrots
	the number of Cosserat rotation variables supplied by the user (must be 3 in current implementation) More...

std::vector< const VariableValue * >	_wc
	The Cosserat rotations. More...

std::vector< const VariableValue * >	_wc_old
	The Cosserat rotations. More...

std::vector< const VariableGradient * >	_grad_wc
	Grad(Cosserat rotation) More...

std::vector< const VariableGradient * >	_grad_wc_old
	Grad(Cosserat rotation) More...

const MaterialProperty< RankTwoTensor > &	_curvature_old
	the Cosserat curvature strain: curvature_ij = nabla_j CosseratRotation_i More...

MaterialProperty< RankTwoTensor > &	_curvature_increment
	_curvature_increment = (curvature - _curvature_old) More...

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

ComputeCosseratIncrementalSmallStrain defines various incremental versions of the Cossserat strain tensor, assuming small strains.

Definition at line 23 of file ComputeCosseratIncrementalSmallStrain.h.

Constructor & Destructor Documentation

◆ ComputeCosseratIncrementalSmallStrain()

ComputeCosseratIncrementalSmallStrain::ComputeCosseratIncrementalSmallStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeCosseratIncrementalSmallStrain.C.

   : ComputeIncrementalStrainBase(parameters),
     _curvature(declareProperty<RankTwoTensor>("curvature")),
     _nrots(coupledComponents("Cosserat_rotations")),
     _wc(_nrots),
     _wc_old(_nrots),
     _grad_wc(_nrots),
     _grad_wc_old(_nrots),
     _curvature_old(getMaterialPropertyOld<RankTwoTensor>("curvature")),
     _curvature_increment(declareProperty<RankTwoTensor>("curvature_increment"))
 {
   if (_nrots != 3)
     mooseError("ComputeCosseratSmallStrain: This Material is only defined for 3-dimensional "
                "simulations so 3 Cosserat rotation variables are needed");
   for (unsigned i = 0; i < _nrots; ++i)
   {
     _wc[i] = &coupledValue("Cosserat_rotations", i);
     _wc_old[i] = &coupledValueOld("Cosserat_rotations", i);
     _grad_wc[i] = &coupledGradient("Cosserat_rotations", i);
     _grad_wc_old[i] = &coupledGradientOld("Cosserat_rotations", i);
   }
 }

Member Function Documentation

◆ computeQpProperties()

void ComputeCosseratIncrementalSmallStrain::computeQpProperties ( )

protectedvirtual

Definition at line 63 of file ComputeCosseratIncrementalSmallStrain.C.

 {
   RankTwoTensor strain((*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]);
   RankTwoTensor strain_old(
       (*_grad_disp_old[0])[_qp], (*_grad_disp_old[1])[_qp], (*_grad_disp_old[2])[_qp]);
   RealVectorValue wc_vector((*_wc[0])[_qp], (*_wc[1])[_qp], (*_wc[2])[_qp]);
   RealVectorValue wc_vector_old((*_wc_old[0])[_qp], (*_wc_old[1])[_qp], (*_wc_old[2])[_qp]);
  
   for (unsigned i = 0; i < LIBMESH_DIM; ++i)
     for (unsigned j = 0; j < LIBMESH_DIM; ++j)
       for (unsigned k = 0; k < LIBMESH_DIM; ++k)
       {
         strain(i, j) += PermutationTensor::eps(i, j, k) * wc_vector(k);
         strain_old(i, j) += PermutationTensor::eps(i, j, k) * wc_vector_old(k);
       }
  
   _deformation_gradient[_qp] = strain;
   _deformation_gradient[_qp].addIa(1.0); // Gauss point deformation gradient
  
   const RankTwoTensor total_strain_increment = strain - strain_old;
  
   _strain_increment[_qp] = total_strain_increment;
  
   // Remove the eigenstrain increment
   subtractEigenstrainIncrementFromStrain(_strain_increment[_qp]);
  
   _strain_rate[_qp] = _strain_increment[_qp] / _dt;
  
   _total_strain[_qp] = _total_strain_old[_qp] + total_strain_increment;
   _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
  
   RankTwoTensor curv((*_grad_wc[0])[_qp], (*_grad_wc[1])[_qp], (*_grad_wc[2])[_qp]);
   RankTwoTensor curv_old((*_grad_wc_old[0])[_qp], (*_grad_wc_old[1])[_qp], (*_grad_wc_old[2])[_qp]);
   _curvature_increment[_qp] = curv - curv_old;
   _curvature[_qp] = _curvature_old[_qp] + _curvature_increment[_qp];
  
   // incremental small strain does not include rotation
   _rotation_increment[_qp].setToIdentity();
 }

◆ 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 ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties ( )

protectedvirtual

Reimplemented from ComputeIncrementalStrainBase.

Definition at line 55 of file ComputeCosseratIncrementalSmallStrain.C.

 {
   ComputeIncrementalStrainBase::initQpStatefulProperties();
  
   _curvature[_qp].zero();
 }

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

◆ validParams()

InputParameters ComputeCosseratIncrementalSmallStrain::validParams ( )

static

Definition at line 22 of file ComputeCosseratIncrementalSmallStrain.C.

 {
   InputParameters params = ComputeIncrementalStrainBase::validParams();
   params.addClassDescription("Compute incremental small Cosserat strains");
   params.addRequiredCoupledVar("Cosserat_rotations", "The 3 Cosserat rotation variables");
   return params;
 }