Add Postprocessor-based Foam boundary conditions

Makefile

@@ -46,6 +46,7 @@ RDG                         := no
 RICHARDS                    := no
 STOCHASTIC_TOOLS            := no
 TENSOR_MECHANICS            := no
+THERMAL_HYDRAULICS          := no
 XFEM                        := no
 
 include $(MOOSE_DIR)/modules/modules.mk

doc/content/hit/step_by_step/fluid.i

@@ -14,9 +14,8 @@
 
 [FoamBCs]
     [solid_heat_flux]
-        type = FoamFixedGradientBC
+        type = FoamDiffusionFluxBC
         foam_variable = 'T'
-        diffusivity_coefficient = kappa
         initial_condition = 0
     []
 []

doc/content/shell_tube_hx.md

@@ -234,7 +234,7 @@ Both `inner.i` and `outer.i` are the same:
 ```
 
 Note that this is a different type to the step-by-step example where a
-`FoamFixedGradientBC` is used.
+`FoamDiffusionFluxBC` is used.
 
 ## Imposing the fluid heat flux on the solid
 

doc/content/step_by_step.md

@@ -136,19 +136,16 @@ and so can be transferred between MOOSE apps.
 
 Hippo also implements the `FoamBC` system that allows you to impose boundary conditions
 on OpenFOAM from the Hippo input file. In this case, we wish to impose a heat flux BC
-on the temperature field. This requires the `FoamFixedGradientBC`, which mirrors OpenFOAM's
-`fixedGradient` BC type. As in this case, we provide a heat flux, we must also provide the
-thermal conductivity, which is specified as the `diffusivity_coefficient`.
-`kappa` is the name of the thermal conductivity variable in OpenFOAM.
+on the temperature field, which can be done using `FoamDiffusionFluxBC`. A diffusivity can be specified,
+although the default is the thermal conductivity `kappa`, which is what we require here.
 
 ```toml
 # fluid.i
 
 [FoamBCs]
     [solid_heat_flux]
-        type = FoamFixedGradientBC
+        type = FoamDiffusionFluxBC
         foam_variable = T
-        diffusivity_coefficient = kappa
     []
 []
 ```

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/bcs/FoamBCBase.h

@@ -7,6 +7,9 @@
 #include <MooseObject.h>
 #include <MooseTypes.h>
 #include <MooseVariableFieldBase.h>
+#include "VariadicTable.h"
+
+typedef std::tuple<std::string, std::string, std::string, std::string, std::string> BCInfoTableRow;
 
 class FoamBCBase : public MooseObject, public Coupleable
 {
@@ -26,7 +29,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 BCInfoTableRow getInfoRow() const = 0;
 
 protected:
   // OpenFOAM variable which this BC is to be imposed on

include/bcs/FoamDiffusionFluxBC.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "FoamVariableBCBase.h"
+
+class FoamDiffusionFluxBC : public FoamVariableBCBase
+{
+public:
+  static InputParameters validParams();
+  explicit FoamDiffusionFluxBC(const InputParameters & params);
+
+  // Impose boundary conditions (to be called from FoamProblem class)
+  virtual void imposeBoundaryCondition() override;
+
+protected:
+  // diffusivity name for flux condition
+  const std::string _diffusivity;
+};

include/bcs/FoamDiffusionFluxPostprocessorBC.h

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

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
@@ -14,8 +14,4 @@ class FoamFixedGradientBC : public FoamBCBase
 
   // Impose boundary conditions (to be called from FoamProblem class)
   virtual void imposeBoundaryCondition() override;
-
-protected:
-  // name of diffusivity coefficient used to divide flux
-  std::string _diffusivity_coefficient;
 };

include/bcs/FoamFixedGradientPostprocessorBC.h

@@ -0,0 +1,15 @@
+#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;
+};

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/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/FoamPostprocessorBCBase.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "FoamBCBase.h"
+#include "InputParameters.h"
+#include "MooseTypes.h"
+#include "PostprocessorInterface.h"
+
+class FoamPostprocessorBCBase : public FoamBCBase, public PostprocessorInterface
+{
+public:
+  static InputParameters validParams();
+
+  explicit FoamPostprocessorBCBase(const InputParameters & params);
+
+  // returns the moose Postprocessor imposed on OpenFOAM
+  VariableName moosePostprocessor() const { return _pp_name; }
+
+  virtual void initialSetup() override {};
+
+  virtual BCInfoTableRow getInfoRow() const override;
+
+protected:
+  const PostprocessorName _pp_name;
+
+  // Reference to Moose PostprocessorValue used to impose BC
+  const PostprocessorValue & _pp_value;
+};

include/bcs/FoamVariableBCBase.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "FoamBCBase.h"
+#include "InputParameters.h"
+#include <functional>
+
+class FoamVariableBCBase : public FoamBCBase
+{
+public:
+  static InputParameters validParams();
+
+  explicit FoamVariableBCBase(const InputParameters & params);
+
+  // returns the moose AuxVariable imposed on OpenFOAM
+  VariableName mooseVariable() const { return _moose_var->get().name(); }
+
+  virtual void initialSetup() override;
+
+  virtual BCInfoTableRow getInfoRow() const override;
+
+protected:
+  // Get the value of the MOOSE variable at an element
+  Real variableValueAtElement(const libMesh::Elem & elem) const;
+
+  // Get the data vector of the MOOSE field on a subdomain
+  std::vector<Real> getMooseVariableArray(int subdomainId) const;
+
+  // Pointer to Moose variable used to impose BC
+  std::optional<std::reference_wrapper<MooseVariableFieldBase>> _moose_var;
+};

include/mesh/FoamMesh.h

@@ -63,12 +63,19 @@ class FoamMesh : public MooseMesh
     return _foam_mesh.foundObject<T>(name);
   }
 
+  // Returns the patch array for field and subdomain
+  template <typename GeoField, typename Type>
+  Foam::fvPatchField<Type> & getBCField(SubdomainID subdomain, Foam::word const & field)
+  {
+    return const_cast<Foam::fvPatchField<Type> &>(
+        _foam_mesh.boundary()[subdomain].lookupPatchField<GeoField, Type>(field));
+  }
+
   // Returns the gradient BC array for field and subdomain
   template <typename GeoField, typename Type>
   Foam::Field<Type> & getGradientBCField(SubdomainID subdomain, Foam::word const & field)
   {
-    auto & var = const_cast<Foam::fvPatchField<Type> &>(
-        _foam_mesh.boundary()[subdomain].lookupPatchField<GeoField, Type>(field));
+    auto & var = getBCField<GeoField, Type>(subdomain, field);
     return Foam::refCast<Foam::fixedGradientFvPatchField<Type>>(var).gradient();
   }
 

include/util/hippoUtils.h

@@ -13,5 +13,19 @@ copyParamFromParam(InputParameters & dst, const InputParameters & src, const std
   if (src.isParamValid(name_in))
     dst.set<T>(name_in) = src.get<T>(name_in);
 }
+
+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{vec[0]};
+  auto binary_op = [&](const std::string & acc, const std::string & it) { return acc + sep + it; };
+  return std::accumulate(vec.begin() + 1, vec.end(), str, binary_op);
+}
 }
 }

src/actions/AddFoamBCAction.C

@@ -7,6 +7,17 @@
 
 registerMooseAction("hippoApp", AddFoamBCAction, "add_foam_bc");
 
+namespace
+{
+inline bool
+findParamKey(const InputParameters & params, const std::string & key)
+{
+  return std::find_if(params.begin(),
+                      params.end(),
+                      [&](const auto & param) { return param.first == key; }) != params.end();
+}
+}
+
 InputParameters
 AddFoamBCAction::validParams()
 {
@@ -27,9 +38,14 @@ AddFoamBCAction::act()
       mooseError("FoamBCs system can only be used with FoamProblem.");
 
     // Do not create aux variable if variable provided.
-    if (!_moose_object_pars.isParamSetByUser("v"))
+    if (findParamKey(_moose_object_pars, "v") && !_moose_object_pars.isParamSetByUser("v"))
       createAuxVariable();
 
+    // Create receiver if pp_name not provided and pp_name is an allowed parameter
+    if (findParamKey(_moose_object_pars, "pp_name") &&
+        !_moose_object_pars.isParamSetByUser("pp_name"))
+      createReceiver(*foam_problem);
+
     foam_problem->addObject<FoamBCBase>(_type, _name, _moose_object_pars, false);
   }
 }
@@ -56,3 +72,12 @@ AddFoamBCAction::createAuxVariable()
       std::static_pointer_cast<Action>(_action_factory.create(class_name, name(), action_params));
   _awh.addActionBlock(action);
 }
+
+void
+AddFoamBCAction::createReceiver(FoamProblem & problem)
+{
+  auto params = _factory.getValidParams("Receiver");
+
+  Hippo::internal::copyParamFromParam<Real>(params, _moose_object_pars, "default");
+  problem.addPostprocessor("Receiver", name(), params);
+}