Add ADCoefReaction (idaholab#21009)

framework/doc/content/source/kernels/CoefReaction.md

@@ -1,4 +1,4 @@
-# CoefReaction
+# CoefReaction / ADCoefReaction
 
 !syntax description /Kernels/CoefReaction
 
@@ -9,9 +9,8 @@
 where $v$ (`v`) is a coupled variable.
 
 !alert note
-There is no AD (automatic differentiation) or FV (finite volume) version of `CoefReaction`.
-If you wish to use AD / FV, use [`ADCoupledForce`](/ADCoupledForce.md) /
-[`FVCoupledForce`](/FVCoupledForce.md) respectively.
+There is no FV (finite volume) version of `CoefReaction`. If you wish to use FV,
+use [/FVCoupledForce.md].
 
 !syntax parameters /Kernels/CoefReaction
 

framework/include/kernels/CoefReaction.h

@@ -11,17 +11,21 @@
 
 #include "Reaction.h"
 
-class CoefReaction : public Reaction
+template <bool is_ad>
+class CoefReactionTempl : public ReactionTempl<is_ad>
 {
 public:
   static InputParameters validParams();
 
-  CoefReaction(const InputParameters & parameters);
+  CoefReactionTempl(const InputParameters & parameters);
 
 protected:
-  virtual Real computeQpResidual() override;
+  virtual GenericReal<is_ad> computeQpResidual() override;
   virtual Real computeQpJacobian() override;
 
   /// input parameter multiplied by the reaction kernel
   const Real _coef;
 };
+
+typedef CoefReactionTempl<false> CoefReaction;
+typedef CoefReactionTempl<true> ADCoefReaction;

framework/src/kernels/CoefReaction.C

@@ -10,29 +10,40 @@
 #include "CoefReaction.h"
 
 registerMooseObject("MooseApp", CoefReaction);
+registerMooseObject("MooseApp", ADCoefReaction);
 
+template <bool is_ad>
 InputParameters
-CoefReaction::validParams()
+CoefReactionTempl<is_ad>::validParams()
 {
-  InputParameters params = Reaction::validParams();
+  InputParameters params = ReactionTempl<is_ad>::validParams();
   params.addClassDescription("Implements the residual term (p*u, test)");
   params.addParam<Real>("coefficient", 1.0, "Coefficient of the term");
   return params;
 }
 
-CoefReaction::CoefReaction(const InputParameters & parameters)
-  : Reaction(parameters), _coef(getParam<Real>("coefficient"))
+template <bool is_ad>
+CoefReactionTempl<is_ad>::CoefReactionTempl(const InputParameters & parameters)
+  : ReactionTempl<is_ad>(parameters), _coef(this->template getParam<Real>("coefficient"))
 {
 }
 
-Real
-CoefReaction::computeQpResidual()
+template <bool is_ad>
+GenericReal<is_ad>
+CoefReactionTempl<is_ad>::computeQpResidual()
 {
-  return _coef * Reaction::computeQpResidual();
+  return _coef * ReactionTempl<is_ad>::computeQpResidual();
 }
 
+template <bool is_ad>
 Real
-CoefReaction::computeQpJacobian()
+CoefReactionTempl<is_ad>::computeQpJacobian()
 {
-  return _coef * Reaction::computeQpJacobian();
+  // This function will never be called for the AD version. But because C++ does
+  // not support an optional function declaration based on a template parameter,
+  // we must keep this this template for all cases.
+  return _coef * ReactionTempl<is_ad>::computeQpJacobian();
 }
+
+template class CoefReactionTempl<false>;
+template class CoefReactionTempl<true>;

test/tests/kernels/ad_reaction/tests

@@ -14,4 +14,22 @@
     design = 'Reaction.md'
     issues = '#21009'
   []
+
+  [ad_coef_reaction]
+    type = 'Exodiff'
+    input = 'ad_reaction.i'
+    cli_args = 'Kernels/reaction/type=ADCoefReaction Kernels/reaction/coefficient=2 Outputs/file_base=ad_coef_reaction_out'
+    exodiff = 'ad_coef_reaction_out.e'
+    requirement = 'The system shall contain a consuming reaction term object with a scalar coefficient whose Jacobian is calculated via automatic forward differentiation.'
+    design = 'CoefReaction.md'
+    issues = '#21009'
+  []
+  [ad_coef_reaction_jac]
+    type = PetscJacobianTester
+    input = 'ad_reaction.i'
+    cli_args = 'Kernels/reaction/type=ADCoefReaction Kernels/reaction/coefficient=2'
+    requirement = 'The system shall produce a perfect Jacobian for a consuming reaction term object with a scalar coefficient using automatic forward differentiation.'
+    design = 'CoefReaction.md'
+    issues = '#21009'
+  []
 []