Implement postprocessors for OpenFOAM-based quantities

include/base/foam/fvCFD_moose.h

@@ -44,4 +44,9 @@
 #include <uniformDimensionedFields.H>
 #include <ddtScheme.H>
 
+// FoamSideIntegratedFunctionObject.h
+#include <functionObject.H>
+#include <functionObjects/field/wallHeatFlux/wallHeatFlux.H>
+#include <functionObjects/field/wallShearStress/wallShearStress.H>
+
 #undef NotImplemented

include/postprocessors/FoamPostprocessorBase.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "fvCFD_moose.h"
+
+#include "InputParameters.h"
+#include "Postprocessor.h"
+#include "ElementUserObject.h"
+
+class FoamPostprocessorBase : public ElementUserObject, public Postprocessor
+{
+public:
+  static InputParameters validParams();
+
+  FoamPostprocessorBase(const InputParameters & params);
+
+  // We dont want the usual UserObject functions to be executed
+  // But we still want the Foam Postprocessors to be reported with the other
+  // Foam postprocessors
+  virtual void initialize() final;
+
+  virtual void execute() final;
+
+  virtual void finalize() final;
+
+  virtual void threadJoin([[maybe_unused]] const UserObject & uo) final {};
+
+  // Compute postprocessor, to be called within FoamProblem
+  virtual void compute() = 0;
+
+protected:
+  Foam::fvMesh * _foam_mesh;
+};

include/postprocessors/FoamSideAdvectiveFluxIntegral.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "FoamSidePostprocessor.h"
+
+class FoamSideAdvectiveFluxIntegral : public FoamSidePostprocessor
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideAdvectiveFluxIntegral(const InputParameters & params);
+
+  virtual PostprocessorValue getValue() const override;
+
+  virtual void compute() override;
+
+protected:
+  Real _value;
+
+  std::string _foam_scalar;
+  std::string _advection_velocity;
+};

include/postprocessors/FoamSideAverageFunctionObject.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "FoamSideIntegratedFunctionObject.h"
+#include "InputParameters.h"
+
+class FoamSideAverageFunctionObject : public FoamSideIntegratedFunctionObject
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideAverageFunctionObject(const InputParameters & params)
+    : FoamSideIntegratedFunctionObject(params)
+  {
+  }
+
+  virtual void compute() override;
+};

include/postprocessors/FoamSideAverageValue.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "FoamSideIntegratedValue.h"
+#include "InputParameters.h"
+
+class FoamSideAverageValue : public FoamSideIntegratedValue
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideAverageValue(const InputParameters & params);
+
+  virtual void compute() override;
+};

include/postprocessors/FoamSideIntegratedBase.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "FoamSidePostprocessor.h"
+
+class FoamSideIntegratedBase : public FoamSidePostprocessor
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideIntegratedBase(const InputParameters & params);
+
+  virtual PostprocessorValue getValue() const override;
+
+protected:
+  virtual Real integrateValue(const std::string & variable);
+
+  Real getArea();
+
+  Real _value;
+};

include/postprocessors/FoamSideIntegratedFunctionObject.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "FoamSideIntegratedBase.h"
+#include "InputParameters.h"
+
+#include <memory>
+
+class FoamSideIntegratedFunctionObject : public FoamSideIntegratedBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideIntegratedFunctionObject(const InputParameters & params);
+
+  virtual void compute() override;
+
+protected:
+  /// Creates function objects to be executed by compute
+  std::unique_ptr<Foam::functionObject> createFunctionObject(const std::string & fo_name);
+
+  std::unique_ptr<Foam::functionObject> _function_object;
+};

include/postprocessors/FoamSideIntegratedValue.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "FoamSideIntegratedBase.h"
+
+class FoamSideIntegratedValue : public FoamSideIntegratedBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideIntegratedValue(const InputParameters & params);
+
+  virtual void compute() override;
+
+protected:
+  const std::string & _foam_variable;
+};

include/postprocessors/FoamSidePostprocessor.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "FoamPostprocessorBase.h"
+#include "MooseTypes.h"
+
+class FoamSidePostprocessor : public FoamPostprocessorBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamSidePostprocessor(const InputParameters & params);
+
+protected:
+  std::vector<SubdomainName> _boundary;
+};

include/problems/FoamProblem.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "FoamMesh.h"
+#include "FoamPostprocessorBase.h"
 #include "FoamSolver.h"
 #include "FoamVariableField.h"
 #include "FoamBCBase.h"
@@ -42,9 +43,13 @@ class FoamProblem : public ExternalProblem
   // check FoamBCs and print summarising table
   void verifyFoamBCs();
 
+  // check FoamPostprocessors and print summarising table
+  void verifyFoamPostprocessors();
+
   FoamMesh * _foam_mesh = nullptr;
   Hippo::FoamSolver _solver;
 
   std::vector<FoamVariableField *> _foam_variables;
   std::vector<FoamBCBase *> _foam_bcs;
+  std::vector<FoamPostprocessorBase *> _foam_postprocessor;
 };

src/postprocessors/FoamPostprocessorBase.C

@@ -0,0 +1,39 @@
+#include "FoamMesh.h"
+#include "FoamPostprocessorBase.h"
+#include "InputParameters.h"
+#include "Postprocessor.h"
+#include "ElementUserObject.h"
+#include "FoamProblem.h"
+
+InputParameters
+FoamPostprocessorBase::validParams()
+{
+  auto params = ElementUserObject::validParams();
+  params += Postprocessor::validParams();
+  return params;
+}
+
+FoamPostprocessorBase::FoamPostprocessorBase(const InputParameters & params)
+  : ElementUserObject(params), Postprocessor(this), _foam_mesh(nullptr)
+{
+  FoamProblem * problem = dynamic_cast<FoamProblem *>(&getSubProblem());
+  if (!problem)
+    mooseError("Foam-based Postprocessors can only be used with FoamProblem");
+
+  _foam_mesh = &problem->mesh().fvMesh();
+}
+
+void
+FoamPostprocessorBase::initialize()
+{
+}
+
+void
+FoamPostprocessorBase::execute()
+{
+}
+
+void
+FoamPostprocessorBase::finalize()
+{
+}

src/postprocessors/FoamSideAdvectiveFluxIntegral.C

@@ -0,0 +1,64 @@
+#include "FoamSideAdvectiveFluxIntegral.h"
+#include "InputParameters.h"
+#include "MooseTypes.h"
+
+registerMooseObject("hippoApp", FoamSideAdvectiveFluxIntegral);
+
+InputParameters
+FoamSideAdvectiveFluxIntegral::validParams()
+{
+  auto params = FoamSidePostprocessor::validParams();
+  params.addClassDescription("Class that calculates the integrated advective flux of a scalar over "
+                             "OpenFOAM boundary patches.");
+  params.addRequiredParam<std::string>("foam_scalar", "Foam scalar being advected.");
+  params.addParam<std::string>("advective_velocity", "U", "Advection velocity");
+  return params;
+}
+
+FoamSideAdvectiveFluxIntegral::FoamSideAdvectiveFluxIntegral(const InputParameters & params)
+  : FoamSidePostprocessor(params),
+    _value(0.),
+    _foam_scalar(params.get<std::string>("foam_scalar")),
+    _advection_velocity(params.get<std::string>("advective_velocity"))
+{
+
+  if (!_foam_mesh->foundObject<Foam::volScalarField>(_foam_scalar))
+    mooseError("foam_scalar '", _foam_scalar, "' not found.");
+
+  if (!_foam_mesh->foundObject<Foam::volVectorField>(_advection_velocity))
+    mooseError("advective_velocity '", _advection_velocity, "' not found.");
+}
+
+void
+FoamSideAdvectiveFluxIntegral::compute()
+{
+  _value = 0.;
+  for (auto & boundary : _boundary)
+  {
+    auto & var_array =
+        _foam_mesh->boundary()[boundary].lookupPatchField<Foam::volScalarField, double>(
+            _foam_scalar);
+
+    auto & vel_array =
+        _foam_mesh->boundary()[boundary].lookupPatchField<Foam::volVectorField, double>(
+            _advection_velocity);
+
+    auto & areas = _foam_mesh->boundary()[boundary].magSf();
+    auto && normals = _foam_mesh->boundary()[boundary].nf();
+
+    // integrate locally
+    for (int i = 0; i < var_array.size(); ++i)
+    {
+      _value += var_array[i] * areas[i] * (normals->data()[i] & vel_array[i]);
+    }
+  }
+
+  // Sum across ranks
+  gatherSum(_value);
+}
+
+PostprocessorValue
+FoamSideAdvectiveFluxIntegral::getValue() const
+{
+  return _value;
+}

src/postprocessors/FoamSideAverageFunctionObject.C

@@ -0,0 +1,19 @@
+#include "FoamSideAverageFunctionObject.h"
+
+registerMooseObject("hippoApp", FoamSideAverageFunctionObject);
+
+InputParameters
+FoamSideAverageFunctionObject::validParams()
+{
+  InputParameters params = FoamSideIntegratedFunctionObject::validParams();
+  params.addClassDescription(
+      "Class that averages a function object over OpenFOAM boundary patches.");
+  return params;
+}
+
+void
+FoamSideAverageFunctionObject::compute()
+{
+  _function_object->execute();
+  _value = integrateValue(_function_object->name()) / getArea();
+}

src/postprocessors/FoamSideAverageValue.C

@@ -0,0 +1,23 @@
+#include "FoamSideAverageValue.h"
+#include "InputParameters.h"
+
+registerMooseObject("hippoApp", FoamSideAverageValue);
+
+InputParameters
+FoamSideAverageValue::validParams()
+{
+  InputParameters params = FoamSideIntegratedValue::validParams();
+  params.addClassDescription("Class that averages a variable over OpenFOAM boundary patches.");
+  return params;
+}
+
+FoamSideAverageValue::FoamSideAverageValue(const InputParameters & params)
+  : FoamSideIntegratedValue(params)
+{
+}
+
+void
+FoamSideAverageValue::compute()
+{
+  _value = integrateValue(_foam_variable) / getArea();
+}