Cleanup and adify Reaction and MatReaction

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

@@ -0,0 +1 @@
+MatReaction.md

framework/include/kernels/ADMatReaction.h

@@ -9,32 +9,4 @@
 
 #pragma once
 
-#include "ADKernel.h"
-
-/**
- *  Kernel representing the contribution of the PDE term $-L*v$, where $L$ is a
- *  reaction rate coefficient material property, $v$ is a scalar variable (nonlinear or coupled
- * auxvariable), and whose Jacobian contribution is calculated using automatic differentiation.
- */
-class ADMatReaction : public ADKernel
-{
-public:
-  static InputParameters validParams();
-
-  ADMatReaction(const InputParameters & parameters);
-
-protected:
-  virtual ADReal computeQpResidual() override;
-
-private:
-  /**
-   * Kernel variable (can be nonlinear or coupled variable)
-   * (For constrained Allen-Cahn problems such as those in
-   * phase field, v = lambda where lambda is the Lagrange
-   * multiplier)
-   */
-  const ADVariableValue & _v;
-
-  /// Reaction rate material property
-  const ADMaterialProperty<Real> & _reaction_rate;
-};
+#include "MatReaction.h"

framework/include/kernels/CoefReaction.h

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

framework/include/kernels/MatReaction.h

@@ -9,26 +9,49 @@
 
 #pragma once
 
-#include "Kernel.h"
+#include "GenericKernel.h"
 #include "JvarMapInterface.h"
 #include "DerivativeMaterialInterface.h"
 
-// Forward Declaration
-
 /**
  * This kernel adds to the residual a contribution of \f$ -L*v \f$ where \f$ L \f$ is a material
  * property and \f$ v \f$ is a variable (nonlinear or coupled).
  */
-class MatReaction : public DerivativeMaterialInterface<JvarMapKernelInterface<Kernel>>
+template <bool is_ad>
+class MatReactionTempl : public GenericKernel<is_ad>
+{
+public:
+  static InputParameters validParams();
+
+  MatReactionTempl(const InputParameters & parameters);
+
+protected:
+  virtual GenericReal<is_ad> computeQpResidual();
+
+  /// Reaction rate
+  const GenericMaterialProperty<Real, is_ad> & _rate;
+
+  /**
+   * Kernel variable (can be nonlinear or coupled variable)
+   * (For constrained Allen-Cahn problems, v = lambda
+   * where lambda is the Lagrange multiplier)
+   */
+  const GenericVariableValue<is_ad> & _v;
+
+  usingGenericKernelMembers;
+};
+
+class MatReaction
+  : public DerivativeMaterialInterface<JvarMapKernelInterface<MatReactionTempl<false>>>
 {
 public:
   static InputParameters validParams();
 
   MatReaction(const InputParameters & parameters);
+
   virtual void initialSetup();
 
 protected:
-  virtual Real computeQpResidual();
   virtual Real computeQpJacobian();
   virtual Real computeQpOffDiagJacobian(unsigned int jvar);
 
@@ -40,23 +63,17 @@ class MatReaction : public DerivativeMaterialInterface<JvarMapKernelInterface<Ke
    * (For constrained Allen-Cahn problems, v = lambda
    * where lambda is the Lagrange multiplier)
    */
-
   std::string _v_name;
-  const VariableValue & _v;
   unsigned int _v_var;
 
-  /// Reaction rate
-  const MaterialProperty<Real> & _L;
-
-  /// name of the order parameter (needed to retrieve the derivative material properties)
-  VariableName _eta_name;
-
-  ///  Reaction rate derivative w.r.t. order parameter
-  const MaterialProperty<Real> & _dLdop;
+  ///  Reaction rate derivative w.r.t. primal variable
+  const MaterialProperty<Real> & _drate_du;
 
   ///  Reaction rate derivative w.r.t. the variable being added by this kernel
-  const MaterialProperty<Real> & _dLdv;
+  const MaterialProperty<Real> & _drate_dv;
 
   ///  Reaction rate derivatives w.r.t. other coupled variables
-  std::vector<const MaterialProperty<Real> *> _dLdarg;
+  std::vector<const MaterialProperty<Real> *> _drate_darg;
 };
+
+typedef MatReactionTempl<true> ADMatReaction;

framework/include/kernels/Reaction.h

@@ -24,13 +24,24 @@ class ReactionTempl : public GenericKernel<is_ad>
 
 protected:
   virtual GenericReal<is_ad> computeQpResidual() override;
-  virtual Real computeQpJacobian() override;
 
   /// Scalar coefficient representing the relative amount consumed per unit time
   const Real & _rate;
 
   usingGenericKernelMembers;
 };
 
-typedef ReactionTempl<false> Reaction;
+class Reaction : public ReactionTempl<false>
+{
+public:
+  static InputParameters validParams();
+
+  Reaction(const InputParameters & parameters);
+
+  using ReactionTempl<false>::ReactionTempl;
+
+protected:
+  virtual Real computeQpJacobian() override;
+};
+
 typedef ReactionTempl<true> ADReaction;

framework/src/kernels/CoefReaction.C

@@ -9,8 +9,8 @@
 
 #include "CoefReaction.h"
 
-registerMooseObject("MooseApp", CoefReaction);
-registerMooseObject("MooseApp", ADCoefReaction);
+registerMooseObjectReplaced("MooseApp", CoefReaction, "01/01/2027 00:00", Reaction);
+registerMooseObjectReplaced("MooseApp", ADCoefReaction, "01/21/2027 00:00", ADReaction);
 
 template <bool is_ad>
 InputParameters
@@ -35,17 +35,21 @@ CoefReactionTempl<is_ad>::computeQpResidual()
   return _coef * ReactionTempl<is_ad>::computeQpResidual();
 }
 
-template <bool is_ad>
+InputParameters
+CoefReaction::validParams()
+{
+  return CoefReactionTempl<false>::validParams();
+}
+
+CoefReaction::CoefReaction(const InputParameters & parameters)
+  : CoefReactionTempl<false>(parameters)
+{
+}
+
 Real
-CoefReactionTempl<is_ad>::computeQpJacobian()
+CoefReaction::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 template for all cases.
-  mooseAssert(!is_ad,
-              "In ADCoefReaction, computeQpJacobian should not be called. Check computeJacobian "
-              "implementation.");
-  return _coef * ReactionTempl<is_ad>::computeQpJacobian();
+  return _coef * _test[_i][_qp] * _rate * _phi[_j][_qp];
 }
 
 template class CoefReactionTempl<false>;