Communicate FieldPerp consistently with other Fields

- Store a `variant` in `FieldGroup` that can handle `FieldPerp`
- Removes `Mesh::communicate(FieldPerp&)` overload

Author: ZedThree

include/bout/fieldgroup.hxx

@@ -1,15 +1,17 @@
 #ifndef BOUT_FIELDGROUP_H
 #define BOUT_FIELDGROUP_H
 
-#include "bout/field_data.hxx"
-#include <bout/field3d.hxx>
-
+#include <bout/sys/variant.hxx>
+#include <bout/traits.hxx>
 #include <bout/vector2d.hxx>
 #include <bout/vector3d.hxx>
 
 #include <vector>
 
-#include <algorithm>
+class Field2D;
+class Field3D;
+class FieldPerp;
+class FieldData;
 
 /// Group together fields for easier communication
 ///
@@ -19,14 +21,18 @@
 /// components (x,y,z) as Field2D or Field3D objects.
 class FieldGroup {
 public:
+  using Item = bout::utils::variant<Field3D*, Field2D*, FieldPerp*>;
+
   FieldGroup() = default;
   FieldGroup(const FieldGroup& other) = default;
   FieldGroup(FieldGroup&& other) = default;
   FieldGroup& operator=(const FieldGroup& other) = default;
   FieldGroup& operator=(FieldGroup&& other) = default;
+  ~FieldGroup() = default;
 
   /// Constructor with a single FieldData \p f
-  FieldGroup(FieldData& f) { fvec.push_back(&f); }
+  FieldGroup(Field2D& f) { fvec.push_back(&f); }
+  FieldGroup(FieldPerp& f) { fvec.push_back(&f); }
 
   /// Constructor with a single Field3D \p f
   FieldGroup(Field3D& f) {
@@ -83,7 +89,8 @@ public:
   /// A pointer to this field will be stored internally,
   /// so the lifetime of this variable should be longer
   /// than the lifetime of this group.
-  void add(FieldData& f) { fvec.push_back(&f); }
+  void add(Field2D& f) { fvec.push_back(&f); }
+  void add(FieldPerp& f) { fvec.push_back(&f); }
 
   // Add a 3D field \p f, which goes into both vectors.
   //
@@ -121,18 +128,8 @@ public:
   }
 
   /// Add multiple fields to this group
-  ///
-  /// This is a variadic template which allows Field3D objects to be
-  /// treated as a special case. An arbitrary number of fields can be
-  /// added.
-  template <typename... Ts>
-  void add(FieldData& t, Ts&... ts) {
-    add(t);     // Add the first using functions above
-    add(ts...); // Add the rest
-  }
-
-  template <typename... Ts>
-  void add(Field3D& t, Ts&... ts) {
+  template <typename T, typename... Ts, typename = bout::utils::EnableIfField<T>>
+  void add(T& t, Ts&... ts) {
     add(t);     // Add the first using functions above
     add(ts...); // Add the rest
   }
@@ -165,16 +162,14 @@ public:
   }
 
   /// Iteration over all fields
-  using iterator = std::vector<FieldData*>::iterator;
-  iterator begin() { return fvec.begin(); }
-  iterator end() { return fvec.end(); }
+  auto begin() { return fvec.begin(); }
+  auto end() { return fvec.end(); }
 
   /// Const iteration over all fields
-  using const_iterator = std::vector<FieldData*>::const_iterator;
-  const_iterator begin() const { return fvec.begin(); }
-  const_iterator end() const { return fvec.end(); }
+  auto begin() const { return fvec.cbegin(); }
+  auto end() const { return fvec.cend(); }
 
-  const std::vector<FieldData*>& get() const { return fvec; }
+  const std::vector<Item>& get() const { return fvec; }
 
   /// Iteration over 3D fields
   const std::vector<Field3D*>& field3d() const { return f3vec; }
@@ -183,8 +178,8 @@ public:
   void makeUnique();
 
 private:
-  std::vector<FieldData*> fvec; // Vector of fields
-  std::vector<Field3D*> f3vec;  // Vector of 3D fields
+  std::vector<Item> fvec;      // Vector of fields
+  std::vector<Field3D*> f3vec; // Vector of 3D fields
 };
 
 /// Combine two FieldGroups

include/bout/mesh.hxx

@@ -3,15 +3,15 @@
  *
  * Interface for mesh classes. Contains standard variables and useful
  * routines.
- * 
+ *
  * Changelog
  * =========
  *
  * 2014-12 Ben Dudson <bd512@york.ac.uk>
  *     * Removing coordinate system into separate
  *       Coordinates class
  *     * Adding index derivative functions from derivs.cxx
- * 
+ *
  * 2010-06 Ben Dudson, Sean Farley
  *     * Initial version, adapted from GridData class
  *     * Incorporates code from topology.cpp and Communicator
@@ -20,7 +20,7 @@
  * Copyright 2010-2025 BOUT++ contributors
  *
  * Contact: Ben Dudson, dudson2@llnl.gov
- * 
+ *
  * This file is part of BOUT++.
  *
  * BOUT++ is free software: you can redistribute it and/or modify
@@ -301,11 +301,6 @@ public:
   /// @param g  The group of fields to communicate. Guard cells will be modified
   void communicateYZ(FieldGroup& g);
 
-  /*!
-   * Communicate an X-Z field
-   */
-  virtual void communicate(FieldPerp& f);
-
   /*!
    * Send a list of FieldData objects
    * Packs arguments into a FieldGroup and passes
@@ -815,7 +810,7 @@ protected:
   const std::vector<int> readInts(const std::string& name, int n);
 
   /// Calculates the size of a message for a given x and y range
-  int msg_len(const std::vector<FieldData*>& var_list, int xge, int xlt, int yge,
+  int msg_len(const std::vector<FieldGroup::Item>& var_list, int xge, int xlt, int yge,
               int ylt);
 
   /// Initialise derivatives

src/mesh/impls/bout/boutmesh.cxx

@@ -49,6 +49,7 @@
 #include <bout/sys/gettext.hxx>
 #include <bout/sys/range.hxx>
 #include <bout/sys/timer.hxx>
+#include <bout/sys/variant.hxx>
 #include <bout/utils.hxx>
 
 #include <fmt/format.h>
@@ -1400,6 +1401,16 @@ comm_handle BoutMesh::sendY(FieldGroup& g, comm_handle handle) {
   return static_cast<void*>(ch);
 }
 
+namespace {
+// FieldGroup stores a vector of variants now, rather than a pointer to the
+// FieldData base class, so we need this visitor as a shim
+struct DoneCommsVisitor {
+  void operator()(Field3D* var) const { var->doneComms(); }
+  void operator()(Field2D* var) const { var->doneComms(); }
+  void operator()(FieldPerp* var) const { var->doneComms(); }
+};
+} // namespace
+
 int BoutMesh::wait(comm_handle handle) {
 
   if (handle == nullptr) {
@@ -1545,7 +1556,7 @@ int BoutMesh::wait(comm_handle handle) {
 #if CHECK > 0
   // Keeping track of whether communications have been done
   for (const auto& var : ch->var_list) {
-    var->doneComms();
+    bout::utils::visit(DoneCommsVisitor{}, var);
   }
 #endif
 
@@ -2218,9 +2229,9 @@ void BoutMesh::topology() {
     }
 
     for (int i = 0; i < limiter_count; ++i) {
-      int const yind = limiter_yinds[i];
-      int const xstart = limiter_xstarts[i];
-      int const xend = limiter_xends[i];
+      const int yind = limiter_yinds[i];
+      const int xstart = limiter_xstarts[i];
+      const int xend = limiter_xends[i];
       output_info.write("Adding a limiter between y={} and {}. X indices {} to {}\n",
                         yind, yind + 1, xstart, xend);
       add_target(yind, xstart, xend);
@@ -2397,72 +2408,121 @@ void BoutMesh::overlapHandleMemory(BoutMesh* yup, BoutMesh* ydown, BoutMesh* xin
  *                   Communication utilities
  ****************************************************************/
 
-int BoutMesh::pack_data(const std::vector<FieldData*>& var_list, int xge, int xlt,
-                        int yge, int ylt, BoutReal* buffer) {
-
-  int len = 0;
+namespace {
+// Visitor for packing data from a `FieldGroup::Item` into an existing buffer
+struct PackDataVisitor {
+  int xge;
+  int xlt;
+  int yge;
+  int ylt;
+  int zge;
+  int zlt;
+  BoutReal* buffer;
+  int len;
 
-  /// Loop over variables
-  for (const auto& var : var_list) {
-    if (var->is3D()) {
-      // 3D variable
-      auto* var3d_ref_ptr = dynamic_cast<Field3D*>(var);
-      ASSERT0(var3d_ref_ptr != nullptr);
-      auto& var3d_ref = *var3d_ref_ptr;
-      ASSERT2(var3d_ref.isAllocated());
-      for (int jx = xge; jx != xlt; jx++) {
-        for (int jy = yge; jy < ylt; jy++) {
-          for (int jz = 0; jz < LocalNz; jz++, len++) {
-            buffer[len] = var3d_ref(jx, jy, jz);
-          }
+  int operator()(const Field3D* var) {
+    const auto& var3d_ref = *var;
+    ASSERT2(var3d_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jy = yge; jy < ylt; jy++) {
+        for (int jz = zge; jz < zlt; jz++, len++) {
+          buffer[len] = var3d_ref(jx, jy, jz);
         }
       }
-    } else {
-      // 2D variable
-      auto* var2d_ref_ptr = dynamic_cast<Field2D*>(var);
-      ASSERT0(var2d_ref_ptr != nullptr);
-      auto& var2d_ref = *var2d_ref_ptr;
-      ASSERT2(var2d_ref.isAllocated());
-      for (int jx = xge; jx != xlt; jx++) {
-        for (int jy = yge; jy < ylt; jy++, len++) {
-          buffer[len] = var2d_ref(jx, jy);
+    }
+    return len;
+  }
+
+  int operator()(const Field2D* var) {
+    const auto& var2d_ref = *var;
+    ASSERT2(var2d_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jy = yge; jy < ylt; jy++, len++) {
+        buffer[len] = var2d_ref(jx, jy);
+      }
+    }
+    return len;
+  }
+
+  int operator()(const FieldPerp* var) {
+    const auto& varperp_ref = *var;
+    ASSERT2(varperp_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jz = zge; jz < zlt; jz++, len++) {
+        buffer[len] = varperp_ref(jx, jz);
+      }
+    }
+    return len;
+  }
+};
+
+// Visitor for unpacking a buffer into a `FieldGroup::Item`
+struct UnpackDataVisitor {
+  int xge;
+  int xlt;
+  int yge;
+  int ylt;
+  int zge;
+  int zlt;
+  BoutReal* buffer;
+  int len;
+
+  void operator()(Field3D* var) {
+    auto& var3d_ref = *var;
+    ASSERT2(var3d_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jy = yge; jy < ylt; jy++) {
+        for (int jz = zge; jz < zlt; jz++, len++) {
+          var3d_ref(jx, jy, jz) = buffer[len];
         }
       }
     }
   }
 
-  return (len);
+  void operator()(Field2D* var) {
+    auto& var2d_ref = *var;
+    ASSERT2(var2d_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jy = yge; jy < ylt; jy++, len++) {
+        var2d_ref(jx, jy) = buffer[len];
+      }
+    }
+  }
+
+  void operator()(FieldPerp* var) {
+    auto& varperp_ref = *var;
+    ASSERT2(varperp_ref.isAllocated());
+    for (int jx = xge; jx < xlt; jx++) {
+      for (int jz = zge; jz < zlt; jz++, len++) {
+        varperp_ref(jx, jz) = buffer[len];
+      }
+    }
+  }
+};
+} // namespace
+
+int BoutMesh::pack_data(const std::vector<FieldGroup::Item>& var_list, int xge, int xlt,
+                        int yge, int ylt, BoutReal* buffer) {
+
+  auto visitor = PackDataVisitor{xge, xlt, yge, ylt, 0, LocalNz, buffer, 0};
+
+  for (const auto& var : var_list) {
+    bout::utils::visit(visitor, var);
+  }
+
+  return visitor.len;
 }
 
-int BoutMesh::unpack_data(const std::vector<FieldData*>& var_list, int xge, int xlt,
+int BoutMesh::unpack_data(const std::vector<FieldGroup::Item>& var_list, int xge, int xlt,
                           int yge, int ylt, BoutReal* buffer) {
 
-  int len = 0;
+  auto visitor = UnpackDataVisitor{xge, xlt, yge, ylt, 0, LocalNz, buffer, 0};
 
-  /// Loop over variables
   for (const auto& var : var_list) {
-    if (var->is3D()) {
-      // 3D variable
-      auto& var3d_ref = *dynamic_cast<Field3D*>(var);
-      for (int jx = xge; jx != xlt; jx++) {
-        for (int jy = yge; jy < ylt; jy++) {
-          for (int jz = 0; jz < LocalNz; jz++, len++) {
-            var3d_ref(jx, jy, jz) = buffer[len];
-          }
-        }
-      }
-    } else {
-      // 2D variable
-      auto& var2d_ref = *dynamic_cast<Field2D*>(var);
-      for (int jx = xge; jx != xlt; jx++) {
-        for (int jy = yge; jy < ylt; jy++, len++) {
-          var2d_ref(jx, jy) = buffer[len];
-        }
-      }
-    }
+    bout::utils::visit(visitor, var);
   }
 
-  return (len);
+  return visitor.len;
 }
 
 /****************************************************************

src/mesh/impls/bout/boutmesh.hxx

@@ -476,12 +476,12 @@ private:
   void post_receiveY(CommHandle& ch);
 
   /// Take data from objects and put into a buffer
-  int pack_data(const std::vector<FieldData*>& var_list, int xge, int xlt, int yge,
+  int pack_data(const std::vector<FieldGroup::Item>& var_list, int xge, int xlt, int yge,
                 int ylt, BoutReal* buffer);
   /// Copy data from a buffer back into the fields
 
-  int unpack_data(const std::vector<FieldData*>& var_list, int xge, int xlt, int yge,
-                  int ylt, BoutReal* buffer);
+  int unpack_data(const std::vector<FieldGroup::Item>& var_list, int xge, int xlt,
+                  int yge, int ylt, BoutReal* buffer);
 };
 
 namespace {