Implement inherited MOOSE variable classes to shadow OpenFOAM fields and function objects

.gitignore

@@ -148,12 +148,19 @@ moose/include/base/Precompiled.h.gch
 # clang
 .clangd
 
+# direnv
+.envrc
+
 # OpenFOAM mesh object files
 test/**/*.obj
 
 # downloaded mesh tarballs
 test/tests/**/*.tar.gz
 
+# OpenFOAM build files
+test/OpenFOAM/**/lnInclude
+test/OpenFOAM/**/linux*
+
 framework/contrib/exodiff/exodiff
 
 # Mac garbage

.pre-commit-config.yaml

@@ -31,3 +31,4 @@ repos:
     hooks:
       - id: remove-crlf
       - id: forbid-tabs
+        exclude: '.*\.mk$'

Makefile

@@ -60,3 +60,8 @@ include            $(FRAMEWORK_DIR)/app.mk
 
 ###############################################################################
 # Additional special case targets should be added here
+
+# Add foam modules
+# TODO: Reorganise build: consider single mk for all OpenFOAM modules
+# as they are written.
+include test/OpenFOAM/foam_modules.mk

include/actions/AddFoamVariableAction.h

@@ -0,0 +1,12 @@
+#include "InputParameters.h"
+#include "MooseObjectAction.h"
+
+class AddFoamVariableAction : public MooseObjectAction
+{
+public:
+  static InputParameters validParams();
+
+  AddFoamVariableAction(const InputParameters & parameters);
+
+  virtual void act() override;
+};

include/problems/FoamProblem.h

@@ -2,12 +2,14 @@
 
 #include "FoamMesh.h"
 #include "FoamSolver.h"
+#include "FoamVariableField.h"
 
 #include <ExternalProblem.h>
 #include <MooseTypes.h>
 #include <MooseVariableFieldBase.h>
 #include <SystemBase.h>
 #include <libmesh/elem.h>
+#include <string>
 
 class FoamProblem : public ExternalProblem
 {
@@ -18,7 +20,7 @@ class FoamProblem : public ExternalProblem
   virtual void syncSolutions(Direction /* dir */) override;
   virtual bool converged(const unsigned int /* nl_sys_num */) override { return true; }
   virtual void addExternalVariables() override {};
-
+  virtual void initialSetup() override;
   using ExternalProblem::mesh;
   virtual FoamMesh const & mesh() const override { return *_foam_mesh; }
   virtual FoamMesh & mesh() override { return *_foam_mesh; }
@@ -42,6 +44,10 @@ class FoamProblem : public ExternalProblem
   Hippo::FoamSolver & solver() { return _solver; }
 
 protected:
+  // check FoamVariables and print summarising table
+  void verifyFoamVariables();
+
   FoamMesh * _foam_mesh = nullptr;
   Hippo::FoamSolver _solver;
+  std::vector<FoamVariableField *> _foam_variables;
 };

include/variables/FoamFunctionObject.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "FoamVariableField.h"
+#include "functionObject.H"
+
+#include <volFields.H>
+
+// Class for mirroring functionObjects
+class FoamFunctionObject : public FoamVariableField
+{
+public:
+  explicit FoamFunctionObject(const InputParameters & params);
+
+  // function that executes functionObject and transfers variable from
+  // OpenFOAM variable to MOOSE
+  virtual void transferVariable();
+
+  // Destroys functionObject pointer
+  ~FoamFunctionObject() { delete _shadow_fo; };
+
+private:
+  // function to construct the functionObject
+  Foam::functionObject * _getFunctionObject(Foam::dictionary fo_dict);
+
+  // The function object pointer
+  Foam::functionObject * _shadow_fo;
+};

include/variables/FoamVariableField.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Moose.h"
+#include "MooseTypes.h"
+#include "FoamMesh.h"
+
+class FoamVariableField : public MooseObject
+{
+public:
+  static InputParameters validParams();
+
+  explicit FoamVariableField(const InputParameters & params);
+
+  // transfer variable from OpenFOAM field to MOOSE variable
+  virtual void transferVariable();
+
+  // returns the name of the foam variable this object shadows
+  std::string foamVariable() const { return _foam_variable; };
+
+protected:
+  // variable name or functionObject to be shadowed
+  std::string _foam_variable;
+
+  // moose variable that shadows the OpenFOAM variable
+  MooseVariableFieldBase & _moose_var;
+
+  // Create Auxilliary variable
+  MooseVariableFieldBase & createMooseVariable(std::string name, const InputParameters & params);
+
+  // Pointer to the FoamMesh object
+  FoamMesh * _mesh;
+};

src/actions/AddFoamVariableAction.C

@@ -0,0 +1,34 @@
+#include "AddFoamVariableAction.h"
+#include "FoamProblem.h"
+#include "FoamVariableField.h"
+#include "InputParameters.h"
+#include "MooseObjectAction.h"
+#include "Registry.h"
+
+registerMooseAction("hippoApp", AddFoamVariableAction, "add_foam_variable");
+
+InputParameters
+AddFoamVariableAction::validParams()
+{
+  auto params = MooseObjectAction::validParams();
+  params.addClassDescription("Adds a FoamVariable that shadows an OpenFOAM scalar field.");
+  return params;
+}
+
+AddFoamVariableAction::AddFoamVariableAction(const InputParameters & parameters)
+  : MooseObjectAction(parameters)
+{
+}
+
+void
+AddFoamVariableAction::act()
+{
+  if (_current_task == "add_foam_variable")
+  {
+    auto * foam_problem = dynamic_cast<FoamProblem *>(_problem.get());
+    if (!foam_problem)
+      mooseError("FoamVariables block must be used with FoamProblem");
+
+    foam_problem->addObject<FoamVariableField>(_type, _name, _moose_object_pars, false);
+  }
+}

src/base/hippoApp.C

@@ -32,6 +32,11 @@ hippoApp::registerAll(Factory & f, ActionFactory & af, Syntax & syntax)
   Registry::registerActionsTo(af, {"hippoApp"});
 
   /* register custom execute flags, action syntax, etc. here */
+
+  // Add input file syntax for the [FoamVariables] block
+  registerSyntaxTask("AddFoamVariableAction", "FoamVariables/*", "add_foam_variable");
+  registerMooseObjectTask("add_foam_variable", FoamVariable, false);
+  addTaskDependency("add_external_aux_variables", "add_foam_variable");
 }
 
 void

src/problems/FoamProblem.C

@@ -6,6 +6,9 @@
 #include <MooseError.h>
 #include <MooseTypes.h>
 #include <MooseVariableFieldBase.h>
+#include "FoamVariableField.h"
+#include "InputParameters.h"
+#include "VariadicTable.h"
 #include <finiteVolume/solver/solver.H>
 #include <fvMesh.H>
 #include <libmesh/enum_order.h>
@@ -60,7 +63,11 @@ FoamProblem::validParams()
 FoamProblem::FoamProblem(InputParameters const & params)
   : ExternalProblem(params),
     _foam_mesh(dynamic_cast<FoamMesh *>(&this->ExternalProblem::mesh())),
-    _solver(Foam::solver::New("fluid", _foam_mesh->fvMesh()).ptr())
+    _solver(Foam::solver::New(_foam_mesh->fvMesh().time().controlDict().lookupOrDefault<Foam::word>(
+                                  "solver", "fluid"),
+                              _foam_mesh->fvMesh())
+                .ptr()),
+    _foam_variables()
 {
   assert(_foam_mesh);
 
@@ -117,6 +124,18 @@ FoamProblem::externalSolve()
   }
 }
 
+void
+FoamProblem::initialSetup()
+{
+  ExternalProblem::initialSetup();
+
+  // Get FoamVariables create by the action AddFoamVariableAction
+  TheWarehouse::Query query = theWarehouse().query().condition<AttribSystem>("FoamVariable");
+  query.queryInto(_foam_variables);
+
+  verifyFoamVariables();
+}
+
 void
 FoamProblem::syncSolutions(Direction dir)
 {
@@ -143,6 +162,12 @@ FoamProblem::syncSolutions(Direction dir)
     {
       syncFromOpenFoam<SyncVariables::WallHeatFlux>();
     }
+
+    // Loop of shadowed variables and perform transfer
+    for (auto & var : _foam_variables)
+    {
+      var->transferVariable();
+    }
   }
   else if (dir == ExternalProblem::Direction::TO_EXTERNAL_APP)
   {
@@ -331,3 +356,19 @@ FoamProblem::getConstantMonomialVariableFromParameters(const std::string & param
   }
   return var;
 }
+
+void
+FoamProblem::verifyFoamVariables()
+{
+  // Create table summarising FoamVariables
+  VariadicTable<std::string, std::string, std::string> vt({
+      "FoamVariable name",
+      "Type",
+      "Foam variable",
+  });
+  for (auto & var : _foam_variables)
+  {
+    vt.addRow(var->name(), var->type(), var->foamVariable());
+  }
+  vt.print(_console);
+}

src/variables/FoamFunctionObject.C

@@ -0,0 +1,58 @@
+#include "FoamVariableField.h"
+#include "FoamFunctionObject.h"
+#include "InputParameters.h"
+#include "Registry.h"
+#include "SystemBase.h"
+#include "dictionary.H"
+#include "functionObject.H"
+// #include "wallHeatFlux.h"
+#include <functionObjects/field/wallHeatFlux/wallHeatFlux.H>
+
+registerMooseObject("hippoApp", FoamFunctionObject);
+
+FoamFunctionObject::FoamFunctionObject(const InputParameters & params) : FoamVariableField(params)
+{
+  auto & mesh = _mesh->fvMesh();
+
+  // construct input Foam dictionary for the functionObject
+  auto fo_dict = mesh.time().controlDict().lookupOrDefault(_foam_variable, Foam::dictionary());
+
+  // create patch names where functionObject applies
+  // TODO: when volumetric mirror is implemented some of this may need to be
+  // put in the _getFunctionObject function.
+  std::vector<int> patch_ids{_mesh->getSubdomainList()};
+  Foam::wordList patch_names;
+  for (auto id : patch_ids)
+    patch_names.append(mesh.boundaryMesh()[id].name());
+
+  fo_dict.set("patches", patch_names);
+  fo_dict.set("writeToFile", false);
+
+  // construct functionObject and execute
+  _shadow_fo = _getFunctionObject(fo_dict);
+  _shadow_fo->execute();
+}
+
+Foam::functionObject *
+FoamFunctionObject::_getFunctionObject(Foam::dictionary fo_dict)
+{
+  // Create polymorphic pointer to each type of valid functionObject
+  if (_foam_variable == "wallHeatFlux")
+  {
+    Foam::functionObjects::wallHeatFlux * whf_func =
+        new Foam::functionObjects::wallHeatFlux("wallHeatFlux", _mesh->fvMesh().time(), fo_dict);
+    return static_cast<Foam::functionObject *>(whf_func);
+  }
+  else
+  {
+    mooseError("Only wallHeatFlux functionObject is currently supported");
+  }
+}
+
+void
+FoamFunctionObject::transferVariable()
+{
+  // execute functionObject before transfer
+  _shadow_fo->execute();
+  FoamVariableField::transferVariable();
+}