ADDynamicStressDivergenceTensors is the automatic differentiation version of DynamicStressDivergenceTensors. More...

#include <ADDynamicStressDivergenceTensors.h>

Inheritance diagram for ADDynamicStressDivergenceTensors< compute_stage >:

Public Member Functions
	ADDynamicStressDivergenceTensors (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
ADReal	computeQpResidual ()

void	initialSetup () override

void	precalculateResidual () override

const	ADMaterialProperty (RankTwoTensor) &_stress

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_stress_older

const MaterialProperty< RankTwoTensor > &	_stress_old

const MaterialProperty< Real > &	_zeta

const Real	_alpha

const bool	_static_initialization

	usingStressDivergenceTensorsMembers

const std::string	_base_name

const unsigned int	_component

const unsigned int	_ndisp
	Coupled displacement variables. More...

std::vector< unsigned int >	_disp_var

std::vector< ADReal >	_avg_grad_test
	Gradient of test function averaged over the element. Used in volumetric locking correction calculation. More...

const bool	_volumetric_locking_correction
	Flag for volumetric locking correction. More...

	usingKernelMembers

Detailed Description

template<ComputeStage compute_stage>
class ADDynamicStressDivergenceTensors< compute_stage >

ADDynamicStressDivergenceTensors is the automatic differentiation version of DynamicStressDivergenceTensors.

This kernel derives from ADStressDivergenceTensors and adds stress related Rayleigh and HHT time integration terms.

Definition at line 16 of file ADDynamicStressDivergenceTensors.h.

Constructor & Destructor Documentation

◆ ADDynamicStressDivergenceTensors()

template<ComputeStage compute_stage>

ADDynamicStressDivergenceTensors< compute_stage >::ADDynamicStressDivergenceTensors ( const InputParameters & parameters )

Definition at line 40 of file ADDynamicStressDivergenceTensors.C.

   : ADStressDivergenceTensors<compute_stage>(parameters),
     _stress_older(getMaterialPropertyOlder<RankTwoTensor>(_base_name + "stress")),
     _stress_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "stress")),
     _zeta(getMaterialProperty<Real>("zeta")),
     _alpha(getParam<Real>("alpha")),
     _static_initialization(getParam<bool>("static_initialization"))
 {
 }

Member Function Documentation

◆ ADMaterialProperty()

template<ComputeStage compute_stage>

const ADStressDivergenceTensors< compute_stage >::ADMaterialProperty ( RankTwoTensor ) &

protectedinherited

◆ computeQpResidual()

template<ComputeStage compute_stage>

ADReal ADDynamicStressDivergenceTensors< compute_stage >::computeQpResidual ( )

protected

This kernel needs to be used only if either Rayleigh damping or numerical damping through HHT time integration scheme needs to be added to the problem thorugh the stiffness dependent damping parameter _zeta or HHT parameter _alpha, respectively.

The residual of _zeta*K*[(1+_alpha)vel-_alpha vel_old]+ alpha K [ u - uold] + K u is required = _zeta*[(1+_alpha)d/dt (Div sigma)-alpha d/dt(Div sigma_old)] +alpha [Div sigma - Div sigma_old]+ Div sigma = _zeta*[(1+alpha)(Div sigma - Div sigma_old)/dt - alpha (Div sigma_old - Div sigma_older)/dt]

alpha [Div sigma - Div sigma_old] +Div sigma = [(1+_alpha)*_zeta/dt +_alpha+1]* Div sigma - [(1+2_alpha)*_zeta/dt + _alpha] Div sigma_old + _alpha*_zeta/dt Div sigma_older

Definition at line 53 of file ADDynamicStressDivergenceTensors.C.

 {
   ADReal residual;
   if (_static_initialization && _t == _dt)
   {
     // If static inialization is true, then in the first step residual is only Ku which is
     // stress.grad(test).
     residual = _stress[_qp].row(_component) * _grad_test[_i][_qp];
  
     if (_volumetric_locking_correction)
       residual +=
           _stress[_qp].trace() / 3.0 * (_avg_grad_test[_i] - _grad_test[_i][_qp](_component));
   }
   else if (_dt > 0)
   {
     residual =
         _stress[_qp].row(_component) * _grad_test[_i][_qp] *
             (1.0 + _alpha + (1.0 + _alpha) * _zeta[_qp] / _dt) -
         (_alpha + (1.0 + 2.0 * _alpha) * _zeta[_qp] / _dt) * _stress_old[_qp].row(_component) *
             _grad_test[_i][_qp] +
         (_alpha * _zeta[_qp] / _dt) * _stress_older[_qp].row(_component) * _grad_test[_i][_qp];
  
     if (_volumetric_locking_correction)
       residual += (_stress[_qp].trace() * (1.0 + _alpha + (1.0 + _alpha) * _zeta[_qp] / _dt) -
                    (_alpha + (1.0 + 2.0 * _alpha) * _zeta[_qp] / _dt) * _stress_old[_qp].trace() +
                    (_alpha * _zeta[_qp] / _dt) * _stress_older[_qp].trace()) /
                   3.0 * (_avg_grad_test[_i] - _grad_test[_i][_qp](_component));
   }
   else
     residual = 0.0;
  
   return residual;
 }

◆ initialSetup()

template<ComputeStage compute_stage>

void ADStressDivergenceTensors< compute_stage >::initialSetup ( )

overrideprotectedinherited

Definition at line 63 of file ADStressDivergenceTensors.C.

 {
   if (getBlockCoordSystem() != Moose::COORD_XYZ)
     mooseError(
         "The coordinate system in the Problem block must be set to XYZ for cartesian geometries.");
 }

◆ precalculateResidual()

template<ComputeStage compute_stage>

void ADStressDivergenceTensors< compute_stage >::precalculateResidual ( )

overrideprotectedinherited

Definition at line 85 of file ADStressDivergenceTensors.C.

 {
   if (!_volumetric_locking_correction)
     return;
  
   ADReal ad_current_elem_volume = 0.0;
   for (unsigned int qp = 0; qp < _qrule->n_points(); qp++)
     ad_current_elem_volume += _ad_JxW[qp] * _ad_coord[qp];
  
   // Calculate volume averaged value of shape function derivative
   _avg_grad_test.resize(_test.size());
   for (_i = 0; _i < _test.size(); ++_i)
   {
     _avg_grad_test[_i] = 0.0;
     for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
       _avg_grad_test[_i] += _grad_test[_i][_qp](_component) * _ad_JxW[_qp] * _ad_coord[_qp];
  
     _avg_grad_test[_i] /= ad_current_elem_volume;
   }
 }

◆ validParams()

template<ComputeStage compute_stage>

InputParameters ADDynamicStressDivergenceTensors< compute_stage >::validParams ( )

static

Definition at line 19 of file ADDynamicStressDivergenceTensors.C.

 {
   InputParameters params = ADStressDivergenceTensors<compute_stage>::validParams();
   params.addClassDescription(
       "Residual due to stress related Rayleigh damping and HHT time integration terms");
   params.addParam<MaterialPropertyName>("zeta",
                                         0.0,
                                         "Name of material property or a constant real "
                                         "number defining the zeta parameter for the "
                                         "Rayleigh damping.");
   params.addParam<Real>("alpha", 0, "alpha parameter for HHT time integration");
   params.addParam<bool>("static_initialization",
                         false,
                         "Set to true to get the system to "
                         "equilibrium under gravity by running a "
                         "quasi-static analysis (by solving Ku = F) "
                         "in the first time step");
   return params;
 }