Add matrix and rhs population functions for reaction and source kerne…

…ls. (#25722)

framework/include/base/LinearSystemContributionObject.h

@@ -23,6 +23,8 @@
 #include "TaggingInterface.h"
 #include "SystemBase.h"
 
+#include "libmesh/linear_implicit_system.h"
+
 class FEProblemBase;
 class MooseMesh;
 class SubProblem;
@@ -56,11 +58,11 @@ class LinearSystemContributionObject : public MooseObject,
    */
   LinearSystemContributionObject(const InputParameters & parameters);
 
-  /// Compute this object's contribution to the residual
-  virtual void computeMatrixContribution() = 0;
+  /// Add this object's contribution to the system matrix
+  virtual void addMatrixContribution() = 0;
 
-  /// Compute this object's contribution to the diagonal Jacobian entries
-  virtual void computeRightHandSideContribution() = 0;
+  /// Add this object's contribution to the system right hand side
+  virtual void addRightHandSideContribution() = 0;
 
   /**
    * Returns the variable that this object operates on.
@@ -91,6 +93,9 @@ class LinearSystemContributionObject : public MooseObject,
   /// Reference to the system this object contributes to
   SystemBase & _sys;
 
+  /// Reference to the libmesh linear system this object contributes to
+  libMesh::LinearImplicitSystem & _linear_system;
+
   /// The thread ID for this object
   THREAD_ID _tid;
 

framework/include/linearfvkernel/ElementalLinearFVKernel.h

@@ -10,10 +10,30 @@
 #pragma once
 
 #include "LinearFVKernel.h"
+#include "ElemInfo.h"
+#include "MooseVariableFV.h"
+#include "MooseVariableInterface.h"
 
-class ElementalLinearFVKernel : public LinearFVKernel
+class ElementalLinearFVKernel : public LinearFVKernel, public MooseVariableInterface<Real>
 {
 public:
   static InputParameters validParams();
   ElementalLinearFVKernel(const InputParameters & params);
+
+  /// Compute this object's contribution to the residual
+  virtual void addMatrixContribution() override;
+
+  /// Compute this object's contribution to the diagonal Jacobian entries
+  virtual void addRightHandSideContribution() override;
+
+  /// Set current element
+  void setCurrentElemInfo(const ElemInfo * elem_info) { _current_elem_info = elem_info; }
+
+  virtual Real computeMatrixContribution() = 0;
+
+  virtual Real computeRightHandSideContribution() = 0;
+
+protected:
+  const ElemInfo * _current_elem_info;
+  MooseVariableFV<Real> & _var;
 };

framework/include/linearfvkernel/LinearFVReactionKernel.h

@@ -16,4 +16,11 @@ class LinearFVReactionKernel : public ElementalLinearFVKernel
 public:
   static InputParameters validParams();
   LinearFVReactionKernel(const InputParameters & params);
+
+  virtual Real computeMatrixContribution() override;
+
+  virtual Real computeRightHandSideContribution() override;
+
+protected:
+  const Real _coeff;
 };

framework/include/linearfvkernel/LinearFVSourceKernel.h

@@ -16,4 +16,11 @@ class LinearFVSourceKernel : public ElementalLinearFVKernel
 public:
   static InputParameters validParams();
   LinearFVSourceKernel(const InputParameters & params);
+
+  virtual Real computeMatrixContribution() override;
+
+  virtual Real computeRightHandSideContribution() override;
+
+protected:
+  const Real _source_density;
 };

framework/src/base/LinearSystemContributionObject.C

@@ -10,6 +10,7 @@
 #include "LinearSystemContributionObject.h"
 #include "SubProblem.h"
 #include "InputParameters.h"
+#include "libmesh/linear_implicit_system.h"
 
 InputParameters
 LinearSystemContributionObject::validParams()
@@ -46,6 +47,7 @@ LinearSystemContributionObject::LinearSystemContributionObject(const InputParame
     _subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
     _fe_problem(*parameters.get<FEProblemBase *>("_fe_problem_base")),
     _sys(*getCheckedPointerParam<SystemBase *>("_sys")),
+    _linear_system(libMesh::cast_ref<libMesh::LinearImplicitSystem &>(_sys.system())),
     _tid(parameters.get<THREAD_ID>("_tid")),
     _mesh(_subproblem.mesh())
 {

framework/src/linearfvkernels/ElementalLinearFVKernel.C

@@ -19,6 +19,27 @@ ElementalLinearFVKernel::validParams()
 }
 
 ElementalLinearFVKernel::ElementalLinearFVKernel(const InputParameters & params)
-  : LinearFVKernel(params)
+  : LinearFVKernel(params),
+    MooseVariableInterface(this,
+                           false,
+                           "variable",
+                           Moose::VarKindType::VAR_NONLINEAR,
+                           Moose::VarFieldType::VAR_FIELD_STANDARD),
+    _current_elem_info(nullptr),
+    _var(*mooseVariableFV())
 {
 }
+
+void
+ElementalLinearFVKernel::addMatrixContribution()
+{
+  const auto dof_id = _current_elem_info->dofIndices()[_var.sys().number()][_var.number()];
+  (*_linear_system.matrix).add(dof_id, dof_id, computeMatrixContribution());
+}
+
+void
+ElementalLinearFVKernel::addRightHandSideContribution()
+{
+  const auto dof_id = _current_elem_info->dofIndices()[_var.sys().number()][_var.number()];
+  (*_linear_system.rhs).add(dof_id, computeRightHandSideContribution());
+}

framework/src/linearfvkernels/LinearFVReactionKernel.C

@@ -15,10 +15,23 @@ InputParameters
 LinearFVReactionKernel::validParams()
 {
   InputParameters params = ElementalLinearFVKernel::validParams();
+  params.addParam<Real>("coeff", 1.0, "The reaction coefficient.");
   return params;
 }
 
 LinearFVReactionKernel::LinearFVReactionKernel(const InputParameters & params)
-  : ElementalLinearFVKernel(params)
+  : ElementalLinearFVKernel(params), _coeff(getParam<Real>("coeff"))
 {
 }
+
+Real
+LinearFVReactionKernel::computeMatrixContribution()
+{
+  return _coeff * _current_elem_info->volume();
+}
+
+Real
+LinearFVReactionKernel::computeRightHandSideContribution()
+{
+  return 0.0;
+}

framework/src/linearfvkernels/LinearFVSourceKernel.C

@@ -15,10 +15,23 @@ InputParameters
 LinearFVSourceKernel::validParams()
 {
   InputParameters params = ElementalLinearFVKernel::validParams();
+  params.addParam<Real>("source_density", 1.0, "The source density.");
   return params;
 }
 
 LinearFVSourceKernel::LinearFVSourceKernel(const InputParameters & params)
-  : ElementalLinearFVKernel(params)
+  : ElementalLinearFVKernel(params), _source_density(getParam<Real>("source_density"))
 {
 }
+
+Real
+LinearFVSourceKernel::computeMatrixContribution()
+{
+  return 0.0;
+}
+
+Real
+LinearFVSourceKernel::computeRightHandSideContribution()
+{
+  return _source_density * _current_elem_info->volume();
+}