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();
}