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

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 VariadicTable<std::string, std::string, std::string, std::string, std::string> BCInfoTable;
 
 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 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/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 AuxVariable imposed on OpenFOAM
+  VariableName moosePostprocessor() const { return _pp_name; }
+
+  virtual void initialSetup() {};
+
+  virtual void addInfoRow(BCInfoTable & table);
+
+protected:
+  const PostprocessorName _pp_name;
+
+  // Pointer to Moose variable used to impose BC
+  const PostprocessorValue & _pp_value;
+};

include/bcs/FoamVariableBCBase.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "FoamBCBase.h"
+#include "InputParameters.h"
+
+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->name(); }
+
+  virtual void initialSetup();
+
+  virtual void addInfoRow(BCInfoTable & table);
+
+protected:
+  // Get the value of the MOOSE variable at an element
+  Real variableValueAtElement(const libMesh::Elem & elem);
+
+  // Get the data vector of the MOOSE field on a subdomain
+  std::vector<Real> getMooseVariableArray(int subdomainId);
+
+  // Pointer to Moose variable used to impose BC
+  MooseVariableFieldBase * _moose_var;
+};

include/mesh/FoamMesh.h

@@ -60,12 +60,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,20 @@ 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;
+  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;
+}
 }
 }

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,13 @@ 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 not provided and pp is an allowed parameter
+    if (findParamKey(_moose_object_pars, "pp") && !_moose_object_pars.isParamSetByUser("pp"))
+      createReceiver(*foam_problem);
+
     foam_problem->addObject<FoamBCBase>(_type, _name, _moose_object_pars, false);
   }
 }
@@ -56,3 +71,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);
+}

src/bcs/FoamBCBase.C

@@ -14,16 +14,6 @@
 #include <algorithm>
 #include <vector>
 
-namespace
-{
-// Private function to check if variables are constant monomials
-inline bool
-is_constant_monomial(const MooseVariableFieldBase & var)
-{
-  return var.order() == libMesh::Order::CONSTANT && var.feType().family == FEFamily::MONOMIAL;
-}
-}
-
 InputParameters
 FoamBCBase::validParams()
 {
@@ -32,13 +22,8 @@ FoamBCBase::validParams()
                                        "Name of a Foam field. e.g. T (temperature) U (velocity).");
   params.addParam<std::vector<SubdomainName>>("boundary",
                                               "Boundaries that the boundary condition applies to.");
-
-  params.addParam<VariableName>(
-      "v",
-      "Optional variable to use in BC. This allows existing AuxVariables to be"
-      " used rather than creating a new one under the hood.");
-  // Get desired parameters from Variable objects
-  params.transferParam<std::vector<Real>>(MooseVariable::validParams(), "initial_condition");
+  params.addRequiredParam<std::string>("foam_variable",
+                                       "Name of a Foam field. e.g. T (temperature) U (velocity).");
 
   params.registerSystemAttributeName("FoamBC");
   params.registerBase("FoamBC");
@@ -50,7 +35,6 @@ FoamBCBase::FoamBCBase(const InputParameters & params)
   : MooseObject(params),
     Coupleable(this, false),
     _foam_variable(params.get<std::string>("foam_variable")),
-    _moose_var(nullptr),
     _boundary(params.get<std::vector<SubdomainName>>("boundary"))
 {
   auto * problem = dynamic_cast<FoamProblem *>(&_c_fe_problem);
@@ -60,7 +44,8 @@ FoamBCBase::FoamBCBase(const InputParameters & params)
   _mesh = &problem->mesh();
 
   // check that the foam variable exists
-  if (!_mesh->foamHasObject<Foam::volScalarField>(_foam_variable))
+  if (!params.isPrivate("foam_variable") &&
+      !_mesh->foamHasObject<Foam::volScalarField>(_foam_variable))
     mooseError("There is no OpenFOAM field named '", _foam_variable, "'");
 
   // check that the boundary is in the FoamMesh
@@ -75,45 +60,3 @@ FoamBCBase::FoamBCBase(const InputParameters & params)
   if (_boundary.empty())
     _boundary = all_subdomain_names;
 }
-
-void
-FoamBCBase::initialSetup()
-{
-  // Check variable exists
-  auto var_name = parameters().isParamValid("v") ? parameters().get<VariableName>("v") : _name;
-  if (!_c_fe_problem.hasVariable(var_name))
-    mooseError("Variable '", var_name, "' doesn't exist");
-
-  THREAD_ID tid = parameters().get<THREAD_ID>("_tid");
-  _moose_var = &_c_fe_problem.getVariable(tid, var_name);
-
-  // Check variable is constant monomial in case it is provided.
-  if (!is_constant_monomial(*_moose_var))
-    mooseError("Variable '", var_name, "' must be a constant monomial.");
-}
-
-Real
-FoamBCBase::variableValueAtElement(const libMesh::Elem * elem)
-{
-  auto & sys = _moose_var->sys();
-  auto dof = elem->dof_number(sys.number(), _moose_var->number(), 0);
-  return sys.solution()(dof);
-}
-
-std::vector<Real>
-FoamBCBase::getMooseVariableArray(int subdomain_id)
-{
-  size_t patch_count = _mesh->getPatchCount(subdomain_id);
-  size_t patch_offset = _mesh->getPatchOffset(subdomain_id);
-
-  std::vector<Real> var_array(patch_count);
-  for (size_t j = 0; j < patch_count; ++j)
-  {
-    auto elem = patch_offset + j;
-    auto elem_ptr = _mesh->getElemPtr(elem + _mesh->rank_element_offset);
-    assert(elem_ptr);
-    var_array[j] = variableValueAtElement(elem_ptr);
-  }
-
-  return var_array;
-}

src/bcs/FoamFixedGradientBC.C

@@ -10,7 +10,7 @@ registerMooseObject("hippoApp", FoamFixedGradientBC);
 InputParameters
 FoamFixedGradientBC::validParams()
 {
-  auto params = FoamBCBase::validParams();
+  auto params = FoamVariableBCBase::validParams();
   params.addClassDescription("A FoamBC that imposes a fixed gradient dirichlet boundary condition "
                              "on the OpenFOAM simulation");
   params.addParam<std::string>("diffusivity_coefficient",
@@ -20,7 +20,7 @@ FoamFixedGradientBC::validParams()
 }
 
 FoamFixedGradientBC::FoamFixedGradientBC(const InputParameters & parameters)
-  : FoamBCBase(parameters),
+  : FoamVariableBCBase(parameters),
     _diffusivity_coefficient(parameters.get<std::string>("diffusivity_coefficient"))
 {
   // check that the diffusivity coefficient is a OpenFOAM scalar field