remove boundary conditions from mesh

src/interface/swarm_container.cpp

@@ -51,7 +51,8 @@ void SwarmContainer::InitializeBoundaries(const std::shared_ptr<MeshBlock> pmb)
   // are not being used
   for (int iFace = 0; iFace < 6; iFace++) {
     if (bcs[iFace] == BoundaryFlag::user) {
-      if (pmb->pmy_mesh->forest.GetTreePtr(pmb->loc.tree())->SwarmBndryFnctn[iFace] == nullptr) {
+      if (pmb->pmy_mesh->forest.GetTreePtr(pmb->loc.tree())->SwarmBndryFnctn[iFace] ==
+          nullptr) {
         msg << (iFace % 2 == 0 ? "i" : "o") << "x" << iFace / 2 + 1
             << " user boundary requested but provided function is null!";
         PARTHENON_FAIL(msg);

src/mesh/forest/forest.hpp

@@ -138,7 +138,8 @@ class Forest {
       std::array<std::vector<BValFunc>, BOUNDARY_NFACES> UserBoundaryFunctions_in,
       std::array<std::vector<SBValFunc>, BOUNDARY_NFACES> UserSwarmBoundaryFunctions_in) {
     for (auto &[id, ptree] : trees)
-      ptree->EnrollBndryFncts(app_in, UserBoundaryFunctions_in, UserSwarmBoundaryFunctions_in);
+      ptree->EnrollBndryFncts(app_in, UserBoundaryFunctions_in,
+                              UserSwarmBoundaryFunctions_in);
   }
 
   std::vector<NeighborLocation> FindNeighbors(const LogicalLocation &loc, int ox1,

src/mesh/forest/tree.cpp

@@ -439,7 +439,7 @@ void Tree::EnrollBndryFncts(
     case BoundaryFlag::reflect:
       // Default "reflect" boundaries not available for swarms; catch later on if swarms
       // are present
-      break;  
+      break;
     case BoundaryFlag::user:
       if (app_in->swarm_boundary_conditions[f] != nullptr) {
         // This is checked to be non-null later in Swarm::AllocateBoundaries, in case user

src/mesh/mesh.cpp

@@ -78,11 +78,10 @@ Mesh::Mesh(ParameterInput *pin, ApplicationInput *app_in, Packages_t &packages,
       // private members:
       num_mesh_threads_(pin->GetOrAddInteger("parthenon/mesh", "num_threads", 1)),
       use_uniform_meshgen_fn_{true, true, true, true}, lb_flag_(true), lb_automatic_(),
-      lb_manual_(), MeshBndryFnctn{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
-      nslist(Globals::nranks), nblist(Globals::nranks), nref(Globals::nranks),
-      nderef(Globals::nranks), rdisp(Globals::nranks), ddisp(Globals::nranks),
-      bnref(Globals::nranks), bnderef(Globals::nranks), brdisp(Globals::nranks),
-      bddisp(Globals::nranks) {
+      lb_manual_(), nslist(Globals::nranks), nblist(Globals::nranks),
+      nref(Globals::nranks), nderef(Globals::nranks), rdisp(Globals::nranks),
+      ddisp(Globals::nranks), bnref(Globals::nranks), bnderef(Globals::nranks),
+      brdisp(Globals::nranks), bddisp(Globals::nranks) {
   // Allow for user overrides to default Parthenon functions
   if (app_in->InitUserMeshData != nullptr) {
     InitUserMeshData = app_in->InitUserMeshData;
@@ -170,11 +169,10 @@ Mesh::Mesh(ParameterInput *pin, ApplicationInput *app_in, Packages_t &packages,
   }
 
   // Load balancing flag and parameters
-  EnrollBndryFncts_(app_in);
-
   forest = forest::Forest::HyperRectangular(mesh_size, base_block_size, mesh_bcs);
   root_level = forest.root_level;
-  forest.EnrollBndryFncts(app_in, resolved_packages->UserBoundaryFunctions, resolved_packages->UserSwarmBoundaryFunctions);
+  forest.EnrollBndryFncts(app_in, resolved_packages->UserBoundaryFunctions,
+                          resolved_packages->UserSwarmBoundaryFunctions);
 
   // SMR / AMR:
   if (adaptive) {
@@ -184,8 +182,6 @@ Mesh::Mesh(ParameterInput *pin, ApplicationInput *app_in, Packages_t &packages,
   }
 
   // Register user defined boundary conditions
-  UserBoundaryFunctions = resolved_packages->UserBoundaryFunctions;
-  UserSwarmBoundaryFunctions = resolved_packages->UserSwarmBoundaryFunctions;
 
   CheckMeshValidity();
 }
@@ -217,10 +213,9 @@ Mesh::Mesh(ParameterInput *pin, ApplicationInput *app_in, Packages_t &packages,
 
   ndim = 2;
   // Load balancing flag and parameters
-  EnrollBndryFncts_(app_in);
   forest = forest::Forest::Make2D(forest_def);
-  forest.EnrollBndryFncts(app_in, resolved_packages->UserBoundaryFunctions, resolved_packages->UserSwarmBoundaryFunctions);
-  UserBoundaryFunctions = resolved_packages->UserBoundaryFunctions;
+  forest.EnrollBndryFncts(app_in, resolved_packages->UserBoundaryFunctions,
+                          resolved_packages->UserSwarmBoundaryFunctions);
   BuildBlockList(pin, app_in, packages, -1);
 }
 
@@ -535,73 +530,6 @@ void Mesh::OutputMeshStructure(const int ndim,
             << std::endl;
 }
 
-//----------------------------------------------------------------------------------------
-//  Enroll user-defined functions for boundary conditions
-void Mesh::EnrollBndryFncts_(ApplicationInput *app_in) {
-  static const BValFunc outflow[6] = {
-      BoundaryFunction::OutflowInnerX1, BoundaryFunction::OutflowOuterX1,
-      BoundaryFunction::OutflowInnerX2, BoundaryFunction::OutflowOuterX2,
-      BoundaryFunction::OutflowInnerX3, BoundaryFunction::OutflowOuterX3};
-  static const BValFunc reflect[6] = {
-      BoundaryFunction::ReflectInnerX1, BoundaryFunction::ReflectOuterX1,
-      BoundaryFunction::ReflectInnerX2, BoundaryFunction::ReflectOuterX2,
-      BoundaryFunction::ReflectInnerX3, BoundaryFunction::ReflectOuterX3};
-  static const SBValFunc soutflow[6] = {
-      BoundaryFunction::SwarmOutflowInnerX1, BoundaryFunction::SwarmOutflowOuterX1,
-      BoundaryFunction::SwarmOutflowInnerX2, BoundaryFunction::SwarmOutflowOuterX2,
-      BoundaryFunction::SwarmOutflowInnerX3, BoundaryFunction::SwarmOutflowOuterX3};
-  static const SBValFunc speriodic[6] = {
-      BoundaryFunction::SwarmPeriodicInnerX1, BoundaryFunction::SwarmPeriodicOuterX1,
-      BoundaryFunction::SwarmPeriodicInnerX2, BoundaryFunction::SwarmPeriodicOuterX2,
-      BoundaryFunction::SwarmPeriodicInnerX3, BoundaryFunction::SwarmPeriodicOuterX3};
-
-  for (int f = 0; f < BOUNDARY_NFACES; f++) {
-    switch (mesh_bcs[f]) {
-    case BoundaryFlag::reflect:
-      MeshBndryFnctn[f] = reflect[f];
-      break;
-    case BoundaryFlag::outflow:
-      MeshBndryFnctn[f] = outflow[f];
-      MeshSwarmBndryFnctn[f] = soutflow[f];
-      break;
-    case BoundaryFlag::user:
-      if (app_in->boundary_conditions[f] != nullptr) {
-        MeshBndryFnctn[f] = app_in->boundary_conditions[f];
-      } else {
-        std::stringstream msg;
-        msg << "A user boundary condition for face " << f
-            << " was requested. but no condition was enrolled." << std::endl;
-        PARTHENON_THROW(msg);
-      }
-      break;
-    default: // periodic/block BCs handled elsewhere.
-      break;
-    }
-
-    switch (mesh_bcs[f]) {
-    case BoundaryFlag::outflow:
-      MeshSwarmBndryFnctn[f] = soutflow[f];
-      break;
-    case BoundaryFlag::periodic:
-      MeshSwarmBndryFnctn[f] = speriodic[f];
-      break;
-    case BoundaryFlag::reflect:
-      // Default "reflect" boundaries not available for swarms; catch later on if swarms
-      // are present
-      break;
-    case BoundaryFlag::user:
-      if (app_in->swarm_boundary_conditions[f] != nullptr) {
-        // This is checked to be non-null later in Swarm::AllocateBoundaries, in case user
-        // boundaries are requested but no swarms are used.
-        MeshSwarmBndryFnctn[f] = app_in->swarm_boundary_conditions[f];
-      }
-      break;
-    default: // Default BCs handled elsewhere
-      break;
-    }
-  }
-}
-
 //----------------------------------------------------------------------------------------
 // \!fn void Mesh::ApplyUserWorkBeforeOutput(ParameterInput *pin)
 // \brief Apply MeshBlock::UserWorkBeforeOutput

src/mesh/mesh.hpp

@@ -165,12 +165,6 @@ class Mesh {
   void ApplyUserWorkBeforeRestartOutput(Mesh *mesh, ParameterInput *pin,
                                         SimTime const &time, OutputParameters *pparams);
 
-  // Boundary Functions
-  BValFunc MeshBndryFnctn[BOUNDARY_NFACES] = {nullptr};
-  SBValFunc MeshSwarmBndryFnctn[BOUNDARY_NFACES] = {nullptr};
-  std::array<std::vector<BValFunc>, BOUNDARY_NFACES> UserBoundaryFunctions;
-  std::array<std::vector<SBValFunc>, BOUNDARY_NFACES> UserSwarmBoundaryFunctions;
-
   // defined in either the prob file or default_pgen.cpp in ../pgen/
   std::function<void(Mesh *, ParameterInput *, MeshData<Real> *)> ProblemGenerator =
       nullptr;
@@ -323,8 +317,6 @@ class Mesh {
   // Optionally defined in the problem file
   std::function<void(Mesh *, ParameterInput *)> InitUserMeshData = nullptr;
 
-  void EnrollBndryFncts_(ApplicationInput *app_in);
-
   // Re-used functionality in constructor
   void RegisterLoadBalancing_(ParameterInput *pin);
 

tst/unit/test_swarm.cpp

@@ -80,10 +80,15 @@ TEST_CASE("Swarm memory management", "[Swarm]") {
   pin->LoadFromStream(is);
   auto app_in = std::make_shared<ApplicationInput>();
   Packages_t packages;
+  auto descrip = std::make_shared<parthenon::StateDescriptor>("test");
+  descrip->UserBoundaryFunctions[0].push_back(OutflowInnerX1);
+  descrip->UserSwarmBoundaryFunctions[0].push_back(SwarmUserInnerX1);
+  packages.Add(descrip);
   auto meshblock = std::make_shared<MeshBlock>(1, 1);
   auto mesh = std::make_shared<Mesh>(pin.get(), app_in.get(), packages, 1);
-  mesh->UserSwarmBoundaryFunctions[0].push_back(SwarmUserInnerX1);
-  mesh->UserBoundaryFunctions[0].push_back(OutflowInnerX1);
+
+  // loc needs to be set to call bndry condition routines below
+  meshblock->loc = mesh->GetLocList()[0];
   mesh->mesh_bcs[0] = BoundaryFlag::user;
   meshblock->boundary_flag[0] = BoundaryFlag::user;
   for (int i = 1; i < 6; i++) {