using elementVariableValue pattern to get element average. Name of cl…

…ass was changed because this will now work for element variables

include/reporters/ClosestElemsToLineNodalVarValue.h → include/reporters/ClosestElemsToLineVarValue.h

@@ -10,24 +10,21 @@
 #pragma once
 
 #include "ClosestElemsToLine.h"
-#include "MooseVariableInterface.h"
 
-class ClosestElemsToLineNodalVarValue : public ClosestElemsToLine,
-                                        public MooseVariableInterface<Real>
+class ClosestElemsToLineVarValue : public ClosestElemsToLine
 {
 public:
   static InputParameters validParams();
 
-  ClosestElemsToLineNodalVarValue(const InputParameters & parameters);
+  ClosestElemsToLineVarValue(const InputParameters & parameters);
 
   virtual void initialSetup() override;
 
   virtual void initialize() override{};
-  virtual void execute() override;
+  virtual void execute() override{};
   virtual void finalize() override;
 
 private:
   std::string _var_name;
-  MooseVariable & _var;
   std::vector<Real> & _value;
 };

src/reporters/ClosestElemsToLineNodalVarValue.C → src/reporters/ClosestElemsToLineVarValue.C

@@ -7,14 +7,17 @@
 //* Licensed under LGPL 2.1, please see LICENSE for details
 //* https://www.gnu.org/licenses/lgpl-2.1.html
 
-#include "ClosestElemsToLineNodalVarValue.h"
+#include "ClosestElemsToLineVarValue.h"
+
+// MOOSE includes
 #include "MooseMesh.h"
 #include "MooseVariable.h"
+#include "SubProblem.h"
 
-registerMooseObject("FalconApp", ClosestElemsToLineNodalVarValue);
+registerMooseObject("FalconApp", ClosestElemsToLineVarValue);
 
 InputParameters
-ClosestElemsToLineNodalVarValue::validParams()
+ClosestElemsToLineVarValue::validParams()
 {
   InputParameters params = ClosestElemsToLine::validParams();
   params.addClassDescription("Creates a real_vector_names reporter that has each "
@@ -23,30 +26,22 @@ ClosestElemsToLineNodalVarValue::validParams()
   return params;
 }
 
-ClosestElemsToLineNodalVarValue::ClosestElemsToLineNodalVarValue(const InputParameters & parameters)
+ClosestElemsToLineVarValue::ClosestElemsToLineVarValue(const InputParameters & parameters)
   : ClosestElemsToLine(parameters),
-    MooseVariableInterface<Real>(this,
-                                 false,
-                                 "variable_to_sample",
-                                 Moose::VarKindType::VAR_ANY,
-                                 Moose::VarFieldType::VAR_FIELD_STANDARD),
     _var_name(parameters.get<VariableName>("variable_to_sample")),
-    _var(_subproblem.getStandardVariable(_tid, _var_name)),
     _value(declareValueByName<std::vector<Real>>(_var_name, REPORTER_MODE_REPLICATED))
 {
-  if (!_var.isNodal())
-    mooseError("variable_to_sample must be a nodal variable.");
 }
 
 void
-ClosestElemsToLineNodalVarValue::initialSetup()
+ClosestElemsToLineVarValue::initialSetup()
 {
   ClosestElemsToLine::initialSetup();
   _value.resize(_eid.size(), std::numeric_limits<Real>::max());
 }
 
 void
-ClosestElemsToLineNodalVarValue::execute()
+ClosestElemsToLineVarValue::finalize()
 {
   const MooseMesh & mesh = _subproblem.mesh();
   for (size_t i = 0; i < _eid.size(); ++i)
@@ -55,23 +50,21 @@ ClosestElemsToLineNodalVarValue::execute()
     const Elem * elem = mesh.getMesh().query_elem_ptr(_eid[i]);
     if (elem->processor_id() == processor_id())
     {
-      size_t n = 0;
-      for (auto & node : elem->node_ref_range())
-      {
-        value += _var.getNodalValue(node);
-        n++;
-      }
-      if (n > 0)
-        value /= (Real)n;
+      _fe_problem.setCurrentSubdomainID(elem, 0);
+      _subproblem.prepare(elem, _tid);
+      _subproblem.reinitElem(elem, _tid);
+
+      MooseVariableField<Real> & var = static_cast<MooseVariableField<Real> &>(
+          _subproblem.getActualFieldVariable(_tid, _var_name));
+      const VariableValue & u = var.sln();
+      unsigned int n = u.size();
+      for (unsigned int i = 0; i < n; i++)
+        value += u[i];
+      value /= n;
     }
     _value[i] = value;
   }
-}
-
-void
-ClosestElemsToLineNodalVarValue::finalize()
-{
-    //_value should be zero on every proc so this will just communicate it.
-    for (size_t i = 0; i < _eid.size(); ++i)
-      gatherSum(_value[i]);
+  //_value should be zero on every proc so this will just communicate it.
+  for (size_t i = 0; i < _eid.size(); ++i)
+    gatherSum(_value[i]);
 }

test/tests/reporters/closest_elems_to_line_NodalVarValue/dfn_test.i → test/tests/reporters/closest_elems_to_line_VarValue/dfn_test.i

@@ -38,7 +38,7 @@
 
   [no_var]
     block = "9 10"
-    type = ClosestElemsToLineNodalVarValue
+    type = ClosestElemsToLineVarValue
     projection_tolerance = 5
     point_x1 = pt/pt1_x
     point_y1 = pt/pt1_y
@@ -50,7 +50,7 @@
     outputs = out
   []
   [domain_var]
-    type = ClosestElemsToLineNodalVarValue
+    type = ClosestElemsToLineVarValue
     projection_tolerance = 5
     point_x1 = pt/pt1_x
     point_y1 = pt/pt1_y

test/tests/reporters/closest_elems_to_line_NodalVarValue/nodal_var_value.i → test/tests/reporters/closest_elems_to_line_VarValue/nodal_var_value.i

@@ -41,7 +41,7 @@
   []
 
   [no_var]
-    type = ClosestElemsToLineNodalVarValue
+    type = ClosestElemsToLineVarValue
     projection_tolerance = 5
     point_x1 = pt/pt1_x
     point_y1 = pt/pt1_y
@@ -53,7 +53,7 @@
     outputs = out
   []
   [domain_var]
-    type = ClosestElemsToLineNodalVarValue
+    type = ClosestElemsToLineVarValue
     projection_tolerance = 5
     point_x1 = pt/pt1_x
     point_y1 = pt/pt1_y