UpdatedLagrangianStressDivergence.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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

#pragma once

#include "LagrangianStressDivergenceBase.h"
#include "GradientOperator.h"
#include "Assembly.h"

template <class G>
class UpdatedLagrangianStressDivergenceBase : public LagrangianStressDivergenceBase, public G
{
public:
  static InputParameters baseParams()
  {
    InputParameters params = LagrangianStressDivergenceBase::validParams();
    return params;
  }
  static InputParameters validParams();
  UpdatedLagrangianStressDivergenceBase(const InputParameters & parameters);
  virtual void initialSetup() override;

protected:
  virtual RankTwoTensor gradTest(unsigned int component) override;
  virtual RankTwoTensor gradTrial(unsigned int component) override;
  virtual void precalculateJacobianDisplacement(unsigned int component) override;
  virtual Real computeQpResidual() override;
  virtual Real computeQpJacobianDisplacement(unsigned int alpha, unsigned int beta) override;
  virtual Real computeQpJacobianTemperature(unsigned int cvar) override;
  virtual Real computeQpJacobianOutOfPlaneStrain() override { return 0; }

  const MaterialProperty<RankTwoTensor> & _stress;

  // The derivative of the increment in Cauchy stress w.r.t. the increment in the spatial velocity
  // gradient
  const MaterialProperty<RankFourTensor> & _material_jacobian;

  // @{
  // The assembly quantities in the reference frame for stabilization
  Assembly & _assembly_undisplaced;
  const VariablePhiGradient & _grad_phi_undisplaced;
  const MooseArray<Real> & _JxW_undisplaced;
  const MooseArray<Real> & _coord_undisplaced;
  const MooseArray<Point> & _q_point_undisplaced;
  // @}

private:
  virtual RankTwoTensor gradTrialUnstabilized(unsigned int component);
};

template <>
inline InputParameters
UpdatedLagrangianStressDivergenceBase<GradientOperatorCartesian>::validParams()
{
  InputParameters params = UpdatedLagrangianStressDivergenceBase::baseParams();
  params.addClassDescription(
      "Enforce equilibrium with an updated Lagrangian formulation in Cartesian coordinates.");
  return params;
}

template <>
inline void
UpdatedLagrangianStressDivergenceBase<GradientOperatorCartesian>::initialSetup()
{
  // Derives _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.
  LagrangianStressDivergenceBase::initialSetup();

  if (getBlockCoordSystem() != Moose::COORD_XYZ)
    mooseError("This kernel should only act in Cartesian coordinates.");

  // The updated Lagrangian kernel integrates on the displaced mesh iff large kinematics is on;
  // large_kinematics is derived from the strain calculator, so validate the pairing here.
  if (_large_kinematics && !getParam<bool>("use_displaced_mesh"))
    mooseError("The UpdatedLagrangianStressDivergence kernels require use_displaced_mesh = true "
               "for large_kinematics = true");
  if (!_large_kinematics && getParam<bool>("use_displaced_mesh"))
    mooseError("The UpdatedLagrangianStressDivergence kernels require use_displaced_mesh = false "
               "for large_kinematics = false");
}

typedef UpdatedLagrangianStressDivergenceBase<GradientOperatorCartesian>
    UpdatedLagrangianStressDivergence;