Add Postprocessor-based Foam boundary conditions

.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
       run: |
         . /opt/openfoam/OpenFOAM-12/etc/bashrc || true
         unset FOAM_SIGFPE && unset FOAM_SETNAN
-        ./run_tests
+        ./run_tests --no-trimmed-output-on-error
 
     - name: Docs
       shell: bash

.gitignore

@@ -156,6 +156,7 @@ test/**/*.obj
 
 # downloaded mesh tarballs
 test/tests/**/*.tar.gz
+!**/gold/*.tar.gz
 
 # OpenFOAM build files
 test/OpenFOAM/**/lnInclude
@@ -274,3 +275,7 @@ conf_vars.mk
 # GPerf performance
 *.prof
 *.heap
+
+#OpenFOAM wmake build files
+**/lnInclude
+**/Make/linux*

Makefile

@@ -46,6 +46,7 @@ RDG                         := no
 RICHARDS                    := no
 STOCHASTIC_TOOLS            := no
 TENSOR_MECHANICS            := no
+THERMAL_HYDRAULICS          := yes
 XFEM                        := no
 
 include $(MOOSE_DIR)/modules/modules.mk
@@ -61,7 +62,4 @@ 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

doc/content/hit/step_by_step/fluid.i

@@ -4,25 +4,25 @@
     foam_patch = 'interface' # the name of the coupled boundary
 []
 
-[AuxVariables]
+[FoamVariables]
     [fluid_wall_temp]
-        family = MONOMIAL
-        order = CONSTANT
+        type = FoamVariableField
+        foam_variable = 'T'
         initial_condition = 300
     []
+[]
+
+[FoamBCs]
     [solid_heat_flux]
-        family = MONOMIAL
-        order = CONSTANT
+        type = FoamFixedGradientBC
+        foam_variable = 'T'
+        diffusivity_coefficient = kappa
         initial_condition = 0
     []
 []
 
 [Problem]
     type = FoamProblem
-    # Take the heat flux from MOOSE and set it on the OpenFOAM mesh.
-    heat_flux = solid_heat_flux
-    # Take the boundary temperature from OpenFOAM and set it on the MOOSE mesh.
-    foam_temp = fluid_wall_temp
 []
 
 [Executioner]

include/actions/AddFoamBCAction.h

@@ -1,7 +1,9 @@
 #pragma once
 
 #include "InputParameters.h"
-#include "MooseObjectAction.h"
+#include "FoamProblem.h"
+
+#include <MooseObjectAction.h>
 
 class AddFoamBCAction : public MooseObjectAction
 {
@@ -15,4 +17,7 @@ class AddFoamBCAction : public MooseObjectAction
 protected:
   // Create AuxVariable associated with new-style BCs
   void createAuxVariable();
+
+  // Create Receiver for Postprocessor-based BCs
+  void createReceiver(FoamProblem & problem);
 };

include/base/FoamSolver.h

@@ -1,9 +1,15 @@
 #pragma once
 
+#include "fvMesh.H"
+#include "scalar.H"
 #include "solver.H"
 #include "functionObject.H"
 
-#include <vector>
+#include <Time.H>
+#include <TimeState.H>
+#include <filesystem>
+
+namespace fs = std::filesystem;
 
 namespace Foam
 {
@@ -36,7 +42,6 @@ class mooseDeltaT : public functionObject
 
 namespace Hippo
 {
-
 class FoamSolver
 {
 public:
@@ -48,8 +53,17 @@ class FoamSolver
   std::size_t patchSize(int patch_id);
   // Set the solver's time step size.
   void setTimeDelta(double dt) { runTime().setDeltaTNoAdjust(dt); }
+  // Get the current time from the solver.
+  double currentTime() const { return _solver->time().userTimeValue(); }
+  // Get the current time index from the solver.
+  int currentTimeIdx() const
+  {
+    return _solver->time().findClosestTimeIndex(runTime().times(), currentTime());
+  }
   // Set the solver to the given time.
   void setCurrentTime(double time) { runTime().setTime(time, runTime().timeIndex()); }
+  // set the time index of the solver
+  void setCurrentTimeIdx(int timeIdx) { runTime().setTime(runTime().userTimeValue(), timeIdx); }
   // Set the time at which the solver should terminate.
   void setEndTime(double time) { runTime().setEndTime(time); }
   // Run the presolve from MOOSE objects.
@@ -64,12 +78,24 @@ class FoamSolver
   // time step is.
   void appendDeltaTFunctionObject(const Foam::scalar & dt);
   // get the current deltaT.
-  Foam::scalar getTimeDelta() { return runTime().deltaTValue(); };
+  Foam::scalar getTimeDelta() const { return runTime().deltaTValue(); }
+  // Get the path to the current time directory, this may or may not exist.
+  fs::path currentTimePath() const { return fs::path(runTime().timePath()); }
+  // Write the current OpenFOAM timestep to its time directory.
+  void write() const { _solver->mesh.write(); }
+  // Reset the solver to the given time.
+  void readTime(const double time)
+  {
+    auto idx = _solver->time().findClosestTimeIndex(runTime().times(), time);
+    runTime().setTime(time, idx);
+    runTime().readModifiedObjects();
+  }
 
 private:
   Foam::solver * _solver = nullptr;
 
   Foam::Time & runTime() { return const_cast<Foam::Time &>(_solver->runTime); }
+  const Foam::Time & runTime() const { return _solver->runTime; }
 };
 
 } // namespace Hippo

include/base/foam/fvCFD_moose.h

@@ -33,4 +33,15 @@
 #include <argList.H>
 #include <fvMesh.H>
 
+// FoamDataStore.h
+#include <error.H>
+#include <surfaceFields.H>
+#include <volFields.H>
+#include <pointFields.H>
+#include <typeInfo.H>
+#include <symmTensorField.H>
+#include <DimensionedField.H>
+#include <uniformDimensionedFields.H>
+#include <ddtScheme.H>
+
 #undef NotImplemented

include/base/hippoApp.h

@@ -1,12 +1,3 @@
-//* This file is part of the MOOSE framework
-//* https://www.mooseframework.org
-//*
-//* All rights reserved, see COPYRIGHT for full restrictions
-//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
-//*
-//* Licensed under LGPL 2.1, please see LICENSE for details
-//* https://www.gnu.org/licenses/lgpl-2.1.html
-
 #pragma once
 
 #include <MooseApp.h>

include/bcs/FoamBCBase.h

@@ -7,6 +7,24 @@
 #include <MooseObject.h>
 #include <MooseTypes.h>
 #include <MooseVariableFieldBase.h>
+#include "VariadicTable.h"
+
+typedef VariadicTable<std::string, std::string, std::string, std::string, std::string> BCInfoTable;
+
+template <typename StrType>
+inline std::string
+listFromVector(std::vector<StrType> vec, StrType sep = ", ")
+{
+  if (vec.size() == 0)
+    return std::string();
+  else if (vec.size() == 1)
+    return vec.at(0);
+
+  std::string str;
+  auto binary_op = [&](const std::string & acc, const std::string & it) { return acc + sep + it; };
+  std::accumulate(vec.begin(), vec.end(), str, binary_op);
+  return str;
+}
 
 class FoamBCBase : public MooseObject, public Coupleable
 {
@@ -26,7 +44,10 @@ class FoamBCBase : public MooseObject, public Coupleable
   // returns the name of the foam boundaries the BC applies to
   std::vector<SubdomainName> boundary() const { return _boundary; };
 
-  virtual void initialSetup();
+  virtual void initialSetup() = 0;
+
+  // Add information about BC to table
+  virtual void addInfoRow(BCInfoTable & table) = 0;
 
 protected:
   // OpenFOAM variable which this BC is to be imposed on

include/bcs/FoamFixedGradientBC.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "FoamBCBase.h"
+#include "FoamVariableBCBase.h"
 #include "InputParameters.h"
 
-class FoamFixedGradientBC : public FoamBCBase
+class FoamFixedGradientBC : public FoamVariableBCBase
 {
 public:
   // Validate input file parameters

include/bcs/FoamFixedGradientPostprocessorBC.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "FoamPostprocessorBCBase.h"
+#include "InputParameters.h"
+
+class FoamFixedGradientPostprocessorBC : public FoamPostprocessorBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamFixedGradientPostprocessorBC(const InputParameters & params);
+
+  // impose boundary condition
+  virtual void imposeBoundaryCondition() override;
+
+protected:
+  // name of diffusivity coefficient used to divide flux
+  std::string _diffusivity_coefficient;
+};

include/bcs/FoamFixedValueBC.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "FoamBCBase.h"
+#include "FoamVariableBCBase.h"
 #include "InputParameters.h"
 
-class FoamFixedValueBC : public FoamBCBase
+class FoamFixedValueBC : public FoamVariableBCBase
 {
 public:
   // Validate input file parameters

include/bcs/FoamFixedValuePostprocessorBC.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "FoamPostprocessorBCBase.h"
+
+class FoamFixedValuePostprocessorBC : public FoamPostprocessorBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamFixedValuePostprocessorBC(const InputParameters & params);
+
+  // Impose boundary conditions (to be called from FoamProblem class)
+  virtual void imposeBoundaryCondition() override;
+};

include/bcs/FoamMappedInletBCBase.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "FoamPostprocessorBCBase.h"
+#include <UPstream.H>
+
+class FoamMappedInletBCBase : public FoamPostprocessorBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamMappedInletBCBase(const InputParameters & params);
+
+  virtual ~FoamMappedInletBCBase() { destroyCommunicator(_foam_comm); }
+
+protected:
+  Foam::vector _offset;
+
+  std::map<int, std::vector<int>> _send_map;
+
+  std::map<int, std::vector<int>> _recv_map;
+
+  Foam::label _foam_comm;
+
+  MPI_Comm _mpi_comm;
+
+  // create send and receive information for mapping
+  void createPatchProcMap();
+
+  // get array from mapped plane on the inlet processes
+  template <typename T>
+  Foam::Field<T> getMappedArray(const Foam::word & name);
+
+  // check if bounding box intersects with rank
+  bool intersectMapPlane(const Foam::fvMesh & mesh, Real cart_bbox[6]);
+
+  // create/assign communicators for the transfers between map and inlet planes
+  void createMapComm(const Foam::fvMesh & mesh,
+                     Foam::vectorField face_centres,
+                     std::vector<int> & send_process,
+                     std::vector<int> & recv_process);
+
+  // find index of cell containing point or raise error if not found
+  int findIndex(const Foam::point & location, const MPI_Comm & comm);
+
+  // handle creation of new communicators in parallel or serial
+  Foam::label
+  createCommunicator(const Foam::label parent_comm, std::vector<int> procs, MPI_Comm & new_comm)
+  {
+    Foam::label foam_comm;
+    if (Foam::UPstream::parRun())
+    {
+      Foam::labelList foam_procs(procs.begin(), procs.end());
+      foam_comm = Foam::UPstream::allocateCommunicator(parent_comm, foam_procs, true);
+      new_comm = Foam::PstreamGlobals::MPICommunicators_[foam_comm];
+    }
+    else
+    {
+      foam_comm = Foam::UPstream::worldComm;
+      new_comm = MPI_COMM_WORLD;
+    }
+    return foam_comm;
+  }
+
+  // free communicators if parallel run
+  void destroyCommunicator(Foam::label comm)
+  {
+    if (Foam::UPstream::parRun())
+      Foam::UPstream::freeCommunicator(comm);
+  }
+};

include/bcs/FoamMassFlowRateInletBC.h

@@ -0,0 +1,17 @@
+#include "FoamPostprocessorBCBase.h"
+#include "InputParameters.h"
+#include "MooseTypes.h"
+#include "PostprocessorInterface.h"
+
+class FoamMassFlowRateInletBC : public FoamPostprocessorBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamMassFlowRateInletBC(const InputParameters & params);
+
+  virtual void imposeBoundaryCondition() override;
+
+protected:
+  const Real _scale_factor;
+};

include/bcs/FoamMassFlowRateMappedInletBC.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "FoamMappedInletBCBase.h"
+#include "MooseEnum.h"
+
+class FoamMassFlowRateMappedInletBC : public FoamMappedInletBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamMassFlowRateMappedInletBC(const InputParameters & params);
+
+  virtual void imposeBoundaryCondition() override;
+
+protected:
+  MooseEnum _scale_method;
+
+  Real _scale_factor;
+};