Add mapped inlet BC classes

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/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;
+};

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

@@ -0,0 +1,19 @@
+#pragma once
+#include "FoamMappedInletBCBase.h"
+#include "MooseEnum.h"
+
+class FoamScalarBulkMappedInletBC : public FoamMappedInletBCBase
+{
+public:
+  static InputParameters validParams();
+
+  FoamScalarBulkMappedInletBC(const InputParameters & params);
+
+  virtual void imposeBoundaryCondition() override;
+
+protected:
+  MooseEnum _scale_method;
+
+  template <typename T>
+  T applyScaleMethod(T & var, const Real bulk_ref, const Real bulk);
+};

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

@@ -62,12 +62,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);
+}