Minimal implementation of hexagonal mesh

include/openmc/mesh.h

@@ -302,10 +302,10 @@ class StructuredMesh : public Mesh {
 
   struct MeshDistance {
     MeshDistance() = default;
-    MeshDistance(int _index, bool _max_surface, double _distance)
-      : next_index {_index}, max_surface {_max_surface}, distance {_distance}
+    MeshDistance(MeshIndex _offset, bool _max_surface, double _distance)
+      : offset {_offset}, max_surface {_max_surface}, distance {_distance}
     {}
-    int next_index {-1};
+    MeshIndex offset {0, 0, 0};
     bool max_surface {true};
     double distance {INFTY};
     bool operator<(const MeshDistance& o) const
@@ -314,6 +314,8 @@ class StructuredMesh : public Mesh {
     }
   };
 
+  virtual void sanitize_index(MeshIndex& idx) const {};
+
   Position sample_element(int32_t bin, uint64_t* seed) const override
   {
     return sample_element(get_indices_from_bin(bin), seed);
@@ -327,6 +329,8 @@ class StructuredMesh : public Mesh {
 
   int n_surface_bins() const override;
 
+  virtual int n_neighbors() const { return n_dimension_; }
+
   void bins_crossed(Position r0, Position r1, const Direction& u,
     vector<int>& bins, vector<double>& lengths) const override;
 
@@ -364,6 +368,15 @@ class StructuredMesh : public Mesh {
   //! \return Array of mesh indices
   virtual MeshIndex get_indices(Position r, bool& in_mesh) const;
 
+  //! Check if mesh indices are inside mesh
+  //
+  //! \param[in] Array of mesh indices
+  //! \return are indices inside mesh?
+  virtual bool index_inside_mesh(const MeshIndex& ijk, int k) const
+  {
+    return ((ijk[k] >= 1) && (ijk[k] <= shape_[k]));
+  }
+
   //! Get mesh indices corresponding to a mesh bin
   //
   //! \param[in] bin Mesh bin
@@ -416,6 +429,10 @@ class StructuredMesh : public Mesh {
   virtual MeshDistance distance_to_grid_boundary(const MeshIndex& ijk, int i,
     const Position& r0, const Direction& u, double l) const = 0;
 
+  virtual double distance_to_mesh(const MeshIndex& ijk,
+    const std::array<MeshDistance, 4>& distances, double traveled_distance,
+    int& k_max) const;
+
   //! Get a label for the mesh bin
   std::string bin_label(int bin) const override;
 
@@ -452,6 +469,7 @@ class StructuredMesh : public Mesh {
 
   // Data members
   std::array<int, 3> shape_; //!< Number of mesh elements in each dimension
+  std::vector<std::vector<int>> correlated_axes_ = {{0}, {1}, {2}};
 
 protected:
 };
@@ -580,6 +598,11 @@ class CylindricalMesh : public PeriodicStructuredMesh {
   CylindricalMesh(hid_t group);
 
   // Overridden methods
+  void sanitize_index(MeshIndex& idx) const override
+  {
+    idx[1] = sanitize_phi(idx[1]);
+  }
+
   virtual MeshIndex get_indices(Position r, bool& in_mesh) const override;
 
   int get_index_in_direction(double r, int i) const override;
@@ -645,6 +668,12 @@ class SphericalMesh : public PeriodicStructuredMesh {
   SphericalMesh(hid_t group);
 
   // Overridden methods
+  void sanitize_index(MeshIndex& idx) const override
+  {
+    idx[1] = sanitize_theta(idx[1]);
+    idx[2] = sanitize_phi(idx[2]);
+  }
+
   virtual MeshIndex get_indices(Position r, bool& in_mesh) const override;
 
   int get_index_in_direction(double r, int i) const override;
@@ -706,6 +735,86 @@ class SphericalMesh : public PeriodicStructuredMesh {
   }
 };
 
+class HexagonalMesh : public PeriodicStructuredMesh {
+public:
+  // Constructors
+  HexagonalMesh() = default;
+  HexagonalMesh(pugi::xml_node node);
+  HexagonalMesh(hid_t group);
+
+  // Overridden methods
+  int get_bin(Position r) const override;
+
+  int n_bins() const override;
+
+  int n_surface_bins() const override;
+
+  MeshIndex get_indices(Position r, bool& in_mesh) const override;
+
+  bool index_inside_mesh(const MeshIndex& ijk, int k) const override
+  {
+    if (k == 3)
+      return ((ijk[2] >= 1) && (ijk[2] < grid_.size()));
+    int rad =
+      std::max({std::abs(ijk[0]), std::abs(ijk[1]), std::abs(ijk[0] + ijk[1])});
+    return (rad <= radius_);
+  }
+
+  int get_bin_from_indices(const MeshIndex& ijk) const override;
+
+  std::string get_mesh_type() const override;
+
+  static const std::string mesh_type;
+
+  int n_neighbors() const override { return 4; }
+
+  Position sample_element(const MeshIndex& ijk, uint64_t* seed) const override;
+
+  MeshDistance distance_to_grid_boundary(const MeshIndex& ijk, int i,
+    const Position& r0, const Direction& u, double l) const override;
+
+  double distance_to_mesh(const MeshIndex& ijk,
+    const std::array<MeshDistance, 4>& distances, double traveled_distance,
+    int& k_max) const override;
+
+  std::pair<vector<double>, vector<double>> plot(
+    Position plot_ll, Position plot_ur) const override;
+
+  void to_hdf5_inner(hid_t group) const override;
+
+  int set_grid();
+
+  // Data members
+  int radius_;
+  double size_;
+  vector<double> grid_;
+  Direction q_;
+  Direction r_;
+  Direction q_dual_;
+  Direction r_dual_;
+
+private:
+  enum class Orientation {
+    y, //!< Flat side of lattice parallel to y-axis
+    x  //!< Flat side of lattice parallel to x-axis
+  };
+
+  Orientation orientation_ {Orientation::y};
+
+  StructuredMesh::MeshDistance find_z_crossing(
+    const Position& r, const Direction& u, double l, int shell) const;
+
+  double volume(const MeshIndex& ijk) const override;
+
+  int get_index_in_direction(double r, int i) const override
+  {
+    fatal_error("This function is not implemented");
+    return -1;
+  }
+
+  int get_index_in_z_direction(double z) const;
+};
+
 // Abstract class for unstructured meshes
 class UnstructuredMesh : public Mesh {