ADPenaltyVelocityContinuity.h

Go to the documentation of this file.

//* 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 "InterfaceKernelBase.h"
#include "MooseVariableFE.h"

class ADPenaltyVelocityContinuity : public InterfaceKernelBase
{
public:
  static InputParameters validParams();

  ADPenaltyVelocityContinuity(const InputParameters & parameters);

  virtual void computeResidual() override;
  virtual void computeResidualAndJacobian() override;
  virtual void computeJacobian() override;
  virtual void computeElementOffDiagJacobian(unsigned int jvar) override;
  virtual void computeNeighborOffDiagJacobian(unsigned int jvar) override;
  virtual const MooseVariableFieldBase & variable() const override;
  virtual const MooseVariableFieldBase & neighborVariable() const override;

protected:
  virtual ADRealVectorValue solidVelocity(const unsigned int qp) const;

  const Real _penalty;

  const VectorMooseVariable * const _velocity_var;

  const ADVectorVariableValue & _velocity;

  std::vector<const ADVariableValue *> _solid_velocities;

  std::vector<const MooseVariable *> _displacements;

  const MooseArray<ADReal> & _ad_JxW;

  const MooseArray<ADReal> & _ad_coord;

  std::vector<ADReal> _residuals;

  std::vector<ADRealVectorValue> _qp_jumps;
};

inline void
ADPenaltyVelocityContinuity::computeJacobian()
{
  computeResidual();
}

inline void
ADPenaltyVelocityContinuity::computeResidualAndJacobian()
{
  computeResidual();
}

inline void
ADPenaltyVelocityContinuity::computeElementOffDiagJacobian(const unsigned int jvar)
{
  if (jvar == _velocity_var->number())
    // Only need to do this once because AD does everything all at once
    computeResidual();
}

inline void
ADPenaltyVelocityContinuity::computeNeighborOffDiagJacobian(unsigned int)
{
}

inline const MooseVariableFieldBase &
ADPenaltyVelocityContinuity::variable() const
{
  return *_velocity_var;
}

inline const MooseVariableFieldBase &
ADPenaltyVelocityContinuity::neighborVariable() const
{
  if (_displacements.empty() || !_displacements.front())
    mooseError("The 'neighborVariable' method was called which requires that displacements be "
               "actual variables.");

  return *_displacements.front();
}