ADDynamicStressDivergenceTensors.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "ADDynamicStressDivergenceTensors.h"
#include "ElasticityTensorTools.h"
 
registerADMooseObject("TensorMechanicsApp", ADDynamicStressDivergenceTensors);
 
defineADLegacyParams(ADDynamicStressDivergenceTensors);
 
template <ComputeStage compute_stage>
InputParameters
ADDynamicStressDivergenceTensors<compute_stage>::validParams()
{
  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;
}
 
template <ComputeStage compute_stage>
ADDynamicStressDivergenceTensors<compute_stage>::ADDynamicStressDivergenceTensors(
    const InputParameters & parameters)
  : 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"))
{
}
 
template <ComputeStage compute_stage>
ADReal
ADDynamicStressDivergenceTensors<compute_stage>::computeQpResidual()
{
  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;
}