Implement postprocessors for OpenFOAM-based quantities

include/postprocessors/FoamPostprocessorBase.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "InputParameters.h"
+#include "Postprocessor.h"
+#include "ElementUserObject.h"
+#include "fvMesh.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(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/FoamSideAverageValue.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "FoamSideIntegratedValue.h"
+#include "InputParameters.h"
+
+#include <functionObjects/field/wallHeatFlux/wallHeatFlux.H>
+#include <functionObjects/field/wallShearStress/wallShearStress.H>
+
+class FoamSideAverageValue : public FoamSideIntegratedValue
+{
+public:
+  static InputParameters validParams() { return FoamSideIntegratedValue::validParams(); }
+
+  FoamSideAverageValue(const InputParameters & params);
+
+  virtual void compute() override;
+};

include/postprocessors/FoamSideIntegratedValue.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "FoamSidePostprocessor.h"
+#include <functionObjects/field/wallHeatFlux/wallHeatFlux.H>
+#include <functionObjects/field/wallShearStress/wallShearStress.H>
+
+static MooseEnum _pp_function_objects("wallHeatFlux wallShearStress");
+
+class FoamSideIntegratedValue : public FoamSidePostprocessor
+{
+public:
+  static InputParameters validParams();
+
+  FoamSideIntegratedValue(const InputParameters & params);
+
+  virtual PostprocessorValue getValue() const override;
+
+  virtual void compute() override;
+
+protected:
+  /// Creates function objects to be executed by compute
+  void createFunctionObject();
+
+  Real _value;
+
+  std::string _foam_variable;
+
+  bool _is_vector;
+
+  Foam::functionObject * _function_object;
+};

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,45 @@
+#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()
+{
+}
+
+void
+FoamPostprocessorBase::threadJoin(const UserObject & uo)
+{
+  (void)uo;
+}

src/postprocessors/FoamSideAdvectiveFluxIntegral.C

@@ -0,0 +1,66 @@
+#include "ElementUserObject.h"
+#include "FoamSideAdvectiveFluxIntegral.h"
+#include "InputParameters.h"
+#include "MooseTypes.h"
+#include "FoamMesh.h"
+
+registerMooseObject("hippoApp", FoamSideAdvectiveFluxIntegral);
+
+InputParameters
+FoamSideAdvectiveFluxIntegral::validParams()
+{
+  auto params = FoamSidePostprocessor::validParams();
+  params.addClassDescription(
+      "Class that calculates the average or scalar on a OpenFOAM boundary patch.");
+  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/FoamSideAverageValue.C

@@ -0,0 +1,34 @@
+#include "Field.H"
+#include "FoamSideAverageValue.h"
+#include "FoamSideIntegratedValue.h"
+#include "InputParameters.h"
+
+registerMooseObject("hippoApp", FoamSideAverageValue);
+
+FoamSideAverageValue::FoamSideAverageValue(const InputParameters & params)
+  : FoamSideIntegratedValue(params)
+{
+}
+
+void
+FoamSideAverageValue::compute()
+{
+
+  FoamSideIntegratedValue::compute();
+
+  Real volume = 0.;
+  // loop over boundary ids
+  for (auto & boundary : _boundary)
+  {
+    auto & areas = _foam_mesh->boundary()[boundary].magSf();
+    for (int i = 0; i < areas.size(); ++i)
+    {
+      volume += areas[i];
+    }
+  }
+  // sum over ranks
+  gatherSum(volume);
+
+  // divide by area
+  _value /= volume;
+}