From 7670dd6518ed3522002d2b943cca0136c5000162 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 17 Mar 2026 23:57:41 -0700
Subject: [PATCH 01/55] templated coordinates type

---
 src/grid/geometry.hpp | 119 ++++++++++++++++++++++++++++++++++++++++++
 src/grid/subpack.hpp  |   4 ++
 2 files changed, 123 insertions(+)
 create mode 100644 src/grid/geometry.hpp

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
new file mode 100644
index 0000000..e00f9cb
--- /dev/null
+++ b/src/grid/geometry.hpp
@@ -0,0 +1,119 @@
+#ifndef GRID_GEOMETRY_HPP_
+#define GRID_GEOMETRY_HPP_
+
+#include <numbers>
+#include <utility>
+
+#include "Kokkos_Macros.hpp"
+
+#include "coordinates/coordinates.hpp"
+
+#include "dispatcher/options.hpp"
+#include "grid/grid_types.hpp"
+#include "grid/subpack.hpp"
+
+namespace kamayan {
+POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
+
+namespace grid {
+
+// This is a (incomplete) wrapper around parthenon's uniform_coordinate (cartesian)
+// to calculate coordinate related items in a different geometry.
+template <Geometry geom>
+struct Coordinates {
+  // distance between cell centers
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx() const {
+    if constexpr (geom == Geometry::cylindrical && ax == Axis::KAXIS) {
+      // I guess we're assuming this only is a useful geometry in NDIM < 3
+      return 2.0 * std::numbers::pi;
+    }
+    return coords_.Dx<AxisToInt(ax)>();
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx(const Axis &ax) const {
+    return AxisOverload([this]<Axis AX>() { return Dx<AX>(); }, ax);
+  }
+
+  // position at cell centroids
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int &idx) const {
+    constexpr auto dir = AxisToInt(ax);
+    if constexpr (ax == Axis::IAXIS && geom == Geometry::cylindrical) {
+      const Real r0 = coords_.Xf<dir>(idx);
+      const Real r0sq = r0 * r0;
+      const Real r1 = coords_.Xf<dir>(idx + 1);
+      const Real r1sq = r1 * r1;
+      return (2.0 / 3.0) * (r1sq * r1 - r0sq * r0) / (r1sq - r0sq);
+    }
+    return coords_.Xc<dir>(idx);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int &idx) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(idx); }, ax);
+  }
+
+  // position at face centers
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int &idx) const {
+    return coords_.Xf<AxisToInt(ax)>(idx);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int &idx) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(idx); }, ax);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const int &k, const int &j,
+                                            const int &i) const {
+    constexpr auto dir = AxisToInt(ax);
+    if constexpr (geom == Geometry::cylindrical) {
+      if constexpr (ax == Axis::IAXIS) {
+        // 2 * pi * r_i * dz
+        return Xf<Axis::IAXIS>(i) * Dx<Axis::JAXIS>() * Dx<Axis::KAXIS>();
+      } else if constexpr (ax == Axis::JAXIS) {
+        // pi * (r_i+1/2**2 - r_i-1/2**2)
+        const Real rp = Xf<Axis::IAXIS>(i + 1);
+        const Real rm = Xf<Axis::IAXIS>(i);
+        return 0.5 * (rp * rp - rm * rm) * Dx<Axis::KAXIS>();
+      }
+    }
+    return coords_.FaceArea<dir>(k, j, i);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const Axis &ax, const int &k, const int &j,
+                                            const int &i) const {
+    return AxisOverload([&, this]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real CellVolume(const int &k, const int &j, const int &i) {
+    if constexpr (geom == Geometry::cylindrical) {
+      // dphi / 2 * (r_p^2 - r_m^2) * dz
+      const Real rp = Xf<Axis::IAXIS>(i + 1);
+      const Real rm = Xf<Axis::IAXIS>(i);
+      return 0.5 * Dx<Axis::KAXIS>() * (rp * rp - rm * rm);
+    }
+    return coords_.CellVolume(k, j, i);
+  }
+
+ private:
+  const parthenon::Coordinates_t coords_;
+
+  template <typename Func, typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION Real AxisOverload(Func function, Axis ax, Args &&...args) {
+    if (ax == Axis::IAXIS) {
+      return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
+    } else if (ax == Axis::JAXIS) {
+      return function.template operator()<Axis::JAXIS>(std::forward<Args>(args)...);
+    } else if (ax == Axis::KAXIS) {
+      return function.template operator()<Axis::KAXIS>(std::forward<Args>(args)...);
+    }
+
+    PARTHENON_FAIL("Axis should only be one of [IJK]AXIS");
+    return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
+  }
+};
+
+}  // namespace grid
+}  // namespace kamayan
+#endif  // GRID_GEOMETRY_HPP_
diff --git a/src/grid/subpack.hpp b/src/grid/subpack.hpp
index b62074d..6230b06 100644
--- a/src/grid/subpack.hpp
+++ b/src/grid/subpack.hpp
@@ -9,6 +9,10 @@
 namespace kamayan {
 enum class Axis { KAXIS = 0, JAXIS = 1, IAXIS = 2 };
 
+constexpr int AxisToInt(Axis ax) {
+  return ax == Axis::IAXIS ? 1 : ax == Axis::JAXIS ? 2 : 3;
+}
+
 template <typename PackType, Axis... axes>
 requires(TemplateSpecialization<PackType, SparsePack>)
 struct SubPack_impl {

From 02773068dcbc732ad4f26d7dc8ecf2c9e647ed7a Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 18 Mar 2026 21:28:52 -0700
Subject: [PATCH 02/55] cli debug help

---
 python/kamayan/cli/app.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/python/kamayan/cli/app.py b/python/kamayan/cli/app.py
index 57d97d7..14f5bd2 100644
--- a/python/kamayan/cli/app.py
+++ b/python/kamayan/cli/app.py
@@ -57,11 +57,16 @@ def run(
             input_file: Optional[str] = None,
             dry_run: bool = False,
             info: bool = False,
+            debug: bool = False,
             **kwargs,
         ):
             parthenon_args: typer.Context = kwargs.pop("ctx")
 
             km = self.func(*args, **kwargs)
+            if debug:
+                import os
+                typer.echo(f"PID: {os.getpid()}")
+                breakpoint()
             if input_file:
                 km.input_file = input_file
 
@@ -139,6 +144,18 @@ def run(
         )
         func_params += [info_param]
 
+        debug_param = inspect.Parameter(
+            "debug",
+            inspect.Parameter.KEYWORD_ONLY,
+            default=typer.Option(
+                False,
+                "--debug",
+                help="Pause execution and wait for debugger to attach",
+            ),
+            annotation=bool,
+        )
+        func_params += [debug_param]
+
         ctx_param = inspect.Parameter(
             "ctx", inspect.Parameter.KEYWORD_ONLY, annotation=typer.Context
         )

From 25d8ea8caaf73e5ee4205b973f2b4fd81d20a402 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 18 Mar 2026 21:29:23 -0700
Subject: [PATCH 03/55] seems to work for cartesian

---
 src/grid/geometry.hpp    | 68 ++++++++++++++++++++++++++++++++++------
 src/grid/grid.cpp        | 58 +++++++++++++++++++++++-----------
 src/grid/grid_update.hpp | 25 ++++++++-------
 src/grid/subpack.hpp     |  5 +++
 src/kamayan/config.hpp   |  2 ++
 5 files changed, 118 insertions(+), 40 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index e00f9cb..98774d7 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -11,16 +11,26 @@
 #include "dispatcher/options.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/subpack.hpp"
+#include "pack/sparse_pack.hpp"
 
 namespace kamayan {
 POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
 
 namespace grid {
 
+using GeometryOptions = OptList<Geometry, Geometry::cartesian, Geometry::cylindrical>;
+
 // This is a (incomplete) wrapper around parthenon's uniform_coordinate (cartesian)
 // to calculate coordinate related items in a different geometry.
 template <Geometry geom>
 struct Coordinates {
+  KOKKOS_INLINE_FUNCTION Coordinates(parthenon::Coordinates_t coords) : coords_(coords) {}
+
+  template <typename... Ts>
+  KOKKOS_INLINE_FUNCTION Coordinates(const parthenon::SparsePack<Ts...> &pack,
+                                     const int block)
+      : coords_(pack.GetCoordinates(block)) {}
+
   // distance between cell centers
   template <Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real Dx() const {
@@ -37,7 +47,7 @@ struct Coordinates {
 
   // position at cell centroids
   template <Axis ax>
-  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int &idx) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int idx) const {
     constexpr auto dir = AxisToInt(ax);
     if constexpr (ax == Axis::IAXIS && geom == Geometry::cylindrical) {
       const Real r0 = coords_.Xf<dir>(idx);
@@ -49,23 +59,22 @@ struct Coordinates {
     return coords_.Xc<dir>(idx);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int &idx) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(idx); }, ax);
   }
 
   // position at face centers
   template <Axis ax>
-  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int &idx) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int idx) const {
     return coords_.Xf<AxisToInt(ax)>(idx);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int &idx) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(idx); }, ax);
   }
 
   template <Axis ax>
-  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const int &k, const int &j,
-                                            const int &i) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
     constexpr auto dir = AxisToInt(ax);
     if constexpr (geom == Geometry::cylindrical) {
       if constexpr (ax == Axis::IAXIS) {
@@ -81,12 +90,28 @@ struct Coordinates {
     return coords_.FaceArea<dir>(k, j, i);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const Axis &ax, const int &k, const int &j,
-                                            const int &i) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const Axis &ax, const int k, const int j,
+                                            const int i) const {
     return AxisOverload([&, this]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION Real CellVolume(const int &k, const int &j, const int &i) {
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const int k, const int j,
+                                              const int i) const {
+    if constexpr (geom == Geometry::cylindrical && ax == Axis::KAXIS) {
+      // phi aligned edges -- dphi * r
+      return std::abs(Xf<Axis::IAXIS>(i)) * Dx<ax>();
+    }
+    return coords_.EdgeLength<AxisToInt(ax)>(k, j, i);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const Axis &ax, const int k, const int j,
+                                              const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return EdgeLength<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real CellVolume(const int k, const int j,
+                                              const int i) const {
     if constexpr (geom == Geometry::cylindrical) {
       // dphi / 2 * (r_p^2 - r_m^2) * dz
       const Real rp = Xf<Axis::IAXIS>(i + 1);
@@ -96,6 +121,31 @@ struct Coordinates {
     return coords_.CellVolume(k, j, i);
   }
 
+  // Generalized volumes for a topological element
+  KOKKOS_FORCEINLINE_FUNCTION
+  Real Volume(TopologicalElement el, const int k, const int j, const int i) const {
+    using TE = TopologicalElement;
+    if (el == TE::CC)
+      return CellVolume(k, j, i);
+    else if (el == TE::F1)
+      return FaceArea<Axis::IAXIS>(k, j, i);
+    else if (el == TE::F2)
+      return FaceArea<Axis::JAXIS>(k, j, i);
+    else if (el == TE::F3)
+      return FaceArea<Axis::KAXIS>(k, j, i);
+    else if (el == TE::E1)
+      return EdgeLength<Axis::IAXIS>(k, j, i);
+    else if (el == TE::E2)
+      return EdgeLength<Axis::JAXIS>(k, j, i);
+    else if (el == TE::E3)
+      return EdgeLength<Axis::KAXIS>(k, j, i);
+    else if (el == TE::NN)
+      return 1.0;
+    PARTHENON_FAIL("If you reach this point, someone has added a new value to the the "
+                   "TopologicalElement enum.");
+    return 0.0;
+  }
+
  private:
   const parthenon::Coordinates_t coords_;
 
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index f6d921e..a632841 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -5,11 +5,14 @@
 #include <vector>
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid_refinement.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/grid_update.hpp"
 #include "grid/scratch_variables.hpp"
 #include "kamayan/runtime_parameters.hpp"
+#include "physics/hydro/hydro_types.hpp"
+#include "utils/instrument.hpp"
 
 namespace kamayan::grid {
 
@@ -21,6 +24,12 @@ std::shared_ptr<KamayanUnit> ProcessUnit() {
 }
 
 void SetupParams(KamayanUnit *unit) {
+  // Geometry
+  auto &geometry = unit->AddData("geometry");
+  geometry.AddParm<Geometry>(
+      "geometry", "cartesian", "grid geometry",
+      {{"cartesian", Geometry::cartesian}, {"cylindrical", Geometry::cylindrical}});
+
   // most of what we're doing here is wrapping the parthenon mesh related
   // input parameters as runtime parameters for the docs!
   // <parthenon/mesh>
@@ -133,27 +142,38 @@ void InitializeData(KamayanUnit *unit) {
   }
 }
 
-TaskStatus FluxesToDuDt(MeshData *md, MeshData *dudt) {
-  static const int ndim = md->GetNDim();
-  using TE = TopologicalElement;
-  switch (ndim) {
-  case 1:
-    FluxDivergence<TE::F1>(md, dudt);
-    break;
-  case 2:
-    FluxDivergence<TE::F1, TE::F2>(md, dudt);
-    FluxStokes<TE::F1, TE::E3>(md, dudt);
-    FluxStokes<TE::F2, TE::E3>(md, dudt);
-    break;
-  case 3:
-    FluxDivergence<TE::F1, TE::F2, TE::F3>(md, dudt);
-    FluxStokes<TE::F1, TE::E3, TE::E2>(md, dudt);
-    FluxStokes<TE::F2, TE::E3, TE::E1>(md, dudt);
-    FluxStokes<TE::F3, TE::E1, TE::E2>(md, dudt);
-    break;
+struct FluxesToDuDt_impl {
+  using options = OptTypeList<GeometryOptions>;
+  using value = TaskStatus;
+
+  template <Geometry geom>
+  value dispatch(MeshData *md, MeshData *dudt) {
+    static const int ndim = md->GetNDim();
+    using TE = TopologicalElement;
+    switch (ndim) {
+    case 1:
+      FluxDivergence<geom, TE::F1>(md, dudt);
+      break;
+    case 2:
+      FluxDivergence<geom, TE::F1, TE::F2>(md, dudt);
+      FluxStokes<geom, TE::F1, TE::E3>(md, dudt);
+      FluxStokes<geom, TE::F2, TE::E3>(md, dudt);
+      break;
+    case 3:
+      FluxDivergence<geom, TE::F1, TE::F2, TE::F3>(md, dudt);
+      FluxStokes<geom, TE::F1, TE::E3, TE::E2>(md, dudt);
+      FluxStokes<geom, TE::F2, TE::E3, TE::E1>(md, dudt);
+      FluxStokes<geom, TE::F3, TE::E1, TE::E2>(md, dudt);
+      break;
+    }
+
+    return TaskStatus::complete;
   }
+};
 
-  return TaskStatus::complete;
+TaskStatus FluxesToDuDt(MeshData *md, MeshData *dudt) {
+  auto cfg = GetConfig(md);
+  return Dispatcher<FluxesToDuDt_impl>(PARTHENON_AUTO_LABEL, cfg.get()).execute(md, dudt);
 }
 
 template <typename PackDesc_t>
diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index 6fe9a2d..f40fb77 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -3,13 +3,14 @@
 #include <parthenon/parthenon.hpp>
 
 #include "grid.hpp"
+#include "grid/geometry.hpp"
 #include "grid_types.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan_utils/parallel.hpp"
 
 namespace kamayan::grid {
 
-template <TopologicalElement... faces>
+template <Geometry geom, TopologicalElement... faces>
 void FluxDivergence(MeshData *md, MeshData *dudt_data) {
   static auto desc_cc =
       GetPackDescriptor(md, {Metadata::Cell, Metadata::WithFluxes}, {PDOpt::WithFluxes});
@@ -26,9 +27,9 @@ void FluxDivergence(MeshData *md, MeshData *dudt_data) {
       PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int km, const int jm, const int im) {
         using TE = TopologicalElement;
-        const auto coords = u0.GetCoordinates(b);
-        const Real dxi[sizeof...(faces)]{
-            1.0 / coords.Dxc<static_cast<int>(faces) % 3 + 1>()...};
+        const auto coords = Coordinates<geom>(u0, b);
+        const Real dxi[sizeof...(faces)]{1.0 /
+                                         coords.template Dx<AxisFromTE(faces)>()...};
         // we have to check the variable bounds for each block in case
         // that we are using sparse fields
         for (int var = u0.GetLowerBound(b); var <= u0.GetUpperBound(b); var++) {
@@ -70,7 +71,7 @@ KOKKOS_INLINE_FUNCTION constexpr int AxisFromFaceEdge(const TopologicalElement &
   return axis;
 }
 
-template <TopologicalElement Face, TopologicalElement... edges>
+template <Geometry geom, TopologicalElement Face, TopologicalElement... edges>
 void FluxStokes(MeshData *md, MeshData *dudt_data) {
   static_assert(Face >= TopologicalElement::F1 && Face <= TopologicalElement::F3,
                 "Face must be F1-F3");
@@ -94,7 +95,7 @@ void FluxStokes(MeshData *md, MeshData *dudt_data) {
       PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int km, const int jm, const int im) {
         using TE = TopologicalElement;
-        const auto coords = u0.GetCoordinates(b);
+        const auto coords = Coordinates<geom>(u0, b);
         // we have to check the variable bounds for each block in case
         // that we are using sparse fields
         for (int var = u0.GetLowerBound(b); var <= u0.GetUpperBound(b); var++) {
@@ -110,18 +111,18 @@ void FluxStokes(MeshData *md, MeshData *dudt_data) {
                 // d_t v_i ~ eps_{ijk}d_j E_k
                 // j -- axis
                 // k -- edge
+                // cylindrical r, z, phi has odd permutations
                 constexpr Real sign =
-                    ((axis + 1) % 3 == static_cast<int>(edges) % 3) ? 1.0 : -1.0;
+                    (geom == Geometry::cylindrical ? -1.0 : 1.0) *
+                    (((axis + 1) % 3 == static_cast<int>(edges) % 3) ? 1.0 : -1.0);
                 dudt(b, Face, var, km, jm, im) +=
-                    sign * (coords.Volume(parthenon::CellLevel::same, edges, km, jm, im) *
+                    sign * (coords.Volume(edges, km, jm, im) *
                                 u0.flux(b, edges, var, km, jm, im) -
-                            coords.Volume(parthenon::CellLevel::same, edges, ijk[2],
-                                          ijk[1], ijk[0]) *
+                            coords.Volume(edges, ijk[2], ijk[1], ijk[0]) *
                                 u0.flux(b, edges, var, ijk[2], ijk[1], ijk[0]));
               }(),
               ...);
-          dudt(b, Face, var, km, jm, im) *=
-              1. / coords.Volume(parthenon::CellLevel::same, Face, km, jm, im);
+          dudt(b, Face, var, km, jm, im) *= 1. / coords.Volume(Face, km, jm, im);
         }
       });
 }
diff --git a/src/grid/subpack.hpp b/src/grid/subpack.hpp
index 6230b06..c776d73 100644
--- a/src/grid/subpack.hpp
+++ b/src/grid/subpack.hpp
@@ -13,6 +13,11 @@ constexpr int AxisToInt(Axis ax) {
   return ax == Axis::IAXIS ? 1 : ax == Axis::JAXIS ? 2 : 3;
 }
 
+constexpr Axis AxisFromTE(const TopologicalElement el) {
+  auto dir = static_cast<int>(el) % 3;
+  return dir == 0 ? Axis::IAXIS : dir == 1 ? Axis::JAXIS : Axis::KAXIS;
+}
+
 template <typename PackType, Axis... axes>
 requires(TemplateSpecialization<PackType, SparsePack>)
 struct SubPack_impl {
diff --git a/src/kamayan/config.hpp b/src/kamayan/config.hpp
index 0ac4022..f93425f 100644
--- a/src/kamayan/config.hpp
+++ b/src/kamayan/config.hpp
@@ -34,6 +34,8 @@ class Config {
     return _params.template Get<T>(OptInfo<T>::key());
   }
 
+  void List() { _params.list(); }
+
  private:
   using Mutability = parthenon::Params::Mutability;
   parthenon::Params _params;

From af5979ef3c2698fb3ab8accc4b4af14221e5d409 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Thu, 19 Mar 2026 18:24:58 -0700
Subject: [PATCH 04/55] coordinates variant

---
 src/grid/geometry.hpp        | 140 +++++++++++++++++++++++++++++++++--
 src/grid/grid_refinement.cpp |   2 +
 src/problems/sedov.cpp       |   8 +-
 3 files changed, 140 insertions(+), 10 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 98774d7..a2789fc 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -4,6 +4,8 @@
 #include <numbers>
 #include <utility>
 
+#include <new>
+
 #include "Kokkos_Macros.hpp"
 
 #include "coordinates/coordinates.hpp"
@@ -12,6 +14,7 @@
 #include "grid/grid_types.hpp"
 #include "grid/subpack.hpp"
 #include "pack/sparse_pack.hpp"
+#include "ports-of-call/variant.hpp"
 
 namespace kamayan {
 POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
@@ -78,10 +81,8 @@ struct Coordinates {
     constexpr auto dir = AxisToInt(ax);
     if constexpr (geom == Geometry::cylindrical) {
       if constexpr (ax == Axis::IAXIS) {
-        // 2 * pi * r_i * dz
         return Xf<Axis::IAXIS>(i) * Dx<Axis::JAXIS>() * Dx<Axis::KAXIS>();
       } else if constexpr (ax == Axis::JAXIS) {
-        // pi * (r_i+1/2**2 - r_i-1/2**2)
         const Real rp = Xf<Axis::IAXIS>(i + 1);
         const Real rm = Xf<Axis::IAXIS>(i);
         return 0.5 * (rp * rp - rm * rm) * Dx<Axis::KAXIS>();
@@ -99,7 +100,6 @@ struct Coordinates {
   KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const int k, const int j,
                                               const int i) const {
     if constexpr (geom == Geometry::cylindrical && ax == Axis::KAXIS) {
-      // phi aligned edges -- dphi * r
       return std::abs(Xf<Axis::IAXIS>(i)) * Dx<ax>();
     }
     return coords_.EdgeLength<AxisToInt(ax)>(k, j, i);
@@ -113,7 +113,6 @@ struct Coordinates {
   KOKKOS_FORCEINLINE_FUNCTION Real CellVolume(const int k, const int j,
                                               const int i) const {
     if constexpr (geom == Geometry::cylindrical) {
-      // dphi / 2 * (r_p^2 - r_m^2) * dz
       const Real rp = Xf<Axis::IAXIS>(i + 1);
       const Real rm = Xf<Axis::IAXIS>(i);
       return 0.5 * Dx<Axis::KAXIS>() * (rp * rp - rm * rm);
@@ -121,7 +120,6 @@ struct Coordinates {
     return coords_.CellVolume(k, j, i);
   }
 
-  // Generalized volumes for a topological element
   KOKKOS_FORCEINLINE_FUNCTION
   Real Volume(TopologicalElement el, const int k, const int j, const int i) const {
     using TE = TopologicalElement;
@@ -147,10 +145,11 @@ struct Coordinates {
   }
 
  private:
-  const parthenon::Coordinates_t coords_;
+  parthenon::Coordinates_t coords_;
 
   template <typename Func, typename... Args>
-  KOKKOS_FORCEINLINE_FUNCTION Real AxisOverload(Func function, Axis ax, Args &&...args) {
+  KOKKOS_FORCEINLINE_FUNCTION Real AxisOverload(Func function, Axis ax,
+                                                Args &&...args) const {
     if (ax == Axis::IAXIS) {
       return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
     } else if (ax == Axis::JAXIS) {
@@ -164,6 +163,133 @@ struct Coordinates {
   }
 };
 
+namespace impl {
+template <typename>
+struct CoordinatesVariant {};
+
+template <Geometry geom, Geometry... geoms>
+struct CoordinatesVariant<OptList<Geometry, geom, geoms...>> {
+  using type = PortsOfCall::variant<Coordinates<geom>, Coordinates<geoms>...>;
+
+  static KOKKOS_INLINE_FUNCTION type Get(const Geometry geometry,
+                                         const parthenon::Coordinates_t coords) {
+    type coordinates = Coordinates<geom>(coords);
+    (
+        [&]() {
+          if (geoms == geometry) coordinates = Coordinates<geom>(coords);
+        }(),
+        ...);
+
+    return coordinates;
+  }
+};
+
+}  // namespace impl
+
+using CoordinatesManager = impl::CoordinatesVariant<GeometryOptions>;
+using CoordinatesVariant = CoordinatesManager::type;
+
+namespace impl {
+KOKKOS_INLINE_FUNCTION CoordinatesManager::type GetCoordinates(MeshBlock *mb) {
+  const Geometry geometry = GetConfig(mb)->Get<Geometry>();
+  return CoordinatesManager::Get(geometry, mb->coords);
+}
+
+KOKKOS_INLINE_FUNCTION CoordinatesManager::type
+GetCoordinates(const Geometry geometry, const parthenon::Coordinates_t &coords) {
+  return CoordinatesManager::Get(geometry, coords);
+}
+}  // namespace impl
+
+struct GenericCoordinate {
+  KOKKOS_INLINE_FUNCTION GenericCoordinate(const CoordinatesVariant coords)
+      : coords_(coords) {}
+
+  KOKKOS_INLINE_FUNCTION GenericCoordinate(MeshBlock *mb)
+      : coords_(impl::GetCoordinates(mb)) {}
+  KOKKOS_INLINE_FUNCTION GenericCoordinate(const Geometry geometry,
+                                           const parthenon::Coordinates_t &coords)
+      : coords_(impl::GetCoordinates(geometry, coords)) {}
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx() const {
+    return PortsOfCall::visit([](const auto &coords) { return coords.template Dx<ax>(); },
+                              coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx(const Axis &ax) const {
+    return PortsOfCall::visit([&ax](const auto &coords) { return coords.Dx(ax); },
+                              coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int idx) const {
+    return PortsOfCall::visit(
+        [idx](const auto &coords) { return coords.template Xc<ax>(idx); }, coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int idx) const {
+    return PortsOfCall::visit(
+        [&ax, idx](const auto &coords) { return coords.Xc(ax, idx); }, coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int idx) const {
+    return PortsOfCall::visit(
+        [idx](const auto &coords) { return coords.template Xf<ax>(idx); }, coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int idx) const {
+    return PortsOfCall::visit(
+        [&ax, idx](const auto &coords) { return coords.Xf(ax, idx); }, coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template FaceArea<ax>(k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const Axis &ax, const int k, const int j,
+                                            const int i) const {
+    return PortsOfCall::visit(
+        [&ax, k, j, i](const auto &coords) { return coords.FaceArea(ax, k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const int k, const int j,
+                                              const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template EdgeLength<ax>(k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const Axis &ax, const int k, const int j,
+                                              const int i) const {
+    return PortsOfCall::visit(
+        [&ax, k, j, i](const auto &coords) { return coords.EdgeLength(ax, k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real CellVolume(const int k, const int j,
+                                              const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.CellVolume(k, j, i); }, coords_);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Volume(TopologicalElement el, const int k, const int j,
+                                          const int i) const {
+    return PortsOfCall::visit(
+        [el, k, j, i](const auto &coords) { return coords.Volume(el, k, j, i); },
+        coords_);
+  }
+
+ private:
+  CoordinatesVariant coords_;
+};
+
 }  // namespace grid
 }  // namespace kamayan
 #endif  // GRID_GEOMETRY_HPP_
diff --git a/src/grid/grid_refinement.cpp b/src/grid/grid_refinement.cpp
index b1bcd28..38e246a 100644
--- a/src/grid/grid_refinement.cpp
+++ b/src/grid/grid_refinement.cpp
@@ -62,6 +62,8 @@ void AMRLoehner::operator()(MeshData *md,
       PARTHENON_AUTO_LABEL, 0, pack.GetNBlocks() - 1, kb.s - k3d, kb.e + k3d, jb.s - k2d,
       jb.e + k2d, ib.s - 1, ib.e + 1,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+        // TODO(acreyes): this could be updated to be templated on geometry, but
+        // would only matter for something more than 2D rz cylindrical to be different
         const auto coords = pack.GetCoordinates(b);
         using TE = TopologicalElement;
         // --8<-- [start:FirstDer]
diff --git a/src/problems/sedov.cpp b/src/problems/sedov.cpp
index 482466a..6fa7a16 100644
--- a/src/problems/sedov.cpp
+++ b/src/problems/sedov.cpp
@@ -6,8 +6,10 @@
 #include "Kokkos_Macros.hpp"
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
+#include "grid/subpack.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan/kamayan.hpp"
 #include "kamayan/unit.hpp"
@@ -109,7 +111,7 @@ void ProblemGenerator(MeshBlock *mb) {
   auto jb = cellbounds.GetBoundsJ(IndexDomain::interior);
   auto kb = cellbounds.GetBoundsK(IndexDomain::interior);
 
-  auto coords = mb->coords;
+  auto coords = grid::GenericCoordinate(mb);
 
   auto nspecies = mb->packages.Get("material")->Param<std::size_t>("nspecies");
   if (nspecies > 1) {
@@ -123,8 +125,8 @@ void ProblemGenerator(MeshBlock *mb) {
   par_for(
       PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        const Real r2 =
-            coords.Xc<1>(i) * coords.Xc<1>(i) + coords.Xc<2>(j) * coords.Xc<2>(j);
+        const Real r2 = coords.Xc<Axis::IAXIS>(i) * coords.Xc<Axis::IAXIS>(i) +
+                        coords.Xc<Axis::JAXIS>(j) * coords.Xc<Axis::JAXIS>(j);
         const auto r = Kokkos::sqrt(r2);
         auto state = sedov_data.State(r);
         type_for(SedovData::variables(), [&]<typename Vars>(const Vars &) {

From 1cfd82105fb46c86be34e1be7b38781975f1d816 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Thu, 19 Mar 2026 18:32:41 -0700
Subject: [PATCH 05/55] generic coords in python

---
 src/grid/pybind/grid_bindings.cpp | 88 +++++++++++++++++++------------
 src/problems/shock_tube.py        |  6 +--
 2 files changed, 56 insertions(+), 38 deletions(-)

diff --git a/src/grid/pybind/grid_bindings.cpp b/src/grid/pybind/grid_bindings.cpp
index 16475f9..d01a53f 100644
--- a/src/grid/pybind/grid_bindings.cpp
+++ b/src/grid/pybind/grid_bindings.cpp
@@ -12,7 +12,7 @@
 #include "kamayan/pybind/kamayan_bindings.hpp"
 #include "kamayan/pybind/kamayan_nanobind.h"
 
-#include "coordinates/coordinates.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan/config.hpp"
 #include "kamayan_utils/parallel.hpp"
@@ -29,6 +29,7 @@ struct SparsePack_py {
     auto desc = parthenon::MakePackDescriptor(pkg, vars, {}, {PDOpt::WithFluxes});
     pack = desc.GetPack(mb->meshblock_data.Get().get());
     map = desc.GetMap();
+    config_ = GetConfig(mb);
   }
 
   SparsePack_py(MeshData *md, const std::vector<std::string> vars,
@@ -37,6 +38,7 @@ struct SparsePack_py {
         md->GetMeshPointer()->resolved_packages.get(), vars, {}, options);
     pack = desc.GetPack(md);
     map = desc.GetMap();
+    config_ = GetConfig(md);
   }
 
   parthenon::ParArray3D<Real> GetParArray3D(const int &block, const std::string &var,
@@ -46,13 +48,16 @@ struct SparsePack_py {
     return pack(block, te, idx + comp);
   }
 
-  parthenon::Coordinates_t GetCoordinates(const int b) const {
-    return pack.GetCoordinates(b);
+  grid::GenericCoordinate GetCoordinates(const int b) const {
+    auto cfg = config_.lock();
+    const Geometry geometry = cfg->Get<Geometry>();
+    return grid::GenericCoordinate(geometry, pack.GetCoordinates(b));
   }
 
  private:
   parthenon::SparsePack<> pack;
   parthenon::SparsePackIdxMap map;
+  std::weak_ptr<Config> config_;
 };
 
 void sparse_pack_py(nanobind::module_ &m) {
@@ -139,62 +144,75 @@ void grid_module(nanobind::module_ &m) {
   te.value("E3", TopologicalElement::E3);
   te.value("NN", TopologicalElement::NN);
 
-  using Coordinates_t = parthenon::Coordinates_t;
-  nanobind::class_<Coordinates_t> coords(m, "Coordinates_t");
-  coords.def("Dx", [](Coordinates_t &self, const int dir) { return self.Dx(dir); });
-  coords.def("Dx1", &Coordinates_t::Dx<1>);
-  coords.def("Dx2", &Coordinates_t::Dx<2>);
-  coords.def("Dx3", &Coordinates_t::Dx<3>);
+  nanobind::class_<grid::GenericCoordinate> gen_coords(m, "GenericCoordinate");
+
+  gen_coords.def(
+      "Dx", [](grid::GenericCoordinate &self, const Axis &ax) { return self.Dx(ax); });
+  gen_coords.def("Dx1",
+                 [](grid::GenericCoordinate &self) { return self.Dx<Axis::IAXIS>(); });
+  gen_coords.def("Dx2",
+                 [](grid::GenericCoordinate &self) { return self.Dx<Axis::JAXIS>(); });
+  gen_coords.def("Dx3",
+                 [](grid::GenericCoordinate &self) { return self.Dx<Axis::KAXIS>(); });
 
   Vectorize(
-      coords, "Xc",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx, const int &dir) {
-        return (dir == 1) * self.Xc<1>(idx) + (dir == 2) * self.Xc<2>(idx) +
-               (dir == 3) * self.Xc<3>(idx);
+      gen_coords, "Xc",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx, const int &dir) {
+        return (dir == 1) * self.Xc<Axis::IAXIS>(idx) +
+               (dir == 2) * self.Xc<Axis::JAXIS>(idx) +
+               (dir == 3) * self.Xc<Axis::KAXIS>(idx);
       },
       TypeList<Real, int, int>());
   Vectorize(
-      coords, "Xf",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx, const int &dir) {
-        return (dir == 1) * self.Xf<1>(idx) + (dir == 2) * self.Xc<2>(idx) +
-               (dir == 3) * self.Xf<3>(idx);
+      gen_coords, "Xf",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx, const int &dir) {
+        return (dir == 1) * self.Xf<Axis::IAXIS>(idx) +
+               (dir == 2) * self.Xf<Axis::JAXIS>(idx) +
+               (dir == 3) * self.Xf<Axis::KAXIS>(idx);
       },
       TypeList<Real, int, int>());
   Vectorize(
-      coords, "Xc1",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xc<1>(idx);
+      gen_coords, "Xc1",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xc<Axis::IAXIS>(idx);
       },
       TypeList<Real, int>());
   Vectorize(
-      coords, "Xc2",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xc<2>(idx);
+      gen_coords, "Xc2",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xc<Axis::JAXIS>(idx);
       },
       TypeList<Real, int>());
   Vectorize(
-      coords, "Xc3",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xc<3>(idx);
+      gen_coords, "Xc3",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xc<Axis::KAXIS>(idx);
       },
       TypeList<Real, int>());
   Vectorize(
-      coords, "Xf1",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xf<1>(idx);
+      gen_coords, "Xf1",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xf<Axis::IAXIS>(idx);
       },
       TypeList<Real, int>());
   Vectorize(
-      coords, "Xf2",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xf<2>(idx);
+      gen_coords, "Xf2",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xf<Axis::JAXIS>(idx);
       },
       TypeList<Real, int>());
   Vectorize(
-      coords, "Xf3",
-      KOKKOS_LAMBDA(const Coordinates_t &self, const int &idx) {
-        return self.Xf<3>(idx);
+      gen_coords, "Xf3",
+      KOKKOS_LAMBDA(const grid::GenericCoordinate &self, const int &idx) {
+        return self.Xf<Axis::KAXIS>(idx);
       },
       TypeList<Real, int>());
+
+  gen_coords.def("FaceArea", [](grid::GenericCoordinate &self, const Axis &ax, int k,
+                                int j, int i) { return self.FaceArea(ax, k, j, i); });
+  gen_coords.def("EdgeLength", [](grid::GenericCoordinate &self, const Axis &ax, int k,
+                                  int j, int i) { return self.EdgeLength(ax, k, j, i); });
+  gen_coords.def("CellVolume", &grid::GenericCoordinate::CellVolume);
+  gen_coords.def("Volume", &grid::GenericCoordinate::Volume);
 }
 }  // namespace kamayan
diff --git a/src/problems/shock_tube.py b/src/problems/shock_tube.py
index 75f5250..b194c28 100644
--- a/src/problems/shock_tube.py
+++ b/src/problems/shock_tube.py
@@ -9,7 +9,7 @@
 from kamayan.code_units import Grid, driver, eos, physics
 from kamayan.code_units.Grid import AdaptiveGrid
 import kamayan.pyKamayan as pyKamayan
-from kamayan.pyKamayan.Grid import Coordinates_t, TopologicalElement as te
+from kamayan.pyKamayan.Grid import GenericCoordinate, TopologicalElement as te
 from kamayan.code_units.Hydro import Hydro
 import kamayan.kamayan_manager as kman
 from kamayan.kamayan_manager import KamayanManager
@@ -132,7 +132,7 @@ def _get_state(s: Literal["L", "R"]) -> State:
 
 
 def _get_coords(
-    indices: np.ndarray, coords: Coordinates_t, el: te = te.CC
+    indices: np.ndarray, coords: GenericCoordinate, el: te = te.CC
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     xx = np.array(coords.Xc1(indices[2, :, :, :]))
     yy = np.array(coords.Xc2(indices[1, :, :, :]))
@@ -163,7 +163,7 @@ def _x_perp(
 def _calc_face_mag(
     face: np.ndarray,
     el: te,
-    coords: Coordinates_t,
+    coords: GenericCoordinate,
     n_perp: np.ndarray,
     n_par1: np.ndarray,
     vL: State,

From 40720c36b02a70795a2726cb6c91f20709ef53bd Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Thu, 19 Mar 2026 23:32:47 -0700
Subject: [PATCH 06/55] cylindrical source terms

---
 src/grid/geometry.hpp              | 81 +++++++++++++++++++++++++++++-
 src/grid/grid_types.hpp            | 10 ++++
 src/grid/subpack.hpp               | 44 ++++++++--------
 src/physics/hydro/hydro.cpp        | 59 ++++++++++++++++++++--
 src/physics/hydro/hydro.hpp        |  3 +-
 src/physics/hydro/primconsflux.cpp | 25 +++++++--
 src/physics/hydro/primconsflux.hpp | 22 ++++++++
 7 files changed, 211 insertions(+), 33 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index a2789fc..aa3874b 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -12,7 +12,6 @@
 
 #include "dispatcher/options.hpp"
 #include "grid/grid_types.hpp"
-#include "grid/subpack.hpp"
 #include "pack/sparse_pack.hpp"
 #include "ports-of-call/variant.hpp"
 
@@ -163,6 +162,86 @@ struct Coordinates {
   }
 };
 
+template <typename T>
+concept CoordinateSystem = requires(T coords) {
+  // Templated methods (compile-time axis dispatch)
+  { coords.template Dx<Axis::IAXIS>() } -> std::same_as<Real>;
+  { coords.template Xc<Axis::IAXIS>(1) } -> std::same_as<Real>;
+  { coords.template Xf<Axis::IAXIS>(1) } -> std::same_as<Real>;
+  { coords.template FaceArea<Axis::IAXIS>(0, 0, 0) } -> std::same_as<Real>;
+  { coords.template EdgeLength<Axis::IAXIS>(0, 0, 0) } -> std::same_as<Real>;
+  // Runtime methods (runtime axis dispatch)
+  { coords.Dx(Axis::IAXIS) } -> std::same_as<Real>;
+  { coords.Xc(Axis::IAXIS, 1) } -> std::same_as<Real>;
+  { coords.Xf(Axis::IAXIS, 1) } -> std::same_as<Real>;
+  { coords.FaceArea(Axis::IAXIS, 0, 0, 0) } -> std::same_as<Real>;
+  { coords.EdgeLength(Axis::IAXIS, 0, 0, 0) } -> std::same_as<Real>;
+  { coords.CellVolume(0, 0, 0) } -> std::same_as<Real>;
+  { coords.Volume(TopologicalElement::CC, 0, 0, 0) } -> std::same_as<Real>;
+};
+
+template <CoordinateSystem T>
+struct CoordinateIndexer {
+  KOKKOS_INLINE_FUNCTION CoordinateIndexer(const T &coords, const int k, const int j,
+                                           const int i)
+      : coords_(coords), kji_({k, j, i}) {}
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx() const {
+    return coords_.template Dx<ax>();
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx(const Axis &ax) const { return coords_.Dx(ax); }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc() const {
+    return coords_.template Xc<ax>(kji_[static_cast<int>(ax)]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax) const {
+    return coords_.Xc(ax, kji_[static_cast<int>(ax)]);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf() const {
+    return coords_.template Xf<ax>(kji_[static_cast<int>(ax)]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax) const {
+    return coords_.Xf(ax, kji_[static_cast<int>(ax)]);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea() const {
+    return coords_.template FaceArea<ax>(kji_[2], kji_[1], kji_[0]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const Axis &ax) const {
+    return coords_.FaceArea(ax, kji_[2], kji_[1], kji_[0]);
+  }
+
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength() const {
+    return coords_.template EdgeLength<ax>(kji_[2], kji_[1], kji_[0]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real EdgeLength(const Axis &ax) const {
+    return coords_.EdgeLength(ax, kji_[2], kji_[1], kji_[0]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real CellVolume() const {
+    return coords_.CellVolume(kji_[2], kji_[1], kji_[0]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Volume(TopologicalElement el) const {
+    return coords_.Volume(el, kji_[2], kji_[1], kji_[0]);
+  }
+
+ private:
+  const T coords_;
+  const Kokkos::Array<int, 3> kji_;
+};
+
 namespace impl {
 template <typename>
 struct CoordinatesVariant {};
diff --git a/src/grid/grid_types.hpp b/src/grid/grid_types.hpp
index 0d44dab..e2c0c1b 100644
--- a/src/grid/grid_types.hpp
+++ b/src/grid/grid_types.hpp
@@ -7,6 +7,7 @@ namespace kamayan {
 using Real = parthenon::Real;
 using TopologicalElement = parthenon::TopologicalElement;
 using TopologicalType = parthenon::TopologicalType;
+enum class Axis { KAXIS = 0, JAXIS = 1, IAXIS = 2 };
 
 KOKKOS_INLINE_FUNCTION constexpr TopologicalElement
 IncrementTE(const TopologicalElement &out_te, const TopologicalElement &in_te,
@@ -16,6 +17,15 @@ IncrementTE(const TopologicalElement &out_te, const TopologicalElement &in_te,
   return static_cast<TopologicalElement>(out);
 }
 
+constexpr int AxisToInt(Axis ax) {
+  return ax == Axis::IAXIS ? 1 : ax == Axis::JAXIS ? 2 : 3;
+}
+
+constexpr Axis AxisFromTE(const TopologicalElement el) {
+  auto dir = static_cast<int>(el) % 3;
+  return dir == 0 ? Axis::IAXIS : dir == 1 ? Axis::JAXIS : Axis::KAXIS;
+}
+
 template <TopologicalElement edge>
 concept EdgeElement = (edge >= TopologicalElement::E1 && edge <= TopologicalElement::E3);
 
diff --git a/src/grid/subpack.hpp b/src/grid/subpack.hpp
index c776d73..e2bef42 100644
--- a/src/grid/subpack.hpp
+++ b/src/grid/subpack.hpp
@@ -3,26 +3,17 @@
 
 #include <Kokkos_Core.hpp>
 
+#include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
 
 namespace kamayan {
-enum class Axis { KAXIS = 0, JAXIS = 1, IAXIS = 2 };
-
-constexpr int AxisToInt(Axis ax) {
-  return ax == Axis::IAXIS ? 1 : ax == Axis::JAXIS ? 2 : 3;
-}
-
-constexpr Axis AxisFromTE(const TopologicalElement el) {
-  auto dir = static_cast<int>(el) % 3;
-  return dir == 0 ? Axis::IAXIS : dir == 1 ? Axis::JAXIS : Axis::KAXIS;
-}
 
 template <typename PackType, Axis... axes>
 requires(TemplateSpecialization<PackType, SparsePack>)
 struct SubPack_impl {
-  KOKKOS_INLINE_FUNCTION SubPack_impl(PackType &pack, const int &b, const int &k,
-                                      const int &j, const int &i)
+  KOKKOS_INLINE_FUNCTION SubPack_impl(PackType &pack, const int b, const int k,
+                                      const int j, const int i)
       : pack_(pack), b_(b), k_(k), j_(j), i_(i) {}
 
   template <typename Var_t>
@@ -45,6 +36,13 @@ struct SubPack_impl {
     return pack_.GetSize(b_, var);
   }
 
+  template <Geometry geom>
+  KOKKOS_INLINE_FUNCTION grid::CoordinateIndexer<grid::Coordinates<geom>>
+  GetCoordinates() const {
+    return grid::CoordinateIndexer<grid::Coordinates<geom>>(pack_.GetCoordinates(b_), k_,
+                                                            j_, i_);
+  }
+
  private:
   PackType &pack_;
   const int b_, k_, j_, i_;
@@ -53,8 +51,8 @@ struct SubPack_impl {
 template <typename PackType, Axis... axes>
 requires(TemplateSpecialization<PackType, SparsePack>)
 struct StencilSubPack_impl {
-  KOKKOS_INLINE_FUNCTION StencilSubPack_impl(PackType &pack, const int &b, const int &k,
-                                             const int &j, const int &i)
+  KOKKOS_INLINE_FUNCTION StencilSubPack_impl(PackType &pack, const int b, const int k,
+                                             const int j, const int i)
       : pack_(pack), b_(b), kji_({k, j, i}) {}
 
   template <typename Var_t, typename... Is>
@@ -100,9 +98,9 @@ struct StencilSubPack_impl {
 template <typename Var_t, typename PackType, Axis... axes>
 requires(TemplateSpecialization<PackType, SparsePack>)
 struct VarStencilSubPack_impl {
-  KOKKOS_INLINE_FUNCTION VarStencilSubPack_impl(PackType &pack, const int &b,
-                                                const Var_t &var, const int &k,
-                                                const int &j, const int &i)
+  KOKKOS_INLINE_FUNCTION VarStencilSubPack_impl(PackType &pack, const int b,
+                                                const Var_t &var, const int k,
+                                                const int j, const int i)
       : pack_(pack), b_(b), var_(var), kji_({k, j, i}) {}
 
   template <typename... Is>
@@ -140,20 +138,20 @@ struct VarStencilSubPack_impl {
 };
 
 template <Axis axis, Axis... axes, typename Var_t, typename PackType>
-KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int &b, const Var_t &var,
-                                    const int &k, const int &j, const int &i) {
+KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int b, const Var_t &var,
+                                    const int k, const int j, const int i) {
   return VarStencilSubPack_impl<Var_t, PackType, axis, axes...>(pack, b, var, k, j, i);
 }
 
 template <Axis axis, Axis... axes, typename PackType>
-KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int &b, const int &k,
-                                    const int &j, const int &i) {
+KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int b, const int k, const int j,
+                                    const int i) {
   return StencilSubPack_impl<PackType, axis, axes...>(pack, b, k, j, i);
 }
 
 template <typename PackType>
-KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int &b, const int &k,
-                                    const int &j, const int &i) {
+KOKKOS_INLINE_FUNCTION auto SubPack(PackType &pack, const int b, const int k, const int j,
+                                    const int i) {
   return SubPack_impl<PackType>(pack, b, k, j, i);
 }
 
diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index daf11b9..bebf2bc 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -9,8 +9,11 @@
 
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid.hpp"
+#include "grid/subpack.hpp"
 #include "hydro_types.hpp"
+#include "kamayan/config.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan/unit_data.hpp"
 #include "kamayan_utils/parallel.hpp"
@@ -30,6 +33,7 @@ std::shared_ptr<KamayanUnit> ProcessUnit() {
   hydro->PreparePrimitive.Register(PreparePrimitive, /*after=*/{}, /*before=*/{"eos"});
   hydro->PostMeshInitialization.Register(PostMeshInitialization, {"eos"});
   hydro->AddFluxTasks.Register(AddFluxTasks);
+  hydro->AddTasksOneStep.Register(AddTasksOneStep);
   // --8<-- [end:register]
   return hydro;
 }
@@ -140,20 +144,21 @@ struct FillDerived_impl {
     auto jb = md->GetBoundsJ(IndexDomain::interior);
     auto kb = md->GetBoundsK(IndexDomain::interior);
     const auto ndim = md->GetNDim();
+    const auto geometry = GetConfig(md)->Get<Geometry>();
 
     parthenon::par_for(
         PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
         KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
           capture(ndim);
-          const auto coords = pack.GetCoordinates(b);
+          const auto coords = grid::GenericCoordinate(geometry, pack.GetCoordinates(b));
           // also need to average the face-fields if doing constrained transport
           if constexpr (hydro_traits::MHD == Mhd::ct) {
             using te = TopologicalElement;
             if (ndim > 1) {
-              pack(b, DIVB(), k, j, i) = 1. / coords.template Dxc<1>() *
+              pack(b, DIVB(), k, j, i) = 1. / coords.template Dx<Axis::IAXIS>() *
                                              (pack(b, te::F1, MAG(), k, j, i + 1) -
                                               pack(b, te::F1, MAG(), k, j, i)) +
-                                         1. / coords.template Dxc<2>() *
+                                         1. / coords.template Dx<Axis::JAXIS>() *
                                              (pack(b, te::F2, MAG(), k, j + 1, i) -
                                               pack(b, te::F2, MAG(), k, j, i));
             }
@@ -169,4 +174,52 @@ TaskStatus FillDerived(MeshData *md) {
   return Dispatcher<FillDerived_impl>(PARTHENON_AUTO_LABEL, cfg.get()).execute(md);
 }
 
+struct AddSourceTerms {
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
+  using value = TaskStatus;
+
+  template <HydroTrait hydro_traits, Geometry geom>
+  requires(geom == Geometry::cartesian)
+  value dispatch(MeshData *md, MeshData *dudt) {
+    return TaskStatus::complete;
+  }
+  template <HydroTrait hydro_traits, Geometry geom>
+  value dispatch(MeshData *md, MeshData *dudt) {
+    using primitives = hydro_traits::Primitive;
+    using conserved = hydro_traits::Conserved;
+
+    auto pack_dudt = grid::GetPack(conserved(), dudt);
+    auto pack_prim = grid::GetPack(primitives(), md);
+
+    const int nblocks = pack_prim.GetNBlocks();
+    auto ib = md->GetBoundsI(IndexDomain::interior);
+    auto jb = md->GetBoundsJ(IndexDomain::interior);
+    auto kb = md->GetBoundsK(IndexDomain::interior);
+
+    par_for(
+        PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+        KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+          auto prim = SubPack(pack_prim, b, k, j, i);
+          auto du = SubPack(pack_dudt, b, k, j, i);
+          AddGeometricSource<hydro_traits::MHD, geom>(
+              prim.template GetCoordinates<geom>(), prim, du);
+        });
+    return TaskStatus::complete;
+  }
+};
+
+TaskID AddTasksOneStep(TaskID prev, TaskList &tl, MeshData *md, MeshData *dudt) {
+  auto sources = tl.AddTask(
+      prev, "hydro::AddSourceTerms",
+      [](MeshData *md, MeshData *dudt) {
+        auto cfg = GetConfig(md);
+        return Dispatcher<AddSourceTerms>(PARTHENON_AUTO_LABEL, cfg.get())
+            .execute(md, dudt);
+      },
+      md, dudt);
+
+  auto final = sources;
+  return final;
+}
+
 }  // namespace kamayan::hydro
diff --git a/src/physics/hydro/hydro.hpp b/src/physics/hydro/hydro.hpp
index bcb3d03..97131d6 100644
--- a/src/physics/hydro/hydro.hpp
+++ b/src/physics/hydro/hydro.hpp
@@ -5,10 +5,8 @@
 
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/grid_types.hpp"
-#include "kamayan/config.hpp"
 #include "kamayan/runtime_parameters.hpp"
 #include "kamayan/unit.hpp"
-#include "kamayan/unit_data.hpp"
 
 namespace kamayan::hydro {
 std::shared_ptr<KamayanUnit> ProcessUnit();
@@ -19,6 +17,7 @@ void InitializeData(KamayanUnit *unit);
 TaskID AddFluxTasks(TaskID prev, TaskList &tl, MeshData *md);
 TaskID AddTasksOneStep(TaskID prev, TaskList &tl, MeshData *md, MeshData *dudt);
 Real EstimateTimeStepMesh(MeshData *md);
+TaskStatus PrepareConserved(MeshData *md);
 
 TaskStatus FillDerived(MeshData *md);
 
diff --git a/src/physics/hydro/primconsflux.cpp b/src/physics/hydro/primconsflux.cpp
index 7f195dc..bdb387d 100644
--- a/src/physics/hydro/primconsflux.cpp
+++ b/src/physics/hydro/primconsflux.cpp
@@ -1,6 +1,7 @@
 #include "physics/hydro/primconsflux.hpp"
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/indexer.hpp"
@@ -13,10 +14,10 @@ namespace kamayan::hydro {
 
 // --8<-- [start:impl]
 struct PrepareConserved_impl {
-  using options = OptTypeList<HydroFactory>;
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
   using value = TaskStatus;
 
-  template <typename hydro_traits>
+  template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
     auto pack = grid::GetPack(typename hydro_traits::ConsPrim(), md);
@@ -48,6 +49,14 @@ struct PrepareConserved_impl {
           auto U = SubPack(pack, b, k, j, i);
           Prim2Cons<hydro_traits>(U, U);
           // --8<-- [end:make-idx]
+          if constexpr (geom == Geometry::cylindrical) {
+            auto coords = grid::Coordinates<geom>(pack, b);
+            // conserve angular momentum
+            U(MOMENTUM(2)) *= coords.template Xc<Axis::IAXIS>(i);
+            if constexpr (hydro_traits::MHD != Mhd::off) {
+              U(MAGC(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(i);
+            }
+          }
         });
     return TaskStatus::complete;
   }
@@ -55,10 +64,10 @@ struct PrepareConserved_impl {
 // --8<-- [end:impl]
 
 struct PreparePrimitive_impl {
-  using options = OptTypeList<HydroFactory>;
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
   using value = TaskStatus;
 
-  template <typename hydro_traits>
+  template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
     auto pack = grid::GetPack(typename hydro_traits::ConsPrim(), md);
@@ -87,6 +96,14 @@ struct PreparePrimitive_impl {
           }
           auto U = SubPack(pack, b, k, j, i);
           Cons2Prim<hydro_traits>(U, U);
+          if constexpr (geom == Geometry::cylindrical) {
+            auto coords = grid::Coordinates<geom>(pack, b);
+            // conserve angular momentum
+            U(VELOCITY(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(i);
+            if constexpr (hydro_traits::MHD != Mhd::off) {
+              U(MAGC(2)) *= coords.template Xc<Axis::IAXIS>(i);
+            }
+          }
         });
     return TaskStatus::complete;
   }
diff --git a/src/physics/hydro/primconsflux.hpp b/src/physics/hydro/primconsflux.hpp
index 3012962..a38e8c9 100644
--- a/src/physics/hydro/primconsflux.hpp
+++ b/src/physics/hydro/primconsflux.hpp
@@ -2,8 +2,11 @@
 #define PHYSICS_HYDRO_PRIMCONSFLUX_HPP_
 #include <Kokkos_Core.hpp>
 
+#include "Kokkos_Macros.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"
+#include "grid/subpack.hpp"
 #include "kamayan/fields.hpp"
 #include "physics/hydro/hydro_types.hpp"
 #include "physics/physics_types.hpp"
@@ -134,5 +137,24 @@ KOKKOS_INLINE_FUNCTION void Prim2Flux(const Prim &V, Flux &F) {
   }
 }
 
+template <typename T>
+concept CoordinatePoint = requires(T coords) {
+  { coords.template Xc<Axis::IAXIS>() } -> std::same_as<Real>;
+};
+
+template <Mhd mhd, Geometry geom, typename DuDt, typename Prim, CoordinatePoint Coords>
+requires(geom == Geometry::cylindrical)
+KOKKOS_FORCEINLINE_FUNCTION void AddGeometricSource(const Coords &coords, const Prim &V,
+                                                    DuDt &dudt) {
+  dudt(MOMENTUM(0)) = (V(DENS()) * V(VELOCITY(2)) * V(VELOCITY(2)) + V(PRES())) /
+                      coords.template Xc<Axis::IAXIS>();
+  if constexpr (mhd != Mhd::off) {
+    const Real pmag = 0.5 * (V(MAGC(0)) * V(MAGC(0)) + V(MAGC(1)) * V(MAGC(1)) +
+                             V(MAGC(2)) * V(MAGC(2)));
+    dudt(MOMENTUM(0)) +=
+        (pmag - V(MAGC(2)) * V(MAGC(2))) / coords.template Xc<Axis::IAXIS>();
+  }
+}
+
 }  // namespace kamayan::hydro
 #endif  // PHYSICS_HYDRO_PRIMCONSFLUX_HPP_

From c9c3669bf4d374032292de95cdf60e2176b0b2b7 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 16:09:20 -0700
Subject: [PATCH 07/55] add boundary conditions

---
 python/kamayan/code_units/Grid.py |  1 +
 src/CMakeLists.txt                |  1 +
 src/grid/boundary_conditions.cpp  | 83 +++++++++++++++++++++++++++++++
 src/grid/grid.hpp                 |  2 +
 src/kamayan/fields.hpp            | 14 ++++--
 src/problems/sedov.py             |  5 +-
 6 files changed, 100 insertions(+), 6 deletions(-)
 create mode 100644 src/grid/boundary_conditions.cpp

diff --git a/python/kamayan/code_units/Grid.py b/python/kamayan/code_units/Grid.py
index 23f2503..875b07f 100644
--- a/python/kamayan/code_units/Grid.py
+++ b/python/kamayan/code_units/Grid.py
@@ -12,6 +12,7 @@
 _resolution = None | int
 _dx = None | float
 refinement_strategy = Literal["none", "static", "adaptive"]
+GEOMETRY = Literal["cartesian", "cylindrical"]
 
 
 def _get_N(N: _resolution, dx: _dx, L: float) -> int:
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5d5386a..1076482 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,5 +1,6 @@
 set(_sources
     driver/kamayan_driver.cpp
+    grid/boundary_conditions.cpp
     grid/grid.cpp
     grid/grid_refinement.cpp
     kamayan/callback_dag.cpp
diff --git a/src/grid/boundary_conditions.cpp b/src/grid/boundary_conditions.cpp
new file mode 100644
index 0000000..3d1b293
--- /dev/null
+++ b/src/grid/boundary_conditions.cpp
@@ -0,0 +1,83 @@
+#include "bvals/boundary_conditions.hpp"
+#include <functional>
+#include <memory>
+#include <set>
+#include <vector>
+
+#include <defs.hpp>
+
+#include "basic_types.hpp"
+#include "grid/grid.hpp"
+#include "grid/grid_types.hpp"
+#include "kamayan/fields.hpp"
+#include "pack/pack_utils.hpp"
+
+namespace kamayan::grid {
+using TE = TopologicalElement;
+// use this as an interface to write boundary conditions per variable topological element
+// types that can be registered through parthenon's appliciation input interface at the
+// bottom of this file
+using BoundaryConditionInterface =
+    std::function<void(const TE, std::shared_ptr<MeshBlockData> &, bool)>;
+
+void Axisymmetric(const TE el, std::shared_ptr<MeshBlockData> &mbd, bool coarse) {
+  const auto ttFlag = [el] {
+    const auto tt = GetTopologicalType(el);
+    switch (tt) {
+    case (TopologicalType::Cell):
+      return Metadata::Cell;
+    case (TopologicalType::Face):
+      return Metadata::Face;
+    case (TopologicalType::Edge):
+      return Metadata::Edge;
+    case (TopologicalType::Node):
+      return Metadata::Node;
+    default:
+      PARTHENON_FAIL("Unknown topological type")
+    }
+  }();
+
+  std::vector<MetadataFlag> flags{Metadata::FillGhost, ttFlag};
+  std::set<PDOpt> opts = coarse ? std::set<PDOpt>{PDOpt::Coarse} : std::set<PDOpt>{};
+  const auto desc =
+      MakePackDescriptor<parthenon::variable_names::any>(mbd.get(), flags, opts);
+
+  auto q = desc.GetPack(mbd.get());
+  const int b = 0;
+  const int lstart = q.GetLowerBoundHost(b);
+  const int lend = q.GetUpperBoundHost(b);
+  // early return if we don't get anything
+  if (lend < lstart) return;
+  auto nb = parthenon::IndexRange{lstart, lend};
+
+  MeshBlock *pmb = mbd->GetBlockPointer();
+  const auto &bounds = (coarse ? pmb->c_cellbounds : pmb->cellbounds);
+
+  const auto &range = bounds.GetBoundsI(IndexDomain::interior, el);
+  const int ref = range.s;
+
+  constexpr IndexDomain domain = IndexDomain::inner_x1;
+  // used for reflections
+  const int offset = 2 * ref - 1;
+
+  pmb->par_for_bndry(
+      PARTHENON_AUTO_LABEL, nb, domain, el, coarse, false,
+      KOKKOS_LAMBDA(const int &l, const int &k, const int &j, const int &i) {
+        const auto vec_component = q(b, el, l).vector_component;
+        const Real factor = (vec_component == 1 || vec_component == 3) ? -1.0 : 1.0;
+        q(b, el, l, k, j, i) = factor * q(b, el, l, k, j, offset - i);
+      });
+}
+
+parthenon::BValFunc GenericBC(BoundaryConditionInterface bndry_func) {
+  return [=](std::shared_ptr<MeshBlockData> &mbd, bool coarse) {
+    for (auto el : {TE::CC, TE::F1, TE::F2, TE::F3, TE::E1, TE::E2, TE::E3, TE::NN})
+      bndry_func(el, mbd, coarse);
+  };
+}
+
+void RegisterBoundaryConditions(parthenon::ApplicationInput *app) {
+  app->RegisterBoundaryCondition(parthenon::BoundaryFace::inner_x1, "axisymmetric",
+                                 GenericBC(Axisymmetric));
+}
+}  // namespace kamayan::grid
diff --git a/src/grid/grid.hpp b/src/grid/grid.hpp
index 3f4f96b..e1f1a88 100644
--- a/src/grid/grid.hpp
+++ b/src/grid/grid.hpp
@@ -21,6 +21,8 @@ std::shared_ptr<KamayanUnit> ProcessUnit();
 void SetupParams(KamayanUnit *unit);
 void InitializeData(KamayanUnit *unit);
 
+void RegisterBoundaryConditions(parthenon::ApplicationInput *app);
+
 template <typename Container>
 requires(std::is_same_v<Container, MeshData> || std::is_same_v<Container, MeshBlockData>)
 auto GetPackDescriptor(Container *md, std::vector<parthenon::MetadataFlag> m = {},
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index 0981731..a8f2b8f 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -18,7 +18,10 @@ namespace kamayan {
 using MetadataFlag = parthenon::MetadataFlag;
 using Metadata = parthenon::Metadata;
 
-template <strings::CompileTimeString var_name, int... NCOMP>
+enum class VariableRank { scalar, vector };
+
+template <strings::CompileTimeString var_name, VariableRank vr = VariableRank::scalar,
+          int... NCOMP>
 struct VariableBase : public parthenon::variable_names::base_t<false, NCOMP...> {
   template <typename... Ts>
   KOKKOS_INLINE_FUNCTION VariableBase(Ts &&...args)
@@ -34,12 +37,14 @@ struct VariableBase : public parthenon::variable_names::base_t<false, NCOMP...>
   static constexpr std::size_t n_comps = (1 * ... * NCOMP);
   static constexpr std::size_t n_dims = sizeof...(NCOMP);
   static constexpr auto vname = var_name;
+  static constexpr VariableRank variable_rank = vr;
 };
 
 template <typename T>
 concept DenseVar = requires {
   { T::n_comps } -> std::same_as<const std::size_t &>;  // number of components
   { T::Shape() } -> std::same_as<std::vector<int>>;     // shape of the array
+  { T::variable_rank } -> std::same_as<VariableRank>;
   requires std::same_as<decltype(std::declval<T &>().idx), const int>;
   requires NonTypeTemplateSpecialization<T, VariableBase>;
 };
@@ -92,6 +97,7 @@ requires(DenseVar<T>)
 void AddField(parthenon::StateDescriptor *pkg, std::vector<MetadataFlag> m,
               std::vector<int> shape = T::Shape()) {
   // can also add refinement ops here depending on the metadata
+  if (T::variable_rank == VariableRank::vector) m.push_back(Metadata::Vector);
   pkg->AddField<T>(Metadata(m, shape));
 }
 
@@ -152,19 +158,19 @@ constexpr int count_components(T<Ts...>) {
 // conserved variables
 using DENS = VariableBase<"dens">;
 // will register with shape=std::vector<int>{3}
-using MOMENTUM = VariableBase<"momentum", 3>;
+using MOMENTUM = VariableBase<"momentum", VariableRank::vector, 3>;
 using ENER = VariableBase<"ener">;
 using MAG = VariableBase<"mag">;
 // --8<-- [end:cons]
 
 // primitives & Eos should be FillGhost?
-using MAGC = VariableBase<"magc", 3>;
+using MAGC = VariableBase<"magc", VariableRank::vector, 3>;
 using EINT = VariableBase<"eint">;
 using PRES = VariableBase<"pres">;
 using BMOD = VariableBase<"bulk modulus">;
 using TEMP = VariableBase<"temp">;
 
-using VELOCITY = VariableBase<"velocity", 3>;
+using VELOCITY = VariableBase<"velocity", VariableRank::vector, 3>;
 
 // 3T
 using TELE = VariableBase<"tele">;
diff --git a/src/problems/sedov.py b/src/problems/sedov.py
index 28b4411..4c14473 100644
--- a/src/problems/sedov.py
+++ b/src/problems/sedov.py
@@ -16,7 +16,7 @@
 from kamayan.cli import kamayan_app
 
 from kamayan.code_units import Grid as gr, eos as eos, driver
-from kamayan.code_units.Grid import AdaptiveGrid
+from kamayan.code_units.Grid import GEOMETRY, AdaptiveGrid
 from kamayan.code_units.Hydro import Hydro
 
 
@@ -118,7 +118,7 @@ def initialize(unit: pyKamayan.KamayanUnit):
 # --8<-- [start:py_sedov]
 @kamayan_app(description="Sedov blast wave simulation")
 def sedov(
-    nxb: int = typer.Option(32, help="cells across block dimension"),
+    geometry: GEOMETRY = typer.Option(default="cartesian", help="""Geometry setup."""),
 ) -> KamayanManager:
     """Build the KamayanManager for Sedov."""
     units = kman.process_units(
@@ -126,6 +126,7 @@ def sedov(
     )
     km = KamayanManager("sedov", units)
 
+    nxb = 32
     nblocks = int(128 / nxb)  # number of blocks to get 128 zones at coarsest resolution
     km.grid = AdaptiveGrid(
         xbnd1=(-0.5, 0.5),  # xmin/max

From 72a60c987be598bfe8618f00c3876eec845c51a2 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 16:46:09 -0700
Subject: [PATCH 08/55] fix it

---
 src/kamayan/fields.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index a8f2b8f..42e77e2 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -44,16 +44,17 @@ template <typename T>
 concept DenseVar = requires {
   { T::n_comps } -> std::same_as<const std::size_t &>;  // number of components
   { T::Shape() } -> std::same_as<std::vector<int>>;     // shape of the array
-  { T::variable_rank } -> std::same_as<VariableRank>;
+  { T::variable_rank } -> std::same_as<const VariableRank &>;
   requires std::same_as<decltype(std::declval<T &>().idx), const int>;
   requires NonTypeTemplateSpecialization<T, VariableBase>;
 };
 
 template <strings::CompileTimeString var_name, int... NCOMP>
-struct SparseBase : public VariableBase<var_name, NCOMP...> {
+struct SparseBase : public VariableBase<var_name, VariableRank::scalar, NCOMP...> {
   template <typename... Ts>
   KOKKOS_INLINE_FUNCTION SparseBase(Ts &&...args)
-      : VariableBase<var_name, NCOMP...>(std::forward<Ts>(args)...) {}
+      : VariableBase<var_name, VariableRank::scalar, NCOMP...>(
+            std::forward<Ts>(args)...) {}
 
   // tensor indexer for sparse variable at sparse index n, with tensor
   // index (ds...)

From e0dade1a0fbb18e0c7a130afedf6fce8c0d4be16 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 21:32:10 -0700
Subject: [PATCH 09/55] cylindrical looks right

---
 python/kamayan/code_units/Grid.py  | 10 +++++++++-
 src/grid/geometry.hpp              | 11 +++++++++++
 src/grid/grid.cpp                  |  6 +++---
 src/grid/grid_update.hpp           | 13 +++++++------
 src/kamayan/kamayan.cpp            |  3 +++
 src/physics/hydro/primconsflux.hpp |  5 +++--
 src/problems/sedov.py              | 17 ++++++++++++++---
 7 files changed, 50 insertions(+), 15 deletions(-)

diff --git a/python/kamayan/code_units/Grid.py b/python/kamayan/code_units/Grid.py
index 875b07f..574cbc0 100644
--- a/python/kamayan/code_units/Grid.py
+++ b/python/kamayan/code_units/Grid.py
@@ -57,7 +57,7 @@ def _set_mesh_block(params: KamayanParams, nxb1: int, nxb2: int, nxb3: int) -> N
     }
 
 
-_boundary_conditions = Literal["outflow", "periodic", "user", "reflect"]
+_boundary_conditions = Literal["outflow", "periodic", "user", "reflect", "axisymmetric"]
 
 
 @dataclass
@@ -126,6 +126,7 @@ class KamayanGrid(Node):
     xbnd2: tuple[float, float] | None = None
     xbnd3: tuple[float, float] | None = None
     numlevel: int = 1
+    geometry: GEOMETRY = "cartesian"
 
     boundary_conditions = auto_property_node(BoundaryConditions, "boundary_conditions")
 
@@ -145,6 +146,7 @@ def set_params(self, params) -> None:
         )
 
         _set_mesh_block(params, self.nxb1, self.nxb2, self.nxb3)
+        params["geometry"] = {"geometry": self.geometry}
 
 
 class UniformGrid(KamayanGrid):
@@ -161,6 +163,7 @@ def __init__(
         dx1: _dx = None,
         dx2: _dx = None,
         dx3: _dx = None,
+        **kwargs,
     ) -> None:
         """Set parameters for a uniform grid.
 
@@ -177,6 +180,7 @@ def __init__(
             dx1: zone size along dimensions of the domain.
             dx2: zone size along dimensions of the domain.
             dx3: zone size along dimensions of the domain.
+            kwargs: kwarguments to init KamayanGrid.
 
         Raises:
             ValueError: When a dimension is over-constrained
@@ -225,6 +229,7 @@ def __init__(
             xbnd1=xbnd1,
             xbnd2=xbnd2,
             xbnd3=xbnd3,
+            **kwargs,
         )
 
 
@@ -334,6 +339,7 @@ def __init__(
         dx2: _dx = None,
         dx3: _dx = None,
         num_levels: int = 1,
+        **kwargs,
     ) -> None:
         """Set parameters for a uniform grid.
 
@@ -354,6 +360,7 @@ def __init__(
             dx2: zone size along dimensions of the domain at highest resoltution.
             dx3: zone size along dimensions of the domain at highest resoltution.
             num_levels: number of total amr refinement levels
+            kwargs: kwarguments to init KamayanGrid.
 
         Raises:
             ValueError: When a dimension is over-constrained
@@ -395,6 +402,7 @@ def __init__(
             xbnd1=xbnd1,
             xbnd2=xbnd2,
             xbnd3=xbnd3,
+            **kwargs,
         )
         self.refinement_fields = RefinementCollection()
 
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index aa3874b..faf25b2 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -61,6 +61,12 @@ struct Coordinates {
     return coords_.Xc<dir>(idx);
   }
 
+  // position at cell centers
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xi(const int idx) const {
+    return coords_.Xc<AxisToInt(ax)>(idx);
+  }
+
   KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(idx); }, ax);
   }
@@ -198,6 +204,11 @@ struct CoordinateIndexer {
     return coords_.template Xc<ax>(kji_[static_cast<int>(ax)]);
   }
 
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xi() const {
+    return coords_.template Xi<ax>(kji_[static_cast<int>(ax)]);
+  }
+
   KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax) const {
     return coords_.Xc(ax, kji_[static_cast<int>(ax)]);
   }
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index a632841..d1b193c 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -56,9 +56,9 @@ void SetupParams(KamayanUnit *unit) {
   parthenon_mesh.AddParm<Real>("x2max", 1.0, "Maximum x2 value of domain.");
   parthenon_mesh.AddParm<Real>("x3max", 1.0, "Maximum x3 value of domain.");
 
-  parthenon_mesh.AddParm<std::string>("ix1_bc", "outflow",
-                                      "Inner boundary condition along x1.",
-                                      {"periodic", "outflow", "reflect", "user"});
+  parthenon_mesh.AddParm<std::string>(
+      "ix1_bc", "outflow", "Inner boundary condition along x1.",
+      {"periodic", "outflow", "reflect", "user", "axisymmetric"});
   parthenon_mesh.AddParm<std::string>("ix2_bc", "outflow",
                                       "Inner boundary condition along x2.",
                                       {"periodic", "outflow", "reflect", "user"});
diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index f40fb77..0df820f 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -23,17 +23,16 @@ void FluxDivergence(MeshData *md, MeshData *dudt_data) {
   auto ib = md->GetBoundsI(IndexDomain::interior);
   auto jb = md->GetBoundsJ(IndexDomain::interior);
   auto kb = md->GetBoundsK(IndexDomain::interior);
+  // could also be done as par_for_outer(b,k,j) par_for_inner(var,i)
   par_for(
       PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int km, const int jm, const int im) {
         using TE = TopologicalElement;
         const auto coords = Coordinates<geom>(u0, b);
-        const Real dxi[sizeof...(faces)]{1.0 /
-                                         coords.template Dx<AxisFromTE(faces)>()...};
         // we have to check the variable bounds for each block in case
         // that we are using sparse fields
         for (int var = u0.GetLowerBound(b); var <= u0.GetUpperBound(b); var++) {
-          dudt(b, var, km, jm, im) = 0.;
+          Real du = 0.;
           (
               [&]() {
                 constexpr int dir = static_cast<int>(faces) % 3;
@@ -41,11 +40,13 @@ void FluxDivergence(MeshData *md, MeshData *dudt_data) {
                 const int jp = jm + (dir == 1);
                 const int ip = im + (dir == 0);
 
-                dudt(b, var, km, jm, im) -=
-                    dxi[dir] * (u0.flux(b, faces, var, kp, jp, ip) -
-                                u0.flux(b, faces, var, km, jm, im));
+                du -= (coords.template FaceArea<AxisFromTE(faces)>(kp, jp, ip) *
+                           u0.flux(b, faces, var, kp, jp, ip) -
+                       coords.template FaceArea<AxisFromTE(faces)>(km, jm, im) *
+                           u0.flux(b, faces, var, km, jm, im));
               }(),
               ...);
+          dudt(b, var, km, jm, im) = du / coords.CellVolume(km, jm, im);
         }
       });
 }
diff --git a/src/kamayan/kamayan.cpp b/src/kamayan/kamayan.cpp
index 98916ba..9c8eb96 100644
--- a/src/kamayan/kamayan.cpp
+++ b/src/kamayan/kamayan.cpp
@@ -6,6 +6,7 @@
 
 #include "driver/kamayan_driver.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/grid.hpp"
 #include "kamayan/unit.hpp"
 #include "parthenon_manager.hpp"
 #include "physics/material_properties/eos/eos.hpp"
@@ -39,6 +40,8 @@ KamayanDriver InitPackages(std::shared_ptr<ParthenonManager> pman,
   auto runtime_parameters =
       std::make_shared<kamayan::runtime_parameters::RuntimeParameters>(pin);
 
+  grid::RegisterBoundaryConditions(pman->app_input.get());
+
   auto config = std::make_shared<Config>();
   for (auto &kamayan_unit : *units) {
     kamayan_unit.second->SetUnits(units);
diff --git a/src/physics/hydro/primconsflux.hpp b/src/physics/hydro/primconsflux.hpp
index a38e8c9..6a94574 100644
--- a/src/physics/hydro/primconsflux.hpp
+++ b/src/physics/hydro/primconsflux.hpp
@@ -146,8 +146,9 @@ template <Mhd mhd, Geometry geom, typename DuDt, typename Prim, CoordinatePoint
 requires(geom == Geometry::cylindrical)
 KOKKOS_FORCEINLINE_FUNCTION void AddGeometricSource(const Coords &coords, const Prim &V,
                                                     DuDt &dudt) {
-  dudt(MOMENTUM(0)) = (V(DENS()) * V(VELOCITY(2)) * V(VELOCITY(2)) + V(PRES())) /
-                      coords.template Xc<Axis::IAXIS>();
+  // ideally we should use the face values and do a better job integrating...
+  dudt(MOMENTUM(0)) += (V(DENS()) * V(VELOCITY(2)) * V(VELOCITY(2)) + V(PRES())) /
+                       coords.template Xi<Axis::IAXIS>();
   if constexpr (mhd != Mhd::off) {
     const Real pmag = 0.5 * (V(MAGC(0)) * V(MAGC(0)) + V(MAGC(1)) * V(MAGC(1)) +
                              V(MAGC(2)) * V(MAGC(2)));
diff --git a/src/problems/sedov.py b/src/problems/sedov.py
index 4c14473..fb5d38b 100644
--- a/src/problems/sedov.py
+++ b/src/problems/sedov.py
@@ -2,6 +2,7 @@
 """Setup for the Sedov blast wave."""
 
 from dataclasses import dataclass
+from typing import Literal
 
 import numpy as np
 from numpy.typing import NDArray
@@ -115,10 +116,16 @@ def initialize(unit: pyKamayan.KamayanUnit):
     # --8<-- [end:py_set_param]
 
 
+DIMENSION_ = Literal[1, 2, 3]
+
+
 # --8<-- [start:py_sedov]
 @kamayan_app(description="Sedov blast wave simulation")
 def sedov(
     geometry: GEOMETRY = typer.Option(default="cartesian", help="""Geometry setup."""),
+    dimension: DIMENSION_ = typer.Option(
+        default=2, help="""Number of spatial dimensions"""
+    ),
 ) -> KamayanManager:
     """Build the KamayanManager for Sedov."""
     units = kman.process_units(
@@ -128,17 +135,21 @@ def sedov(
 
     nxb = 32
     nblocks = int(128 / nxb)  # number of blocks to get 128 zones at coarsest resolution
+    xbnd1 = (-0.5, 0.5) if geometry == "cartesian" else (0.0, 1.0)
     km.grid = AdaptiveGrid(
-        xbnd1=(-0.5, 0.5),  # xmin/max
+        xbnd1=xbnd1,  # xmin/max
         xbnd2=(-0.5, 0.5),  # ymin/max
         nxb1=nxb,  # zones per block along x
-        nxb2=nxb,
+        nxb2=nxb if dimension > 1 else 1,
         num_levels=3,  # 3 levels of refinement
         nblocks1=nblocks,  # number of root blocks in each direction
-        nblocks2=nblocks,
+        nblocks2=nblocks if dimension > 1 else 1,
+        geometry=geometry,
     )
     km.grid.refinement_fields.add("pres")
     km.grid.boundary_conditions = gr.outflow_box()
+    if geometry == "cylindrical":
+        km.grid.boundary_conditions.ix1 = "axisymmetric"
 
     km.driver = driver.Driver(integrator="rk2", tlim=0.05)
     km.outputs.add("restarts", "rst", dt=0.01)

From bcd061fb83a43bac58f3cab1ea8164fb7ffd5b6e Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 22:56:56 -0700
Subject: [PATCH 10/55] another bug

---
 src/grid/geometry.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index faf25b2..18c89f9 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -120,7 +120,7 @@ struct Coordinates {
     if constexpr (geom == Geometry::cylindrical) {
       const Real rp = Xf<Axis::IAXIS>(i + 1);
       const Real rm = Xf<Axis::IAXIS>(i);
-      return 0.5 * Dx<Axis::KAXIS>() * (rp * rp - rm * rm);
+      return 0.5 * Dx<Axis::KAXIS>() * (rp * rp - rm * rm) * Dx<Axis::JAXIS>();
     }
     return coords_.CellVolume(k, j, i);
   }

From 16eff5edc72f1c4709793d012b2ed5229c80eda7 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 23:18:18 -0700
Subject: [PATCH 11/55] format

---
 python/kamayan/cli/app.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/python/kamayan/cli/app.py b/python/kamayan/cli/app.py
index 14f5bd2..fb454e3 100644
--- a/python/kamayan/cli/app.py
+++ b/python/kamayan/cli/app.py
@@ -65,6 +65,7 @@ def run(
             km = self.func(*args, **kwargs)
             if debug:
                 import os
+
                 typer.echo(f"PID: {os.getpid()}")
                 breakpoint()
             if input_file:

From af92c33e877077aaa57ec262495e748ec10124ef Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 22 Mar 2026 23:21:30 -0700
Subject: [PATCH 12/55] good job codex

---
 src/grid/geometry.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 18c89f9..10c3ea3 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -266,7 +266,7 @@ struct CoordinatesVariant<OptList<Geometry, geom, geoms...>> {
     type coordinates = Coordinates<geom>(coords);
     (
         [&]() {
-          if (geoms == geometry) coordinates = Coordinates<geom>(coords);
+          if (geoms == geometry) coordinates = Coordinates<geoms>(coords);
         }(),
         ...);
 

From 268503964c042d6f191012e167942834352af64b Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 24 Mar 2026 21:21:58 -0700
Subject: [PATCH 13/55] add refinement operations for geometry

---
 src/grid/refinement_operations.hpp | 367 +++++++++++++++++++++++++++++
 1 file changed, 367 insertions(+)
 create mode 100644 src/grid/refinement_operations.hpp

diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
new file mode 100644
index 0000000..c48a0d0
--- /dev/null
+++ b/src/grid/refinement_operations.hpp
@@ -0,0 +1,367 @@
+#ifndef GRID_REFINEMENT_OPERATIONS_HPP_
+#define GRID_REFINEMENT_OPERATIONS_HPP_
+#include <algorithm>
+
+#include <Kokkos_Core.hpp>
+
+#include "basic_types.hpp"
+#include "coordinates/coordinates.hpp"
+#include "grid/geometry.hpp"
+#include "grid/grid_types.hpp"
+#include "interface/variable_state.hpp"
+namespace kamayan::grid {
+
+namespace util {
+// compute distances from cell center to the nearest center in the + or -
+// coordinate direction. Do so for both coarse and fine grids.
+template <int DIM, TopologicalElement EL>
+KOKKOS_FORCEINLINE_FUNCTION void
+GetGridSpacings(const parthenon::Coordinates_t &coords,
+                const parthenon::Coordinates_t &coarse_coords,
+                const parthenon::IndexRange &cib, const parthenon::IndexRange &ib, int i,
+                int fi, Real *dxm, Real *dxp, Real *dxfm, Real *dxfp) {
+  // here "f" signifies the fine grid, not face locations.
+  const Real xm = coarse_coords.X<DIM, EL>(i - 1);
+  const Real xc = coarse_coords.X<DIM, EL>(i);
+  const Real xp = coarse_coords.X<DIM, EL>(i + 1);
+  *dxm = xc - xm;
+  *dxp = xp - xc;
+  const Real fxm = coords.X<DIM, EL>(fi);
+  const Real fxp = coords.X<DIM, EL>(fi + 1);
+  *dxfm = xc - fxm;
+  *dxfp = fxp - xc;
+}
+
+KOKKOS_FORCEINLINE_FUNCTION
+Real GradMinMod(const Real fc, const Real fm, const Real fp, const Real dxm,
+                const Real dxp, Real &gxm, Real &gxp) {
+  gxm = (fc - fm) / dxm;
+  gxp = (fp - fc) / dxp;
+  return 0.5 * (SIGN(gxm) + SIGN(gxp)) * std::min(std::abs(gxm), std::abs(gxp));
+}
+
+}  // namespace util
+
+template <Geometry geom>
+struct RestrictAverage {
+  static constexpr bool OperationRequired(TopologicalElement fel,
+                                          TopologicalElement cel) {
+    return fel == cel;
+  }
+
+  template <int DIM, TopologicalElement el = TopologicalElement::CC,
+            TopologicalElement /*cel*/ = TopologicalElement::CC>
+  KOKKOS_FORCEINLINE_FUNCTION static void
+  Do(const int l, const int m, const int n, const int ck, const int cj, const int ci,
+     const parthenon::IndexRange &ckb, const parthenon::IndexRange &cjb,
+     const parthenon::IndexRange &cib, const parthenon::IndexRange &kb,
+     const parthenon::IndexRange &jb, const parthenon::IndexRange &ib,
+     const parthenon::Coordinates_t &pcoords,
+     const parthenon::Coordinates_t &pcoarse_coords,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pcoarse,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
+    using TE = TopologicalElement;
+
+    auto coords = Coordinates<geom>(pcoords);
+    auto coarse_coords = Coordinates<geom>(pcoarse_coords);
+
+    constexpr bool INCLUDE_X1 =
+        (DIM > 0) && (el == TE::CC || el == TE::F2 || el == TE::F3 || el == TE::E1);
+    constexpr bool INCLUDE_X2 =
+        (DIM > 1) && (el == TE::CC || el == TE::F3 || el == TE::F1 || el == TE::E2);
+    constexpr bool INCLUDE_X3 =
+        (DIM > 2) && (el == TE::CC || el == TE::F1 || el == TE::F2 || el == TE::E3);
+    constexpr int element_idx = static_cast<int>(el) % 3;
+
+    auto &coarse = *pcoarse;
+    auto &fine = *pfine;
+
+    const int i = (DIM > 0) ? (ci - cib.s) * 2 + ib.s : ib.s;
+    const int j = (DIM > 1) ? (cj - cjb.s) * 2 + jb.s : jb.s;
+    const int k = (DIM > 2) ? (ck - ckb.s) * 2 + kb.s : kb.s;
+
+    // JMM: If dimensionality is wrong, accesses are out of bounds. Only
+    // access cells if dimensionality is correct.
+    Real vol[2][2][2], terms[2][2][2];  // memset not available on all accelerators
+    for (int ok = 0; ok < 2; ++ok) {
+      for (int oj = 0; oj < 2; ++oj) {
+        for (int oi = 0; oi < 2; ++oi) {
+          vol[ok][oj][oi] = terms[ok][oj][oi] = 0;
+        }
+      }
+    }
+
+    for (int ok = 0; ok < 1 + INCLUDE_X3; ++ok) {
+      for (int oj = 0; oj < 1 + INCLUDE_X2; ++oj) {
+        for (int oi = 0; oi < 1 + INCLUDE_X1; ++oi) {
+          vol[ok][oj][oi] = coords.template Volume<el>(k + ok, j + oj, i + oi);
+          terms[ok][oj][oi] =
+              vol[ok][oj][oi] * fine(element_idx, l, m, n, k + ok, j + oj, i + oi);
+        }
+      }
+    }
+    // KGF: add the off-centered quantities first to preserve FP
+    // symmetry
+    const Real tvol = ((vol[0][0][0] + vol[0][1][0]) + (vol[0][0][1] + vol[0][1][1])) +
+                      ((vol[1][0][0] + vol[1][1][0]) + (vol[1][0][1] + vol[1][1][1]));
+    coarse(element_idx, l, m, n, ck, cj, ci) =
+        tvol > 0.0
+            ? (((terms[0][0][0] + terms[0][1][0]) + (terms[0][0][1] + terms[0][1][1])) +
+               ((terms[1][0][0] + terms[1][1][0]) + (terms[1][0][1] + terms[1][1][1]))) /
+                  tvol
+            : 0.0;
+  }
+};
+
+template <Geometry geom, bool use_minmod_slope, bool piecewise_constant = false>
+struct ProlongateSharedGeneral {
+  static constexpr bool OperationRequired(TopologicalElement fel,
+                                          TopologicalElement cel) {
+    return fel == cel;
+  }
+
+  template <int DIM, TopologicalElement el = TopologicalElement::CC,
+            TopologicalElement /*cel*/ = TopologicalElement::CC>
+  KOKKOS_FORCEINLINE_FUNCTION static void
+  Do(const int l, const int m, const int n, const int k, const int j, const int i,
+     const parthenon::IndexRange &ckb, const parthenon::IndexRange &cjb,
+     const parthenon::IndexRange &cib, const parthenon::IndexRange &kb,
+     const parthenon::IndexRange &jb, const parthenon::IndexRange &ib,
+     const parthenon::Coordinates_t &pcoords,
+     const parthenon::Coordinates_t &pcoarse_coords,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pcoarse,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
+    using util::GradMinMod;
+    using TE = TopologicalElement;
+
+    auto coords = Coordinates<geom>(pcoords);
+    auto coarse_coords = Coordinates<geom>(pcoarse_coords);
+
+    auto &coarse = *pcoarse;
+    auto &fine = *pfine;
+
+    constexpr int element_idx = static_cast<int>(el) % 3;
+
+    const int fi = (DIM > 0) ? (i - cib.s) * 2 + ib.s : ib.s;
+    const int fj = (DIM > 1) ? (j - cjb.s) * 2 + jb.s : jb.s;
+    const int fk = (DIM > 2) ? (k - ckb.s) * 2 + kb.s : kb.s;
+
+    constexpr bool INCLUDE_X1 =
+        (DIM > 0) && (el == TE::CC || el == TE::F2 || el == TE::F3 || el == TE::E1);
+    constexpr bool INCLUDE_X2 =
+        (DIM > 1) && (el == TE::CC || el == TE::F3 || el == TE::F1 || el == TE::E2);
+    constexpr bool INCLUDE_X3 =
+        (DIM > 2) && (el == TE::CC || el == TE::F1 || el == TE::F2 || el == TE::E3);
+
+    const Real fc = coarse(element_idx, l, m, n, k, j, i);
+
+    Real dx1fm = 0;
+    [[maybe_unused]] Real dx1fp = 0;
+    [[maybe_unused]] Real gx1m = 0, gx1p = 0;
+    if constexpr (INCLUDE_X1) {
+      Real dx1m, dx1p;
+      GetGridSpacings<1, el>(pcoords, pcoarse_coords, cib, ib, i, fi, &dx1m, &dx1p,
+                             &dx1fm, &dx1fp);
+
+      Real gx1c =
+          GradMinMod(fc, coarse(element_idx, l, m, n, k, j, i - 1),
+                     coarse(element_idx, l, m, n, k, j, i + 1), dx1m, dx1p, gx1m, gx1p);
+      if constexpr (use_minmod_slope) {
+        gx1m = gx1c;
+        gx1p = gx1c;
+      }
+    }
+
+    Real dx2fm = 0;
+    [[maybe_unused]] Real dx2fp = 0;
+    [[maybe_unused]] Real gx2m = 0, gx2p = 0;
+    if constexpr (INCLUDE_X2) {
+      Real dx2m, dx2p;
+      GetGridSpacings<2, el>(pcoords, pcoarse_coords, cjb, jb, j, fj, &dx2m, &dx2p,
+                             &dx2fm, &dx2fp);
+      Real gx2c =
+          GradMinMod(fc, coarse(element_idx, l, m, n, k, j - 1, i),
+                     coarse(element_idx, l, m, n, k, j + 1, i), dx2m, dx2p, gx2m, gx2p);
+      if constexpr (use_minmod_slope) {
+        gx2m = gx2c;
+        gx2p = gx2c;
+      }
+    }
+
+    Real dx3fm = 0;
+    [[maybe_unused]] Real dx3fp = 0;
+    [[maybe_unused]] Real gx3m = 0, gx3p = 0;
+    if constexpr (INCLUDE_X3) {
+      Real dx3m, dx3p;
+      GetGridSpacings<3, el>(pcoords, pcoarse_coords, ckb, kb, k, fk, &dx3m, &dx3p,
+                             &dx3fm, &dx3fp);
+      Real gx3c =
+          GradMinMod(fc, coarse(element_idx, l, m, n, k - 1, j, i),
+                     coarse(element_idx, l, m, n, k + 1, j, i), dx3m, dx3p, gx3m, gx3p);
+      if constexpr (use_minmod_slope) {
+        gx3m = gx3c;
+        gx3p = gx3c;
+      }
+    }
+
+    if constexpr (piecewise_constant) {
+      gx1m = 0.0;
+      gx1p = 0.0;
+      gx2m = 0.0;
+      gx2p = 0.0;
+      gx3m = 0.0;
+      gx3p = 0.0;
+    }
+
+    // KGF: add the off-centered quantities first to preserve FP symmetry
+    // JMM: Extraneous quantities are zero
+    fine(element_idx, l, m, n, fk, fj, fi) =
+        fc - (gx1m * dx1fm + gx2m * dx2fm + gx3m * dx3fm);
+    if constexpr (INCLUDE_X1)
+      fine(element_idx, l, m, n, fk, fj, fi + 1) =
+          fc + (gx1p * dx1fp - gx2m * dx2fm - gx3m * dx3fm);
+    if constexpr (INCLUDE_X2)
+      fine(element_idx, l, m, n, fk, fj + 1, fi) =
+          fc - (gx1m * dx1fm - gx2p * dx2fp + gx3m * dx3fm);
+    if constexpr (INCLUDE_X2 && INCLUDE_X1)
+      fine(element_idx, l, m, n, fk, fj + 1, fi + 1) =
+          fc + (gx1p * dx1fp + gx2p * dx2fp - gx3m * dx3fm);
+    if constexpr (INCLUDE_X3)
+      fine(element_idx, l, m, n, fk + 1, fj, fi) =
+          fc - (gx1m * dx1fm + gx2m * dx2fm - gx3p * dx3fp);
+    if constexpr (INCLUDE_X3 && INCLUDE_X1)
+      fine(element_idx, l, m, n, fk + 1, fj, fi + 1) =
+          fc + (gx1p * dx1fp - gx2m * dx2fm + gx3p * dx3fp);
+    if constexpr (INCLUDE_X3 && INCLUDE_X2)
+      fine(element_idx, l, m, n, fk + 1, fj + 1, fi) =
+          fc - (gx1m * dx1fm - gx2p * dx2fp - gx3p * dx3fp);
+    if constexpr (INCLUDE_X3 && INCLUDE_X2 && INCLUDE_X1)
+      fine(element_idx, l, m, n, fk + 1, fj + 1, fi + 1) =
+          fc + (gx1p * dx1fp + gx2p * dx2fp + gx3p * dx3fp);
+  }
+};
+
+template <Geometry geom>
+using ProlongateSharedMinMod = ProlongateSharedGeneral<geom, true, false>;
+template <Geometry geom>
+using ProlongateSharedLinear = ProlongateSharedGeneral<geom, false, false>;
+template <Geometry geom>
+using ProlongatePiecewiseConstant = ProlongateSharedGeneral<geom, false, true>;
+
+// Implements divergence-free prolongation to internal faces using the method
+// described in Toth & Roe (2002). Any prolongation method for faces shared
+// between the coarse and the fine grid can be used alongside this internal
+// prolongation operation. Obviously, this prolongation operation is only
+// defined for face fields.
+//
+// We modify it here for cylindrical coordinates where the divergence constraint
+// is satisfied for r*B
+template <Geometry geom>
+struct ProlongateInternalTothAndRoe {
+  static constexpr bool OperationRequired(TopologicalElement fel,
+                                          TopologicalElement cel) {
+    using TE = TopologicalElement;
+    return (cel == TE::CC) && (GetTopologicalType(fel) == TopologicalType::Face);
+  }
+  // Here, fel is the topological element on which the field is defined and
+  // cel is the topological element on which we are filling the internal values
+  // of the field. So, for instance, we could fill the fine cell values of an
+  // x-face field within the volume of a coarse cell. This is assumes that the
+  // values of the fine cells on the elements corresponding with the coarse cell
+  // have been filled.
+  template <int DIM, TopologicalElement fel = TopologicalElement::CC,
+            TopologicalElement cel = TopologicalElement::CC>
+  KOKKOS_FORCEINLINE_FUNCTION static void
+  Do(const int l, const int m, const int n, const int k, const int j, const int i,
+     const parthenon::IndexRange &ckb, const parthenon::IndexRange &cjb,
+     const parthenon::IndexRange &cib, const parthenon::IndexRange &kb,
+     const parthenon::IndexRange &jb, const parthenon::IndexRange &ib,
+     const parthenon::Coordinates_t &pcoords,
+     const parthenon::Coordinates_t &pcoarse_coords,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
+    using TE = TopologicalElement;
+    using util::GradMinMod;
+
+    auto coords = Coordinates<geom>(pcoords);
+    auto coarse_coords = Coordinates<geom>(pcoarse_coords);
+
+    if constexpr (!IsSubmanifold(fel, cel)) {
+      return;
+    } else {
+      const int fi = (DIM > 0) ? (i - cib.s) * 2 + ib.s : ib.s;
+      const int fj = (DIM > 1) ? (j - cjb.s) * 2 + jb.s : jb.s;
+      const int fk = (DIM > 2) ? (k - ckb.s) * 2 + kb.s : kb.s;
+
+      // Here, we write the update for the x-component of the B-field and recover the
+      // other components by cyclic permutation
+      constexpr int element_idx = static_cast<int>(fel) % 3;
+      auto get_fine_permuted_kji = [&](int ok, int oj, int oi) -> std::array<int, 3> {
+        // Guard against offsetting in symmetry dimensions
+        constexpr int g3 = (DIM > 2);
+        constexpr int g2 = (DIM > 1);
+        if constexpr (fel == TE::F1) {
+          return {fk + ok * g3, fj + oj * g2, fi + oi};
+        } else if constexpr (fel == TE::F2) {
+          return {fk + oj * g3, fj + oi * g2, fi + ok};
+        } else {
+          return {fk + oi * g3, fj + ok * g2, fi + oj};
+        }
+      };
+      auto get_fine_permuted = [&](int eidx, int ok, int oj, int oi) -> Real & {
+        eidx = (element_idx + eidx) % 3;
+        const auto [kk, jj, ii] = get_fine_permuted_kji(ok, oj, oi);
+        return (*pfine)(eidx, l, m, n, kk, jj, ii);
+      };
+      auto get_geometric_factor = [&](int v, int u, int t) {
+        if constexpr (geom == Geometry::cylindrical) {
+          return coords.template Xf<fel, Axis::IAXIS>(fi + t);
+        } else {
+          return 1.0;
+        }
+      };
+
+      using iarr2 = std::array<int, 2>;
+      auto sg = [](int offset) -> Real { return offset == 0 ? -1.0 : 1.0; };
+      Real Uxx{0.0};
+      Real Vxyz{0.0};
+      Real Wxyz{0.0};
+      for (const int v : iarr2{0, 1}) {
+        // Note step size of 2 for the direction normal to the eidx2/eidx3
+        for (const int u : iarr2{0, 2}) {
+          for (const int t : iarr2{0, 1}) {
+            // we should multiply by the radial coordinate in cylindrical
+            // coordinates for r-faces
+            const auto fine2 =
+                get_fine_permuted(1, v, u, t) * get_geometric_factor(v, u, t);
+            const auto fine3 =
+                get_fine_permuted(2, u, v, t) * get_geometric_factor(v, u, t);
+            Uxx += sg(t) * sg(u) * (fine2 + fine3);
+            Vxyz += sg(t) * sg(u) * sg(v) * fine2;
+            Wxyz += sg(t) * sg(u) * sg(v) * fine3;
+          }
+        }
+      }
+      Uxx *= 0.125;
+      const int dir1 = element_idx + 1;
+      const int dir2 = (element_idx + 1) % 3 + 1;
+      const int dir3 = (element_idx + 2) % 3 + 1;
+      const auto dx2 = std::pow(coarse_coords.Dxc(dir1, k, j, i), 2);
+      const auto dy2 = std::pow(coarse_coords.Dxc(dir2, k, j, i), 2);
+      const auto dz2 = std::pow(coarse_coords.Dxc(dir3, k, j, i), 2);
+      Vxyz *= 0.125 * dz2 / (dx2 + dz2);
+      Wxyz *= 0.125 * dy2 / (dx2 + dy2);
+
+      for (int ok : iarr2{0, 1}) {
+        for (int oj : iarr2{0, 1}) {
+          get_fine_permuted(0, ok, oj, 1) =
+              0.5 * (get_fine_permuted(0, ok, oj, 0) + get_fine_permuted(0, ok, oj, 2)) +
+              Uxx + sg(ok) * Vxyz + sg(oj) * Wxyz;
+          get_fine_permuted(0, ok, oj, 1) *= 1. / get_geometric_factor(ok, oj, 1);
+        }
+      }
+    }
+  }
+};
+}  // namespace kamayan::grid
+#endif  // GRID_REFINEMENT_OPERATIONS_HPP_

From 2c4316bcdd46967ecb05f7627e904b770b16f8c3 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 25 Mar 2026 21:26:54 -0700
Subject: [PATCH 14/55] tweaks

---
 src/grid/geometry.hpp              | 52 +++++++++++++++++++++++++++++-
 src/grid/grid_types.hpp            |  4 +++
 src/grid/refinement_operations.hpp | 51 +++++++++++++++++------------
 src/kamayan/fields.hpp             |  3 +-
 src/physics/hydro/hydro.cpp        | 11 ++++---
 5 files changed, 94 insertions(+), 27 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 10c3ea3..6823f31 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -33,6 +33,22 @@ struct Coordinates {
                                      const int block)
       : coords_(pack.GetCoordinates(block)) {}
 
+  template <Axis ax, TopologicalElement el>
+  KOKKOS_FORCEINLINE_FUNCTION Real X(const int idx) const {
+    constexpr int dir = AxisToInt(ax);
+    if constexpr (ax == Axis::IAXIS && TopologicalOffsetI(el)) {
+      return coords_.X<1, el>(idx);
+    } else if constexpr (ax == Axis::JAXIS && TopologicalOffsetJ(el)) {
+      return coords_.X<2, el>(idx);
+    } else if constexpr (ax == Axis::JAXIS && TopologicalOffsetK(el)) {
+      return coords_.X<3, el>(idx);
+    } else {
+      return Xc<ax>(idx);
+    }
+    return 0;  // This should never be reached, but w/o it some compilers generate
+               // warnings
+  }
+
   // distance between cell centers
   template <Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real Dx() const {
@@ -77,10 +93,20 @@ struct Coordinates {
     return coords_.Xf<AxisToInt(ax)>(idx);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int idx) const {
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(idx); }, ax);
   }
 
+  // coordinate ax at center of element el
+  template <TopologicalElement el, Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int idx) const {
+    if constexpr (static_cast<int>(el) % 3 + 1 == AxisToInt(ax)) {
+      return Xf<ax>(idx);
+    } else {
+      return Xi<ax>(idx);
+    }
+  }
+
   template <Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
     constexpr auto dir = AxisToInt(ax);
@@ -125,6 +151,30 @@ struct Coordinates {
     return coords_.CellVolume(k, j, i);
   }
 
+  template <TopologicalElement el>
+  KOKKOS_FORCEINLINE_FUNCTION Real Volume(const int k, const int j, const int i) const {
+    using TE = TopologicalElement;
+    if constexpr (el == TE::CC)
+      return CellVolume(k, j, i);
+    else if constexpr (el == TE::F1)
+      return FaceArea<Axis::IAXIS>(k, j, i);
+    else if constexpr (el == TE::F2)
+      return FaceArea<Axis::JAXIS>(k, j, i);
+    else if constexpr (el == TE::F3)
+      return FaceArea<Axis::KAXIS>(k, j, i);
+    else if constexpr (el == TE::E1)
+      return EdgeLength<Axis::IAXIS>(k, j, i);
+    else if constexpr (el == TE::E2)
+      return EdgeLength<Axis::JAXIS>(k, j, i);
+    else if constexpr (el == TE::E3)
+      return EdgeLength<Axis::KAXIS>(k, j, i);
+    else if constexpr (el == TE::NN)
+      return 1.0;
+    PARTHENON_FAIL("ifyou reach this point, someone has added a new value to the the "
+                   "TopologicalElement enum.");
+    return 0.0;
+  }
+
   KOKKOS_FORCEINLINE_FUNCTION
   Real Volume(TopologicalElement el, const int k, const int j, const int i) const {
     using TE = TopologicalElement;
diff --git a/src/grid/grid_types.hpp b/src/grid/grid_types.hpp
index e2c0c1b..94555a9 100644
--- a/src/grid/grid_types.hpp
+++ b/src/grid/grid_types.hpp
@@ -26,6 +26,10 @@ constexpr Axis AxisFromTE(const TopologicalElement el) {
   return dir == 0 ? Axis::IAXIS : dir == 1 ? Axis::JAXIS : Axis::KAXIS;
 }
 
+constexpr Axis AxisFromInt(const int dir) {
+  return dir == 1 ? Axis::IAXIS : dir == 2 ? Axis::JAXIS : Axis::KAXIS;
+}
+
 template <TopologicalElement edge>
 concept EdgeElement = (edge >= TopologicalElement::E1 && edge <= TopologicalElement::E3);
 
diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index c48a0d0..b24cb2d 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -10,24 +10,29 @@
 #include "grid/grid_types.hpp"
 #include "interface/variable_state.hpp"
 namespace kamayan::grid {
-
+// Parthenon's implementation of non-cartesian coordinates assumes that
+// it is determined at compile time for the entire library. In order
+// to enable runtime geometry we re-implement the refinement operations upstream
+// templated on the geometry.
+//
 namespace util {
-// compute distances from cell center to the nearest center in the + or -
-// coordinate direction. Do so for both coarse and fine grids.
-template <int DIM, TopologicalElement EL>
+
+// distances between element centroids, so that prolongation is always
+// done in the volume coordinate
+template <int DIM, TopologicalElement EL, Geometry geom>
 KOKKOS_FORCEINLINE_FUNCTION void
-GetGridSpacings(const parthenon::Coordinates_t &coords,
-                const parthenon::Coordinates_t &coarse_coords,
+GetGridSpacings(const Coordinates<geom> &coords, const Coordinates<geom> &coarse_coords,
                 const parthenon::IndexRange &cib, const parthenon::IndexRange &ib, int i,
                 int fi, Real *dxm, Real *dxp, Real *dxfm, Real *dxfp) {
   // here "f" signifies the fine grid, not face locations.
-  const Real xm = coarse_coords.X<DIM, EL>(i - 1);
-  const Real xc = coarse_coords.X<DIM, EL>(i);
-  const Real xp = coarse_coords.X<DIM, EL>(i + 1);
+  constexpr auto ax = AxisFromInt(DIM);
+  const Real xm = coarse_coords.template X<ax, EL>(i - 1);
+  const Real xc = coarse_coords.template X<ax, EL>(i);
+  const Real xp = coarse_coords.template X<ax, EL>(i + 1);
   *dxm = xc - xm;
   *dxp = xp - xc;
-  const Real fxm = coords.X<DIM, EL>(fi);
-  const Real fxp = coords.X<DIM, EL>(fi + 1);
+  const Real fxm = coords.template X<ax, EL>(fi);
+  const Real fxp = coords.template X<ax, EL>(fi + 1);
   *dxfm = xc - fxm;
   *dxfp = fxp - xc;
 }
@@ -131,6 +136,7 @@ struct ProlongateSharedGeneral {
      const parthenon::Coordinates_t &pcoarse_coords,
      const parthenon::ParArrayND<Real, parthenon::VariableState> *pcoarse,
      const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
+    using util::GetGridSpacings;
     using util::GradMinMod;
     using TE = TopologicalElement;
 
@@ -160,8 +166,8 @@ struct ProlongateSharedGeneral {
     [[maybe_unused]] Real gx1m = 0, gx1p = 0;
     if constexpr (INCLUDE_X1) {
       Real dx1m, dx1p;
-      GetGridSpacings<1, el>(pcoords, pcoarse_coords, cib, ib, i, fi, &dx1m, &dx1p,
-                             &dx1fm, &dx1fp);
+      GetGridSpacings<1, el, geom>(coords, coarse_coords, cib, ib, i, fi, &dx1m, &dx1p,
+                                   &dx1fm, &dx1fp);
 
       Real gx1c =
           GradMinMod(fc, coarse(element_idx, l, m, n, k, j, i - 1),
@@ -177,8 +183,8 @@ struct ProlongateSharedGeneral {
     [[maybe_unused]] Real gx2m = 0, gx2p = 0;
     if constexpr (INCLUDE_X2) {
       Real dx2m, dx2p;
-      GetGridSpacings<2, el>(pcoords, pcoarse_coords, cjb, jb, j, fj, &dx2m, &dx2p,
-                             &dx2fm, &dx2fp);
+      GetGridSpacings<2, el, geom>(coords, coarse_coords, cjb, jb, j, fj, &dx2m, &dx2p,
+                                   &dx2fm, &dx2fp);
       Real gx2c =
           GradMinMod(fc, coarse(element_idx, l, m, n, k, j - 1, i),
                      coarse(element_idx, l, m, n, k, j + 1, i), dx2m, dx2p, gx2m, gx2p);
@@ -193,8 +199,8 @@ struct ProlongateSharedGeneral {
     [[maybe_unused]] Real gx3m = 0, gx3p = 0;
     if constexpr (INCLUDE_X3) {
       Real dx3m, dx3p;
-      GetGridSpacings<3, el>(pcoords, pcoarse_coords, ckb, kb, k, fk, &dx3m, &dx3p,
-                             &dx3fm, &dx3fp);
+      GetGridSpacings<3, el, geom>(coords, coarse_coords, ckb, kb, k, fk, &dx3m, &dx3p,
+                                   &dx3fm, &dx3fp);
       Real gx3c =
           GradMinMod(fc, coarse(element_idx, l, m, n, k - 1, j, i),
                      coarse(element_idx, l, m, n, k + 1, j, i), dx3m, dx3p, gx3m, gx3p);
@@ -346,9 +352,9 @@ struct ProlongateInternalTothAndRoe {
       const int dir1 = element_idx + 1;
       const int dir2 = (element_idx + 1) % 3 + 1;
       const int dir3 = (element_idx + 2) % 3 + 1;
-      const auto dx2 = std::pow(coarse_coords.Dxc(dir1, k, j, i), 2);
-      const auto dy2 = std::pow(coarse_coords.Dxc(dir2, k, j, i), 2);
-      const auto dz2 = std::pow(coarse_coords.Dxc(dir3, k, j, i), 2);
+      const auto dx2 = std::pow(coarse_coords.Dx(Axis::IAXIS), 2);
+      const auto dy2 = std::pow(coarse_coords.Dx(Axis::JAXIS), 2);
+      const auto dz2 = std::pow(coarse_coords.Dx(Axis::KAXIS), 2);
       Vxyz *= 0.125 * dz2 / (dx2 + dz2);
       Wxyz *= 0.125 * dy2 / (dx2 + dy2);
 
@@ -363,5 +369,10 @@ struct ProlongateInternalTothAndRoe {
     }
   }
 };
+
+// TODO(acreyes): ProlongateInternalAverage
+// In principle I guess we should weight the averaging based on the generalized volume of
+// the elements
+
 }  // namespace kamayan::grid
 #endif  // GRID_REFINEMENT_OPERATIONS_HPP_
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index 42e77e2..5907356 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -99,7 +99,8 @@ void AddField(parthenon::StateDescriptor *pkg, std::vector<MetadataFlag> m,
               std::vector<int> shape = T::Shape()) {
   // can also add refinement ops here depending on the metadata
   if (T::variable_rank == VariableRank::vector) m.push_back(Metadata::Vector);
-  pkg->AddField<T>(Metadata(m, shape));
+  auto md = Metadata(m, shape);
+  pkg->AddField<T>(md);
 }
 
 template <typename... Ts>
diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index bebf2bc..da226be 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -11,6 +11,7 @@
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid.hpp"
+#include "grid/refinement_operations.hpp"
 #include "grid/subpack.hpp"
 #include "hydro_types.hpp"
 #include "kamayan/config.hpp"
@@ -82,9 +83,9 @@ void SetupParams(KamayanUnit *unit) {
 }
 
 struct InitializeHydro {
-  using options = OptTypeList<HydroFactory>;
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
   using value = void;
-  template <typename hydro_vars>
+  template <typename hydro_vars, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_vars, HydroTraits>)
   value dispatch(KamayanUnit *unit, Config *cfg) {
     // --8<-- [start:hydro_add_fields]
@@ -97,9 +98,9 @@ struct InitializeHydro {
     if constexpr (hydro_vars::MHD == Mhd::ct) {
       auto m = Metadata(std::vector<MetadataFlag>{
           FACE_FLAGS(Metadata::Independent, Metadata::WithFluxes)});
-      m.RegisterRefinementOps<parthenon::refinement_ops::ProlongateSharedMinMod,
-                              parthenon::refinement_ops::RestrictAverage,
-                              parthenon::refinement_ops::ProlongateInternalTothAndRoe>();
+      m.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
+                              grid::RestrictAverage<geom>,
+                              grid::ProlongateInternalTothAndRoe<geom>>();
       unit->AddField<MAG>(m);
     }
 

From 7603d7e6879370c40e275422a1c7090e73a756c1 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sat, 28 Mar 2026 18:57:02 -0700
Subject: [PATCH 15/55] refining vars for caching geometry

---
 src/dispatcher/options.hpp   |  30 +++++++++--
 src/grid/coordinates.hpp     | 100 +++++++++++++++++++++++++++++++++++
 src/grid/geometry.hpp        |  60 ++++++++++++++++++---
 src/grid/grid_update.hpp     |   1 +
 src/grid/tests/test_grid.cpp |   9 ++--
 src/grid/tests/test_grid.hpp |   3 +-
 src/kamayan/fields.hpp       |  22 +++++---
 src/kamayan/kamayan.cpp      |   6 +++
 src/kamayan/unit.hpp         |   3 ++
 src/physics/hydro/hydro.cpp  |  16 ++++--
 10 files changed, 224 insertions(+), 26 deletions(-)
 create mode 100644 src/grid/coordinates.hpp

diff --git a/src/dispatcher/options.hpp b/src/dispatcher/options.hpp
index 68d2a32..8409f1f 100644
--- a/src/dispatcher/options.hpp
+++ b/src/dispatcher/options.hpp
@@ -17,19 +17,41 @@
 
 namespace kamayan {
 
-template <typename, auto...>
-struct OptList {};
+// checks that a functor can be instantiated for EnumV
+// used to describe functors that can be used with OptList::dispatch below
+template <typename F, typename EnumT, EnumT EnumV, typename... Args>
+concept OptionFunctor = requires {
+  requires std::is_void_v<decltype(std::declval<F>().template operator()<EnumV>(
+      std::declval<Args>()...))>;
+};
 
 // used to enumerate the allowed values of a PolyOpt in a given
 // dispatch functor. By default this list is exactly what is written
 // unless cmake has been configured with -DOPT_enum_opt="enum_v,..."
 // in that case OptInf<enum_opt>::isdef == true and the ParmList()
 // will just be those defined at configure time
-template <typename enum_opt, auto enum_v, auto... enum_vs>
+template <typename enum_opt, enum_opt... enum_vs>
 requires(PolyOpt<enum_opt>)
-struct OptList<enum_opt, enum_v, enum_vs...> {
+struct OptList {
   using type = enum_opt;
   static constexpr auto value = OptInfo<enum_opt>::ParmList();
+
+  // used to dispatch to a runtime template specialization of a type's operator()
+  template <typename Functor, typename... Args>
+  requires(OptionFunctor<Functor, enum_opt, enum_vs, Args...> && ...)
+  static bool dispatch(const Functor &functor, const enum_opt parm, Args &&...args) {
+    bool found_parm = false;
+    (void)((
+               [&]() {
+                 if (parm == enum_vs) {
+                   found_parm = true;
+                   functor.template operator()<enum_vs>(std::forward<Args>(args)...);
+                 }
+               }(),
+               !found_parm) &&
+           ...);
+    return found_parm;
+  }
 };
 
 template <typename OL>
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
new file mode 100644
index 0000000..b2db85c
--- /dev/null
+++ b/src/grid/coordinates.hpp
@@ -0,0 +1,100 @@
+#ifndef GRID_COORDINATES_HPP_
+#define GRID_COORDINATES_HPP_
+#include <string>
+#include <utility>
+
+#include <parthenon/parthenon.hpp>
+
+#include "grid/grid_types.hpp"
+#include "utils/strings.hpp"
+#include "utils/type_list.hpp"
+
+namespace kamayan::grid {
+
+// Idea for this is to have a variable that is stored per meshblock
+// that is associated with a topological element, but might be only allocated for a
+// particular kji dimension. For example radial face areas in cylindrical coordinates
+// these face areas on a mesh block only depend on the radial index (i) and are
+// located on the TE::F1 faces. In the case that there are no axes this is just a scalar
+//
+// using AreaF1 = CoordVar<"geom.area_f1">
+//
+// The raw parthenon way of accessing this would be to pack it, then access it
+// with the i-index
+// pack(b, AreaF1())(i);
+//
+// It is not necessarily the case that an arbitrary coordinate system would
+// index with i, it might even be the full (k,j,i), so we need some kind of helper
+// to forward that
+//
+// coords.Area<Axes::IAXIS>(pack, b, k, j, i);
+//
+// I think we define all the variables as CoordVars with just the var_name,
+// we collect them into a TypeList, and then each coordinate system becomes
+// responsible for exporting the shapes, so we can add as
+//
+// const auto shape = coords.shape<AreaF1>(nx3, nx2, nx1); // should include ghosts
+// pkg->AddField<AreaF1>(Metadata({Metadata::None, Metadata::OneCopy}, shape));
+//
+// this could also be wrapped in a type_for
+template <strings::CompileTimeString var_name>
+struct CoordVar : parthenon::variable_names::base_t<false> {
+  template <typename... Args>
+  KOKKOS_INLINE_FUNCTION CoordVar(Args &&...args)
+      : parthenon::variable_names::base_t<false>(std::forward<Args>(args)...) {}
+
+  static std::string name() { return std::string(var_name.value); }
+  static constexpr auto label = var_name;
+};
+
+namespace impl {
+template <std::size_t N>
+constexpr auto AxisNamer(const strings::CompileTimeString<N> base, Axis ax) {
+  if (ax == Axis::IAXIS) {
+    return strings::concat_cts(base, strings::make_cts("1"));
+  } else if (ax == Axis::JAXIS) {
+    return strings::concat_cts(base, strings::make_cts("2"));
+  } else if (ax == Axis::KAXIS) {
+    return strings::concat_cts(base, strings::make_cts("3"));
+  }
+  return strings::concat_cts(base, strings::make_cts("1"));
+}
+}  // namespace impl
+
+template <strings::CompileTimeString var_name, Axis ax>
+using AxisCoord = CoordVar<impl::AxisNamer(var_name, ax)>;
+
+template <Axis ax>
+using Dx = AxisCoord<"geom.Dx", ax>;
+
+template <Axis ax>
+using X = AxisCoord<"geom.X", ax>;
+
+template <Axis ax>
+using Xc = AxisCoord<"geom.Xc", ax>;
+
+template <Axis ax>
+using Xf = AxisCoord<"geom.Xf", ax>;
+
+template <Axis ax>
+using FaceArea = AxisCoord<"geom.FaceArea", ax>;
+
+template <Axis ax>
+using EdgeLength = AxisCoord<"geom.EdgeLength", ax>;
+
+using Volume = CoordVar<"geom.Volume">;
+
+template <template <Axis> typename T, template <Axis> typename... Ts>
+auto AxisTL() {
+  if constexpr (sizeof...(Ts) == 0) {
+    return TypeList<T<Axis::IAXIS>, T<Axis::JAXIS>, T<Axis::KAXIS>>();
+  } else {
+    return ConcatTypeLists_t<decltype(AxisTL<T>()), decltype(AxisTL<Ts...>())>();
+  }
+}
+
+// compiler seems really unhappy if I attempt to alias this
+using AxisCoords = decltype(AxisTL<Dx, X, Xc, Xf, FaceArea, EdgeLength>());
+using CoordFields = ConcatTypeLists_t<AxisCoords, TypeList<Volume>>;
+}  // namespace kamayan::grid
+#endif  // GRID_COORDINATES_HPP_
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 6823f31..865ca98 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -1,19 +1,22 @@
 #ifndef GRID_GEOMETRY_HPP_
 #define GRID_GEOMETRY_HPP_
 
+#include <format>
 #include <numbers>
 #include <utility>
+#include <vector>
 
-#include <new>
+#include <Kokkos_Macros.hpp>
 
-#include "Kokkos_Macros.hpp"
-
-#include "coordinates/coordinates.hpp"
+#include <coordinates/coordinates.hpp>
+#include <pack/sparse_pack.hpp>
+#include <ports-of-call/variant.hpp>
 
+#include "dispatcher/option_types.hpp"
 #include "dispatcher/options.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/grid_types.hpp"
-#include "pack/sparse_pack.hpp"
-#include "ports-of-call/variant.hpp"
+#include "utils/type_list.hpp"
 
 namespace kamayan {
 POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
@@ -430,6 +433,51 @@ struct GenericCoordinate {
   CoordinatesVariant coords_;
 };
 
+// the following could probably all be in an implementation file geometry.cpp
+namespace impl {
+template <Geometry>
+struct CoordShapes {};
+
+template <>
+struct CoordShapes<Geometry::cartesian> {
+  using Scalars =
+      ConcatTypeLists_t<TypeList<Volume>, decltype(AxisTL<Dx, FaceArea, EdgeLength>())>;
+  using Icoord = TypeList<X<Axis::IAXIS>, Xc<Axis::IAXIS>, Xf<Axis::IAXIS>>;
+  using Jcoord = TypeList<X<Axis::JAXIS>, Xc<Axis::JAXIS>, Xf<Axis::JAXIS>>;
+  using Kcoord = TypeList<X<Axis::KAXIS>, Xc<Axis::KAXIS>, Xf<Axis::KAXIS>>;
+};
+
+template <>
+struct CoordShapes<Geometry::cylindrical> {
+  using Scalars = decltype(AxisTL<Dx>());
+  using Icoord = ConcatTypeLists_t<
+      TypeList<Volume, X<Axis::IAXIS>, Xc<Axis::IAXIS>, Xf<Axis::IAXIS>>,
+      decltype(AxisTL<FaceArea, EdgeLength>())>;
+  using Jcoord = TypeList<X<Axis::JAXIS>, Xc<Axis::JAXIS>, Xf<Axis::JAXIS>>;
+  using Kcoord = TypeList<X<Axis::KAXIS>, Xc<Axis::KAXIS>, Xf<Axis::KAXIS>>;
+};
+}  // namespace impl
+
+template <Geometry geom, typename T>
+requires(CoordFields::template Contains<T>())
+std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1) {
+  using shapes = impl::CoordShapes<geom>;
+
+  if constexpr (shapes::Scalars::template Contains<T>()) {
+    return {1, 1, 1};
+  } else if constexpr (shapes::Icoord::template Contains<T>()) {
+    return {1, 1, nx1};
+  } else if constexpr (shapes::Jcoord::template Contains<T>()) {
+    return {1, nx2, 1};
+  } else if constexpr (shapes::Kcoord::template Contains<T>()) {
+    return {nx3, 1, 1};
+  }
+
+  PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
+                             T::name(), OptInfo<Geometry>::Label(geom))
+                     .c_str());
+}
+
 }  // namespace grid
 }  // namespace kamayan
 #endif  // GRID_GEOMETRY_HPP_
diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index 0df820f..4b20111 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -3,6 +3,7 @@
 #include <parthenon/parthenon.hpp>
 
 #include "grid.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid_types.hpp"
 #include "kamayan/fields.hpp"
diff --git a/src/grid/tests/test_grid.cpp b/src/grid/tests/test_grid.cpp
index 7507bc7..4ff2274 100644
--- a/src/grid/tests/test_grid.cpp
+++ b/src/grid/tests/test_grid.cpp
@@ -12,6 +12,7 @@
 #include "grid/scratch_variables.hpp"
 #include "grid/subpack.hpp"
 #include "kamayan/fields.hpp"
+#include "kamayan/unit.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kokkos_abstraction.hpp"
 #include "physics/hydro/hydro_types.hpp"
@@ -20,8 +21,8 @@
 using parthenon::BlockList_t;
 
 namespace kamayan {
-BlockList_t MakeTestBlockList(const std::shared_ptr<StateDescriptor> pkg,
-                              const int NBLOCKS, const int NXB, const int NDIM) {
+BlockList_t MakeTestBlockList(const std::shared_ptr<KamayanUnit> pkg, const int NBLOCKS,
+                              const int NXB, const int NDIM) {
   BlockList_t block_list;
   block_list.reserve(NBLOCKS);
   for (int i = 0; i < NBLOCKS; ++i) {
@@ -45,7 +46,7 @@ TEST(grid, PackIndexer) {
   constexpr int NDIM = 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 9;
-  auto pkg = std::make_shared<StateDescriptor>("Test Package");
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
   AddFields(Fields(), pkg.get(), {CENTER_FLAGS(Metadata::WithFluxes)});
 
   // now build our test grid
@@ -141,7 +142,7 @@ TEST(ScratchVarTest, SubPack) {
   constexpr int ntj = 5;
   constexpr int nti = 2;
 
-  auto pkg = std::make_shared<StateDescriptor>("Test Package");
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
 
   Scratch::type scratch;
   scratch.template RegisterShape<Scratch::Vector>({nvec});
diff --git a/src/grid/tests/test_grid.hpp b/src/grid/tests/test_grid.hpp
index 8110d7c..27bf58a 100644
--- a/src/grid/tests/test_grid.hpp
+++ b/src/grid/tests/test_grid.hpp
@@ -5,13 +5,14 @@
 
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/grid_types.hpp"
+#include "kamayan/unit.hpp"
 #include "mesh/meshblock.hpp"
 
 namespace kamayan {
 // Builds a block list and initializes a MeshData from that block list
 // We export these in case additional tests need to use a pack
 // that can be built from the MeshData
-parthenon::BlockList_t MakeTestBlockList(const std::shared_ptr<StateDescriptor> pkg,
+parthenon::BlockList_t MakeTestBlockList(const std::shared_ptr<KamayanUnit> pkg,
                                          const int NBLOCKS, const int NSIDE,
                                          const int NDIM);
 MeshData MakeTestMeshData(parthenon::BlockList_t block_list);
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index 5907356..ce46d27 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -8,7 +8,10 @@
 
 #include <parthenon/parthenon.hpp>
 
+#include "grid/geometry.hpp"
+#include "grid/refinement_operations.hpp"
 #include "interface/state_descriptor.hpp"
+#include "kamayan/unit.hpp"
 #include "kamayan_utils/strings.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
 #include "kamayan_utils/type_list.hpp"
@@ -95,30 +98,37 @@ concept SparseVar = requires {
 
 template <typename T>
 requires(DenseVar<T>)
-void AddField(parthenon::StateDescriptor *pkg, std::vector<MetadataFlag> m,
+void AddField(KamayanUnit *pkg, std::vector<MetadataFlag> m,
               std::vector<int> shape = T::Shape()) {
   // can also add refinement ops here depending on the metadata
   if (T::variable_rank == VariableRank::vector) m.push_back(Metadata::Vector);
   auto md = Metadata(m, shape);
+
+  const auto geometry = pkg->Configuration()->Get<Geometry>();
+  auto register_ops = [&]<Geometry geom>() {
+    md.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
+                             grid::RestrictAverage<geom>>();
+  };
+  const auto handled = grid::GeometryOptions::dispatch(register_ops, geometry);
+  PARTHENON_REQUIRE_THROWS(handled, "Geometry not handled for refinement operations.");
   pkg->AddField<T>(md);
 }
 
 template <typename... Ts>
 requires(DenseVar<Ts> && ...)
-void AddFields(parthenon::StateDescriptor *pkg, std::vector<MetadataFlag> m) {
+void AddFields(KamayanUnit *pkg, std::vector<MetadataFlag> m) {
   (void)(AddField<Ts>(pkg, m), ...);
 }
 
 template <typename... Ts>
 requires(DenseVar<Ts> && ...)
-void AddFields(TypeList<Ts...>, parthenon::StateDescriptor *pkg,
-               std::vector<MetadataFlag> m) {
+void AddFields(TypeList<Ts...>, KamayanUnit *pkg, std::vector<MetadataFlag> m) {
   AddFields<Ts...>(pkg, m);
 }
 
 template <typename T, typename V>
 requires(SparseVar<T> && SparseVar<V>)
-void AddSparseField(V, parthenon::StateDescriptor *pkg, const std::vector<MetadataFlag> m,
+void AddSparseField(V, KamayanUnit *pkg, const std::vector<MetadataFlag> m,
                     const std::vector<int> &ids) {
   std::vector<int> shape = T::Shape();
   auto m_plus = m;
@@ -128,7 +138,7 @@ void AddSparseField(V, parthenon::StateDescriptor *pkg, const std::vector<Metada
 
 template <typename... Ts, typename V>
 requires(SparseVar<V> && (SparseVar<Ts> && ...))
-void AddSparseFields(TypeList<Ts...>, V, parthenon::StateDescriptor *pkg,
+void AddSparseFields(TypeList<Ts...>, V, KamayanUnit *pkg,
                      const std::vector<MetadataFlag> m, const std::vector<int> &ids) {
   (void)(AddSparseField<Ts>(V(), pkg, m, ids), ...);
 }
diff --git a/src/kamayan/kamayan.cpp b/src/kamayan/kamayan.cpp
index 9c8eb96..c9ee49f 100644
--- a/src/kamayan/kamayan.cpp
+++ b/src/kamayan/kamayan.cpp
@@ -95,6 +95,12 @@ KamayanDriver InitPackages(std::shared_ptr<ParthenonManager> pman,
                        "PostMeshInitialization");
   };
 
+  pman->app_input->InitMeshBlockUserData = [units](MeshBlock *mb, ParameterInput *pin) {
+    units->AddTasksDAG([](KamayanUnit *u) -> auto & { return u->InitMeshBlockData; },
+                       [&](KamayanUnit *u) { u->InitMeshBlockData(mb); },
+                       "InitMeshBlockUserData");
+  };
+
   // maybe this should be a part of all the units...
   pman->app_input->PreStepMeshUserWorkInLoop = driver::PreStepUserWorkInLoop;
 
diff --git a/src/kamayan/unit.hpp b/src/kamayan/unit.hpp
index 165ff5d..43a664f 100644
--- a/src/kamayan/unit.hpp
+++ b/src/kamayan/unit.hpp
@@ -49,6 +49,9 @@ struct KamayanUnit : public StateDescriptor,
   // Run after mesh initialization
   CallbackRegistration<std::function<TaskStatus(MeshData *md)>> PostMeshInitialization;
 
+  // Set MeshBlockData on remeshing
+  CallbackRegistration<std::function<void(MeshBlock *)>> InitMeshBlockData;
+
   // makes sure the conserved variables are ready before applying dudt
   CallbackRegistration<std::function<TaskStatus(MeshData *md)>> PrepareConserved;
 
diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index da226be..7cec8e7 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -83,9 +83,9 @@ void SetupParams(KamayanUnit *unit) {
 }
 
 struct InitializeHydro {
-  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
+  using options = OptTypeList<HydroFactory>;
   using value = void;
-  template <typename hydro_vars, Geometry geom>
+  template <typename hydro_vars>
   requires(NonTypeTemplateSpecialization<hydro_vars, HydroTraits>)
   value dispatch(KamayanUnit *unit, Config *cfg) {
     // --8<-- [start:hydro_add_fields]
@@ -98,9 +98,15 @@ struct InitializeHydro {
     if constexpr (hydro_vars::MHD == Mhd::ct) {
       auto m = Metadata(std::vector<MetadataFlag>{
           FACE_FLAGS(Metadata::Independent, Metadata::WithFluxes)});
-      m.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
-                              grid::RestrictAverage<geom>,
-                              grid::ProlongateInternalTothAndRoe<geom>>();
+      auto register_ops = [&]<Geometry geom>() {
+        m.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
+                                grid::RestrictAverage<geom>,
+                                grid::ProlongateInternalTothAndRoe<geom>>();
+      };
+      const auto geometry = unit->Configuration()->Get<Geometry>();
+      const auto handled = grid::GeometryOptions::dispatch(register_ops, geometry);
+      PARTHENON_REQUIRE_THROWS(handled,
+                               "Geometry not handled for refinement operations.");
       unit->AddField<MAG>(m);
     }
 

From a63641798eafe8c565cf22c57139a13c411c7d27 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sat, 28 Mar 2026 20:57:28 -0700
Subject: [PATCH 16/55] fix reference cycles

---
 src/grid/coordinates.hpp |  4 ++--
 src/kamayan/fields.hpp   | 14 +++++++++++---
 src/kamayan/kamayan.cpp  |  5 +++++
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index b2db85c..1e2f64d 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -6,8 +6,8 @@
 #include <parthenon/parthenon.hpp>
 
 #include "grid/grid_types.hpp"
-#include "utils/strings.hpp"
-#include "utils/type_list.hpp"
+#include "kamayan_utils/strings.hpp"
+#include "kamayan_utils/type_list.hpp"
 
 namespace kamayan::grid {
 
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index ce46d27..a92df45 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -2,6 +2,7 @@
 #define KAMAYAN_FIELDS_HPP_
 
 #include <concepts>
+#include <iostream>
 #include <string>
 #include <utility>
 #include <vector>
@@ -106,10 +107,17 @@ void AddField(KamayanUnit *pkg, std::vector<MetadataFlag> m,
 
   const auto geometry = pkg->Configuration()->Get<Geometry>();
   auto register_ops = [&]<Geometry geom>() {
-    md.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
-                             grid::RestrictAverage<geom>>();
+    try {
+      md.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
+                               grid::RestrictAverage<geom>>();
+    } catch (const std::exception &e) {
+      std::cerr << "Variable: " << T::name() << std::endl;
+      throw;
+    }
   };
-  const auto handled = grid::GeometryOptions::dispatch(register_ops, geometry);
+  const auto handled = md.HasRefinementOps()
+                           ? grid::GeometryOptions::dispatch(register_ops, geometry)
+                           : true;
   PARTHENON_REQUIRE_THROWS(handled, "Geometry not handled for refinement operations.");
   pkg->AddField<T>(md);
 }
diff --git a/src/kamayan/kamayan.cpp b/src/kamayan/kamayan.cpp
index c9ee49f..e6b6cdc 100644
--- a/src/kamayan/kamayan.cpp
+++ b/src/kamayan/kamayan.cpp
@@ -61,6 +61,9 @@ KamayanDriver InitPackages(std::shared_ptr<ParthenonManager> pman,
     }
   }
 
+  // Add app_input callbacks, but take care that these are released in
+  // kamayan::Finalize below in case they're holding references to
+  // any KamayanUnits
   pman->app_input->ProcessPackages =
       [units, config](std::unique_ptr<kamayan::ParameterInput> &pin) {
         parthenon::Packages_t packages;
@@ -136,6 +139,8 @@ void Finalize(std::shared_ptr<ParthenonManager> pman) {
     pman->app_input->ProcessPackages = nullptr;
     pman->app_input->ProblemGenerator = nullptr;
     pman->app_input->MeshPostInitialization = nullptr;
+    pman->app_input->InitMeshBlockUserData = nullptr;
+    pman->app_input->PreStepMeshUserWorkInLoop = nullptr;
   }
   pman->ProcessPackages = nullptr;
   pman->ParthenonFinalize();

From 1e817f64361882b294df967c99c8f65ba0d048f3 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 29 Mar 2026 22:33:35 -0700
Subject: [PATCH 17/55] pattern for filling in coordinates

---
 CMakeLists.txt           |  1 +
 src/CMakeLists.txt       |  1 +
 src/grid/coordinates.cpp | 55 ++++++++++++++++++++++++++++++++++++++++
 src/grid/coordinates.hpp | 20 +++++++++++----
 src/grid/geometry.hpp    | 43 ++++++++++++++++++++++++++++---
 src/grid/grid.cpp        | 21 +++++++++++++++
 src/grid/grid.hpp        |  1 +
 7 files changed, 133 insertions(+), 9 deletions(-)
 create mode 100644 src/grid/coordinates.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 340369e..6b470bf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -120,6 +120,7 @@ set(SINGULARITY_USE_KOKKOS
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/external/singularity-eos/CMakeLists.txt)
   # this forces singularity to use our version of kokkos-kernels to be
   # compatible with parthenon's kokkos 5.1
+  set(KokkosKernels_ENABLE_SUPERNODAL_SPTRSV OFF)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/external/kokkos-kernels)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/external/singularity-eos)
 else()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1076482..56f59f2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,6 +1,7 @@
 set(_sources
     driver/kamayan_driver.cpp
     grid/boundary_conditions.cpp
+    grid/coordinates.cpp
     grid/grid.cpp
     grid/grid_refinement.cpp
     kamayan/callback_dag.cpp
diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
new file mode 100644
index 0000000..0250910
--- /dev/null
+++ b/src/grid/coordinates.cpp
@@ -0,0 +1,55 @@
+#include "grid/coordinates.hpp"
+
+#include "basic_types.hpp"
+#include "grid/geometry.hpp"
+#include "grid/grid.hpp"
+#include "grid/grid_types.hpp"
+#include "kamayan_utils/parallel.hpp"
+
+namespace kamayan::grid {
+
+// for a given variable T, need to:
+//    * get index bounds
+//    * launch par_for
+//    * fill pack(T(), k, j, i) for the mb
+//       * means calling the coords method
+//       * pass a KOKKOS_LAMBDA(k,j,i) ?
+template <Geometry geom, typename T, typename Functor>
+void FillCoords(const Functor &functor, const parthenon::IndexShape cellbounds) {
+  auto [kb, jb, ib] = CoordinateIndexRanges<geom, T>(cellbounds);
+  par_for(PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e, functor);
+}
+
+void CalculateCoordinates(MeshBlock *mb) {
+  const auto geometry = GetConfig(mb)->Get<Geometry>();
+  GeometryOptions::dispatch(
+      [&]<Geometry geom>() {
+        auto cellbounds = mb->cellbounds;
+
+        auto pack = GetPack(CoordFields(), mb);
+        auto coords = Coordinates<geom>(pack, 0);
+
+        FillCoords<geom, Volume>(
+            KOKKOS_LAMBDA(const int k, const int j, const int i) {
+              pack(0, Volume(), k, j, i) = coords.CellVolume(k, j, i);
+            },
+            cellbounds);
+
+        [&]<Axis... axes>() {
+          (FillCoords<geom, Dx<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, Dx<axes>(), k, j, i) = coords.Dx<axes>();
+               },
+               cellbounds),
+           ...);
+          (FillCoords<geom, X<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, X<axes>(), k, j, i) = coords.template Xi<axes>(k, j, i);
+               },
+               cellbounds),
+           ...);
+        }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
+      },
+      geometry);
+}
+}  // namespace kamayan::grid
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 1e2f64d..3f1d107 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -37,7 +37,8 @@ namespace kamayan::grid {
 // pkg->AddField<AreaF1>(Metadata({Metadata::None, Metadata::OneCopy}, shape));
 //
 // this could also be wrapped in a type_for
-template <strings::CompileTimeString var_name>
+template <strings::CompileTimeString var_name,
+          TopologicalElement el = TopologicalElement::CC>
 struct CoordVar : parthenon::variable_names::base_t<false> {
   template <typename... Args>
   KOKKOS_INLINE_FUNCTION CoordVar(Args &&...args)
@@ -45,6 +46,7 @@ struct CoordVar : parthenon::variable_names::base_t<false> {
 
   static std::string name() { return std::string(var_name.value); }
   static constexpr auto label = var_name;
+  static constexpr auto element = el;
 };
 
 namespace impl {
@@ -61,7 +63,12 @@ constexpr auto AxisNamer(const strings::CompileTimeString<N> base, Axis ax) {
 }
 }  // namespace impl
 
-template <strings::CompileTimeString var_name, Axis ax>
+constexpr TopologicalElement AxisToTE(const TopologicalElement el, Axis ax) {
+  return static_cast<TopologicalElement>(static_cast<int>(el) + AxisToInt(ax) - 1);
+}
+
+template <strings::CompileTimeString var_name, Axis ax,
+          TopologicalElement el = TopologicalElement::CC>
 using AxisCoord = CoordVar<impl::AxisNamer(var_name, ax)>;
 
 template <Axis ax>
@@ -74,13 +81,13 @@ template <Axis ax>
 using Xc = AxisCoord<"geom.Xc", ax>;
 
 template <Axis ax>
-using Xf = AxisCoord<"geom.Xf", ax>;
+using Xf = AxisCoord<"geom.Xf", ax, AxisToTE(TopologicalElement::F1, ax)>;
 
 template <Axis ax>
-using FaceArea = AxisCoord<"geom.FaceArea", ax>;
+using FaceArea = AxisCoord<"geom.FaceArea", ax, AxisToTE(TopologicalElement::F1, ax)>;
 
 template <Axis ax>
-using EdgeLength = AxisCoord<"geom.EdgeLength", ax>;
+using EdgeLength = AxisCoord<"geom.EdgeLength", ax, AxisToTE(TopologicalElement::E1, ax)>;
 
 using Volume = CoordVar<"geom.Volume">;
 
@@ -96,5 +103,8 @@ auto AxisTL() {
 // compiler seems really unhappy if I attempt to alias this
 using AxisCoords = decltype(AxisTL<Dx, X, Xc, Xf, FaceArea, EdgeLength>());
 using CoordFields = ConcatTypeLists_t<AxisCoords, TypeList<Volume>>;
+
+// fill meshblock with coordinate CoordFields
+void CalculateCoordinates(MeshBlock *mb);
 }  // namespace kamayan::grid
 #endif  // GRID_COORDINATES_HPP_
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 865ca98..c5cd078 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -1,8 +1,9 @@
 #ifndef GRID_GEOMETRY_HPP_
 #define GRID_GEOMETRY_HPP_
+#include <numbers>
 
 #include <format>
-#include <numbers>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -16,6 +17,8 @@
 #include "dispatcher/options.hpp"
 #include "grid/coordinates.hpp"
 #include "grid/grid_types.hpp"
+#include "mesh/domain.hpp"
+#include "parthenon/prelude.hpp"
 #include "utils/type_list.hpp"
 
 namespace kamayan {
@@ -86,6 +89,12 @@ struct Coordinates {
     return coords_.Xc<AxisToInt(ax)>(idx);
   }
 
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xi(const int k, const int j, const int i) const {
+    int kji[]{k, j, i};
+    return coords_.Xc<AxisToInt(ax)>(kji[static_cast<int>(ax)]);
+  }
+
   KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(idx); }, ax);
   }
@@ -461,16 +470,23 @@ struct CoordShapes<Geometry::cylindrical> {
 template <Geometry geom, typename T>
 requires(CoordFields::template Contains<T>())
 std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1) {
+  using TE = TopologicalElement;
   using shapes = impl::CoordShapes<geom>;
 
   if constexpr (shapes::Scalars::template Contains<T>()) {
     return {1, 1, 1};
   } else if constexpr (shapes::Icoord::template Contains<T>()) {
-    return {1, 1, nx1};
+    auto N = nx1;
+    N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
+    return {1, 1, N};
   } else if constexpr (shapes::Jcoord::template Contains<T>()) {
-    return {1, nx2, 1};
+    auto N = nx2;
+    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+    return {1, N, 1};
   } else if constexpr (shapes::Kcoord::template Contains<T>()) {
-    return {nx3, 1, 1};
+    auto N = nx3;
+    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+    return {N, 1, 1};
   }
 
   PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
@@ -478,6 +494,25 @@ std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1) {
                      .c_str());
 }
 
+template <Geometry geom, typename T>
+requires(CoordFields::template Contains<T>())
+std::tuple<parthenon::IndexRange, parthenon::IndexRange, parthenon::IndexRange>
+CoordinateIndexRanges(parthenon::IndexShape cellbounds,
+                      const IndexDomain domain = IndexDomain::entire) {
+  auto shapes = CoordinateShape<geom, T>(
+      cellbounds.ncellsk(domain), cellbounds.ncellsj(domain), cellbounds.ncellsi(domain));
+
+  auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
+    auto out = parthenon::IndexRange{bounds.s, bounds.s};
+    out.e += n - 1;
+  };
+  return {
+      make_index_range(cellbounds.ncellsk(domain), shapes[0]),
+      make_index_range(cellbounds.ncellsk(domain), shapes[1]),
+      make_index_range(cellbounds.ncellsk(domain), shapes[2]),
+  };
+}
+
 }  // namespace grid
 }  // namespace kamayan
 #endif  // GRID_GEOMETRY_HPP_
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index d1b193c..55f8a4a 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -5,6 +5,7 @@
 #include <vector>
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid_refinement.hpp"
 #include "grid/grid_types.hpp"
@@ -13,6 +14,7 @@
 #include "kamayan/runtime_parameters.hpp"
 #include "physics/hydro/hydro_types.hpp"
 #include "utils/instrument.hpp"
+#include "utils/type_list.hpp"
 
 namespace kamayan::grid {
 
@@ -20,6 +22,7 @@ std::shared_ptr<KamayanUnit> ProcessUnit() {
   auto grid_unit = std::make_shared<KamayanUnit>("grid");
   grid_unit->SetupParams.Register(SetupParams);
   grid_unit->InitializeData.Register(InitializeData);
+  grid_unit->InitMeshBlockData.Register(InitMeshBlockData);
   return grid_unit;
 }
 
@@ -140,6 +143,22 @@ void InitializeData(KamayanUnit *unit) {
     unit->AddParam("refinement_scratch", refinement_scratch);
     AddScratch(refinement_scratch, unit);
   }
+
+  // set the meshblock variables needed for coordinates
+  const auto geometry = unit->Configuration()->Get<Geometry>();
+  const auto meshblock = unit->Data("parthenon/meshblock");
+  const auto nx1 = meshblock.Get<int>("nx1");
+  const auto nx2 = meshblock.Get<int>("nx2");
+  const auto nx3 = meshblock.Get<int>("nx3");
+  GeometryOptions::dispatch(
+      [&]<Geometry geom>() {
+        type_for(CoordFields(), [&]<typename T>(const T) {
+          auto m = Metadata({Metadata::OneCopy, Metadata::None},
+                            CoordinateShape<geom, T>(nx3, nx2, nx1));
+          unit->AddField<T>(m);
+        });
+      },
+      geometry);
 }
 
 struct FluxesToDuDt_impl {
@@ -248,4 +267,6 @@ TaskID ApplyDuDt(TaskID prev, TaskList &tl, MeshData *mbase, MeshData *md0, Mesh
   return cell_update | face_update;
 }
 
+void InitMeshBlockData(MeshBlock *mb) { grid::CalculateCoordinates(mb); }
+
 }  // namespace kamayan::grid
diff --git a/src/grid/grid.hpp b/src/grid/grid.hpp
index e1f1a88..2f8cfff 100644
--- a/src/grid/grid.hpp
+++ b/src/grid/grid.hpp
@@ -20,6 +20,7 @@ std::shared_ptr<KamayanUnit> ProcessUnit();
 
 void SetupParams(KamayanUnit *unit);
 void InitializeData(KamayanUnit *unit);
+void InitMeshBlockData(MeshBlock *mb);
 
 void RegisterBoundaryConditions(parthenon::ApplicationInput *app);
 

From d849d984f9d0b4ce16af4522db09177dab939975 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 29 Mar 2026 23:17:54 -0700
Subject: [PATCH 18/55] fill in the rest

---
 src/grid/coordinates.cpp | 28 +++++++++++++++++++++++++++-
 src/grid/geometry.hpp    | 29 ++++++++++++++++++++++++++---
 2 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index 0250910..e93f5a2 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -38,7 +38,7 @@ void CalculateCoordinates(MeshBlock *mb) {
         [&]<Axis... axes>() {
           (FillCoords<geom, Dx<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, Dx<axes>(), k, j, i) = coords.Dx<axes>();
+                 pack(0, Dx<axes>(), k, j, i) = coords.template Dx<axes>();
                },
                cellbounds),
            ...);
@@ -48,6 +48,32 @@ void CalculateCoordinates(MeshBlock *mb) {
                },
                cellbounds),
            ...);
+          (FillCoords<geom, Xc<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, Xc<axes>(), k, j, i) = coords.template Xc<axes>(k, j, i);
+               },
+               cellbounds),
+           ...);
+          (FillCoords<geom, Xf<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, Xf<axes>(), k, j, i) = coords.template Xf<axes>(k, j, i);
+               },
+               cellbounds),
+           ...);
+          (FillCoords<geom, FaceArea<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, FaceArea<axes>(), k, j, i) =
+                     coords.template FaceArea<axes>(k, j, i);
+               },
+               cellbounds),
+           ...);
+          (FillCoords<geom, EdgeLength<axes>>(
+               KOKKOS_LAMBDA(const int k, const int j, const int i) {
+                 pack(0, EdgeLength<axes>(), k, j, i) =
+                     coords.template EdgeLength<axes>(k, j, i);
+               },
+               cellbounds),
+           ...);
         }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
       },
       geometry);
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index c5cd078..db58d2a 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -95,10 +95,21 @@ struct Coordinates {
     return coords_.Xc<AxisToInt(ax)>(kji[static_cast<int>(ax)]);
   }
 
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int k, const int j, const int i) const {
+    int kji[]{k, j, i};
+    return Xc<ax>(kji[static_cast<int>(ax)]);
+  }
+
   KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int idx) const {
     return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(idx); }, ax);
   }
 
+  KOKKOS_FORCEINLINE_FUNCTION Real Xc(const Axis &ax, const int k, const int j,
+                                      const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(k, j, i); }, ax);
+  }
+
   // position at face centers
   template <Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int idx) const {
@@ -109,6 +120,17 @@ struct Coordinates {
     return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(idx); }, ax);
   }
 
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
+    int kji[]{k, j, i};
+    return Xf<ax>(kji[static_cast<int>(ax)]);
+  }
+
+  KOKKOS_FORCEINLINE_FUNCTION Real Xf(const Axis &ax, const int k, const int j,
+                                      const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(k, j, i); }, ax);
+  }
+
   // coordinate ax at center of element el
   template <TopologicalElement el, Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real Xf(const int idx) const {
@@ -505,11 +527,12 @@ CoordinateIndexRanges(parthenon::IndexShape cellbounds,
   auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
     auto out = parthenon::IndexRange{bounds.s, bounds.s};
     out.e += n - 1;
+    return out;
   };
   return {
-      make_index_range(cellbounds.ncellsk(domain), shapes[0]),
-      make_index_range(cellbounds.ncellsk(domain), shapes[1]),
-      make_index_range(cellbounds.ncellsk(domain), shapes[2]),
+      make_index_range(cellbounds.GetBoundsK(domain, T::element), shapes[0]),
+      make_index_range(cellbounds.GetBoundsJ(domain, T::element), shapes[1]),
+      make_index_range(cellbounds.GetBoundsI(domain, T::element), shapes[2]),
   };
 }
 

From a40c0fba453b9012939c84a416cbbc1a8dd89cd7 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Mon, 30 Mar 2026 00:45:54 -0700
Subject: [PATCH 19/55] seems to be computing

---
 src/grid/geometry.hpp | 17 ++++++++++-------
 src/grid/grid.cpp     |  4 +++-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index db58d2a..1160695 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -1,5 +1,6 @@
 #ifndef GRID_GEOMETRY_HPP_
 #define GRID_GEOMETRY_HPP_
+#include <algorithm>
 #include <numbers>
 
 #include <format>
@@ -491,22 +492,23 @@ struct CoordShapes<Geometry::cylindrical> {
 
 template <Geometry geom, typename T>
 requires(CoordFields::template Contains<T>())
-std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1) {
+std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1,
+                                 const int nghost) {
   using TE = TopologicalElement;
   using shapes = impl::CoordShapes<geom>;
 
   if constexpr (shapes::Scalars::template Contains<T>()) {
     return {1, 1, 1};
   } else if constexpr (shapes::Icoord::template Contains<T>()) {
-    auto N = nx1;
+    auto N = nx1 + 2 * nghost;
     N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
     return {1, 1, N};
   } else if constexpr (shapes::Jcoord::template Contains<T>()) {
-    auto N = nx2;
+    auto N = nx2 + 2 * nghost;
     N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
     return {1, N, 1};
   } else if constexpr (shapes::Kcoord::template Contains<T>()) {
-    auto N = nx3;
+    auto N = nx3 + 2 * nghost;
     N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
     return {N, 1, 1};
   }
@@ -521,12 +523,13 @@ requires(CoordFields::template Contains<T>())
 std::tuple<parthenon::IndexRange, parthenon::IndexRange, parthenon::IndexRange>
 CoordinateIndexRanges(parthenon::IndexShape cellbounds,
                       const IndexDomain domain = IndexDomain::entire) {
-  auto shapes = CoordinateShape<geom, T>(
-      cellbounds.ncellsk(domain), cellbounds.ncellsj(domain), cellbounds.ncellsi(domain));
+  auto shapes =
+      CoordinateShape<geom, T>(cellbounds.ncellsk(domain), cellbounds.ncellsj(domain),
+                               cellbounds.ncellsi(domain), 0);
 
   auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
     auto out = parthenon::IndexRange{bounds.s, bounds.s};
-    out.e += n - 1;
+    out.e += std::max(n - 2, 0);
     return out;
   };
   return {
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index 55f8a4a..93056aa 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -150,11 +150,13 @@ void InitializeData(KamayanUnit *unit) {
   const auto nx1 = meshblock.Get<int>("nx1");
   const auto nx2 = meshblock.Get<int>("nx2");
   const auto nx3 = meshblock.Get<int>("nx3");
+  const auto mesh = unit->Data("parthenon/mesh");
+  const auto nghost = mesh.Get<int>("nghost");
   GeometryOptions::dispatch(
       [&]<Geometry geom>() {
         type_for(CoordFields(), [&]<typename T>(const T) {
           auto m = Metadata({Metadata::OneCopy, Metadata::None},
-                            CoordinateShape<geom, T>(nx3, nx2, nx1));
+                            CoordinateShape<geom, T>(nx3, nx2, nx1, nghost));
           unit->AddField<T>(m);
         });
       },

From 39554dddc2804c878ddae0373e4f4e4f7a1883b8 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Mon, 30 Mar 2026 23:15:28 -0700
Subject: [PATCH 20/55] building out the type

---
 src/grid/coordinates.cpp    |  28 ++--
 src/grid/coordinates.hpp    | 268 ++++++++++++++++++++++++++++++++----
 src/grid/geometry.hpp       |  95 +------------
 src/grid/geometry_types.hpp |  11 ++
 src/problems/sedov.cpp      |   3 +
 5 files changed, 271 insertions(+), 134 deletions(-)
 create mode 100644 src/grid/geometry_types.hpp

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index e93f5a2..6cc643a 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -29,47 +29,47 @@ void CalculateCoordinates(MeshBlock *mb) {
         auto pack = GetPack(CoordFields(), mb);
         auto coords = Coordinates<geom>(pack, 0);
 
-        FillCoords<geom, Volume>(
+        FillCoords<geom, coords::Volume>(
             KOKKOS_LAMBDA(const int k, const int j, const int i) {
-              pack(0, Volume(), k, j, i) = coords.CellVolume(k, j, i);
+              pack(0, coords::Volume(), k, j, i) = coords.CellVolume(k, j, i);
             },
             cellbounds);
 
         [&]<Axis... axes>() {
-          (FillCoords<geom, Dx<axes>>(
+          (FillCoords<geom, coords::Dx<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, Dx<axes>(), k, j, i) = coords.template Dx<axes>();
+                 pack(0, coords::Dx<axes>(), k, j, i) = coords.template Dx<axes>();
                },
                cellbounds),
            ...);
-          (FillCoords<geom, X<axes>>(
+          (FillCoords<geom, coords::X<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, X<axes>(), k, j, i) = coords.template Xi<axes>(k, j, i);
+                 pack(0, coords::X<axes>(), k, j, i) = coords.template Xi<axes>(k, j, i);
                },
                cellbounds),
            ...);
-          (FillCoords<geom, Xc<axes>>(
+          (FillCoords<geom, coords::Xc<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, Xc<axes>(), k, j, i) = coords.template Xc<axes>(k, j, i);
+                 pack(0, coords::Xc<axes>(), k, j, i) = coords.template Xc<axes>(k, j, i);
                },
                cellbounds),
            ...);
-          (FillCoords<geom, Xf<axes>>(
+          (FillCoords<geom, coords::Xf<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, Xf<axes>(), k, j, i) = coords.template Xf<axes>(k, j, i);
+                 pack(0, coords::Xf<axes>(), k, j, i) = coords.template Xf<axes>(k, j, i);
                },
                cellbounds),
            ...);
-          (FillCoords<geom, FaceArea<axes>>(
+          (FillCoords<geom, coords::FaceArea<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, FaceArea<axes>(), k, j, i) =
+                 pack(0, coords::FaceArea<axes>(), k, j, i) =
                      coords.template FaceArea<axes>(k, j, i);
                },
                cellbounds),
            ...);
-          (FillCoords<geom, EdgeLength<axes>>(
+          (FillCoords<geom, coords::EdgeLength<axes>>(
                KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, EdgeLength<axes>(), k, j, i) =
+                 pack(0, coords::EdgeLength<axes>(), k, j, i) =
                      coords.template EdgeLength<axes>(k, j, i);
                },
                cellbounds),
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 3f1d107..9792d2f 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -1,42 +1,25 @@
 #ifndef GRID_COORDINATES_HPP_
 #define GRID_COORDINATES_HPP_
+#include <algorithm>
+#include <array>
+#include <format>
 #include <string>
+#include <tuple>
+#include <type_traits>
 #include <utility>
+#include <vector>
 
 #include <parthenon/parthenon.hpp>
 
+#include "grid/geometry_types.hpp"
 #include "grid/grid_types.hpp"
+#include "interface/variable_state.hpp"
 #include "kamayan_utils/strings.hpp"
 #include "kamayan_utils/type_list.hpp"
+#include "kokkos_types.hpp"
 
 namespace kamayan::grid {
 
-// Idea for this is to have a variable that is stored per meshblock
-// that is associated with a topological element, but might be only allocated for a
-// particular kji dimension. For example radial face areas in cylindrical coordinates
-// these face areas on a mesh block only depend on the radial index (i) and are
-// located on the TE::F1 faces. In the case that there are no axes this is just a scalar
-//
-// using AreaF1 = CoordVar<"geom.area_f1">
-//
-// The raw parthenon way of accessing this would be to pack it, then access it
-// with the i-index
-// pack(b, AreaF1())(i);
-//
-// It is not necessarily the case that an arbitrary coordinate system would
-// index with i, it might even be the full (k,j,i), so we need some kind of helper
-// to forward that
-//
-// coords.Area<Axes::IAXIS>(pack, b, k, j, i);
-//
-// I think we define all the variables as CoordVars with just the var_name,
-// we collect them into a TypeList, and then each coordinate system becomes
-// responsible for exporting the shapes, so we can add as
-//
-// const auto shape = coords.shape<AreaF1>(nx3, nx2, nx1); // should include ghosts
-// pkg->AddField<AreaF1>(Metadata({Metadata::None, Metadata::OneCopy}, shape));
-//
-// this could also be wrapped in a type_for
 template <strings::CompileTimeString var_name,
           TopologicalElement el = TopologicalElement::CC>
 struct CoordVar : parthenon::variable_names::base_t<false> {
@@ -71,6 +54,7 @@ template <strings::CompileTimeString var_name, Axis ax,
           TopologicalElement el = TopologicalElement::CC>
 using AxisCoord = CoordVar<impl::AxisNamer(var_name, ax)>;
 
+namespace coords {
 template <Axis ax>
 using Dx = AxisCoord<"geom.Dx", ax>;
 
@@ -90,6 +74,7 @@ template <Axis ax>
 using EdgeLength = AxisCoord<"geom.EdgeLength", ax, AxisToTE(TopologicalElement::E1, ax)>;
 
 using Volume = CoordVar<"geom.Volume">;
+}  // namespace coords
 
 template <template <Axis> typename T, template <Axis> typename... Ts>
 auto AxisTL() {
@@ -101,10 +86,237 @@ auto AxisTL() {
 }
 
 // compiler seems really unhappy if I attempt to alias this
-using AxisCoords = decltype(AxisTL<Dx, X, Xc, Xf, FaceArea, EdgeLength>());
-using CoordFields = ConcatTypeLists_t<AxisCoords, TypeList<Volume>>;
+using AxisCoords = decltype(AxisTL<coords::Dx, coords::X, coords::Xc, coords::Xf,
+                                   coords::FaceArea, coords::EdgeLength>());
+using ScalarCoords = TypeList<coords::Volume>;
+using CoordFields = ConcatTypeLists_t<AxisCoords, ScalarCoords>;
+
+namespace impl {
+template <Geometry>
+struct CoordShapes {
+  using Scalars = TypeList<>;
+  using Icoord = TypeList<>;
+  using Jcoord = TypeList<>;
+  using Kcoord = TypeList<>;
+};
+
+template <>
+struct CoordShapes<Geometry::cartesian> {
+  using Scalars = ConcatTypeLists_t<
+      TypeList<coords::Volume>,
+      decltype(AxisTL<coords::Dx, coords::FaceArea, coords::EdgeLength>())>;
+  using Icoord =
+      TypeList<coords::X<Axis::IAXIS>, coords::Xc<Axis::IAXIS>, coords::Xf<Axis::IAXIS>>;
+  using Jcoord =
+      TypeList<coords::X<Axis::JAXIS>, coords::Xc<Axis::JAXIS>, coords::Xf<Axis::JAXIS>>;
+  using Kcoord =
+      TypeList<coords::X<Axis::KAXIS>, coords::Xc<Axis::KAXIS>, coords::Xf<Axis::KAXIS>>;
+};
+
+template <>
+struct CoordShapes<Geometry::cylindrical> {
+  using Scalars = decltype(AxisTL<coords::Dx>());
+  using Icoord =
+      ConcatTypeLists_t<TypeList<coords::Volume, coords::X<Axis::IAXIS>,
+                                 coords::Xc<Axis::IAXIS>, coords::Xf<Axis::IAXIS>>,
+                        decltype(AxisTL<coords::FaceArea, coords::EdgeLength>())>;
+  using Jcoord =
+      TypeList<coords::X<Axis::JAXIS>, coords::Xc<Axis::JAXIS>, coords::Xf<Axis::JAXIS>>;
+  using Kcoord =
+      TypeList<coords::X<Axis::KAXIS>, coords::Xc<Axis::KAXIS>, coords::Xf<Axis::KAXIS>>;
+};
+}  // namespace impl
+
+template <Geometry geom, typename T>
+requires(CoordFields::template Contains<T>())
+std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1,
+                                 const int nghost) {
+  using TE = TopologicalElement;
+  using shapes = impl::CoordShapes<geom>;
+
+  if constexpr (shapes::Scalars::template Contains<T>()) {
+    return {1, 1, 1};
+  } else if constexpr (shapes::Icoord::template Contains<T>()) {
+    auto N = nx1 + 2 * nghost;
+    N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
+    return {1, 1, N};
+  } else if constexpr (shapes::Jcoord::template Contains<T>()) {
+    auto N = nx2 + 2 * nghost;
+    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+    return {1, N, 1};
+  } else if constexpr (shapes::Kcoord::template Contains<T>()) {
+    auto N = nx3 + 2 * nghost;
+    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+    return {N, 1, 1};
+  }
+
+  PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
+                             T::name(), OptInfo<Geometry>::Label(geom))
+                     .c_str());
+}
+
+template <Geometry geom, typename T>
+requires(CoordFields::template Contains<T>())
+std::tuple<parthenon::IndexRange, parthenon::IndexRange, parthenon::IndexRange>
+CoordinateIndexRanges(parthenon::IndexShape cellbounds,
+                      const IndexDomain domain = IndexDomain::entire) {
+  auto shapes =
+      CoordinateShape<geom, T>(cellbounds.ncellsk(domain), cellbounds.ncellsj(domain),
+                               cellbounds.ncellsi(domain), 0);
+
+  auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
+    auto out = parthenon::IndexRange{bounds.s, bounds.s};
+    out.e += std::max(n - 2, 0);
+    return out;
+  };
+  return {
+      make_index_range(cellbounds.GetBoundsK(domain, T::element), shapes[0]),
+      make_index_range(cellbounds.GetBoundsJ(domain, T::element), shapes[1]),
+      make_index_range(cellbounds.GetBoundsI(domain, T::element), shapes[2]),
+  };
+}
 
 // fill meshblock with coordinate CoordFields
 void CalculateCoordinates(MeshBlock *mb);
+
+template <Geometry geom>
+struct CoordinatePack {
+  template <Axis ax>
+  struct AxisHelper {
+    static constexpr Axis axis = ax;
+  };
+
+  template <typename... Fields, typename... Ts>
+  KOKKOS_INLINE_FUNCTION CoordinatePack(TypeList<Fields...>,
+                                        const SparsePack<Ts...> &pack, const int b) {
+    (
+        [&]<typename Field>() {
+          Get_(Field()) = pack(b, Field());
+        }.template operator()<Fields>(),
+        ...);
+  }
+
+  template <typename... Ts>
+  KOKKOS_INLINE_FUNCTION CoordinatePack(const SparsePack<Ts...> &pack, const int b)
+      : CoordinatePack(CoordFields(), pack, b) {}
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return Dx_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return X_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return Xc_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return Xf_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return FaceArea_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real EdgeLength(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Volume(const int k, const int j, const int i) {
+    auto kji = Index_(k, j, i);
+    return Volume_(kji[0], kji[1], kji[2]);
+  }
+
+ private:
+  // par array type returned by SparsePack<>(b, V())
+  using par_array_t = parthenon::ParArray3D<Real, parthenon::VariableState>;
+
+  par_array_t Dx_[3], X_[3], Xc_[3], Xf_[3], FaceArea_[3], EdgeLength_[3], Volume_;
+
+  template <typename T>
+  requires(CoordFields::Contains<T>())
+  KOKKOS_INLINE_FUNCTION std::array<int, 3> Index_(const int k, const int j,
+                                                   const int i) {
+    using shapes = impl::CoordShapes<geom>;
+    if constexpr (shapes::Scalars::template Contains<T>()) {
+      return {0, 0, 0};
+    } else if constexpr (shapes::Icoord::template Contains<T>()) {
+      return {0, 0, i};
+    } else if constexpr (shapes::Jcoord::template Contains<T>()) {
+      return {0, j, 0};
+    } else if constexpr (shapes::Kcoord::template Contains<T>()) {
+      return {k, 0, 0};
+    }
+  }
+
+  template <typename T>
+  requires(AxisCoords::Contains<T>())
+  KOKKOS_INLINE_FUNCTION par_array_t &Get_(const T &t) {
+    if constexpr (std::is_same_v<T, coords::Dx<Axis::KAXIS>>) {
+      return Dx_[0];
+    } else if constexpr (std::is_same_v<T, coords::Dx<Axis::JAXIS>>) {
+      return Dx_[1];
+    } else if constexpr (std::is_same_v<T, coords::Dx<Axis::IAXIS>>) {
+      return Dx_[2];
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::KAXIS>>) {
+      return X_[0];
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::JAXIS>>) {
+      return X_[1];
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::IAXIS>>) {
+      return X_[2];
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::KAXIS>>) {
+      return Xc_[0];
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::JAXIS>>) {
+      return Xc_[1];
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::IAXIS>>) {
+      return Xc_[2];
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::KAXIS>>) {
+      return Xf_[0];
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::JAXIS>>) {
+      return Xf_[1];
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::IAXIS>>) {
+      return Xf_[2];
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::KAXIS>>) {
+      return FaceArea_[0];
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::JAXIS>>) {
+      return FaceArea_[1];
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::IAXIS>>) {
+      return FaceArea_[2];
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::KAXIS>>) {
+      return EdgeLength_[0];
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::JAXIS>>) {
+      return EdgeLength_[1];
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::IAXIS>>) {
+      return EdgeLength_[2];
+    } else {
+      static_assert(false, "Type not mapped to a coordinate");
+    }
+  }
+
+  template <typename T>
+  requires(ScalarCoords::Contains<T>())
+  KOKKOS_INLINE_FUNCTION par_array_t &Get_(const T &t) {
+    if constexpr (std::is_same_v<T, coords::Volume>) {
+      return Volume_;
+    } else {
+      static_assert(false, "Type not mapped to a coordinate");
+    }
+  }
+};
+
 }  // namespace kamayan::grid
 #endif  // GRID_COORDINATES_HPP_
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 1160695..86322ca 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -1,12 +1,7 @@
 #ifndef GRID_GEOMETRY_HPP_
 #define GRID_GEOMETRY_HPP_
-#include <algorithm>
 #include <numbers>
-
-#include <format>
-#include <tuple>
 #include <utility>
-#include <vector>
 
 #include <Kokkos_Macros.hpp>
 
@@ -14,20 +9,11 @@
 #include <pack/sparse_pack.hpp>
 #include <ports-of-call/variant.hpp>
 
-#include "dispatcher/option_types.hpp"
 #include "dispatcher/options.hpp"
-#include "grid/coordinates.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid_types.hpp"
-#include "mesh/domain.hpp"
-#include "parthenon/prelude.hpp"
-#include "utils/type_list.hpp"
-
-namespace kamayan {
-POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
 
-namespace grid {
-
-using GeometryOptions = OptList<Geometry, Geometry::cartesian, Geometry::cylindrical>;
+namespace kamayan::grid {
 
 // This is a (incomplete) wrapper around parthenon's uniform_coordinate (cartesian)
 // to calculate coordinate related items in a different geometry.
@@ -465,80 +451,5 @@ struct GenericCoordinate {
   CoordinatesVariant coords_;
 };
 
-// the following could probably all be in an implementation file geometry.cpp
-namespace impl {
-template <Geometry>
-struct CoordShapes {};
-
-template <>
-struct CoordShapes<Geometry::cartesian> {
-  using Scalars =
-      ConcatTypeLists_t<TypeList<Volume>, decltype(AxisTL<Dx, FaceArea, EdgeLength>())>;
-  using Icoord = TypeList<X<Axis::IAXIS>, Xc<Axis::IAXIS>, Xf<Axis::IAXIS>>;
-  using Jcoord = TypeList<X<Axis::JAXIS>, Xc<Axis::JAXIS>, Xf<Axis::JAXIS>>;
-  using Kcoord = TypeList<X<Axis::KAXIS>, Xc<Axis::KAXIS>, Xf<Axis::KAXIS>>;
-};
-
-template <>
-struct CoordShapes<Geometry::cylindrical> {
-  using Scalars = decltype(AxisTL<Dx>());
-  using Icoord = ConcatTypeLists_t<
-      TypeList<Volume, X<Axis::IAXIS>, Xc<Axis::IAXIS>, Xf<Axis::IAXIS>>,
-      decltype(AxisTL<FaceArea, EdgeLength>())>;
-  using Jcoord = TypeList<X<Axis::JAXIS>, Xc<Axis::JAXIS>, Xf<Axis::JAXIS>>;
-  using Kcoord = TypeList<X<Axis::KAXIS>, Xc<Axis::KAXIS>, Xf<Axis::KAXIS>>;
-};
-}  // namespace impl
-
-template <Geometry geom, typename T>
-requires(CoordFields::template Contains<T>())
-std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1,
-                                 const int nghost) {
-  using TE = TopologicalElement;
-  using shapes = impl::CoordShapes<geom>;
-
-  if constexpr (shapes::Scalars::template Contains<T>()) {
-    return {1, 1, 1};
-  } else if constexpr (shapes::Icoord::template Contains<T>()) {
-    auto N = nx1 + 2 * nghost;
-    N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
-    return {1, 1, N};
-  } else if constexpr (shapes::Jcoord::template Contains<T>()) {
-    auto N = nx2 + 2 * nghost;
-    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
-    return {1, N, 1};
-  } else if constexpr (shapes::Kcoord::template Contains<T>()) {
-    auto N = nx3 + 2 * nghost;
-    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
-    return {N, 1, 1};
-  }
-
-  PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
-                             T::name(), OptInfo<Geometry>::Label(geom))
-                     .c_str());
-}
-
-template <Geometry geom, typename T>
-requires(CoordFields::template Contains<T>())
-std::tuple<parthenon::IndexRange, parthenon::IndexRange, parthenon::IndexRange>
-CoordinateIndexRanges(parthenon::IndexShape cellbounds,
-                      const IndexDomain domain = IndexDomain::entire) {
-  auto shapes =
-      CoordinateShape<geom, T>(cellbounds.ncellsk(domain), cellbounds.ncellsj(domain),
-                               cellbounds.ncellsi(domain), 0);
-
-  auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
-    auto out = parthenon::IndexRange{bounds.s, bounds.s};
-    out.e += std::max(n - 2, 0);
-    return out;
-  };
-  return {
-      make_index_range(cellbounds.GetBoundsK(domain, T::element), shapes[0]),
-      make_index_range(cellbounds.GetBoundsJ(domain, T::element), shapes[1]),
-      make_index_range(cellbounds.GetBoundsI(domain, T::element), shapes[2]),
-  };
-}
-
-}  // namespace grid
-}  // namespace kamayan
+}  // namespace kamayan::grid
 #endif  // GRID_GEOMETRY_HPP_
diff --git a/src/grid/geometry_types.hpp b/src/grid/geometry_types.hpp
new file mode 100644
index 0000000..1f63f2d
--- /dev/null
+++ b/src/grid/geometry_types.hpp
@@ -0,0 +1,11 @@
+#ifndef GRID_GEOMETRY_TYPES_HPP_
+#define GRID_GEOMETRY_TYPES_HPP_
+#include "dispatcher/options.hpp"
+namespace kamayan {
+POLYMORPHIC_PARM(Geometry, cartesian, cylindrical);
+
+namespace grid {
+using GeometryOptions = OptList<Geometry, Geometry::cartesian, Geometry::cylindrical>;
+}
+}  // namespace kamayan
+#endif  // GRID_GEOMETRY_TYPES_HPP_
diff --git a/src/problems/sedov.cpp b/src/problems/sedov.cpp
index 6fa7a16..31b2368 100644
--- a/src/problems/sedov.cpp
+++ b/src/problems/sedov.cpp
@@ -6,6 +6,7 @@
 #include "Kokkos_Macros.hpp"
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
@@ -122,12 +123,14 @@ void ProblemGenerator(MeshBlock *mb) {
 
   // get our pack
   auto pack = grid::GetPack<DENS, VELOCITY, PRES, material::MFRAC>(mb);
+  auto c_pack = grid::GetPack(grid::CoordFields(), mb);
   par_for(
       PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int k, const int j, const int i) {
         const Real r2 = coords.Xc<Axis::IAXIS>(i) * coords.Xc<Axis::IAXIS>(i) +
                         coords.Xc<Axis::JAXIS>(j) * coords.Xc<Axis::JAXIS>(j);
         const auto r = Kokkos::sqrt(r2);
+        auto cpack = grid::CoordinatePack<Geometry::cartesian>(c_pack, 0);
         auto state = sedov_data.State(r);
         type_for(SedovData::variables(), [&]<typename Vars>(const Vars &) {
           for (int comp = 0; comp < Vars::n_comps; comp++) {

From e627f4d74624b679b222414e9553df0bd597a7d4 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 00:01:13 -0700
Subject: [PATCH 21/55] fill out the methods

---
 src/grid/coordinates.hpp | 67 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 1 deletion(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 9792d2f..8d31f55 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -236,17 +236,82 @@ struct CoordinatePack {
     return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
-  KOKKOS_INLINE_FUNCTION Real Volume(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) {
     auto kji = Index_(k, j, i);
     return Volume_(kji[0], kji[1], kji[2]);
   }
 
+  KOKKOS_INLINE_FUNCTION Real Dx(const Axis ax, const int k, const int j, const int i) {
+    return AxisOverload([&]<Axis AX>() { return Dx<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real X(const Axis ax, const int k, const int j, const int i) {
+    return AxisOverload([&]<Axis AX>() { return X<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Xc(const Axis ax, const int k, const int j, const int i) {
+    return AxisOverload([&]<Axis AX>() { return Xc<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Xf(const Axis ax, const int k, const int j, const int i) {
+    return AxisOverload([&]<Axis AX>() { return Xf<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real FaceArea(const Axis ax, const int k, const int j,
+                                       const int i) {
+    return AxisOverload([&]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real EdgeLength(const Axis ax, const int k, const int j,
+                                         const int i) {
+    return AxisOverload([&]<Axis AX>() { return EdgeLength<AX>(k, j, i); }, ax);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Volume(const TopologicalElement el, const int k,
+                                     const int j, const int i) const {
+    using TE = TopologicalElement;
+    if (el == TE::CC)
+      return CellVolume(k, j, i);
+    else if (el == TE::F1)
+      return FaceArea(Axis::IAXIS, k, j, i);
+    else if (el == TE::F2)
+      return FaceArea(Axis::JAXIS, k, j, i);
+    else if (el == TE::F3)
+      return FaceArea(Axis::KAXIS, k, j, i);
+    else if (el == TE::E1)
+      return EdgeLength(Axis::IAXIS, k, j, i);
+    else if (el == TE::E2)
+      return EdgeLength(Axis::JAXIS, k, j, i);
+    else if (el == TE::E3)
+      return EdgeLength(Axis::KAXIS, k, j, i);
+    else if (el == TE::NN)
+      return 1.0;
+    PARTHENON_FAIL("If you reach this point, someone has added a new value to the the "
+                   "TopologicalElement enum.");
+    return 0.0;
+  }
+
  private:
   // par array type returned by SparsePack<>(b, V())
   using par_array_t = parthenon::ParArray3D<Real, parthenon::VariableState>;
 
   par_array_t Dx_[3], X_[3], Xc_[3], Xf_[3], FaceArea_[3], EdgeLength_[3], Volume_;
 
+  template <typename Func, typename... Args>
+  KOKKOS_FORCEINLINE_FUNCTION Real AxisOverload(Func function, Axis ax,
+                                                Args &&...args) const {
+    if (ax == Axis::IAXIS) {
+      return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
+    } else if (ax == Axis::JAXIS) {
+      return function.template operator()<Axis::JAXIS>(std::forward<Args>(args)...);
+    } else if (ax == Axis::KAXIS) {
+      return function.template operator()<Axis::KAXIS>(std::forward<Args>(args)...);
+    }
+
+    PARTHENON_FAIL("Axis should only be one of [IJK]AXIS");
+    return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
+  }
+
   template <typename T>
   requires(CoordFields::Contains<T>())
   KOKKOS_INLINE_FUNCTION std::array<int, 3> Index_(const int k, const int j,

From 9b54e132a254920b1ec38a0333271391cd9aa01e Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 00:37:45 -0700
Subject: [PATCH 22/55] fix unit tests

---
 src/grid/tests/test_grid.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/grid/tests/test_grid.cpp b/src/grid/tests/test_grid.cpp
index 4ff2274..d23a05b 100644
--- a/src/grid/tests/test_grid.cpp
+++ b/src/grid/tests/test_grid.cpp
@@ -7,11 +7,14 @@
 #include <mesh/meshblock.hpp>
 
 #include "basic_types.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/scratch_variables.hpp"
 #include "grid/subpack.hpp"
+#include "kamayan/config.hpp"
 #include "kamayan/fields.hpp"
+#include "kamayan/runtime_parameters.hpp"
 #include "kamayan/unit.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kokkos_abstraction.hpp"
@@ -47,6 +50,13 @@ TEST(grid, PackIndexer) {
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 9;
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
+
+  // need to add a config to the unit for AddFields
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
   AddFields(Fields(), pkg.get(), {CENTER_FLAGS(Metadata::WithFluxes)});
 
   // now build our test grid

From 22f5cf8aee770b768653cc27c125d1d84066e3c0 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 00:37:51 -0700
Subject: [PATCH 23/55] generic coord pack

---
 src/grid/coordinates.cpp     |   8 ++
 src/grid/coordinates.hpp     | 172 ++++++++++++++++++++++++++++-------
 src/grid/tests/test_grid.cpp |   1 -
 3 files changed, 148 insertions(+), 33 deletions(-)

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index 6cc643a..6f0eac7 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -78,4 +78,12 @@ void CalculateCoordinates(MeshBlock *mb) {
       },
       geometry);
 }
+
+template <typename... Ts>
+GenericCoordinatePack::GenericCoordinatePack(const Geometry geometry,
+                                             const parthenon::SparsePack<Ts...> &pack,
+                                             const int b) {
+  GeometryOptions::dispatch(
+      [&]<Geometry geom>() { coords_ = CoordinatePack<geom>(pack, b); }, geometry);
+}
 }  // namespace kamayan::grid
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 8d31f55..045a18a 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -11,6 +11,8 @@
 
 #include <parthenon/parthenon.hpp>
 
+#include <ports-of-call/variant.hpp>
+
 #include "grid/geometry_types.hpp"
 #include "grid/grid_types.hpp"
 #include "interface/variable_state.hpp"
@@ -201,70 +203,74 @@ struct CoordinatePack {
       : CoordinatePack(CoordFields(), pack, b) {}
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return Dx_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return X_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return Xc_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return Xf_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return FaceArea_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
-  KOKKOS_INLINE_FUNCTION Real EdgeLength(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real EdgeLength(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
-  KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) {
+  KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) const {
     auto kji = Index_(k, j, i);
     return Volume_(kji[0], kji[1], kji[2]);
   }
 
-  KOKKOS_INLINE_FUNCTION Real Dx(const Axis ax, const int k, const int j, const int i) {
-    return AxisOverload([&]<Axis AX>() { return Dx<AX>(k, j, i); }, ax);
+  KOKKOS_INLINE_FUNCTION Real Dx(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return Dx<AX>(k, j, i); }, ax);
   }
 
-  KOKKOS_INLINE_FUNCTION Real X(const Axis ax, const int k, const int j, const int i) {
-    return AxisOverload([&]<Axis AX>() { return X<AX>(k, j, i); }, ax);
+  KOKKOS_INLINE_FUNCTION Real X(const Axis ax, const int k, const int j,
+                                const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return X<AX>(k, j, i); }, ax);
   }
 
-  KOKKOS_INLINE_FUNCTION Real Xc(const Axis ax, const int k, const int j, const int i) {
-    return AxisOverload([&]<Axis AX>() { return Xc<AX>(k, j, i); }, ax);
+  KOKKOS_INLINE_FUNCTION Real Xc(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(k, j, i); }, ax);
   }
 
-  KOKKOS_INLINE_FUNCTION Real Xf(const Axis ax, const int k, const int j, const int i) {
-    return AxisOverload([&]<Axis AX>() { return Xf<AX>(k, j, i); }, ax);
+  KOKKOS_INLINE_FUNCTION Real Xf(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real FaceArea(const Axis ax, const int k, const int j,
-                                       const int i) {
-    return AxisOverload([&]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
+                                       const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real EdgeLength(const Axis ax, const int k, const int j,
-                                         const int i) {
-    return AxisOverload([&]<Axis AX>() { return EdgeLength<AX>(k, j, i); }, ax);
+                                         const int i) const {
+    return AxisOverload([&, this]<Axis AX>() { return EdgeLength<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real Volume(const TopologicalElement el, const int k,
@@ -312,20 +318,9 @@ struct CoordinatePack {
     return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
   }
 
-  template <typename T>
-  requires(CoordFields::Contains<T>())
   KOKKOS_INLINE_FUNCTION std::array<int, 3> Index_(const int k, const int j,
-                                                   const int i) {
-    using shapes = impl::CoordShapes<geom>;
-    if constexpr (shapes::Scalars::template Contains<T>()) {
-      return {0, 0, 0};
-    } else if constexpr (shapes::Icoord::template Contains<T>()) {
-      return {0, 0, i};
-    } else if constexpr (shapes::Jcoord::template Contains<T>()) {
-      return {0, j, 0};
-    } else if constexpr (shapes::Kcoord::template Contains<T>()) {
-      return {k, 0, 0};
-    }
+                                                   const int i) const {
+    return {k, j, i};
   }
 
   template <typename T>
@@ -383,5 +378,118 @@ struct CoordinatePack {
   }
 };
 
+namespace impl {
+template <typename>
+struct CoordinatePackVariant {};
+
+template <Geometry geom, Geometry... geoms>
+struct CoordinatePackVariant<OptList<Geometry, geom, geoms...>> {
+  using type = PortsOfCall::variant<CoordinatePack<geom>, CoordinatePack<geoms>...>;
+};
+}  // namespace impl
+
+using CoordinatePackVariant = impl::CoordinatePackVariant<GeometryOptions>::type;
+
+struct GenericCoordinatePack {
+  template <typename... Ts>
+  GenericCoordinatePack(const Geometry geometry, const parthenon::SparsePack<Ts...> &pack,
+                        const int b);
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template Dx<ax>(k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template X<ax>(k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template Xc<ax>(k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template Xf<ax>(k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template FaceArea<ax>(k, j, i); },
+        coords_);
+  }
+
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real EdgeLength(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.template EdgeLength<ax>(k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Dx(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.Dx(ax, k, j, i); }, coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real X(const Axis ax, const int k, const int j,
+                                const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.X(ax, k, j, i); }, coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Xc(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.Xc(ax, k, j, i); }, coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Xf(const Axis ax, const int k, const int j,
+                                 const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.Xf(ax, k, j, i); }, coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real FaceArea(const Axis ax, const int k, const int j,
+                                       const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.FaceArea(ax, k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real EdgeLength(const Axis ax, const int k, const int j,
+                                         const int i) const {
+    return PortsOfCall::visit(
+        [ax, k, j, i](const auto &coords) { return coords.EdgeLength(ax, k, j, i); },
+        coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) const {
+    return PortsOfCall::visit(
+        [k, j, i](const auto &coords) { return coords.CellVolume(k, j, i); }, coords_);
+  }
+
+  KOKKOS_INLINE_FUNCTION Real Volume(const TopologicalElement el, const int k,
+                                     const int j, const int i) const {
+    return PortsOfCall::visit(
+        [el, k, j, i](const auto &coords) { return coords.Volume(el, k, j, i); },
+        coords_);
+  }
+
+ private:
+  CoordinatePackVariant coords_;
+};
+
 }  // namespace kamayan::grid
 #endif  // GRID_COORDINATES_HPP_
diff --git a/src/grid/tests/test_grid.cpp b/src/grid/tests/test_grid.cpp
index d23a05b..3ad8020 100644
--- a/src/grid/tests/test_grid.cpp
+++ b/src/grid/tests/test_grid.cpp
@@ -18,7 +18,6 @@
 #include "kamayan/unit.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kokkos_abstraction.hpp"
-#include "physics/hydro/hydro_types.hpp"
 #include "utils/instrument.hpp"
 
 using parthenon::BlockList_t;

From 106b82afeb974e38fa5d20fa08c3a5a862711f5d Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 21:26:44 -0700
Subject: [PATCH 24/55] better guarding

---
 src/grid/coordinates.cpp        |   7 --
 src/grid/coordinates.hpp        | 111 ++++++++++++++++++++++++++++----
 src/grid/grid.hpp               |   5 ++
 src/kamayan_utils/type_list.hpp |   5 ++
 src/problems/sedov.cpp          |  11 ++--
 5 files changed, 112 insertions(+), 27 deletions(-)

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index 6f0eac7..68c427e 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -79,11 +79,4 @@ void CalculateCoordinates(MeshBlock *mb) {
       geometry);
 }
 
-template <typename... Ts>
-GenericCoordinatePack::GenericCoordinatePack(const Geometry geometry,
-                                             const parthenon::SparsePack<Ts...> &pack,
-                                             const int b) {
-  GeometryOptions::dispatch(
-      [&]<Geometry geom>() { coords_ = CoordinatePack<geom>(pack, b); }, geometry);
-}
 }  // namespace kamayan::grid
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 045a18a..42afc60 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -93,6 +93,15 @@ using AxisCoords = decltype(AxisTL<coords::Dx, coords::X, coords::Xc, coords::Xf
 using ScalarCoords = TypeList<coords::Volume>;
 using CoordFields = ConcatTypeLists_t<AxisCoords, ScalarCoords>;
 
+// some common combinations
+template <template <Axis> typename Coord>
+using AllAxes = TypeList<Coord<Axis::IAXIS>, Coord<Axis::JAXIS>, Coord<Axis::KAXIS>>;
+
+using Xcenter = AllAxes<coords::X>;
+using Xcoord = AllAxes<coords::Xc>;
+using Xface = AllAxes<coords::Xf>;
+using FaceAreas = AllAxes<coords::FaceArea>;
+
 namespace impl {
 template <Geometry>
 struct CoordShapes {
@@ -181,16 +190,13 @@ CoordinateIndexRanges(parthenon::IndexShape cellbounds,
 // fill meshblock with coordinate CoordFields
 void CalculateCoordinates(MeshBlock *mb);
 
-template <Geometry geom>
+template <Geometry geom, typename... Fields>
 struct CoordinatePack {
-  template <Axis ax>
-  struct AxisHelper {
-    static constexpr Axis axis = ax;
-  };
-
-  template <typename... Fields, typename... Ts>
-  KOKKOS_INLINE_FUNCTION CoordinatePack(TypeList<Fields...>,
-                                        const SparsePack<Ts...> &pack, const int b) {
+  using FieldList = TypeList<Fields...>;
+  template <typename... Ts>
+  KOKKOS_INLINE_FUNCTION CoordinatePack(const SparsePack<Ts...> &pack, const int b) {
+    static_assert((TypeList<Ts...>::template Contains<Fields>() && ...),
+                  "Pack must contain all requested coordinate fields.");
     (
         [&]<typename Field>() {
           Get_(Field()) = pack(b, Field());
@@ -198,83 +204,133 @@ struct CoordinatePack {
         ...);
   }
 
-  template <typename... Ts>
-  KOKKOS_INLINE_FUNCTION CoordinatePack(const SparsePack<Ts...> &pack, const int b)
-      : CoordinatePack(CoordFields(), pack, b) {}
-
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::Dx<ax>>(),
+                  "Coordinate Pack must be constructed with required Dx coordinate");
     auto kji = Index_(k, j, i);
     return Dx_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::X<ax>>(),
+                  "Coordinate Pack must be constructed with required X coordinate");
     auto kji = Index_(k, j, i);
     return X_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::Xc<ax>>(),
+                  "Coordinate Pack must be constructed with required Xc coordinate");
     auto kji = Index_(k, j, i);
     return Xc_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::Xf<ax>>(),
+                  "Coordinate Pack must be constructed with required Xf coordinate");
     auto kji = Index_(k, j, i);
     return Xf_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real FaceArea(const int k, const int j, const int i) const {
+    static_assert(
+        FieldList::template Contains<coords::FaceArea<ax>>(),
+        "Coordinate Pack must be constructed with required FaceArea coordinate");
     auto kji = Index_(k, j, i);
     return FaceArea_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real EdgeLength(const int k, const int j, const int i) const {
+    static_assert(
+        FieldList::template Contains<coords::EdgeLength<ax>>(),
+        "Coordinate Pack must be constructed with required EdgeLength coordinate");
     auto kji = Index_(k, j, i);
     return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::Volume>(),
+                  "Coordinate Pack must be constructed with required Volume");
     auto kji = Index_(k, j, i);
     return Volume_(kji[0], kji[1], kji[2]);
   }
 
   KOKKOS_INLINE_FUNCTION Real Dx(const Axis ax, const int k, const int j,
                                  const int i) const {
+    static_assert(
+        FieldList::Contains(TypeList<coords::Dx<Axis::KAXIS>, coords::Dx<Axis::JAXIS>,
+                                     coords::Dx<Axis::IAXIS>>()),
+        "Dx requires all 3 Dx<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return Dx<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real X(const Axis ax, const int k, const int j,
                                 const int i) const {
+    static_assert(
+        FieldList::Contains(TypeList<coords::X<Axis::KAXIS>, coords::X<Axis::JAXIS>,
+                                     coords::X<Axis::IAXIS>>()),
+        "X requires all 3 X<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return X<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real Xc(const Axis ax, const int k, const int j,
                                  const int i) const {
+    static_assert(
+        FieldList::Contains(TypeList<coords::Xc<Axis::KAXIS>, coords::Xc<Axis::JAXIS>,
+                                     coords::Xc<Axis::IAXIS>>()),
+        "Xc requires all 3 Xc<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return Xc<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real Xf(const Axis ax, const int k, const int j,
                                  const int i) const {
+    static_assert(
+        FieldList::Contains(TypeList<coords::Xf<Axis::KAXIS>, coords::Xf<Axis::JAXIS>,
+                                     coords::Xf<Axis::IAXIS>>()),
+        "Xf requires all 3 Xf<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return Xf<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real FaceArea(const Axis ax, const int k, const int j,
                                        const int i) const {
+    static_assert(
+        FieldList::Contains(
+            TypeList<coords::FaceArea<Axis::KAXIS>, coords::FaceArea<Axis::JAXIS>,
+                     coords::FaceArea<Axis::IAXIS>>()),
+        "FaceArea requires all 3 FaceArea<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return FaceArea<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real EdgeLength(const Axis ax, const int k, const int j,
                                          const int i) const {
+    static_assert(
+        FieldList::Contains(
+            TypeList<coords::EdgeLength<Axis::KAXIS>, coords::EdgeLength<Axis::JAXIS>,
+                     coords::EdgeLength<Axis::IAXIS>>()),
+        "EdgeLength requires all 3 EdgeLength<axes> to be packed");
     return AxisOverload([&, this]<Axis AX>() { return EdgeLength<AX>(k, j, i); }, ax);
   }
 
   KOKKOS_INLINE_FUNCTION Real Volume(const TopologicalElement el, const int k,
                                      const int j, const int i) const {
+    static_assert(FieldList::template Contains<coords::Volume>(),
+                  "Volume requires Volume to be packed.");
+    static_assert(
+        FieldList::Contains(
+            TypeList<coords::FaceArea<Axis::KAXIS>, coords::FaceArea<Axis::JAXIS>,
+                     coords::FaceArea<Axis::IAXIS>>()),
+        "Volume requires all 3 FaceArea<axes> to be packed");
+    static_assert(
+        FieldList::Contains(
+            TypeList<coords::EdgeLength<Axis::KAXIS>, coords::EdgeLength<Axis::JAXIS>,
+                     coords::EdgeLength<Axis::IAXIS>>()),
+        "Volume requires all 3 EdgeLength<axes> to be packed");
     using TE = TopologicalElement;
     if (el == TE::CC)
       return CellVolume(k, j, i);
@@ -378,6 +434,20 @@ struct CoordinatePack {
   }
 };
 
+template <Geometry geom, typename... Fields>
+struct CoordinatePack<geom, TypeList<Fields...>> : CoordinatePack<geom, Fields...> {
+  template <typename Pack>
+  KOKKOS_INLINE_FUNCTION CoordinatePack(const Pack &pack, const int b)
+      : CoordinatePack<geom, Fields...>(pack, b) {}
+};
+
+template <Geometry geom>
+struct CoordinatePack<geom> : CoordinatePack<geom, CoordFields> {
+  template <typename Pack>
+  KOKKOS_INLINE_FUNCTION CoordinatePack(const Pack &pack, const int b)
+      : CoordinatePack<geom, CoordFields>(pack, b) {}
+};
+
 namespace impl {
 template <typename>
 struct CoordinatePackVariant {};
@@ -391,9 +461,22 @@ struct CoordinatePackVariant<OptList<Geometry, geom, geoms...>> {
 using CoordinatePackVariant = impl::CoordinatePackVariant<GeometryOptions>::type;
 
 struct GenericCoordinatePack {
+  template <typename... Cs, typename... Ts>
+  GenericCoordinatePack(TypeList<Cs...>, const Geometry geometry,
+                        const parthenon::SparsePack<Ts...> &pack, const int b) {
+    GeometryOptions::dispatch(
+        [&]<Geometry geom>() {
+          coords_ = CoordinatePack<geom>(TypeList<Cs...>(), pack, b);
+        },
+        geometry);
+  }
+
   template <typename... Ts>
   GenericCoordinatePack(const Geometry geometry, const parthenon::SparsePack<Ts...> &pack,
-                        const int b);
+                        const int b) {
+    GeometryOptions::dispatch(
+        [&]<Geometry geom>() { coords_ = CoordinatePack<geom>(pack, b); }, geometry);
+  }
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
diff --git a/src/grid/grid.hpp b/src/grid/grid.hpp
index 2f8cfff..c8cdd28 100644
--- a/src/grid/grid.hpp
+++ b/src/grid/grid.hpp
@@ -95,6 +95,11 @@ auto GetPack(TypeList<Ts...>, MeshData *md, std::set<PDOpt> pack_opts = {}) {
   return impl::GetPack(TypeList<Ts...>(), md, pack_opts);
 }
 
+template <typename... Ts, typename... Vs, typename... Args>
+auto GetPack(TypeList<Ts...>, TypeList<Vs...>, Args &&...args) {
+  return GetPack(TypeList<Ts..., Vs...>(), std::forward<Args>(args)...);
+}
+
 TaskStatus FluxesToDuDt(MeshData *md, MeshData *dudt);
 TaskID ApplyDuDt(TaskID prev, TaskList &tl, MeshData *mbase, MeshData *md0, MeshData *md1,
                  MeshData *dudt_data, const Real &beta, const Real &dt);
diff --git a/src/kamayan_utils/type_list.hpp b/src/kamayan_utils/type_list.hpp
index 06d19c8..6bf3c72 100644
--- a/src/kamayan_utils/type_list.hpp
+++ b/src/kamayan_utils/type_list.hpp
@@ -62,6 +62,11 @@ struct TypeList {
     }
   }
 
+  template <typename... Vs>
+  KOKKOS_INLINE_FUNCTION static constexpr bool Contains(TypeList<Vs...>) {
+    return (Contains<Vs>() && ...);
+  }
+
   // this is useful when you have a parameter pack of arguments that corresponds to the
   // types in a TypeList and you want to pluck out the argument that corresponds to a
   // specific type
diff --git a/src/problems/sedov.cpp b/src/problems/sedov.cpp
index 31b2368..decb367 100644
--- a/src/problems/sedov.cpp
+++ b/src/problems/sedov.cpp
@@ -121,16 +121,15 @@ void ProblemGenerator(MeshBlock *mb) {
     }
   }
 
-  // get our pack
-  auto pack = grid::GetPack<DENS, VELOCITY, PRES, material::MFRAC>(mb);
-  auto c_pack = grid::GetPack(grid::CoordFields(), mb);
+  auto pack = grid::GetPack(TypeList<DENS, VELOCITY, PRES, material::MFRAC>(),
+                            grid::Xcoord(), mb);
   par_for(
       PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        const Real r2 = coords.Xc<Axis::IAXIS>(i) * coords.Xc<Axis::IAXIS>(i) +
-                        coords.Xc<Axis::JAXIS>(j) * coords.Xc<Axis::JAXIS>(j);
+        auto cpack = grid::CoordinatePack<Geometry::cartesian, grid::Xcoord>(pack, 0);
+        const Real r2 = cpack.Xc<Axis::IAXIS>(k, j, i) * cpack.Xc<Axis::IAXIS>(k, j, i) +
+                        cpack.Xc<Axis::JAXIS>(k, j, i) * cpack.Xc<Axis::JAXIS>(k, j, i);
         const auto r = Kokkos::sqrt(r2);
-        auto cpack = grid::CoordinatePack<Geometry::cartesian>(c_pack, 0);
         auto state = sedov_data.State(r);
         type_for(SedovData::variables(), [&]<typename Vars>(const Vars &) {
           for (int comp = 0; comp < Vars::n_comps; comp++) {

From 03a0973ad53f5badcc575133c24f5a9556b188b0 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 21:45:36 -0700
Subject: [PATCH 25/55] unit test geometry

---
 src/CMakeLists.txt               |   1 +
 src/grid/tests/test_geometry.cpp | 458 +++++++++++++++++++++++++++++++
 src/grid/tests/test_geometry.hpp |  14 +
 3 files changed, 473 insertions(+)
 create mode 100644 src/grid/tests/test_geometry.cpp
 create mode 100644 src/grid/tests/test_geometry.hpp

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 56f59f2..3c65b41 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -30,6 +30,7 @@ set(_pybind_sources
 # maybe I should just glob for tests...
 set(_test_sources
     grid/tests/test_grid.cpp
+    grid/tests/test_geometry.cpp
     kamayan_utils/tests/test_strings.cpp
     kamayan_utils/tests/test_type_list.cpp
     kamayan_utils/tests/test_type_list_array.cpp
diff --git a/src/grid/tests/test_geometry.cpp b/src/grid/tests/test_geometry.cpp
new file mode 100644
index 0000000..d553ec4
--- /dev/null
+++ b/src/grid/tests/test_geometry.cpp
@@ -0,0 +1,458 @@
+#include "test_geometry.hpp"
+
+#include <cmath>
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include <mesh/meshblock.hpp>
+
+#include "grid/geometry.hpp"
+#include "grid/geometry_types.hpp"
+#include "kamayan/config.hpp"
+#include "kamayan/unit.hpp"
+
+namespace kamayan {
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  auto pmb = std::make_shared<parthenon::MeshBlock>(8, 3);
+  auto &pmbd = pmb->meshblock_data.Get();
+  pmbd->Initialize(pkg, pmb);
+  return pmb;
+}
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cylindrical);
+  pkg->InitResources(rps, cfg);
+
+  auto pmb = std::make_shared<parthenon::MeshBlock>(8, 2);
+  auto &pmbd = pmb->meshblock_data.Get();
+  pmbd->Initialize(pkg, pmb);
+  return pmb;
+}
+
+namespace {
+
+constexpr Real REL_TOL = 1e-12;
+constexpr Real ABS_TOL = 1e-14;
+
+bool IsRelClose(Real a, Real b) {
+  if (std::abs(b) < ABS_TOL) {
+    return std::abs(a - b) < ABS_TOL;
+  }
+  return std::abs((a - b) / b) < REL_TOL;
+}
+
+}  // namespace
+
+TEST(CoordinatesTest, Cartesian3D_Construction) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+  (void)coords;
+}
+
+TEST(CoordinatesTest, Cartesian3D_Dx) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+
+  EXPECT_FLOAT_EQ(dx_i, dx_j);
+  EXPECT_FLOAT_EQ(dx_j, dx_k);
+}
+
+TEST(CoordinatesTest, Cartesian3D_Xc) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto xc_i = coords.template Xc<Axis::IAXIS>(0);
+  auto xc_j = coords.template Xc<Axis::JAXIS>(0);
+  auto xc_k = coords.template Xc<Axis::KAXIS>(0);
+
+  EXPECT_GT(xc_i, 0.0);
+  EXPECT_GT(xc_j, 0.0);
+  EXPECT_GT(xc_k, 0.0);
+}
+
+TEST(CoordinatesTest, Cartesian3D_Xc_3DIndex) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto xc_i = coords.template Xc<Axis::IAXIS>(0, 0, 0);
+  auto xc_j = coords.template Xc<Axis::JAXIS>(0, 0, 0);
+  auto xc_k = coords.template Xc<Axis::KAXIS>(0, 0, 0);
+
+  auto xc_i_single = coords.template Xc<Axis::IAXIS>(0);
+  auto xc_j_single = coords.template Xc<Axis::JAXIS>(0);
+  auto xc_k_single = coords.template Xc<Axis::KAXIS>(0);
+
+  EXPECT_FLOAT_EQ(xc_i, xc_i_single);
+  EXPECT_FLOAT_EQ(xc_j, xc_j_single);
+  EXPECT_FLOAT_EQ(xc_k, xc_k_single);
+}
+
+TEST(CoordinatesTest, Cartesian3D_Xf) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto xf_i = coords.template Xf<Axis::IAXIS>(0);
+  auto xf_j = coords.template Xf<Axis::JAXIS>(0);
+  auto xf_k = coords.template Xf<Axis::KAXIS>(0);
+
+  EXPECT_GE(xf_i, 0.0);
+  EXPECT_GE(xf_j, 0.0);
+  EXPECT_GE(xf_k, 0.0);
+
+  auto xf_i_idx = coords.template Xf<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(xf_i, xf_i_idx);
+}
+
+TEST(CoordinatesTest, Cartesian3D_Xf_TopologicalElement) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto xf_cc = coords.template Xf<TopologicalElement::CC, Axis::IAXIS>(0);
+  auto xc = coords.template Xc<Axis::IAXIS>(0);
+  EXPECT_FLOAT_EQ(xf_cc, xc);
+
+  auto xf_f1 = coords.template Xf<TopologicalElement::F1, Axis::IAXIS>(0);
+  auto xf_face = coords.template Xf<Axis::IAXIS>(0);
+  EXPECT_FLOAT_EQ(xf_f1, xf_face);
+}
+
+TEST(CoordinatesTest, Cartesian3D_FaceArea) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+  auto expected_area = dx_j * dx_k;
+
+  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(face_area_i, expected_area);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto dx_k2 = coords.template Dx<Axis::KAXIS>();
+  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(face_area_j, dx_i * dx_k2);
+
+  auto dx_i2 = coords.template Dx<Axis::IAXIS>();
+  auto dx_j2 = coords.template Dx<Axis::JAXIS>();
+  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(face_area_k, dx_i2 * dx_j2);
+}
+
+TEST(CoordinatesTest, Cartesian3D_EdgeLength) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0), dx_i);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, 0, 0), dx_j);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, 0, 0), dx_k);
+}
+
+TEST(CoordinatesTest, Cartesian3D_CellVolume) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+  auto expected_volume = dx_i * dx_j * dx_k;
+
+  auto volume = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume, expected_volume);
+}
+
+TEST(CoordinatesTest, Cartesian3D_Volume_TopologicalElements) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto volume_cc = coords.Volume(TopologicalElement::CC, 0, 0, 0);
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_cc, cell_vol);
+
+  auto volume_f1 = coords.Volume(TopologicalElement::F1, 0, 0, 0);
+  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_f1, face_area_i);
+
+  auto volume_f2 = coords.Volume(TopologicalElement::F2, 0, 0, 0);
+  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_f2, face_area_j);
+
+  auto volume_f3 = coords.Volume(TopologicalElement::F3, 0, 0, 0);
+  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_f3, face_area_k);
+
+  auto volume_e1 = coords.Volume(TopologicalElement::E1, 0, 0, 0);
+  auto edge_i = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_e1, edge_i);
+
+  auto volume_e2 = coords.Volume(TopologicalElement::E2, 0, 0, 0);
+  auto edge_j = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_e2, edge_j);
+
+  auto volume_e3 = coords.Volume(TopologicalElement::E3, 0, 0, 0);
+  auto edge_k = coords.template EdgeLength<Axis::KAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_e3, edge_k);
+
+  auto volume_nn = coords.Volume(TopologicalElement::NN, 0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_nn, 1.0);
+}
+
+TEST(CoordinatesTest, Cylindrical2D_Construction) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+  (void)coords;
+}
+
+TEST(CoordinatesTest, Cylindrical2D_Dx) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+
+  auto expected_dx_k = 2.0 * std::numbers::pi;
+  EXPECT_FLOAT_EQ(dx_k, expected_dx_k);
+
+  EXPECT_GT(dx_k, dx_i);
+  EXPECT_GT(dx_k, dx_j);
+}
+
+TEST(CoordinatesTest, Cylindrical2D_Xc) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto xc_k = coords.template Xc<Axis::KAXIS>(0);
+  auto xc_j = coords.template Xc<Axis::JAXIS>(0);
+  EXPECT_GT(xc_k, 0.0);
+  EXPECT_GT(xc_j, 0.0);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  EXPECT_GT(dx_i, 0.0);
+}
+
+TEST(CoordinatesTest, Cylindrical2D_Xc_3DIndex) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto xc_j = coords.template Xc<Axis::JAXIS>(0, 0, 0);
+  auto xc_j_single = coords.template Xc<Axis::JAXIS>(0);
+  EXPECT_FLOAT_EQ(xc_j, xc_j_single);
+
+  auto xc_k = coords.template Xc<Axis::KAXIS>(0, 0, 0);
+  auto xc_k_single = coords.template Xc<Axis::KAXIS>(0);
+  EXPECT_FLOAT_EQ(xc_k, xc_k_single);
+}
+
+TEST(CoordinatesTest, Cylindrical2D_FaceArea) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto r = coords.template Xf<Axis::IAXIS>(0);
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+  auto expected_area_i = r * dx_j * dx_k;
+
+  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(face_area_i, expected_area_i));
+
+  auto rp = coords.template Xf<Axis::IAXIS>(1);
+  auto rm = coords.template Xf<Axis::IAXIS>(0);
+  auto expected_area_j = 0.5 * (rp * rp - rm * rm) * dx_k;
+
+  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(face_area_j, expected_area_j));
+}
+
+TEST(CoordinatesTest, Cylindrical2D_EdgeLength) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto dx_i = coords.template Dx<Axis::IAXIS>();
+  auto edge_i = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_i, dx_i);
+
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto edge_j = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_j, dx_j);
+
+  auto r = coords.template Xf<Axis::IAXIS>(0);
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+  auto expected_edge_k = std::abs(r) * dx_k;
+  auto edge_k = coords.template EdgeLength<Axis::KAXIS>(0, 0, 0);
+
+  EXPECT_TRUE(IsRelClose(edge_k, expected_edge_k));
+}
+
+TEST(CoordinatesTest, Cylindrical2D_CellVolume) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto rp = coords.template Xf<Axis::IAXIS>(1);
+  auto rm = coords.template Xf<Axis::IAXIS>(0);
+  auto dx_k = coords.template Dx<Axis::KAXIS>();
+  auto dx_j = coords.template Dx<Axis::JAXIS>();
+  auto expected_volume = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
+
+  auto volume = coords.CellVolume(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume, expected_volume));
+}
+
+TEST(CoordinatesTest, Cylindrical2D_Volume_TopologicalElements) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto volume_cc = coords.Volume(TopologicalElement::CC, 0, 0, 0);
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume_cc, cell_vol));
+
+  auto volume_f1 = coords.Volume(TopologicalElement::F1, 0, 0, 0);
+  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume_f1, face_area_i));
+
+  auto volume_f2 = coords.Volume(TopologicalElement::F2, 0, 0, 0);
+  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume_f2, face_area_j));
+
+  auto volume_f3 = coords.Volume(TopologicalElement::F3, 0, 0, 0);
+  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume_f3, face_area_k));
+
+  auto volume_nn = coords.Volume(TopologicalElement::NN, 0, 0, 0);
+  EXPECT_FLOAT_EQ(volume_nn, 1.0);
+}
+
+TEST(CoordinatesTest, RuntimeAxisDispatch_Cartesian) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto dx_i_template = coords.template Dx<Axis::IAXIS>();
+  auto dx_i_runtime = coords.Dx(Axis::IAXIS);
+  EXPECT_FLOAT_EQ(dx_i_template, dx_i_runtime);
+
+  auto xc_i_template = coords.template Xc<Axis::IAXIS>(0);
+  auto xc_i_runtime = coords.Xc(Axis::IAXIS, 0);
+  EXPECT_FLOAT_EQ(xc_i_template, xc_i_runtime);
+
+  auto xf_i_template = coords.template Xf<Axis::IAXIS>(0);
+  auto xf_i_runtime = coords.Xf(Axis::IAXIS, 0);
+  EXPECT_FLOAT_EQ(xf_i_template, xf_i_runtime);
+
+  auto face_area_template = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  auto face_area_runtime = coords.FaceArea(Axis::IAXIS, 0, 0, 0);
+  EXPECT_FLOAT_EQ(face_area_template, face_area_runtime);
+
+  auto edge_length_template = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
+  auto edge_length_runtime = coords.EdgeLength(Axis::IAXIS, 0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_length_template, edge_length_runtime);
+}
+
+TEST(CoordinatesTest, RuntimeAxisDispatch_Cylindrical) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto dx_i_template = coords.template Dx<Axis::IAXIS>();
+  auto dx_i_runtime = coords.Dx(Axis::IAXIS);
+  EXPECT_FLOAT_EQ(dx_i_template, dx_i_runtime);
+
+  auto xc_j_template = coords.template Xc<Axis::JAXIS>(0);
+  auto xc_j_runtime = coords.Xc(Axis::JAXIS, 0);
+  EXPECT_FLOAT_EQ(xc_j_template, xc_j_runtime);
+
+  auto xf_i_template = coords.template Xf<Axis::IAXIS>(0);
+  auto xf_i_runtime = coords.Xf(Axis::IAXIS, 0);
+  EXPECT_FLOAT_EQ(xf_i_template, xf_i_runtime);
+
+  auto face_area_template = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  auto face_area_runtime = coords.FaceArea(Axis::IAXIS, 0, 0, 0);
+  EXPECT_TRUE(IsRelClose(face_area_template, face_area_runtime));
+
+  auto edge_length_template = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
+  auto edge_length_runtime = coords.EdgeLength(Axis::IAXIS, 0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_length_template, edge_length_runtime);
+}
+
+TEST(CoordinatesTest, CoordinateIndexer_Cartesian) {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+
+  auto indexer = grid::CoordinateIndexer(coords, 0, 0, 0);
+
+  auto dx = indexer.template Dx<Axis::IAXIS>();
+  auto expected_dx = coords.template Dx<Axis::IAXIS>();
+  EXPECT_FLOAT_EQ(dx, expected_dx);
+
+  auto xc = indexer.template Xc<Axis::IAXIS>();
+  auto expected_xc = coords.template Xc<Axis::IAXIS>(0);
+  EXPECT_FLOAT_EQ(xc, expected_xc);
+
+  auto xf = indexer.template Xf<Axis::IAXIS>();
+  auto expected_xf = coords.template Xf<Axis::IAXIS>(0);
+  EXPECT_FLOAT_EQ(xf, expected_xf);
+
+  auto face_area = indexer.template FaceArea<Axis::IAXIS>();
+  auto expected_face_area = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(face_area, expected_face_area);
+
+  auto edge_length = indexer.template EdgeLength<Axis::IAXIS>();
+  auto expected_edge_length = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_length, expected_edge_length);
+
+  auto volume = indexer.CellVolume();
+  auto expected_volume = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(volume, expected_volume);
+}
+
+TEST(CoordinatesTest, CoordinateIndexer_Cylindrical) {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+
+  auto indexer = grid::CoordinateIndexer(coords, 0, 0, 0);
+
+  auto dx = indexer.template Dx<Axis::IAXIS>();
+  auto expected_dx = coords.template Dx<Axis::IAXIS>();
+  EXPECT_FLOAT_EQ(dx, expected_dx);
+
+  auto xc = indexer.template Xc<Axis::JAXIS>();
+  auto expected_xc = coords.template Xc<Axis::JAXIS>(0);
+  EXPECT_FLOAT_EQ(xc, expected_xc);
+
+  auto xf = indexer.template Xf<Axis::JAXIS>();
+  auto expected_xf = coords.template Xf<Axis::JAXIS>(0);
+  EXPECT_FLOAT_EQ(xf, expected_xf);
+
+  auto face_area = indexer.template FaceArea<Axis::JAXIS>();
+  auto expected_face_area = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(face_area, expected_face_area));
+
+  auto edge_length = indexer.template EdgeLength<Axis::JAXIS>();
+  auto expected_edge_length = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
+  EXPECT_FLOAT_EQ(edge_length, expected_edge_length);
+
+  auto volume = indexer.CellVolume();
+  auto expected_volume = coords.CellVolume(0, 0, 0);
+  EXPECT_TRUE(IsRelClose(volume, expected_volume));
+
+  auto vol_top = indexer.Volume(TopologicalElement::CC);
+  EXPECT_TRUE(IsRelClose(vol_top, expected_volume));
+}
+
+}  // namespace kamayan
\ No newline at end of file
diff --git a/src/grid/tests/test_geometry.hpp b/src/grid/tests/test_geometry.hpp
new file mode 100644
index 0000000..8eaef2f
--- /dev/null
+++ b/src/grid/tests/test_geometry.hpp
@@ -0,0 +1,14 @@
+#ifndef GRID_TESTS_TEST_GEOMETRY_HPP_
+#define GRID_TESTS_TEST_GEOMETRY_HPP_
+
+#include <memory>
+
+#include <mesh/meshblock.hpp>
+
+namespace kamayan {
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D();
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D();
+
+}  // namespace kamayan
+#endif  // GRID_TESTS_TEST_GEOMETRY_HPP_
\ No newline at end of file

From d4641c1d2b795a3baf35b845e493090f6e3d0f28 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 22:26:13 -0700
Subject: [PATCH 26/55] better tests

---
 src/grid/geometry.hpp            |   2 +-
 src/grid/tests/test_geometry.cpp | 654 +++++++++++++++----------------
 2 files changed, 317 insertions(+), 339 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 86322ca..1bee8ec 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -65,7 +65,7 @@ struct Coordinates {
       const Real r0sq = r0 * r0;
       const Real r1 = coords_.Xf<dir>(idx + 1);
       const Real r1sq = r1 * r1;
-      return (2.0 / 3.0) * (r1sq * r1 - r0sq * r0) / (r1sq - r0sq);
+      return (2.0 / 3.0) * (r1sq * std::abs(r1) - r0sq * std::abs(r0)) / (r1sq - r0sq);
     }
     return coords_.Xc<dir>(idx);
   }
diff --git a/src/grid/tests/test_geometry.cpp b/src/grid/tests/test_geometry.cpp
index d553ec4..5c300b4 100644
--- a/src/grid/tests/test_geometry.cpp
+++ b/src/grid/tests/test_geometry.cpp
@@ -5,6 +5,7 @@
 
 #include <gtest/gtest.h>
 
+#include <coordinates/uniform_cartesian.hpp>
 #include <mesh/meshblock.hpp>
 
 #include "grid/geometry.hpp"
@@ -14,6 +15,26 @@
 
 namespace kamayan {
 
+struct TestRegion {
+  std::array<Real, 3> xmin;
+  std::array<Real, 3> xmax;
+  std::array<Real, 3> xrat;
+  std::array<int, 3> nx;
+};
+
+TestRegion Cartesian3D() {
+  return {{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {8, 8, 8}};
+}
+
+TestRegion Cylindrical2D() {
+  return {
+      {0.0, 0.0, 0.0}, {1.0, 2.0 * std::numbers::pi, 1.0}, {1.0, 1.0, 1.0}, {4, 4, 1}};
+}
+
+parthenon::RegionSize MakeRegionSize(const TestRegion &r) {
+  return parthenon::RegionSize(r.xmin, r.xmax, r.xrat, r.nx);
+}
+
 std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D() {
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
@@ -28,22 +49,21 @@ std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D() {
 }
 
 std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D() {
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cylindrical);
-  pkg->InitResources(rps, cfg);
+  return std::make_shared<parthenon::MeshBlock>(8, 2);
+}
 
-  auto pmb = std::make_shared<parthenon::MeshBlock>(8, 2);
-  auto &pmbd = pmb->meshblock_data.Get();
-  pmbd->Initialize(pkg, pmb);
-  return pmb;
+parthenon::UniformCartesian MakeCoordinatesCartesian3D() {
+  return parthenon::UniformCartesian(MakeRegionSize(Cartesian3D()), nullptr);
+}
+
+parthenon::UniformCartesian MakeCoordinatesCylindrical2D() {
+  return parthenon::UniformCartesian(MakeRegionSize(Cylindrical2D()), nullptr);
 }
 
 namespace {
 
-constexpr Real REL_TOL = 1e-12;
-constexpr Real ABS_TOL = 1e-14;
+constexpr Real REL_TOL = 1e-10;
+constexpr Real ABS_TOL = 1e-12;
 
 bool IsRelClose(Real a, Real b) {
   if (std::abs(b) < ABS_TOL) {
@@ -52,407 +72,365 @@ bool IsRelClose(Real a, Real b) {
   return std::abs((a - b) / b) < REL_TOL;
 }
 
-}  // namespace
-
-TEST(CoordinatesTest, Cartesian3D_Construction) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-  (void)coords;
-}
-
-TEST(CoordinatesTest, Cartesian3D_Dx) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-
+void VerifyCartesian3D_Dx(const grid::Coordinates<Geometry::cartesian> &coords) {
   auto dx_i = coords.template Dx<Axis::IAXIS>();
   auto dx_j = coords.template Dx<Axis::JAXIS>();
   auto dx_k = coords.template Dx<Axis::KAXIS>();
+  EXPECT_FLOAT_EQ(dx_i, 0.125);
+  EXPECT_FLOAT_EQ(dx_j, 0.125);
+  EXPECT_FLOAT_EQ(dx_k, 0.125);
+}
 
-  EXPECT_FLOAT_EQ(dx_i, dx_j);
-  EXPECT_FLOAT_EQ(dx_j, dx_k);
+void VerifyCartesian3D_Xc_AllCells(const grid::Coordinates<Geometry::cartesian> &coords) {
+  for (int i = 0; i < 8; i++) {
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::IAXIS>(i), 0.0625 + i * 0.125);
+  }
+  for (int j = 0; j < 8; j++) {
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(j), 0.0625 + j * 0.125);
+  }
+  for (int k = 0; k < 8; k++) {
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::KAXIS>(k), 0.0625 + k * 0.125);
+  }
 }
 
-TEST(CoordinatesTest, Cartesian3D_Xc) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+void VerifyCartesian3D_Xf_AllFaces(const grid::Coordinates<Geometry::cartesian> &coords) {
+  for (int i = 0; i <= 8; i++) {
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(i), i * 0.125);
+  }
+  for (int j = 0; j <= 8; j++) {
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::JAXIS>(j), j * 0.125);
+  }
+  for (int k = 0; k <= 8; k++) {
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::KAXIS>(k), k * 0.125);
+  }
+}
 
-  auto xc_i = coords.template Xc<Axis::IAXIS>(0);
-  auto xc_j = coords.template Xc<Axis::JAXIS>(0);
-  auto xc_k = coords.template Xc<Axis::KAXIS>(0);
+void VerifyCartesian3D_FaceArea(const grid::Coordinates<Geometry::cartesian> &coords) {
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0), 0.125 * 0.125);
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(0, 0, 0), 0.125 * 0.125);
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(0, 0, 0), 0.125 * 0.125);
+
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(k, j, i), 0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(k, j, i), 0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(k, j, i), 0.125 * 0.125);
+      }
+    }
+  }
+}
 
-  EXPECT_GT(xc_i, 0.0);
-  EXPECT_GT(xc_j, 0.0);
-  EXPECT_GT(xc_k, 0.0);
+void VerifyCartesian3D_EdgeLength(const grid::Coordinates<Geometry::cartesian> &coords) {
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, 0, 0), 0.125);
+
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(k, j, i), 0.125);
+      }
+    }
+  }
 }
 
-TEST(CoordinatesTest, Cartesian3D_Xc_3DIndex) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+void VerifyCartesian3D_CellVolume(const grid::Coordinates<Geometry::cartesian> &coords) {
+  EXPECT_FLOAT_EQ(coords.CellVolume(0, 0, 0), 0.125 * 0.125 * 0.125);
 
-  auto xc_i = coords.template Xc<Axis::IAXIS>(0, 0, 0);
-  auto xc_j = coords.template Xc<Axis::JAXIS>(0, 0, 0);
-  auto xc_k = coords.template Xc<Axis::KAXIS>(0, 0, 0);
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coords.CellVolume(k, j, i), 0.125 * 0.125 * 0.125);
+      }
+    }
+  }
+}
 
-  auto xc_i_single = coords.template Xc<Axis::IAXIS>(0);
-  auto xc_j_single = coords.template Xc<Axis::JAXIS>(0);
-  auto xc_k_single = coords.template Xc<Axis::KAXIS>(0);
+void VerifyCartesian3D_VolumeTopological(
+    const grid::Coordinates<Geometry::cartesian> &coords) {
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E1, 0, 0, 0),
+                  coords.template EdgeLength<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E2, 0, 0, 0),
+                  coords.template EdgeLength<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E3, 0, 0, 0),
+                  coords.template EdgeLength<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+}
 
-  EXPECT_FLOAT_EQ(xc_i, xc_i_single);
-  EXPECT_FLOAT_EQ(xc_j, xc_j_single);
-  EXPECT_FLOAT_EQ(xc_k, xc_k_single);
+void VerifyCylindrical2D_Dx(const grid::Coordinates<Geometry::cylindrical> &coords) {
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), 0.25);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::JAXIS>(), std::numbers::pi / 2.0);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::KAXIS>(), 2.0 * std::numbers::pi);
 }
 
-TEST(CoordinatesTest, Cartesian3D_Xf) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+void VerifyCylindrical2D_Xc_AllCells(
+    const grid::Coordinates<Geometry::cylindrical> &coords) {
+  for (int i = 0; i < 4; i++) {
+    auto r0 = coords.template Xf<Axis::IAXIS>(i);
+    auto r1 = coords.template Xf<Axis::IAXIS>(i + 1);
+    auto expected_xc = (2.0 / 3.0) * (r1 * r1 * r1 - r0 * r0 * r0) / (r1 * r1 - r0 * r0);
+    auto actual_xc = coords.template Xc<Axis::IAXIS>(i);
+    EXPECT_FLOAT_EQ(actual_xc, expected_xc);
+  }
 
-  auto xf_i = coords.template Xf<Axis::IAXIS>(0);
-  auto xf_j = coords.template Xf<Axis::JAXIS>(0);
-  auto xf_k = coords.template Xf<Axis::KAXIS>(0);
+  for (int j = 0; j < 4; j++) {
+    auto expected_xc_j = std::numbers::pi / 4.0 + j * (std::numbers::pi / 2.0);
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(j), expected_xc_j);
+  }
 
-  EXPECT_GE(xf_i, 0.0);
-  EXPECT_GE(xf_j, 0.0);
-  EXPECT_GE(xf_k, 0.0);
+  EXPECT_FLOAT_EQ(coords.template Xc<Axis::KAXIS>(0), 0.5);
+}
 
-  auto xf_i_idx = coords.template Xf<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(xf_i, xf_i_idx);
+void VerifyCylindrical2D_FaceArea_AllCells(
+    const grid::Coordinates<Geometry::cylindrical> &coords) {
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      auto r = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_j = coords.template Dx<Axis::JAXIS>();
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
+      auto expected_i = r * dx_j * dx_k;
+      EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, j, i), expected_i);
+
+      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
+      auto rm = coords.template Xf<Axis::IAXIS>(i);
+      auto expected_j = 0.5 * (rp * rp - rm * rm) * dx_k;
+      EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(0, j, i), expected_j);
+
+      auto dx_i = coords.template Dx<Axis::IAXIS>();
+      EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(0, j, i), dx_i * dx_j);
+    }
+  }
 }
 
-TEST(CoordinatesTest, Cartesian3D_Xf_TopologicalElement) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+void VerifyCylindrical2D_EdgeLength_AllCells(
+    const grid::Coordinates<Geometry::cylindrical> &coords) {
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, j, i),
+                      coords.template Dx<Axis::IAXIS>());
+      EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, j, i),
+                      coords.template Dx<Axis::JAXIS>());
+
+      auto r = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
+      auto expected_k = std::abs(r) * dx_k;
+      EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, j, i), expected_k);
+    }
+  }
+}
 
-  auto xf_cc = coords.template Xf<TopologicalElement::CC, Axis::IAXIS>(0);
-  auto xc = coords.template Xc<Axis::IAXIS>(0);
-  EXPECT_FLOAT_EQ(xf_cc, xc);
+void VerifyCylindrical2D_CellVolume_AllCells(
+    const grid::Coordinates<Geometry::cylindrical> &coords) {
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
+      auto rm = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
+      auto dx_j = coords.template Dx<Axis::JAXIS>();
+      auto expected = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
+      EXPECT_FLOAT_EQ(coords.CellVolume(0, j, i), expected);
+    }
+  }
+}
 
-  auto xf_f1 = coords.template Xf<TopologicalElement::F1, Axis::IAXIS>(0);
-  auto xf_face = coords.template Xf<Axis::IAXIS>(0);
-  EXPECT_FLOAT_EQ(xf_f1, xf_face);
+void VerifyCylindrical2D_VolumeTopological(
+    const grid::Coordinates<Geometry::cylindrical> &coords) {
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
 }
 
-TEST(CoordinatesTest, Cartesian3D_FaceArea) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+}  // namespace
 
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-  auto expected_area = dx_j * dx_k;
+TEST(CoordinatesTest, Cartesian3D_Construction) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  (void)wrapped;
+}
 
-  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(face_area_i, expected_area);
+TEST(CoordinatesTest, Cartesian3D_Dx) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_Dx(wrapped);
+}
 
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  auto dx_k2 = coords.template Dx<Axis::KAXIS>();
-  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(face_area_j, dx_i * dx_k2);
+TEST(CoordinatesTest, Cartesian3D_Xc) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_Xc_AllCells(wrapped);
+}
 
-  auto dx_i2 = coords.template Dx<Axis::IAXIS>();
-  auto dx_j2 = coords.template Dx<Axis::JAXIS>();
-  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(face_area_k, dx_i2 * dx_j2);
+TEST(CoordinatesTest, Cartesian3D_Xc_3DIndex) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::IAXIS>(0, 0, 0),
+                  wrapped.template Xc<Axis::IAXIS>(0));
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::JAXIS>(0, 0, 0),
+                  wrapped.template Xc<Axis::JAXIS>(0));
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::KAXIS>(0, 0, 0),
+                  wrapped.template Xc<Axis::KAXIS>(0));
 }
 
-TEST(CoordinatesTest, Cartesian3D_EdgeLength) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
+TEST(CoordinatesTest, Cartesian3D_Xf) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_Xf_AllFaces(wrapped);
+}
 
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
+TEST(CoordinatesTest, Cartesian3D_FaceArea) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_FaceArea(wrapped);
+}
 
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0), dx_i);
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, 0, 0), dx_j);
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, 0, 0), dx_k);
+TEST(CoordinatesTest, Cartesian3D_EdgeLength) {
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_EdgeLength(wrapped);
 }
 
 TEST(CoordinatesTest, Cartesian3D_CellVolume) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-  auto expected_volume = dx_i * dx_j * dx_k;
-
-  auto volume = coords.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume, expected_volume);
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_CellVolume(wrapped);
 }
 
 TEST(CoordinatesTest, Cartesian3D_Volume_TopologicalElements) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-
-  auto volume_cc = coords.Volume(TopologicalElement::CC, 0, 0, 0);
-  auto cell_vol = coords.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_cc, cell_vol);
-
-  auto volume_f1 = coords.Volume(TopologicalElement::F1, 0, 0, 0);
-  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_f1, face_area_i);
-
-  auto volume_f2 = coords.Volume(TopologicalElement::F2, 0, 0, 0);
-  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_f2, face_area_j);
-
-  auto volume_f3 = coords.Volume(TopologicalElement::F3, 0, 0, 0);
-  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_f3, face_area_k);
-
-  auto volume_e1 = coords.Volume(TopologicalElement::E1, 0, 0, 0);
-  auto edge_i = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_e1, edge_i);
-
-  auto volume_e2 = coords.Volume(TopologicalElement::E2, 0, 0, 0);
-  auto edge_j = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_e2, edge_j);
-
-  auto volume_e3 = coords.Volume(TopologicalElement::E3, 0, 0, 0);
-  auto edge_k = coords.template EdgeLength<Axis::KAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_e3, edge_k);
-
-  auto volume_nn = coords.Volume(TopologicalElement::NN, 0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_nn, 1.0);
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+  VerifyCartesian3D_VolumeTopological(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_Construction) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-  (void)coords;
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  (void)wrapped;
 }
 
 TEST(CoordinatesTest, Cylindrical2D_Dx) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-
-  auto expected_dx_k = 2.0 * std::numbers::pi;
-  EXPECT_FLOAT_EQ(dx_k, expected_dx_k);
-
-  EXPECT_GT(dx_k, dx_i);
-  EXPECT_GT(dx_k, dx_j);
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_Dx(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_Xc) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto xc_k = coords.template Xc<Axis::KAXIS>(0);
-  auto xc_j = coords.template Xc<Axis::JAXIS>(0);
-  EXPECT_GT(xc_k, 0.0);
-  EXPECT_GT(xc_j, 0.0);
-
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  EXPECT_GT(dx_i, 0.0);
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_Xc_AllCells(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_Xc_3DIndex) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
 
-  auto xc_j = coords.template Xc<Axis::JAXIS>(0, 0, 0);
-  auto xc_j_single = coords.template Xc<Axis::JAXIS>(0);
-  EXPECT_FLOAT_EQ(xc_j, xc_j_single);
-
-  auto xc_k = coords.template Xc<Axis::KAXIS>(0, 0, 0);
-  auto xc_k_single = coords.template Xc<Axis::KAXIS>(0);
-  EXPECT_FLOAT_EQ(xc_k, xc_k_single);
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::JAXIS>(0, 0, 0),
+                  wrapped.template Xc<Axis::JAXIS>(0));
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::KAXIS>(0, 0, 0),
+                  wrapped.template Xc<Axis::KAXIS>(0));
 }
 
 TEST(CoordinatesTest, Cylindrical2D_FaceArea) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto r = coords.template Xf<Axis::IAXIS>(0);
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-  auto expected_area_i = r * dx_j * dx_k;
-
-  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(face_area_i, expected_area_i));
-
-  auto rp = coords.template Xf<Axis::IAXIS>(1);
-  auto rm = coords.template Xf<Axis::IAXIS>(0);
-  auto expected_area_j = 0.5 * (rp * rp - rm * rm) * dx_k;
-
-  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(face_area_j, expected_area_j));
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_FaceArea_AllCells(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_EdgeLength) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto dx_i = coords.template Dx<Axis::IAXIS>();
-  auto edge_i = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_i, dx_i);
-
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto edge_j = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_j, dx_j);
-
-  auto r = coords.template Xf<Axis::IAXIS>(0);
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-  auto expected_edge_k = std::abs(r) * dx_k;
-  auto edge_k = coords.template EdgeLength<Axis::KAXIS>(0, 0, 0);
-
-  EXPECT_TRUE(IsRelClose(edge_k, expected_edge_k));
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_EdgeLength_AllCells(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_CellVolume) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto rp = coords.template Xf<Axis::IAXIS>(1);
-  auto rm = coords.template Xf<Axis::IAXIS>(0);
-  auto dx_k = coords.template Dx<Axis::KAXIS>();
-  auto dx_j = coords.template Dx<Axis::JAXIS>();
-  auto expected_volume = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
-
-  auto volume = coords.CellVolume(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume, expected_volume));
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_CellVolume_AllCells(wrapped);
 }
 
 TEST(CoordinatesTest, Cylindrical2D_Volume_TopologicalElements) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto volume_cc = coords.Volume(TopologicalElement::CC, 0, 0, 0);
-  auto cell_vol = coords.CellVolume(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume_cc, cell_vol));
-
-  auto volume_f1 = coords.Volume(TopologicalElement::F1, 0, 0, 0);
-  auto face_area_i = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume_f1, face_area_i));
-
-  auto volume_f2 = coords.Volume(TopologicalElement::F2, 0, 0, 0);
-  auto face_area_j = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume_f2, face_area_j));
-
-  auto volume_f3 = coords.Volume(TopologicalElement::F3, 0, 0, 0);
-  auto face_area_k = coords.template FaceArea<Axis::KAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume_f3, face_area_k));
-
-  auto volume_nn = coords.Volume(TopologicalElement::NN, 0, 0, 0);
-  EXPECT_FLOAT_EQ(volume_nn, 1.0);
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+  VerifyCylindrical2D_VolumeTopological(wrapped);
 }
 
 TEST(CoordinatesTest, RuntimeAxisDispatch_Cartesian) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-
-  auto dx_i_template = coords.template Dx<Axis::IAXIS>();
-  auto dx_i_runtime = coords.Dx(Axis::IAXIS);
-  EXPECT_FLOAT_EQ(dx_i_template, dx_i_runtime);
-
-  auto xc_i_template = coords.template Xc<Axis::IAXIS>(0);
-  auto xc_i_runtime = coords.Xc(Axis::IAXIS, 0);
-  EXPECT_FLOAT_EQ(xc_i_template, xc_i_runtime);
-
-  auto xf_i_template = coords.template Xf<Axis::IAXIS>(0);
-  auto xf_i_runtime = coords.Xf(Axis::IAXIS, 0);
-  EXPECT_FLOAT_EQ(xf_i_template, xf_i_runtime);
-
-  auto face_area_template = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  auto face_area_runtime = coords.FaceArea(Axis::IAXIS, 0, 0, 0);
-  EXPECT_FLOAT_EQ(face_area_template, face_area_runtime);
-
-  auto edge_length_template = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
-  auto edge_length_runtime = coords.EdgeLength(Axis::IAXIS, 0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_length_template, edge_length_runtime);
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+
+  EXPECT_FLOAT_EQ(wrapped.template Dx<Axis::IAXIS>(), wrapped.Dx(Axis::IAXIS));
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::IAXIS>(0), wrapped.Xc(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(wrapped.template Xf<Axis::IAXIS>(0), wrapped.Xf(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(wrapped.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  wrapped.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(wrapped.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  wrapped.EdgeLength(Axis::IAXIS, 0, 0, 0));
 }
 
 TEST(CoordinatesTest, RuntimeAxisDispatch_Cylindrical) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto dx_i_template = coords.template Dx<Axis::IAXIS>();
-  auto dx_i_runtime = coords.Dx(Axis::IAXIS);
-  EXPECT_FLOAT_EQ(dx_i_template, dx_i_runtime);
-
-  auto xc_j_template = coords.template Xc<Axis::JAXIS>(0);
-  auto xc_j_runtime = coords.Xc(Axis::JAXIS, 0);
-  EXPECT_FLOAT_EQ(xc_j_template, xc_j_runtime);
-
-  auto xf_i_template = coords.template Xf<Axis::IAXIS>(0);
-  auto xf_i_runtime = coords.Xf(Axis::IAXIS, 0);
-  EXPECT_FLOAT_EQ(xf_i_template, xf_i_runtime);
-
-  auto face_area_template = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  auto face_area_runtime = coords.FaceArea(Axis::IAXIS, 0, 0, 0);
-  EXPECT_TRUE(IsRelClose(face_area_template, face_area_runtime));
-
-  auto edge_length_template = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
-  auto edge_length_runtime = coords.EdgeLength(Axis::IAXIS, 0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_length_template, edge_length_runtime);
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+
+  EXPECT_FLOAT_EQ(wrapped.template Dx<Axis::IAXIS>(), wrapped.Dx(Axis::IAXIS));
+  EXPECT_FLOAT_EQ(wrapped.template Xc<Axis::JAXIS>(0), wrapped.Xc(Axis::JAXIS, 0));
+  EXPECT_FLOAT_EQ(wrapped.template Xf<Axis::IAXIS>(0), wrapped.Xf(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(wrapped.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  wrapped.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(wrapped.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  wrapped.EdgeLength(Axis::IAXIS, 0, 0, 0));
 }
 
 TEST(CoordinatesTest, CoordinateIndexer_Cartesian) {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  auto coords = grid::Coordinates<Geometry::cartesian>(pmb->coords);
-
-  auto indexer = grid::CoordinateIndexer(coords, 0, 0, 0);
-
-  auto dx = indexer.template Dx<Axis::IAXIS>();
-  auto expected_dx = coords.template Dx<Axis::IAXIS>();
-  EXPECT_FLOAT_EQ(dx, expected_dx);
-
-  auto xc = indexer.template Xc<Axis::IAXIS>();
-  auto expected_xc = coords.template Xc<Axis::IAXIS>(0);
-  EXPECT_FLOAT_EQ(xc, expected_xc);
-
-  auto xf = indexer.template Xf<Axis::IAXIS>();
-  auto expected_xf = coords.template Xf<Axis::IAXIS>(0);
-  EXPECT_FLOAT_EQ(xf, expected_xf);
-
-  auto face_area = indexer.template FaceArea<Axis::IAXIS>();
-  auto expected_face_area = coords.template FaceArea<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(face_area, expected_face_area);
-
-  auto edge_length = indexer.template EdgeLength<Axis::IAXIS>();
-  auto expected_edge_length = coords.template EdgeLength<Axis::IAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_length, expected_edge_length);
-
-  auto volume = indexer.CellVolume();
-  auto expected_volume = coords.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(volume, expected_volume);
+  auto coords = MakeCoordinatesCartesian3D();
+  auto wrapped = grid::Coordinates<Geometry::cartesian>(coords);
+
+  auto indexer = grid::CoordinateIndexer(wrapped, 0, 0, 0);
+
+  EXPECT_FLOAT_EQ(indexer.template Dx<Axis::IAXIS>(), wrapped.template Dx<Axis::IAXIS>());
+  EXPECT_FLOAT_EQ(indexer.template Xc<Axis::IAXIS>(),
+                  wrapped.template Xc<Axis::IAXIS>(0));
+  EXPECT_FLOAT_EQ(indexer.template Xf<Axis::IAXIS>(),
+                  wrapped.template Xf<Axis::IAXIS>(0));
+  EXPECT_FLOAT_EQ(indexer.template FaceArea<Axis::IAXIS>(),
+                  wrapped.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(indexer.template EdgeLength<Axis::IAXIS>(),
+                  wrapped.template EdgeLength<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(indexer.CellVolume(), wrapped.CellVolume(0, 0, 0));
 }
 
 TEST(CoordinatesTest, CoordinateIndexer_Cylindrical) {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(pmb->coords);
-
-  auto indexer = grid::CoordinateIndexer(coords, 0, 0, 0);
-
-  auto dx = indexer.template Dx<Axis::IAXIS>();
-  auto expected_dx = coords.template Dx<Axis::IAXIS>();
-  EXPECT_FLOAT_EQ(dx, expected_dx);
-
-  auto xc = indexer.template Xc<Axis::JAXIS>();
-  auto expected_xc = coords.template Xc<Axis::JAXIS>(0);
-  EXPECT_FLOAT_EQ(xc, expected_xc);
-
-  auto xf = indexer.template Xf<Axis::JAXIS>();
-  auto expected_xf = coords.template Xf<Axis::JAXIS>(0);
-  EXPECT_FLOAT_EQ(xf, expected_xf);
-
-  auto face_area = indexer.template FaceArea<Axis::JAXIS>();
-  auto expected_face_area = coords.template FaceArea<Axis::JAXIS>(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(face_area, expected_face_area));
-
-  auto edge_length = indexer.template EdgeLength<Axis::JAXIS>();
-  auto expected_edge_length = coords.template EdgeLength<Axis::JAXIS>(0, 0, 0);
-  EXPECT_FLOAT_EQ(edge_length, expected_edge_length);
-
-  auto volume = indexer.CellVolume();
-  auto expected_volume = coords.CellVolume(0, 0, 0);
-  EXPECT_TRUE(IsRelClose(volume, expected_volume));
-
-  auto vol_top = indexer.Volume(TopologicalElement::CC);
-  EXPECT_TRUE(IsRelClose(vol_top, expected_volume));
+  auto coords = MakeCoordinatesCylindrical2D();
+  auto wrapped = grid::Coordinates<Geometry::cylindrical>(coords);
+
+  auto indexer = grid::CoordinateIndexer(wrapped, 0, 0, 0);
+
+  EXPECT_FLOAT_EQ(indexer.template Dx<Axis::IAXIS>(), wrapped.template Dx<Axis::IAXIS>());
+  EXPECT_FLOAT_EQ(indexer.template Xc<Axis::JAXIS>(),
+                  wrapped.template Xc<Axis::JAXIS>(0));
+  EXPECT_FLOAT_EQ(indexer.template Xf<Axis::JAXIS>(),
+                  wrapped.template Xf<Axis::JAXIS>(0));
+  EXPECT_FLOAT_EQ(indexer.template FaceArea<Axis::JAXIS>(),
+                  wrapped.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(indexer.template EdgeLength<Axis::JAXIS>(),
+                  wrapped.template EdgeLength<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(indexer.CellVolume(), wrapped.CellVolume(0, 0, 0));
 }
 
-}  // namespace kamayan
\ No newline at end of file
+}  // namespace kamayan

From dc0d7a3599511f9d08a872b3adc85ca2c964d3d6 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 31 Mar 2026 22:59:08 -0700
Subject: [PATCH 27/55] rounding out the tests

---
 src/CMakeLists.txt                       |   1 +
 src/grid/tests/test_coordinates_pack.cpp | 440 +++++++++++++++++++++++
 src/grid/tests/test_coordinates_pack.hpp |  14 +
 src/grid/tests/test_geometry.cpp         |   4 +-
 4 files changed, 457 insertions(+), 2 deletions(-)
 create mode 100644 src/grid/tests/test_coordinates_pack.cpp
 create mode 100644 src/grid/tests/test_coordinates_pack.hpp

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3c65b41..319a096 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -31,6 +31,7 @@ set(_pybind_sources
 set(_test_sources
     grid/tests/test_grid.cpp
     grid/tests/test_geometry.cpp
+    grid/tests/test_coordinates_pack.cpp
     kamayan_utils/tests/test_strings.cpp
     kamayan_utils/tests/test_type_list.cpp
     kamayan_utils/tests/test_type_list_array.cpp
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
new file mode 100644
index 0000000..d5b0bda
--- /dev/null
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -0,0 +1,440 @@
+#include "test_coordinates_pack.hpp"
+
+#include <gtest/gtest.h>
+
+#include <cmath>
+#include <memory>
+
+#include <coordinates/uniform_cartesian.hpp>
+#include <mesh/meshblock.hpp>
+
+#include "grid/coordinates.hpp"
+#include "grid/geometry.hpp"
+#include "grid/geometry_types.hpp"
+#include "grid/grid.hpp"
+#include "grid/grid_types.hpp"
+#include "kamayan/config.hpp"
+#include "kamayan/unit.hpp"
+
+namespace kamayan {
+
+struct TestRegion {
+  std::array<Real, 3> xmin;
+  std::array<Real, 3> xmax;
+  std::array<Real, 3> xrat;
+  std::array<int, 3> nx;
+};
+
+TestRegion Cartesian3D() {
+  return {{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {8, 8, 8}};
+}
+
+TestRegion Cylindrical2D() {
+  return {
+      {0.0, 0.0, 0.0}, {1.0, 2.0 * std::numbers::pi, 1.0}, {1.0, 1.0, 1.0}, {4, 4, 1}};
+}
+
+parthenon::RegionSize MakeRegionSize(const TestRegion &r) {
+  return parthenon::RegionSize(r.xmin, r.xmax, r.xrat, r.nx);
+}
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  auto pmb = std::make_shared<parthenon::MeshBlock>(8, 3);
+  auto &pmbd = pmb->meshblock_data.Get();
+  pmbd->Initialize(pkg, pmb);
+  return pmb;
+}
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cylindrical);
+  pkg->InitResources(rps, cfg);
+
+  auto pmb = std::make_shared<parthenon::MeshBlock>(4, 2);
+  auto &pmbd = pmb->meshblock_data.Get();
+  pmbd->Initialize(pkg, pmb);
+  return pmb;
+}
+
+parthenon::BlockList_t MakeTestBlockListCartesian3D() {
+  auto pmb = MakeTestMeshBlockCartesian3D();
+  parthenon::BlockList_t block_list;
+  block_list.push_back(pmb);
+  return block_list;
+}
+
+parthenon::BlockList_t MakeTestBlockListCylindrical2D() {
+  auto pmb = MakeTestMeshBlockCylindrical2D();
+  parthenon::BlockList_t block_list;
+  block_list.push_back(pmb);
+  return block_list;
+}
+
+MeshData MakeTestMeshDataCartesian3D() {
+  auto block_list = MakeTestBlockListCartesian3D();
+  MeshData mesh_data("base");
+  mesh_data.Initialize(block_list, nullptr);
+  return mesh_data;
+}
+
+MeshData MakeTestMeshDataCylindrical2D() {
+  auto block_list = MakeTestBlockListCylindrical2D();
+  MeshData mesh_data("base");
+  mesh_data.Initialize(block_list, nullptr);
+  return mesh_data;
+}
+
+std::shared_ptr<KamayanUnit> MakeTestPackageCartesian3D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+  return pkg;
+}
+
+std::shared_ptr<KamayanUnit> MakeTestPackageCylindrical2D() {
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cylindrical);
+  pkg->InitResources(rps, cfg);
+  return pkg;
+}
+
+namespace {
+
+constexpr Real REL_TOL = 1e-10;
+constexpr Real ABS_TOL = 1e-12;
+
+bool IsRelClose(Real a, Real b) {
+  if (std::abs(b) < ABS_TOL) {
+    return std::abs(a - b) < ABS_TOL;
+  }
+  return std::abs((a - b) / b) < REL_TOL;
+}
+
+}  // namespace
+
+TEST(CoordinatePackTest, Cartesian3D_PackConstruction) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  (void)coord_pack;
+}
+
+TEST(CoordinatePackTest, Cartesian3D_Dx_Template) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::JAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::KAXIS>(0, 0, 0), 0.125);
+}
+
+TEST(CoordinatePackTest, Cartesian3D_Xc_Template) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  for (int i = 0; i < 8; i++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::IAXIS>(0, 0, i), 0.0625 + i * 0.125);
+  }
+  for (int j = 0; j < 8; j++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::JAXIS>(0, j, 0), 0.0625 + j * 0.125);
+  }
+  for (int k = 0; k < 8; k++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::KAXIS>(k, 0, 0), 0.0625 + k * 0.125);
+  }
+}
+
+TEST(CoordinatePackTest, Cartesian3D_Xf_Template) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  for (int i = 0; i <= 8; i++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, i), i * 0.125);
+  }
+  for (int j = 0; j <= 8; j++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::JAXIS>(0, j, 0), j * 0.125);
+  }
+  for (int k = 0; k <= 8; k++) {
+    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::KAXIS>(k, 0, 0), k * 0.125);
+  }
+}
+
+TEST(CoordinatePackTest, Cartesian3D_FaceArea_Template) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(k, j, i),
+                        0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::JAXIS>(k, j, i),
+                        0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::KAXIS>(k, j, i),
+                        0.125 * 0.125);
+      }
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cartesian3D_EdgeLength_Template) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::JAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::KAXIS>(k, j, i), 0.125);
+      }
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cartesian3D_CellVolume) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(coord_pack.CellVolume(k, j, i), 0.125 * 0.125 * 0.125);
+      }
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cartesian3D_Volume_Topological) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  auto cell_vol = coord_pack.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E1, 0, 0, 0),
+                  coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E2, 0, 0, 0),
+                  coord_pack.template EdgeLength<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E3, 0, 0, 0),
+                  coord_pack.template EdgeLength<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+}
+
+TEST(CoordinatePackTest, Cartesian3D_RuntimeAxisDispatch) {
+  auto md = MakeTestMeshDataCartesian3D();
+  auto pkg = MakeTestPackageCartesian3D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.Dx(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.Xc(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.Xf(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_PackConstruction) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+  (void)coord_pack;
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_Dx_Template) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0), 0.25);
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::JAXIS>(0, 0, 0), std::numbers::pi / 2.0);
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::KAXIS>(0, 0, 0), 2.0 * std::numbers::pi);
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_Xc_Template) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  for (int i = 0; i < 4; i++) {
+    auto r0 = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+    auto r1 = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
+    auto expected_xc = (2.0 / 3.0) * (r1 * r1 * r1 - r0 * r0 * r0) / (r1 * r1 - r0 * r0);
+    auto actual_xc = coord_pack.template Xc<Axis::IAXIS>(0, 0, i);
+    ASSERT_TRUE(IsRelClose(actual_xc, expected_xc));
+  }
+
+  for (int j = 0; j < 4; j++) {
+    auto expected_xc_j = std::numbers::pi / 4.0 + j * (std::numbers::pi / 2.0);
+    auto actual_xc_j = coord_pack.template Xc<Axis::JAXIS>(0, j, 0);
+    ASSERT_TRUE(IsRelClose(actual_xc_j, expected_xc_j));
+  }
+
+  ASSERT_TRUE(IsRelClose(coord_pack.template Xc<Axis::KAXIS>(0, 0, 0), 0.5));
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_FaceArea_Template) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      auto r = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
+      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
+      auto expected_i = r * dx_j * dx_k;
+      auto actual_i = coord_pack.template FaceArea<Axis::IAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(actual_i, expected_i));
+
+      auto rp = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
+      auto rm = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+      auto expected_j = 0.5 * (rp * rp - rm * rm) * dx_k;
+      auto actual_j = coord_pack.template FaceArea<Axis::JAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(actual_j, expected_j));
+
+      auto dx_i = coord_pack.template Dx<Axis::IAXIS>(0, 0, 0);
+      auto expected_k = dx_i * dx_j;
+      auto actual_k = coord_pack.template FaceArea<Axis::KAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(actual_k, expected_k));
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_EdgeLength_Template) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      auto dx_i = coord_pack.template Dx<Axis::IAXIS>(0, 0, 0);
+      auto el_i = coord_pack.template EdgeLength<Axis::IAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(el_i, dx_i));
+
+      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
+      auto el_j = coord_pack.template EdgeLength<Axis::JAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(el_j, dx_j));
+
+      auto r = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
+      auto expected_k = std::abs(r) * dx_k;
+      auto actual_k = coord_pack.template EdgeLength<Axis::KAXIS>(0, j, i);
+      ASSERT_TRUE(IsRelClose(actual_k, expected_k));
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_CellVolume) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      auto rp = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
+      auto rm = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
+      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
+      auto expected = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
+      auto actual = coord_pack.CellVolume(0, j, i);
+      ASSERT_TRUE(IsRelClose(actual, expected));
+    }
+  }
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_Volume_Topological) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  auto cell_vol = coord_pack.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coord_pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+}
+
+TEST(CoordinatePackTest, Cylindrical2D_RuntimeAxisDispatch) {
+  auto md = MakeTestMeshDataCylindrical2D();
+  auto pkg = MakeTestPackageCylindrical2D();
+
+  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
+  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+
+  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.Dx(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::JAXIS>(0, 0, 0),
+                  coord_pack.Xc(Axis::JAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.Xf(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  coord_pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
+}
+
+}  // namespace kamayan
diff --git a/src/grid/tests/test_coordinates_pack.hpp b/src/grid/tests/test_coordinates_pack.hpp
new file mode 100644
index 0000000..73107b9
--- /dev/null
+++ b/src/grid/tests/test_coordinates_pack.hpp
@@ -0,0 +1,14 @@
+#ifndef GRID_TESTS_TEST_COORDINATES_PACK_HPP_
+#define GRID_TESTS_TEST_COORDINATES_PACK_HPP_
+
+#include <memory>
+
+#include <mesh/meshblock.hpp>
+
+namespace kamayan {
+
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D();
+std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D();
+
+}  // namespace kamayan
+#endif  // GRID_TESTS_TEST_COORDINATES_PACK_HPP_
diff --git a/src/grid/tests/test_geometry.cpp b/src/grid/tests/test_geometry.cpp
index 5c300b4..c6ae8c9 100644
--- a/src/grid/tests/test_geometry.cpp
+++ b/src/grid/tests/test_geometry.cpp
@@ -1,10 +1,10 @@
 #include "test_geometry.hpp"
 
+#include <gtest/gtest.h>
+
 #include <cmath>
 #include <memory>
 
-#include <gtest/gtest.h>
-
 #include <coordinates/uniform_cartesian.hpp>
 #include <mesh/meshblock.hpp>
 

From fc31f4f9c412c930977db366062c0d5b678d6ce9 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 1 Apr 2026 22:11:43 -0700
Subject: [PATCH 28/55] coordinates

---
 src/grid/coordinates.cpp | 70 ++++++++++++++++++++++++++++++++++++----
 src/grid/coordinates.hpp |  4 +++
 src/grid/grid.hpp        | 32 +++++++++++++++++-
 3 files changed, 99 insertions(+), 7 deletions(-)

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index 68c427e..e762695 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -8,18 +8,63 @@
 
 namespace kamayan::grid {
 
-// for a given variable T, need to:
-//    * get index bounds
-//    * launch par_for
-//    * fill pack(T(), k, j, i) for the mb
-//       * means calling the coords method
-//       * pass a KOKKOS_LAMBDA(k,j,i) ?
 template <Geometry geom, typename T, typename Functor>
 void FillCoords(const Functor &functor, const parthenon::IndexShape cellbounds) {
   auto [kb, jb, ib] = CoordinateIndexRanges<geom, T>(cellbounds);
   par_for(PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e, functor);
 }
 
+template <Geometry geom>
+void CalculateCoordinates(const Coordinates<geom> &coords, auto &pack,
+                          const parthenon::IndexShape &cellbounds) {
+  FillCoords<geom, coords::Volume>(
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::Volume(), k, j, i) = coords.CellVolume(k, j, i);
+      },
+      cellbounds);
+
+  [&]<Axis... axes>() {
+    (FillCoords<geom, coords::Dx<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::Dx<axes>(), k, j, i) = coords.template Dx<axes>();
+         },
+         cellbounds),
+     ...);
+    (FillCoords<geom, coords::X<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::X<axes>(), k, j, i) = coords.template Xi<axes>(k, j, i);
+         },
+         cellbounds),
+     ...);
+    (FillCoords<geom, coords::Xc<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::Xc<axes>(), k, j, i) = coords.template Xc<axes>(k, j, i);
+         },
+         cellbounds),
+     ...);
+    (FillCoords<geom, coords::Xf<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::Xf<axes>(), k, j, i) = coords.template Xf<axes>(k, j, i);
+         },
+         cellbounds),
+     ...);
+    (FillCoords<geom, coords::FaceArea<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::FaceArea<axes>(), k, j, i) =
+               coords.template FaceArea<axes>(k, j, i);
+         },
+         cellbounds),
+     ...);
+    (FillCoords<geom, coords::EdgeLength<axes>>(
+         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+           pack(0, coords::EdgeLength<axes>(), k, j, i) =
+               coords.template EdgeLength<axes>(k, j, i);
+         },
+         cellbounds),
+     ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
+}
+
 void CalculateCoordinates(MeshBlock *mb) {
   const auto geometry = GetConfig(mb)->Get<Geometry>();
   GeometryOptions::dispatch(
@@ -79,4 +124,17 @@ void CalculateCoordinates(MeshBlock *mb) {
       geometry);
 }
 
+void CalculateCoordinates(MeshBlock *mb, Geometry geom) {
+  GeometryOptions::dispatch(
+      [&]<Geometry g>() {
+        auto cellbounds = mb->cellbounds;
+
+        auto pack = GetPack(CoordFields(), mb);
+        auto coords = Coordinates<g>(pack, 0);
+
+        CalculateCoordinates(coords, pack, cellbounds);
+      },
+      geom);
+}
+
 }  // namespace kamayan::grid
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 42afc60..fc7ee18 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -13,9 +13,12 @@
 
 #include <ports-of-call/variant.hpp>
 
+#include "grid/geometry.hpp"
 #include "grid/geometry_types.hpp"
+#include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "interface/variable_state.hpp"
+#include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/strings.hpp"
 #include "kamayan_utils/type_list.hpp"
 #include "kokkos_types.hpp"
@@ -189,6 +192,7 @@ CoordinateIndexRanges(parthenon::IndexShape cellbounds,
 
 // fill meshblock with coordinate CoordFields
 void CalculateCoordinates(MeshBlock *mb);
+void CalculateCoordinates(MeshBlock *mb, Geometry geom);
 
 template <Geometry geom, typename... Fields>
 struct CoordinatePack {
diff --git a/src/grid/grid.hpp b/src/grid/grid.hpp
index c8cdd28..5b0f2ef 100644
--- a/src/grid/grid.hpp
+++ b/src/grid/grid.hpp
@@ -70,11 +70,41 @@ auto GetPack(StateDescriptor *pkg, MeshData *md) {
   return impl::GetPack(TypeList<Ts...>(), pkg, md);
 }
 
+template <typename... Ts>
+auto GetPack(std::shared_ptr<StateDescriptor> pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), pkg.get(), md);
+}
+
+template <typename... Ts>
+auto GetPack(KamayanUnit *pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), static_cast<StateDescriptor *>(pkg), md);
+}
+
+template <typename... Ts>
+auto GetPack(std::shared_ptr<KamayanUnit> pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), static_cast<StateDescriptor *>(pkg.get()), md);
+}
+
 template <typename... Ts>
 auto GetPack(TypeList<Ts...>, StateDescriptor *pkg, MeshData *md) {
   return impl::GetPack(TypeList<Ts...>(), pkg, md);
 }
 
+template <typename... Ts>
+auto GetPack(TypeList<Ts...>, std::shared_ptr<StateDescriptor> pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), pkg.get(), md);
+}
+
+template <typename... Ts>
+auto GetPack(TypeList<Ts...>, KamayanUnit *pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), static_cast<StateDescriptor *>(pkg), md);
+}
+
+template <typename... Ts>
+auto GetPack(TypeList<Ts...>, std::shared_ptr<KamayanUnit> pkg, MeshData *md) {
+  return impl::GetPack(TypeList<Ts...>(), static_cast<StateDescriptor *>(pkg.get()), md);
+}
+
 template <typename... Ts, typename Container>
 auto GetPack(Container *md, std::set<PDOpt> pack_opts = {}) {
   return impl::GetPack(TypeList<Ts...>(), md, pack_opts);
@@ -106,4 +136,4 @@ TaskID ApplyDuDt(TaskID prev, TaskList &tl, MeshData *mbase, MeshData *md0, Mesh
 
 }  // namespace kamayan::grid
 
-#endif  // GRID_GRID_HPP_
+#endif  // GRID_GRID_HPP_
\ No newline at end of file

From 10be29485c76404ca5b48bda38b1e922c690b28f Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 1 Apr 2026 22:22:36 -0700
Subject: [PATCH 29/55] tests work but aren't set up right

---
 src/grid/tests/test_coordinates_pack.cpp | 504 +++++++++++------------
 src/grid/tests/test_coordinates_pack.hpp |  14 -
 2 files changed, 245 insertions(+), 273 deletions(-)
 delete mode 100644 src/grid/tests/test_coordinates_pack.hpp

diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index d5b0bda..db41f65 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -1,9 +1,7 @@
-#include "test_coordinates_pack.hpp"
-
 #include <gtest/gtest.h>
 
+#include <array>
 #include <cmath>
-#include <memory>
 
 #include <coordinates/uniform_cartesian.hpp>
 #include <mesh/meshblock.hpp>
@@ -11,10 +9,7 @@
 #include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/geometry_types.hpp"
-#include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
-#include "kamayan/config.hpp"
-#include "kamayan/unit.hpp"
 
 namespace kamayan {
 
@@ -25,416 +20,407 @@ struct TestRegion {
   std::array<int, 3> nx;
 };
 
-TestRegion Cartesian3D() {
-  return {{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {8, 8, 8}};
+parthenon::UniformCartesian MakeCoordinatesCartesian3DForPack() {
+  TestRegion region{{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {8, 8, 8}};
+  return parthenon::UniformCartesian(
+      parthenon::RegionSize(region.xmin, region.xmax, region.xrat, region.nx), nullptr);
 }
 
-TestRegion Cylindrical2D() {
-  return {
+parthenon::UniformCartesian MakeCoordinatesCylindrical2DForPack() {
+  TestRegion region{
       {0.0, 0.0, 0.0}, {1.0, 2.0 * std::numbers::pi, 1.0}, {1.0, 1.0, 1.0}, {4, 4, 1}};
+  return parthenon::UniformCartesian(
+      parthenon::RegionSize(region.xmin, region.xmax, region.xrat, region.nx), nullptr);
 }
 
-parthenon::RegionSize MakeRegionSize(const TestRegion &r) {
-  return parthenon::RegionSize(r.xmin, r.xmax, r.xrat, r.nx);
-}
+namespace {
 
-std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D() {
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
-  pkg->InitResources(rps, cfg);
-
-  auto pmb = std::make_shared<parthenon::MeshBlock>(8, 3);
-  auto &pmbd = pmb->meshblock_data.Get();
-  pmbd->Initialize(pkg, pmb);
-  return pmb;
-}
+constexpr Real REL_TOL = 1e-10;
+constexpr Real ABS_TOL = 1e-12;
 
-std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D() {
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cylindrical);
-  pkg->InitResources(rps, cfg);
-
-  auto pmb = std::make_shared<parthenon::MeshBlock>(4, 2);
-  auto &pmbd = pmb->meshblock_data.Get();
-  pmbd->Initialize(pkg, pmb);
-  return pmb;
+bool IsRelClose(Real a, Real b) {
+  if (std::abs(b) < ABS_TOL) {
+    return std::abs(a - b) < ABS_TOL;
+  }
+  return std::abs((a - b) / b) < REL_TOL;
 }
 
-parthenon::BlockList_t MakeTestBlockListCartesian3D() {
-  auto pmb = MakeTestMeshBlockCartesian3D();
-  parthenon::BlockList_t block_list;
-  block_list.push_back(pmb);
-  return block_list;
+template <typename CoordPack, typename CoordObj>
+void VerifyDx(CoordPack &pack, CoordObj &coords) {
+  static_assert(
+      std::is_same_v<CoordPack, grid::CoordinatePack<Geometry::cartesian>> ||
+          std::is_same_v<CoordPack, grid::CoordinatePack<Geometry::cylindrical>>,
+      "CoordPack must be CoordinatePack");
+  EXPECT_FLOAT_EQ(pack.template Dx<Axis::IAXIS>(0, 0, 0),
+                  coords.template Dx<Axis::IAXIS>());
+  EXPECT_FLOAT_EQ(pack.template Dx<Axis::JAXIS>(0, 0, 0),
+                  coords.template Dx<Axis::JAXIS>());
+  EXPECT_FLOAT_EQ(pack.template Dx<Axis::KAXIS>(0, 0, 0),
+                  coords.template Dx<Axis::KAXIS>());
 }
 
-parthenon::BlockList_t MakeTestBlockListCylindrical2D() {
-  auto pmb = MakeTestMeshBlockCylindrical2D();
-  parthenon::BlockList_t block_list;
-  block_list.push_back(pmb);
-  return block_list;
+template <typename CoordPack, typename CoordObj>
+void VerifyXc(CoordPack &pack, CoordObj &coords) {
+  for (int i = 0; i < 8; i++) {
+    EXPECT_FLOAT_EQ(pack.template Xc<Axis::IAXIS>(0, 0, i),
+                    coords.template Xc<Axis::IAXIS>(i));
+  }
+  for (int j = 0; j < 8; j++) {
+    EXPECT_FLOAT_EQ(pack.template Xc<Axis::JAXIS>(0, j, 0),
+                    coords.template Xc<Axis::JAXIS>(j));
+  }
+  for (int k = 0; k < 8; k++) {
+    EXPECT_FLOAT_EQ(pack.template Xc<Axis::KAXIS>(k, 0, 0),
+                    coords.template Xc<Axis::KAXIS>(k));
+  }
 }
 
-MeshData MakeTestMeshDataCartesian3D() {
-  auto block_list = MakeTestBlockListCartesian3D();
-  MeshData mesh_data("base");
-  mesh_data.Initialize(block_list, nullptr);
-  return mesh_data;
+template <typename CoordPack, typename CoordObj>
+void VerifyXf(CoordPack &pack, CoordObj &coords) {
+  for (int i = 0; i <= 8; i++) {
+    EXPECT_FLOAT_EQ(pack.template Xf<Axis::IAXIS>(0, 0, i),
+                    coords.template Xf<Axis::IAXIS>(i));
+  }
+  for (int j = 0; j <= 8; j++) {
+    EXPECT_FLOAT_EQ(pack.template Xf<Axis::JAXIS>(0, j, 0),
+                    coords.template Xf<Axis::JAXIS>(j));
+  }
+  for (int k = 0; k <= 8; k++) {
+    EXPECT_FLOAT_EQ(pack.template Xf<Axis::KAXIS>(k, 0, 0),
+                    coords.template Xf<Axis::KAXIS>(k));
+  }
 }
 
-MeshData MakeTestMeshDataCylindrical2D() {
-  auto block_list = MakeTestBlockListCylindrical2D();
-  MeshData mesh_data("base");
-  mesh_data.Initialize(block_list, nullptr);
-  return mesh_data;
+template <typename CoordPack, typename CoordObj>
+void VerifyFaceArea(CoordPack &pack, CoordObj &coords) {
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::IAXIS>(k, j, i),
+                        coords.template FaceArea<Axis::IAXIS>(k, j, i));
+        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::JAXIS>(k, j, i),
+                        coords.template FaceArea<Axis::JAXIS>(k, j, i));
+        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::KAXIS>(k, j, i),
+                        coords.template FaceArea<Axis::KAXIS>(k, j, i));
+      }
+    }
+  }
 }
 
-std::shared_ptr<KamayanUnit> MakeTestPackageCartesian3D() {
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
-  pkg->InitResources(rps, cfg);
-  return pkg;
+template <typename CoordPack, typename CoordObj>
+void VerifyEdgeLength(CoordPack &pack, CoordObj &coords) {
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::IAXIS>(k, j, i),
+                        coords.template EdgeLength<Axis::IAXIS>(k, j, i));
+        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::JAXIS>(k, j, i),
+                        coords.template EdgeLength<Axis::JAXIS>(k, j, i));
+        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::KAXIS>(k, j, i),
+                        coords.template EdgeLength<Axis::KAXIS>(k, j, i));
+      }
+    }
+  }
 }
 
-std::shared_ptr<KamayanUnit> MakeTestPackageCylindrical2D() {
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cylindrical);
-  pkg->InitResources(rps, cfg);
-  return pkg;
+template <typename CoordPack, typename CoordObj>
+void VerifyCellVolume(CoordPack &pack, CoordObj &coords) {
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      for (int k = 0; k < 8; k++) {
+        EXPECT_FLOAT_EQ(pack.CellVolume(k, j, i), coords.CellVolume(k, j, i));
+      }
+    }
+  }
 }
 
-namespace {
-
-constexpr Real REL_TOL = 1e-10;
-constexpr Real ABS_TOL = 1e-12;
+template <typename CoordPack, typename CoordObj>
+void VerifyVolumeTopological(CoordPack &pack, CoordObj &coords) {
+  auto cell_vol = pack.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F1, 0, 0, 0),
+                  pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F2, 0, 0, 0),
+                  pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F3, 0, 0, 0),
+                  pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+}
 
-bool IsRelClose(Real a, Real b) {
-  if (std::abs(b) < ABS_TOL) {
-    return std::abs(a - b) < ABS_TOL;
-  }
-  return std::abs((a - b) / b) < REL_TOL;
+template <typename CoordPack, typename CoordObj>
+void VerifyRuntimeAxisDispatch(CoordPack &pack, CoordObj &coords) {
+  EXPECT_FLOAT_EQ(pack.template Dx<Axis::IAXIS>(0, 0, 0), pack.Dx(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.template Xc<Axis::IAXIS>(0, 0, 0), pack.Xc(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.template Xf<Axis::IAXIS>(0, 0, 0), pack.Xf(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  pack.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
 }
 
 }  // namespace
 
 TEST(CoordinatePackTest, Cartesian3D_PackConstruction) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
-  (void)coord_pack;
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
+  (void)coords;
 }
 
 TEST(CoordinatePackTest, Cartesian3D_Dx_Template) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
-
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0), 0.125);
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::JAXIS>(0, 0, 0), 0.125);
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::KAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), 0.125);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::JAXIS>(), 0.125);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::KAXIS>(), 0.125);
 }
 
 TEST(CoordinatePackTest, Cartesian3D_Xc_Template) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
   for (int i = 0; i < 8; i++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::IAXIS>(0, 0, i), 0.0625 + i * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::IAXIS>(i), 0.0625 + i * 0.125);
   }
   for (int j = 0; j < 8; j++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::JAXIS>(0, j, 0), 0.0625 + j * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(j), 0.0625 + j * 0.125);
   }
   for (int k = 0; k < 8; k++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::KAXIS>(k, 0, 0), 0.0625 + k * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xc<Axis::KAXIS>(k), 0.0625 + k * 0.125);
   }
 }
 
 TEST(CoordinatePackTest, Cartesian3D_Xf_Template) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
   for (int i = 0; i <= 8; i++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, i), i * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(i), i * 0.125);
   }
   for (int j = 0; j <= 8; j++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::JAXIS>(0, j, 0), j * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::JAXIS>(j), j * 0.125);
   }
   for (int k = 0; k <= 8; k++) {
-    EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::KAXIS>(k, 0, 0), k * 0.125);
+    EXPECT_FLOAT_EQ(coords.template Xf<Axis::KAXIS>(k), k * 0.125);
   }
 }
 
 TEST(CoordinatePackTest, Cartesian3D_FaceArea_Template) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0), 0.125 * 0.125);
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(0, 0, 0), 0.125 * 0.125);
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(0, 0, 0), 0.125 * 0.125);
 
   for (int i = 0; i < 8; i++) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(k, j, i),
-                        0.125 * 0.125);
-        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::JAXIS>(k, j, i),
-                        0.125 * 0.125);
-        EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::KAXIS>(k, j, i),
-                        0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(k, j, i), 0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(k, j, i), 0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(k, j, i), 0.125 * 0.125);
       }
     }
   }
 }
 
 TEST(CoordinatePackTest, Cartesian3D_EdgeLength_Template) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, 0, 0), 0.125);
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, 0, 0), 0.125);
 
   for (int i = 0; i < 8; i++) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(k, j, i), 0.125);
-        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::JAXIS>(k, j, i), 0.125);
-        EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::KAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(k, j, i), 0.125);
+        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(k, j, i), 0.125);
       }
     }
   }
 }
 
 TEST(CoordinatePackTest, Cartesian3D_CellVolume) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
 
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
+  EXPECT_FLOAT_EQ(coords.CellVolume(0, 0, 0), 0.125 * 0.125 * 0.125);
 
   for (int i = 0; i < 8; i++) {
     for (int j = 0; j < 8; j++) {
       for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coord_pack.CellVolume(k, j, i), 0.125 * 0.125 * 0.125);
+        EXPECT_FLOAT_EQ(coords.CellVolume(k, j, i), 0.125 * 0.125 * 0.125);
       }
     }
   }
 }
 
 TEST(CoordinatePackTest, Cartesian3D_Volume_Topological) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
-
-  auto cell_vol = coord_pack.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F1, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F2, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F3, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E1, 0, 0, 0),
-                  coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E2, 0, 0, 0),
-                  coord_pack.template EdgeLength<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::E3, 0, 0, 0),
-                  coord_pack.template EdgeLength<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
+
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E1, 0, 0, 0),
+                  coords.template EdgeLength<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E2, 0, 0, 0),
+                  coords.template EdgeLength<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E3, 0, 0, 0),
+                  coords.template EdgeLength<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
 }
 
 TEST(CoordinatePackTest, Cartesian3D_RuntimeAxisDispatch) {
-  auto md = MakeTestMeshDataCartesian3D();
-  auto pkg = MakeTestPackageCartesian3D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cartesian>(pack, 0);
-
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.Dx(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.Xc(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.Xf(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.FaceArea(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
+  auto raw_coords = MakeCoordinatesCartesian3DForPack();
+  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
+
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), coords.Dx(Axis::IAXIS));
+  EXPECT_FLOAT_EQ(coords.template Xc<Axis::IAXIS>(0), coords.Xc(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(0), coords.Xf(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  coords.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  coords.EdgeLength(Axis::IAXIS, 0, 0, 0));
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_PackConstruction) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
-  (void)coord_pack;
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
+  (void)coords;
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_Dx_Template) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
 
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
-
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0), 0.25);
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::JAXIS>(0, 0, 0), std::numbers::pi / 2.0);
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::KAXIS>(0, 0, 0), 2.0 * std::numbers::pi);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), 0.25);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::JAXIS>(), std::numbers::pi / 2.0);
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::KAXIS>(), 2.0 * std::numbers::pi);
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_Xc_Template) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
 
   for (int i = 0; i < 4; i++) {
-    auto r0 = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
-    auto r1 = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
+    auto r0 = coords.template Xf<Axis::IAXIS>(i);
+    auto r1 = coords.template Xf<Axis::IAXIS>(i + 1);
     auto expected_xc = (2.0 / 3.0) * (r1 * r1 * r1 - r0 * r0 * r0) / (r1 * r1 - r0 * r0);
-    auto actual_xc = coord_pack.template Xc<Axis::IAXIS>(0, 0, i);
+    auto actual_xc = coords.template Xc<Axis::IAXIS>(i);
     ASSERT_TRUE(IsRelClose(actual_xc, expected_xc));
   }
 
   for (int j = 0; j < 4; j++) {
     auto expected_xc_j = std::numbers::pi / 4.0 + j * (std::numbers::pi / 2.0);
-    auto actual_xc_j = coord_pack.template Xc<Axis::JAXIS>(0, j, 0);
+    auto actual_xc_j = coords.template Xc<Axis::JAXIS>(j);
     ASSERT_TRUE(IsRelClose(actual_xc_j, expected_xc_j));
   }
 
-  ASSERT_TRUE(IsRelClose(coord_pack.template Xc<Axis::KAXIS>(0, 0, 0), 0.5));
+  ASSERT_TRUE(IsRelClose(coords.template Xc<Axis::KAXIS>(0), 0.5));
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_FaceArea_Template) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
 
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
-      auto r = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
-      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
-      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
+      auto r = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_j = coords.template Dx<Axis::JAXIS>();
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
       auto expected_i = r * dx_j * dx_k;
-      auto actual_i = coord_pack.template FaceArea<Axis::IAXIS>(0, j, i);
+      auto actual_i = coords.template FaceArea<Axis::IAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(actual_i, expected_i));
 
-      auto rp = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
-      auto rm = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
+      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
+      auto rm = coords.template Xf<Axis::IAXIS>(i);
       auto expected_j = 0.5 * (rp * rp - rm * rm) * dx_k;
-      auto actual_j = coord_pack.template FaceArea<Axis::JAXIS>(0, j, i);
+      auto actual_j = coords.template FaceArea<Axis::JAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(actual_j, expected_j));
 
-      auto dx_i = coord_pack.template Dx<Axis::IAXIS>(0, 0, 0);
+      auto dx_i = coords.template Dx<Axis::IAXIS>();
       auto expected_k = dx_i * dx_j;
-      auto actual_k = coord_pack.template FaceArea<Axis::KAXIS>(0, j, i);
+      auto actual_k = coords.template FaceArea<Axis::KAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(actual_k, expected_k));
     }
   }
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_EdgeLength_Template) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
 
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
-      auto dx_i = coord_pack.template Dx<Axis::IAXIS>(0, 0, 0);
-      auto el_i = coord_pack.template EdgeLength<Axis::IAXIS>(0, j, i);
+      auto dx_i = coords.template Dx<Axis::IAXIS>();
+      auto el_i = coords.template EdgeLength<Axis::IAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(el_i, dx_i));
 
-      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
-      auto el_j = coord_pack.template EdgeLength<Axis::JAXIS>(0, j, i);
+      auto dx_j = coords.template Dx<Axis::JAXIS>();
+      auto el_j = coords.template EdgeLength<Axis::JAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(el_j, dx_j));
 
-      auto r = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
-      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
+      auto r = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
       auto expected_k = std::abs(r) * dx_k;
-      auto actual_k = coord_pack.template EdgeLength<Axis::KAXIS>(0, j, i);
+      auto actual_k = coords.template EdgeLength<Axis::KAXIS>(0, j, i);
       ASSERT_TRUE(IsRelClose(actual_k, expected_k));
     }
   }
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_CellVolume) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
 
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
-      auto rp = coord_pack.template Xf<Axis::IAXIS>(0, 0, i + 1);
-      auto rm = coord_pack.template Xf<Axis::IAXIS>(0, 0, i);
-      auto dx_k = coord_pack.template Dx<Axis::KAXIS>(0, 0, 0);
-      auto dx_j = coord_pack.template Dx<Axis::JAXIS>(0, 0, 0);
+      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
+      auto rm = coords.template Xf<Axis::IAXIS>(i);
+      auto dx_k = coords.template Dx<Axis::KAXIS>();
+      auto dx_j = coords.template Dx<Axis::JAXIS>();
       auto expected = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
-      auto actual = coord_pack.CellVolume(0, j, i);
+      auto actual = coords.CellVolume(0, j, i);
       ASSERT_TRUE(IsRelClose(actual, expected));
     }
   }
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_Volume_Topological) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
-
-  auto cell_vol = coord_pack.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F1, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F2, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::F3, 0, 0, 0),
-                  coord_pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
+
+  auto cell_vol = coords.CellVolume(0, 0, 0);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
+                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
+                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
+                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
 }
 
 TEST(CoordinatePackTest, Cylindrical2D_RuntimeAxisDispatch) {
-  auto md = MakeTestMeshDataCylindrical2D();
-  auto pkg = MakeTestPackageCylindrical2D();
-
-  auto pack = grid::GetPack(grid::CoordFields(), pkg.get(), &md);
-  auto coord_pack = grid::CoordinatePack<Geometry::cylindrical>(pack, 0);
-
-  EXPECT_FLOAT_EQ(coord_pack.template Dx<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.Dx(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template Xc<Axis::JAXIS>(0, 0, 0),
-                  coord_pack.Xc(Axis::JAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template Xf<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.Xf(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.FaceArea(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coord_pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
-                  coord_pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
+  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
+  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
+
+  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), coords.Dx(Axis::IAXIS));
+  EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(0), coords.Xc(Axis::JAXIS, 0));
+  EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(0), coords.Xf(Axis::IAXIS, 0));
+  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0),
+                  coords.FaceArea(Axis::IAXIS, 0, 0, 0));
+  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0),
+                  coords.EdgeLength(Axis::IAXIS, 0, 0, 0));
 }
 
 }  // namespace kamayan
diff --git a/src/grid/tests/test_coordinates_pack.hpp b/src/grid/tests/test_coordinates_pack.hpp
deleted file mode 100644
index 73107b9..0000000
--- a/src/grid/tests/test_coordinates_pack.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef GRID_TESTS_TEST_COORDINATES_PACK_HPP_
-#define GRID_TESTS_TEST_COORDINATES_PACK_HPP_
-
-#include <memory>
-
-#include <mesh/meshblock.hpp>
-
-namespace kamayan {
-
-std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D();
-std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D();
-
-}  // namespace kamayan
-#endif  // GRID_TESTS_TEST_COORDINATES_PACK_HPP_

From 6fbe00e1e39389458771967975b4c6d17596df25 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Thu, 2 Apr 2026 21:05:20 -0700
Subject: [PATCH 30/55] finally a usable test

---
 src/grid/coordinates.cpp                 |  56 +--
 src/grid/coordinates.hpp                 |   4 +
 src/grid/tests/test_coordinates_pack.cpp | 507 ++++-------------------
 3 files changed, 96 insertions(+), 471 deletions(-)

diff --git a/src/grid/coordinates.cpp b/src/grid/coordinates.cpp
index e762695..52550b2 100644
--- a/src/grid/coordinates.cpp
+++ b/src/grid/coordinates.cpp
@@ -67,61 +67,7 @@ void CalculateCoordinates(const Coordinates<geom> &coords, auto &pack,
 
 void CalculateCoordinates(MeshBlock *mb) {
   const auto geometry = GetConfig(mb)->Get<Geometry>();
-  GeometryOptions::dispatch(
-      [&]<Geometry geom>() {
-        auto cellbounds = mb->cellbounds;
-
-        auto pack = GetPack(CoordFields(), mb);
-        auto coords = Coordinates<geom>(pack, 0);
-
-        FillCoords<geom, coords::Volume>(
-            KOKKOS_LAMBDA(const int k, const int j, const int i) {
-              pack(0, coords::Volume(), k, j, i) = coords.CellVolume(k, j, i);
-            },
-            cellbounds);
-
-        [&]<Axis... axes>() {
-          (FillCoords<geom, coords::Dx<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::Dx<axes>(), k, j, i) = coords.template Dx<axes>();
-               },
-               cellbounds),
-           ...);
-          (FillCoords<geom, coords::X<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::X<axes>(), k, j, i) = coords.template Xi<axes>(k, j, i);
-               },
-               cellbounds),
-           ...);
-          (FillCoords<geom, coords::Xc<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::Xc<axes>(), k, j, i) = coords.template Xc<axes>(k, j, i);
-               },
-               cellbounds),
-           ...);
-          (FillCoords<geom, coords::Xf<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::Xf<axes>(), k, j, i) = coords.template Xf<axes>(k, j, i);
-               },
-               cellbounds),
-           ...);
-          (FillCoords<geom, coords::FaceArea<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::FaceArea<axes>(), k, j, i) =
-                     coords.template FaceArea<axes>(k, j, i);
-               },
-               cellbounds),
-           ...);
-          (FillCoords<geom, coords::EdgeLength<axes>>(
-               KOKKOS_LAMBDA(const int k, const int j, const int i) {
-                 pack(0, coords::EdgeLength<axes>(), k, j, i) =
-                     coords.template EdgeLength<axes>(k, j, i);
-               },
-               cellbounds),
-           ...);
-        }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
-      },
-      geometry);
+  CalculateCoordinates(mb, geometry);
 }
 
 void CalculateCoordinates(MeshBlock *mb, Geometry geom) {
diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index fc7ee18..691c2d1 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -194,6 +194,10 @@ CoordinateIndexRanges(parthenon::IndexShape cellbounds,
 void CalculateCoordinates(MeshBlock *mb);
 void CalculateCoordinates(MeshBlock *mb, Geometry geom);
 
+template <Geometry geom>
+void CalculateCoordinates(const Coordinates<geom> &coords, auto &pack,
+                          const parthenon::IndexShape &cellbounds);
+
 template <Geometry geom, typename... Fields>
 struct CoordinatePack {
   using FieldList = TypeList<Fields...>;
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index db41f65..b2c5c8f 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -1,426 +1,101 @@
 #include <gtest/gtest.h>
 
-#include <array>
-#include <cmath>
+#include <iostream>
+#include <memory>
 
-#include <coordinates/uniform_cartesian.hpp>
 #include <mesh/meshblock.hpp>
 
 #include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/geometry_types.hpp"
+#include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
-
-namespace kamayan {
-
-struct TestRegion {
-  std::array<Real, 3> xmin;
-  std::array<Real, 3> xmax;
-  std::array<Real, 3> xrat;
-  std::array<int, 3> nx;
-};
-
-parthenon::UniformCartesian MakeCoordinatesCartesian3DForPack() {
-  TestRegion region{{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}, {8, 8, 8}};
-  return parthenon::UniformCartesian(
-      parthenon::RegionSize(region.xmin, region.xmax, region.xrat, region.nx), nullptr);
-}
-
-parthenon::UniformCartesian MakeCoordinatesCylindrical2DForPack() {
-  TestRegion region{
-      {0.0, 0.0, 0.0}, {1.0, 2.0 * std::numbers::pi, 1.0}, {1.0, 1.0, 1.0}, {4, 4, 1}};
-  return parthenon::UniformCartesian(
-      parthenon::RegionSize(region.xmin, region.xmax, region.xrat, region.nx), nullptr);
-}
-
-namespace {
-
-constexpr Real REL_TOL = 1e-10;
-constexpr Real ABS_TOL = 1e-12;
-
-bool IsRelClose(Real a, Real b) {
-  if (std::abs(b) < ABS_TOL) {
-    return std::abs(a - b) < ABS_TOL;
-  }
-  return std::abs((a - b) / b) < REL_TOL;
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyDx(CoordPack &pack, CoordObj &coords) {
-  static_assert(
-      std::is_same_v<CoordPack, grid::CoordinatePack<Geometry::cartesian>> ||
-          std::is_same_v<CoordPack, grid::CoordinatePack<Geometry::cylindrical>>,
-      "CoordPack must be CoordinatePack");
-  EXPECT_FLOAT_EQ(pack.template Dx<Axis::IAXIS>(0, 0, 0),
-                  coords.template Dx<Axis::IAXIS>());
-  EXPECT_FLOAT_EQ(pack.template Dx<Axis::JAXIS>(0, 0, 0),
-                  coords.template Dx<Axis::JAXIS>());
-  EXPECT_FLOAT_EQ(pack.template Dx<Axis::KAXIS>(0, 0, 0),
-                  coords.template Dx<Axis::KAXIS>());
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyXc(CoordPack &pack, CoordObj &coords) {
-  for (int i = 0; i < 8; i++) {
-    EXPECT_FLOAT_EQ(pack.template Xc<Axis::IAXIS>(0, 0, i),
-                    coords.template Xc<Axis::IAXIS>(i));
-  }
-  for (int j = 0; j < 8; j++) {
-    EXPECT_FLOAT_EQ(pack.template Xc<Axis::JAXIS>(0, j, 0),
-                    coords.template Xc<Axis::JAXIS>(j));
-  }
-  for (int k = 0; k < 8; k++) {
-    EXPECT_FLOAT_EQ(pack.template Xc<Axis::KAXIS>(k, 0, 0),
-                    coords.template Xc<Axis::KAXIS>(k));
-  }
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyXf(CoordPack &pack, CoordObj &coords) {
-  for (int i = 0; i <= 8; i++) {
-    EXPECT_FLOAT_EQ(pack.template Xf<Axis::IAXIS>(0, 0, i),
-                    coords.template Xf<Axis::IAXIS>(i));
-  }
-  for (int j = 0; j <= 8; j++) {
-    EXPECT_FLOAT_EQ(pack.template Xf<Axis::JAXIS>(0, j, 0),
-                    coords.template Xf<Axis::JAXIS>(j));
-  }
-  for (int k = 0; k <= 8; k++) {
-    EXPECT_FLOAT_EQ(pack.template Xf<Axis::KAXIS>(k, 0, 0),
-                    coords.template Xf<Axis::KAXIS>(k));
-  }
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyFaceArea(CoordPack &pack, CoordObj &coords) {
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::IAXIS>(k, j, i),
-                        coords.template FaceArea<Axis::IAXIS>(k, j, i));
-        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::JAXIS>(k, j, i),
-                        coords.template FaceArea<Axis::JAXIS>(k, j, i));
-        EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::KAXIS>(k, j, i),
-                        coords.template FaceArea<Axis::KAXIS>(k, j, i));
-      }
-    }
-  }
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyEdgeLength(CoordPack &pack, CoordObj &coords) {
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::IAXIS>(k, j, i),
-                        coords.template EdgeLength<Axis::IAXIS>(k, j, i));
-        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::JAXIS>(k, j, i),
-                        coords.template EdgeLength<Axis::JAXIS>(k, j, i));
-        EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::KAXIS>(k, j, i),
-                        coords.template EdgeLength<Axis::KAXIS>(k, j, i));
-      }
-    }
-  }
+#include "kamayan/fields.hpp"
+#include "kamayan/kamayan.hpp"
+#include "kamayan/unit.hpp"
+
+using namespace kamayan;
+using namespace grid;
+
+parthenon::BlockList_t MakeTestBlockList(const std::shared_ptr<KamayanUnit> pkg,
+                                         const int NBLOCKS, const int NXB,
+                                         const int NDIM) {
+  parthenon::BlockList_t block_list;
+  block_list.reserve(NBLOCKS);
+  for (int i = 0; i < NBLOCKS; ++i) {
+    auto pmb = std::make_shared<parthenon::MeshBlock>(NXB, NDIM);
+    auto &pmbd = pmb->meshblock_data.Get();
+    pmbd->Initialize(pkg, pmb);
+    block_list.push_back(pmb);
+  }
+  return block_list;
+}
+
+parthenon::MeshData<Real> MakeTestMeshData(parthenon::BlockList_t block_list) {
+  parthenon::MeshData<Real> mesh_data("base");
+  mesh_data.Initialize(block_list, nullptr);
+  return mesh_data;
+}
+
+void AddCoordFields(KamayanUnit *pkg, Geometry geom) {
+  using parthenon::Metadata;
+  GeometryOptions::dispatch(
+      [&]<Geometry g>() {
+        auto md = Metadata({Metadata::Cell, Metadata::Derived});
+        pkg->AddField<coords::Volume>(md);
+        auto axis_md = Metadata({Metadata::Cell, Metadata::Derived});
+        [&]<Axis... axes>() {
+          (pkg->AddField<coords::Dx<axes>>(axis_md), ...);
+          (pkg->AddField<coords::X<axes>>(axis_md), ...);
+          (pkg->AddField<coords::Xc<axes>>(axis_md), ...);
+          (pkg->AddField<coords::Xf<axes>>(axis_md), ...);
+          (pkg->AddField<coords::FaceArea<axes>>(axis_md), ...);
+          (pkg->AddField<coords::EdgeLength<axes>>(axis_md), ...);
+        }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
+      },
+      geom);
+}
+
+TEST(CoordinatePackTest, SimpleKernelConstruction) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cartesian);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  const Real dx = 1.0 / static_cast<Real>(NXB);
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::Dx<Axis::IAXIS>(), k, j, i) = dx;
+        pack(0, coords::Dx<Axis::JAXIS>(), k, j, i) = dx;
+        pack(0, coords::Dx<Axis::KAXIS>(), k, j, i) = dx;
+        pack(0, coords::Volume(), k, j, i) = dx * dx * dx;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - 0.125) > 1e-10) nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
 }
-
-template <typename CoordPack, typename CoordObj>
-void VerifyCellVolume(CoordPack &pack, CoordObj &coords) {
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(pack.CellVolume(k, j, i), coords.CellVolume(k, j, i));
-      }
-    }
-  }
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyVolumeTopological(CoordPack &pack, CoordObj &coords) {
-  auto cell_vol = pack.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
-  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F1, 0, 0, 0),
-                  pack.template FaceArea<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F2, 0, 0, 0),
-                  pack.template FaceArea<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::F3, 0, 0, 0),
-                  pack.template FaceArea<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
-}
-
-template <typename CoordPack, typename CoordObj>
-void VerifyRuntimeAxisDispatch(CoordPack &pack, CoordObj &coords) {
-  EXPECT_FLOAT_EQ(pack.template Dx<Axis::IAXIS>(0, 0, 0), pack.Dx(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.template Xc<Axis::IAXIS>(0, 0, 0), pack.Xc(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.template Xf<Axis::IAXIS>(0, 0, 0), pack.Xf(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.template FaceArea<Axis::IAXIS>(0, 0, 0),
-                  pack.FaceArea(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(pack.template EdgeLength<Axis::IAXIS>(0, 0, 0),
-                  pack.EdgeLength(Axis::IAXIS, 0, 0, 0));
-}
-
-}  // namespace
-
-TEST(CoordinatePackTest, Cartesian3D_PackConstruction) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-  (void)coords;
-}
-
-TEST(CoordinatePackTest, Cartesian3D_Dx_Template) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), 0.125);
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::JAXIS>(), 0.125);
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::KAXIS>(), 0.125);
-}
-
-TEST(CoordinatePackTest, Cartesian3D_Xc_Template) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  for (int i = 0; i < 8; i++) {
-    EXPECT_FLOAT_EQ(coords.template Xc<Axis::IAXIS>(i), 0.0625 + i * 0.125);
-  }
-  for (int j = 0; j < 8; j++) {
-    EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(j), 0.0625 + j * 0.125);
-  }
-  for (int k = 0; k < 8; k++) {
-    EXPECT_FLOAT_EQ(coords.template Xc<Axis::KAXIS>(k), 0.0625 + k * 0.125);
-  }
-}
-
-TEST(CoordinatePackTest, Cartesian3D_Xf_Template) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  for (int i = 0; i <= 8; i++) {
-    EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(i), i * 0.125);
-  }
-  for (int j = 0; j <= 8; j++) {
-    EXPECT_FLOAT_EQ(coords.template Xf<Axis::JAXIS>(j), j * 0.125);
-  }
-  for (int k = 0; k <= 8; k++) {
-    EXPECT_FLOAT_EQ(coords.template Xf<Axis::KAXIS>(k), k * 0.125);
-  }
-}
-
-TEST(CoordinatePackTest, Cartesian3D_FaceArea_Template) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0), 0.125 * 0.125);
-  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(0, 0, 0), 0.125 * 0.125);
-  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(0, 0, 0), 0.125 * 0.125);
-
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(k, j, i), 0.125 * 0.125);
-        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::JAXIS>(k, j, i), 0.125 * 0.125);
-        EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::KAXIS>(k, j, i), 0.125 * 0.125);
-      }
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cartesian3D_EdgeLength_Template) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0), 0.125);
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(0, 0, 0), 0.125);
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(0, 0, 0), 0.125);
-
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(k, j, i), 0.125);
-        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::JAXIS>(k, j, i), 0.125);
-        EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::KAXIS>(k, j, i), 0.125);
-      }
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cartesian3D_CellVolume) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.CellVolume(0, 0, 0), 0.125 * 0.125 * 0.125);
-
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++) {
-      for (int k = 0; k < 8; k++) {
-        EXPECT_FLOAT_EQ(coords.CellVolume(k, j, i), 0.125 * 0.125 * 0.125);
-      }
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cartesian3D_Volume_Topological) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  auto cell_vol = coords.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
-                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
-                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
-                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E1, 0, 0, 0),
-                  coords.template EdgeLength<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E2, 0, 0, 0),
-                  coords.template EdgeLength<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::E3, 0, 0, 0),
-                  coords.template EdgeLength<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
-}
-
-TEST(CoordinatePackTest, Cartesian3D_RuntimeAxisDispatch) {
-  auto raw_coords = MakeCoordinatesCartesian3DForPack();
-  auto coords = grid::Coordinates<Geometry::cartesian>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), coords.Dx(Axis::IAXIS));
-  EXPECT_FLOAT_EQ(coords.template Xc<Axis::IAXIS>(0), coords.Xc(Axis::IAXIS, 0));
-  EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(0), coords.Xf(Axis::IAXIS, 0));
-  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0),
-                  coords.FaceArea(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0),
-                  coords.EdgeLength(Axis::IAXIS, 0, 0, 0));
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_PackConstruction) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-  (void)coords;
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_Dx_Template) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), 0.25);
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::JAXIS>(), std::numbers::pi / 2.0);
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::KAXIS>(), 2.0 * std::numbers::pi);
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_Xc_Template) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  for (int i = 0; i < 4; i++) {
-    auto r0 = coords.template Xf<Axis::IAXIS>(i);
-    auto r1 = coords.template Xf<Axis::IAXIS>(i + 1);
-    auto expected_xc = (2.0 / 3.0) * (r1 * r1 * r1 - r0 * r0 * r0) / (r1 * r1 - r0 * r0);
-    auto actual_xc = coords.template Xc<Axis::IAXIS>(i);
-    ASSERT_TRUE(IsRelClose(actual_xc, expected_xc));
-  }
-
-  for (int j = 0; j < 4; j++) {
-    auto expected_xc_j = std::numbers::pi / 4.0 + j * (std::numbers::pi / 2.0);
-    auto actual_xc_j = coords.template Xc<Axis::JAXIS>(j);
-    ASSERT_TRUE(IsRelClose(actual_xc_j, expected_xc_j));
-  }
-
-  ASSERT_TRUE(IsRelClose(coords.template Xc<Axis::KAXIS>(0), 0.5));
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_FaceArea_Template) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 4; j++) {
-      auto r = coords.template Xf<Axis::IAXIS>(i);
-      auto dx_j = coords.template Dx<Axis::JAXIS>();
-      auto dx_k = coords.template Dx<Axis::KAXIS>();
-      auto expected_i = r * dx_j * dx_k;
-      auto actual_i = coords.template FaceArea<Axis::IAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(actual_i, expected_i));
-
-      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
-      auto rm = coords.template Xf<Axis::IAXIS>(i);
-      auto expected_j = 0.5 * (rp * rp - rm * rm) * dx_k;
-      auto actual_j = coords.template FaceArea<Axis::JAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(actual_j, expected_j));
-
-      auto dx_i = coords.template Dx<Axis::IAXIS>();
-      auto expected_k = dx_i * dx_j;
-      auto actual_k = coords.template FaceArea<Axis::KAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(actual_k, expected_k));
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_EdgeLength_Template) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 4; j++) {
-      auto dx_i = coords.template Dx<Axis::IAXIS>();
-      auto el_i = coords.template EdgeLength<Axis::IAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(el_i, dx_i));
-
-      auto dx_j = coords.template Dx<Axis::JAXIS>();
-      auto el_j = coords.template EdgeLength<Axis::JAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(el_j, dx_j));
-
-      auto r = coords.template Xf<Axis::IAXIS>(i);
-      auto dx_k = coords.template Dx<Axis::KAXIS>();
-      auto expected_k = std::abs(r) * dx_k;
-      auto actual_k = coords.template EdgeLength<Axis::KAXIS>(0, j, i);
-      ASSERT_TRUE(IsRelClose(actual_k, expected_k));
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_CellVolume) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 4; j++) {
-      auto rp = coords.template Xf<Axis::IAXIS>(i + 1);
-      auto rm = coords.template Xf<Axis::IAXIS>(i);
-      auto dx_k = coords.template Dx<Axis::KAXIS>();
-      auto dx_j = coords.template Dx<Axis::JAXIS>();
-      auto expected = 0.5 * dx_k * (rp * rp - rm * rm) * dx_j;
-      auto actual = coords.CellVolume(0, j, i);
-      ASSERT_TRUE(IsRelClose(actual, expected));
-    }
-  }
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_Volume_Topological) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  auto cell_vol = coords.CellVolume(0, 0, 0);
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::CC, 0, 0, 0), cell_vol);
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F1, 0, 0, 0),
-                  coords.template FaceArea<Axis::IAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F2, 0, 0, 0),
-                  coords.template FaceArea<Axis::JAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::F3, 0, 0, 0),
-                  coords.template FaceArea<Axis::KAXIS>(0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.Volume(TopologicalElement::NN, 0, 0, 0), 1.0);
-}
-
-TEST(CoordinatePackTest, Cylindrical2D_RuntimeAxisDispatch) {
-  auto raw_coords = MakeCoordinatesCylindrical2DForPack();
-  auto coords = grid::Coordinates<Geometry::cylindrical>(raw_coords);
-
-  EXPECT_FLOAT_EQ(coords.template Dx<Axis::IAXIS>(), coords.Dx(Axis::IAXIS));
-  EXPECT_FLOAT_EQ(coords.template Xc<Axis::JAXIS>(0), coords.Xc(Axis::JAXIS, 0));
-  EXPECT_FLOAT_EQ(coords.template Xf<Axis::IAXIS>(0), coords.Xf(Axis::IAXIS, 0));
-  EXPECT_FLOAT_EQ(coords.template FaceArea<Axis::IAXIS>(0, 0, 0),
-                  coords.FaceArea(Axis::IAXIS, 0, 0, 0));
-  EXPECT_FLOAT_EQ(coords.template EdgeLength<Axis::IAXIS>(0, 0, 0),
-                  coords.EdgeLength(Axis::IAXIS, 0, 0, 0));
-}
-
-}  // namespace kamayan

From 5e68444172019d70016362bedfef884b8091e468 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Thu, 2 Apr 2026 21:29:36 -0700
Subject: [PATCH 31/55] thats better

---
 src/grid/tests/test_coordinates_pack.cpp | 262 ++++++++++++++++++++++-
 1 file changed, 253 insertions(+), 9 deletions(-)

diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index b2c5c8f..5f2735a 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -1,22 +1,16 @@
 #include <gtest/gtest.h>
 
-#include <iostream>
 #include <memory>
 
 #include <mesh/meshblock.hpp>
 
 #include "grid/coordinates.hpp"
-#include "grid/geometry.hpp"
 #include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
-#include "kamayan/fields.hpp"
-#include "kamayan/kamayan.hpp"
 #include "kamayan/unit.hpp"
 
-using namespace kamayan;
-using namespace grid;
-
+namespace kamayan::grid {
 parthenon::BlockList_t MakeTestBlockList(const std::shared_ptr<KamayanUnit> pkg,
                                          const int NBLOCKS, const int NXB,
                                          const int NDIM) {
@@ -56,10 +50,11 @@ void AddCoordFields(KamayanUnit *pkg, Geometry geom) {
       geom);
 }
 
-TEST(CoordinatePackTest, SimpleKernelConstruction) {
+TEST(CoordinatePackTest, CartesianDx) {
   constexpr int NDIM = 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
+  const Real expected_dx = 0.125;
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
@@ -85,6 +80,52 @@ TEST(CoordinatePackTest, SimpleKernelConstruction) {
         pack(0, coords::Dx<Axis::IAXIS>(), k, j, i) = dx;
         pack(0, coords::Dx<Axis::JAXIS>(), k, j, i) = dx;
         pack(0, coords::Dx<Axis::KAXIS>(), k, j, i) = dx;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - expected_dx) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, j, i) - expected_dx) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, j, i) - expected_dx) > 1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+TEST(CoordinatePackTest, CartesianVolume) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+  const Real expected_vol = 0.125 * 0.125 * 0.125;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cartesian);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  const Real dx = 1.0 / static_cast<Real>(NXB);
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
         pack(0, coords::Volume(), k, j, i) = dx * dx * dx;
       });
 
@@ -93,9 +134,212 @@ TEST(CoordinatePackTest, SimpleKernelConstruction) {
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
         auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - 0.125) > 1e-10) nw += 1;
+        if (Kokkos::abs(cpack.CellVolume(k, j, i) - expected_vol) > 1e-10) nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+TEST(CoordinatePackTest, CartesianXc) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+  const Real dx = 1.0 / static_cast<Real>(NXB);
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cartesian);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::Xc<Axis::IAXIS>(), k, j, i) = (static_cast<Real>(i) + 0.5) * dx;
+        pack(0, coords::Xc<Axis::JAXIS>(), k, j, i) = (static_cast<Real>(j) + 0.5) * dx;
+        pack(0, coords::Xc<Axis::KAXIS>(), k, j, i) = (static_cast<Real>(k) + 0.5) * dx;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+        auto expected_xc_i = (static_cast<Real>(i) + 0.5) * dx;
+        auto expected_xc_j = (static_cast<Real>(j) + 0.5) * dx;
+        auto expected_xc_k = (static_cast<Real>(k) + 0.5) * dx;
+        if (Kokkos::abs(cpack.template Xc<Axis::IAXIS>(k, j, i) - expected_xc_i) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Xc<Axis::JAXIS>(k, j, i) - expected_xc_j) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Xc<Axis::KAXIS>(k, j, i) - expected_xc_k) > 1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+TEST(CoordinatePackTest, CartesianFaceArea) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+  const Real dx = 1.0 / static_cast<Real>(NXB);
+  const Real expected_fa = dx * dx;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cartesian);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::FaceArea<Axis::IAXIS>(), k, j, i) = dx * dx;
+        pack(0, coords::FaceArea<Axis::JAXIS>(), k, j, i) = dx * dx;
+        pack(0, coords::FaceArea<Axis::KAXIS>(), k, j, i) = dx * dx;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+        if (Kokkos::abs(cpack.template FaceArea<Axis::IAXIS>(k, j, i) - expected_fa) >
+            1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template FaceArea<Axis::JAXIS>(k, j, i) - expected_fa) >
+            1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template FaceArea<Axis::KAXIS>(k, j, i) - expected_fa) >
+            1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+TEST(CoordinatePackTest, CartesianEdgeLength) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+  const Real dx = 1.0 / static_cast<Real>(NXB);
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cartesian);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cartesian);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::EdgeLength<Axis::IAXIS>(), k, j, i) = dx;
+        pack(0, coords::EdgeLength<Axis::JAXIS>(), k, j, i) = dx;
+        pack(0, coords::EdgeLength<Axis::KAXIS>(), k, j, i) = dx;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::IAXIS>(k, j, i) - dx) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::JAXIS>(k, j, i) - dx) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::KAXIS>(k, j, i) - dx) > 1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+TEST(CoordinatePackTest, CylindricalDxAndVolume) {
+  constexpr int NDIM = 3;
+  constexpr int NXB = 4;
+  constexpr int NBLOCKS = 1;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(Geometry::cylindrical);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), Geometry::cylindrical);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  const Real dr = 0.25;
+  const Real dtheta = 0.7853981633974483;
+  const Real dphi = 1.5707963267948966;
+
+  parthenon::par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        pack(0, coords::Dx<Axis::IAXIS>(), k, j, i) = dr;
+        pack(0, coords::Dx<Axis::JAXIS>(), k, j, i) = dtheta;
+        pack(0, coords::Dx<Axis::KAXIS>(), k, j, i) = dphi;
+        pack(0, coords::Volume(), k, j, i) = dr * dtheta * dphi;
+      });
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<Geometry::cylindrical, CoordFields>(pack, b);
+        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - dr) > 1e-10) nw += 1;
+        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, j, i) - dtheta) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, j, i) - dphi) > 1e-10) nw += 1;
+        if (Kokkos::abs(cpack.CellVolume(k, j, i) - dr * dtheta * dphi) > 1e-10) nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
 
   EXPECT_EQ(n_wrong, 0);
 }
+}  // namespace kamayan::grid

From fe143f6c81f63f60383852b059b492a5d09ab598 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sat, 4 Apr 2026 15:57:30 -0700
Subject: [PATCH 32/55] making tests closer to real usage

---
 src/grid/coordinates.hpp                 |  28 ++++--
 src/grid/geometry.hpp                    |   5 +
 src/grid/tests/test_coordinates_pack.cpp | 116 +++++++++++++++++------
 src/grid/tests/test_geometry.cpp         |   4 +
 src/grid/tests/test_geometry.hpp         |   4 +-
 5 files changed, 120 insertions(+), 37 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 691c2d1..62a4991 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -100,6 +100,7 @@ using CoordFields = ConcatTypeLists_t<AxisCoords, ScalarCoords>;
 template <template <Axis> typename Coord>
 using AllAxes = TypeList<Coord<Axis::IAXIS>, Coord<Axis::JAXIS>, Coord<Axis::KAXIS>>;
 
+using Deltas = AllAxes<coords::Dx>;
 using Xcenter = AllAxes<coords::X>;
 using Xcoord = AllAxes<coords::Xc>;
 using Xface = AllAxes<coords::Xf>;
@@ -216,7 +217,7 @@ struct CoordinatePack {
   KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::Dx<ax>>(),
                   "Coordinate Pack must be constructed with required Dx coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::Dx<ax>>(k, j, i);
     return Dx_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
@@ -224,7 +225,7 @@ struct CoordinatePack {
   KOKKOS_INLINE_FUNCTION Real X(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::X<ax>>(),
                   "Coordinate Pack must be constructed with required X coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::X<ax>>(k, j, i);
     return X_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
@@ -232,7 +233,7 @@ struct CoordinatePack {
   KOKKOS_INLINE_FUNCTION Real Xc(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::Xc<ax>>(),
                   "Coordinate Pack must be constructed with required Xc coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::Xc<ax>>(k, j, i);
     return Xc_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
@@ -240,7 +241,7 @@ struct CoordinatePack {
   KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::Xf<ax>>(),
                   "Coordinate Pack must be constructed with required Xf coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::Xf<ax>>(k, j, i);
     return Xf_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
@@ -249,7 +250,7 @@ struct CoordinatePack {
     static_assert(
         FieldList::template Contains<coords::FaceArea<ax>>(),
         "Coordinate Pack must be constructed with required FaceArea coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::FaceArea<ax>>(k, j, i);
     return FaceArea_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
@@ -258,14 +259,14 @@ struct CoordinatePack {
     static_assert(
         FieldList::template Contains<coords::EdgeLength<ax>>(),
         "Coordinate Pack must be constructed with required EdgeLength coordinate");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::EdgeLength<ax>>(k, j, i);
     return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
   }
 
   KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::Volume>(),
                   "Coordinate Pack must be constructed with required Volume");
-    auto kji = Index_(k, j, i);
+    auto kji = Index_<coords::Volume>(k, j, i);
     return Volume_(kji[0], kji[1], kji[2]);
   }
 
@@ -382,8 +383,21 @@ struct CoordinatePack {
     return function.template operator()<Axis::IAXIS>(std::forward<Args>(args)...);
   }
 
+  template <typename T>
   KOKKOS_INLINE_FUNCTION std::array<int, 3> Index_(const int k, const int j,
                                                    const int i) const {
+    using shapes = impl::CoordShapes<geom>;
+    if constexpr (shapes::Scalars::template Contains<T>()) {
+      return {0, 0, 0};
+    } else if constexpr (shapes::Icoord::template Contains<T>()) {
+      return {0, 0, i};
+    } else if constexpr (shapes::Jcoord::template Contains<T>()) {
+      return {0, j, 0};
+    } else if constexpr (shapes::Kcoord::template Contains<T>()) {
+      return {k, 0, 0};
+    } else {
+      static_assert(false, "Type not handled by CoordShapes");
+    }
     return {k, j, i};
   }
 
diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 1bee8ec..1bf5e53 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -56,6 +56,11 @@ struct Coordinates {
     return AxisOverload([this]<Axis AX>() { return Dx<AX>(); }, ax);
   }
 
+  template <Axis ax>
+  KOKKOS_FORCEINLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
+    return Dx<ax>();
+  }
+
   // position at cell centroids
   template <Axis ax>
   KOKKOS_FORCEINLINE_FUNCTION Real Xc(const int idx) const {
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 5f2735a..24bc5e6 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -1,13 +1,18 @@
+#include <format>
 #include <gtest/gtest.h>
 
 #include <memory>
+#include <vector>
 
 #include <mesh/meshblock.hpp>
 
 #include "grid/coordinates.hpp"
+#include "grid/geometry.hpp"
 #include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
+#include "grid/tests/test_geometry.hpp"
+#include "kamayan/fields.hpp"
 #include "kamayan/unit.hpp"
 
 namespace kamayan::grid {
@@ -31,38 +36,75 @@ parthenon::MeshData<Real> MakeTestMeshData(parthenon::BlockList_t block_list) {
   return mesh_data;
 }
 
-void AddCoordFields(KamayanUnit *pkg, Geometry geom) {
+void AddCoordFields(KamayanUnit *pkg, Geometry geom, const int nx3, const int nx2,
+                    const int nx1) {
   using parthenon::Metadata;
   GeometryOptions::dispatch(
       [&]<Geometry g>() {
-        auto md = Metadata({Metadata::Cell, Metadata::Derived});
+        const int nghost = 0;
+        auto md = Metadata({Metadata::Cell, Metadata::OneCopy},
+                           CoordinateShape<g, coords::Volume>(nx3, nx2, nx1, nghost));
         pkg->AddField<coords::Volume>(md);
-        auto axis_md = Metadata({Metadata::Cell, Metadata::Derived});
+        std::vector<MetadataFlag> axis_md{Metadata::None, Metadata::OneCopy};
         [&]<Axis... axes>() {
-          (pkg->AddField<coords::Dx<axes>>(axis_md), ...);
-          (pkg->AddField<coords::X<axes>>(axis_md), ...);
-          (pkg->AddField<coords::Xc<axes>>(axis_md), ...);
-          (pkg->AddField<coords::Xf<axes>>(axis_md), ...);
-          (pkg->AddField<coords::FaceArea<axes>>(axis_md), ...);
-          (pkg->AddField<coords::EdgeLength<axes>>(axis_md), ...);
+          (pkg->AddField<coords::Dx<axes>>(Metadata(
+               axis_md, CoordinateShape<g, coords::Dx<axes>>(nx3, nx2, nx1, nghost))),
+           ...);
+          (pkg->AddField<coords::X<axes>>(Metadata(
+               axis_md, CoordinateShape<g, coords::X<axes>>(nx3, nx2, nx1, nghost))),
+           ...);
+          (pkg->AddField<coords::Xc<axes>>(Metadata(
+               axis_md, CoordinateShape<g, coords::Xc<axes>>(nx3, nx2, nx1, nghost))),
+           ...);
+          (pkg->AddField<coords::Xf<axes>>(Metadata(
+               axis_md, CoordinateShape<g, coords::Xf<axes>>(nx3, nx2, nx1, nghost))),
+           ...);
+          (pkg->AddField<coords::FaceArea<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::FaceArea<axes>>(nx3, nx2, nx1,
+                                                                            nghost))),
+           ...);
+          (pkg->AddField<coords::EdgeLength<axes>>(Metadata(
+               axis_md,
+               CoordinateShape<g, coords::EdgeLength<axes>>(nx3, nx2, nx1, nghost))),
+           ...);
         }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
       },
       geom);
 }
 
-TEST(CoordinatePackTest, CartesianDx) {
+template <Geometry geom, typename T, typename Functor>
+void FillCoords(const Functor &functor, const int nblocks, const parthenon::IndexRange jb,
+                const parthenon::IndexRange ib, const parthenon::IndexRange kb) {
+  par_for(PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+          functor);
+}
+
+template <Geometry geom>
+auto MakeCoords() {
+  if constexpr (geom == Geometry::cylindrical) {
+    return MakeCoordinatesCylindrical2D();
+  } else if constexpr (geom == Geometry::cartesian) {
+    return MakeCoordinatesCartesian3D();
+  } else {
+    static_assert(false, "Can't make coordinates for geometry");
+  }
+
+  return MakeCoordinatesCartesian3D();
+}
+
+template <Geometry geom>
+void TestCoordsPackDx(const int ndim) {
   constexpr int NDIM = 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
-  const Real expected_dx = 0.125;
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
   auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
+  cfg->Add(geom);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian);
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -73,25 +115,36 @@ TEST(CoordinatePackTest, CartesianDx) {
   auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
   auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
 
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
   const Real dx = 1.0 / static_cast<Real>(NXB);
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::Dx<Axis::IAXIS>(), k, j, i) = dx;
-        pack(0, coords::Dx<Axis::JAXIS>(), k, j, i) = dx;
-        pack(0, coords::Dx<Axis::KAXIS>(), k, j, i) = dx;
-      });
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] = CoordinateIndexRanges<geom, coords::Dx<ax>>(cellbounds);
+          FillCoords<geom, coords::Dx<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::Dx<ax>(), k, j, i) = coords.template Dx<ax>(k, j, i);
+              },
+              NBLOCKS, kb, jb, ib);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
 
   int n_wrong = 0;
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - expected_dx) > 1e-10)
+        auto cpack = CoordinatePack<geom, Deltas>(pack, b);
+        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, i, i) -
+                        coords.template Dx<Axis::IAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, j, i) - expected_dx) > 1e-10)
+        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, i, i) -
+                        coords.template Dx<Axis::JAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, j, i) - expected_dx) > 1e-10)
+        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, i, i) -
+                        coords.template Dx<Axis::KAXIS>(k, j, i)) > 1e-10)
           nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
@@ -99,6 +152,10 @@ TEST(CoordinatePackTest, CartesianDx) {
   EXPECT_EQ(n_wrong, 0);
 }
 
+TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(3); }
+TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(2); }
+
+#if 0
 TEST(CoordinatePackTest, CartesianVolume) {
   constexpr int NDIM = 3;
   constexpr int NXB = 8;
@@ -111,7 +168,7 @@ TEST(CoordinatePackTest, CartesianVolume) {
   cfg->Add(Geometry::cartesian);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian);
+  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -153,7 +210,7 @@ TEST(CoordinatePackTest, CartesianXc) {
   cfg->Add(Geometry::cartesian);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian);
+  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -205,7 +262,7 @@ TEST(CoordinatePackTest, CartesianFaceArea) {
   cfg->Add(Geometry::cartesian);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian);
+  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -256,7 +313,7 @@ TEST(CoordinatePackTest, CartesianEdgeLength) {
   cfg->Add(Geometry::cartesian);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian);
+  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -303,7 +360,7 @@ TEST(CoordinatePackTest, CylindricalDxAndVolume) {
   cfg->Add(Geometry::cylindrical);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cylindrical);
+  AddCoordFields(pkg.get(), Geometry::cylindrical, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -342,4 +399,5 @@ TEST(CoordinatePackTest, CylindricalDxAndVolume) {
 
   EXPECT_EQ(n_wrong, 0);
 }
+#endif
 }  // namespace kamayan::grid
diff --git a/src/grid/tests/test_geometry.cpp b/src/grid/tests/test_geometry.cpp
index c6ae8c9..f11d328 100644
--- a/src/grid/tests/test_geometry.cpp
+++ b/src/grid/tests/test_geometry.cpp
@@ -56,6 +56,10 @@ parthenon::UniformCartesian MakeCoordinatesCartesian3D() {
   return parthenon::UniformCartesian(MakeRegionSize(Cartesian3D()), nullptr);
 }
 
+parthenon::UniformCartesian MakeCoordinates2D() {
+  return parthenon::UniformCartesian(MakeRegionSize(Cylindrical2D()), nullptr);
+}
+
 parthenon::UniformCartesian MakeCoordinatesCylindrical2D() {
   return parthenon::UniformCartesian(MakeRegionSize(Cylindrical2D()), nullptr);
 }
diff --git a/src/grid/tests/test_geometry.hpp b/src/grid/tests/test_geometry.hpp
index 8eaef2f..3b0b0cb 100644
--- a/src/grid/tests/test_geometry.hpp
+++ b/src/grid/tests/test_geometry.hpp
@@ -9,6 +9,8 @@ namespace kamayan {
 
 std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCartesian3D();
 std::shared_ptr<parthenon::MeshBlock> MakeTestMeshBlockCylindrical2D();
+parthenon::UniformCartesian MakeCoordinatesCartesian3D();
+parthenon::UniformCartesian MakeCoordinatesCylindrical2D();
 
 }  // namespace kamayan
-#endif  // GRID_TESTS_TEST_GEOMETRY_HPP_
\ No newline at end of file
+#endif  // GRID_TESTS_TEST_GEOMETRY_HPP_

From dc0e77bb78cc03f4c97c950bf450e4b1ba2d132b Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sat, 4 Apr 2026 19:36:15 -0700
Subject: [PATCH 33/55] most of these work

---
 src/grid/coordinates.hpp                 |   2 +-
 src/grid/tests/test_coordinates_pack.cpp | 258 ++++++++++++-----------
 2 files changed, 132 insertions(+), 128 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 62a4991..6d133de 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -181,7 +181,7 @@ CoordinateIndexRanges(parthenon::IndexShape cellbounds,
 
   auto make_index_range = [](const parthenon::IndexRange bounds, const int n) {
     auto out = parthenon::IndexRange{bounds.s, bounds.s};
-    out.e += std::max(n - 2, 0);
+    out.e += std::max(n - 1, 0);
     return out;
   };
   return {
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 24bc5e6..23cb802 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -94,8 +94,8 @@ auto MakeCoords() {
 
 template <Geometry geom>
 void TestCoordsPackDx(const int ndim) {
-  constexpr int NDIM = 3;
-  constexpr int NXB = 8;
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
+  constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
@@ -118,7 +118,6 @@ void TestCoordsPackDx(const int ndim) {
   auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
   auto coords = Coordinates<geom>(MakeCoords<geom>());
 
-  const Real dx = 1.0 / static_cast<Real>(NXB);
   [&]<Axis... axes>() {
     (
         [&]<Axis ax>() {
@@ -127,7 +126,7 @@ void TestCoordsPackDx(const int ndim) {
               KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
                 pack(b, coords::Dx<ax>(), k, j, i) = coords.template Dx<ax>(k, j, i);
               },
-              NBLOCKS, kb, jb, ib);
+              NBLOCKS, jb, ib, kb);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
@@ -137,13 +136,13 @@ void TestCoordsPackDx(const int ndim) {
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
         auto cpack = CoordinatePack<geom, Deltas>(pack, b);
-        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, i, i) -
+        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) -
                         coords.template Dx<Axis::IAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, i, i) -
+        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, j, i) -
                         coords.template Dx<Axis::JAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, i, i) -
+        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, j, i) -
                         coords.template Dx<Axis::KAXIS>(k, j, i)) > 1e-10)
           nw += 1;
       },
@@ -152,23 +151,19 @@ void TestCoordsPackDx(const int ndim) {
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(3); }
-TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(2); }
-
-#if 0
-TEST(CoordinatePackTest, CartesianVolume) {
-  constexpr int NDIM = 3;
+template <Geometry geom>
+void TestCoordsPackVolume() {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
-  const Real expected_vol = 0.125 * 0.125 * 0.125;
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
   auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
+  cfg->Add(geom);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -179,38 +174,42 @@ TEST(CoordinatePackTest, CartesianVolume) {
   auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
   auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
 
-  const Real dx = 1.0 / static_cast<Real>(NXB);
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::Volume(), k, j, i) = dx * dx * dx;
-      });
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  auto [kb_vol, jb_vol, ib_vol] = CoordinateIndexRanges<geom, coords::Volume>(cellbounds);
+  FillCoords<geom, coords::Volume>(
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+        pack(b, coords::Volume(), k, j, i) = coords.CellVolume(k, j, i);
+      },
+      NBLOCKS, jb_vol, ib_vol, kb_vol);
 
   int n_wrong = 0;
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.CellVolume(k, j, i) - expected_vol) > 1e-10) nw += 1;
+        auto cpack = CoordinatePack<geom, ScalarCoords>(pack, b);
+        if (Kokkos::abs(cpack.CellVolume(k, j, i) - coords.CellVolume(k, j, i)) > 1e-10)
+          nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
 
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CartesianXc) {
-  constexpr int NDIM = 3;
+template <Geometry geom>
+void TestCoordsPackXc(const int ndim) {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
-  const Real dx = 1.0 / static_cast<Real>(NXB);
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
   auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
+  cfg->Add(geom);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -221,48 +220,56 @@ TEST(CoordinatePackTest, CartesianXc) {
   auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
   auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
 
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::Xc<Axis::IAXIS>(), k, j, i) = (static_cast<Real>(i) + 0.5) * dx;
-        pack(0, coords::Xc<Axis::JAXIS>(), k, j, i) = (static_cast<Real>(j) + 0.5) * dx;
-        pack(0, coords::Xc<Axis::KAXIS>(), k, j, i) = (static_cast<Real>(k) + 0.5) * dx;
-      });
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] = CoordinateIndexRanges<geom, coords::Xc<ax>>(cellbounds);
+          FillCoords<geom, coords::Xc<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::Xc<ax>(), k, j, i) = coords.template Xc<ax>(k, j, i);
+              },
+              NBLOCKS, jb, ib, kb);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
 
   int n_wrong = 0;
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        auto expected_xc_i = (static_cast<Real>(i) + 0.5) * dx;
-        auto expected_xc_j = (static_cast<Real>(j) + 0.5) * dx;
-        auto expected_xc_k = (static_cast<Real>(k) + 0.5) * dx;
-        if (Kokkos::abs(cpack.template Xc<Axis::IAXIS>(k, j, i) - expected_xc_i) > 1e-10)
+        auto cpack = CoordinatePack<geom, Xcoord>(pack, b);
+        if (Kokkos::abs(cpack.template Xc<Axis::IAXIS>(k, j, i) -
+                        coords.template Xc<Axis::IAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Xc<Axis::JAXIS>(k, j, i) - expected_xc_j) > 1e-10)
+        if (Kokkos::abs(cpack.template Xc<Axis::JAXIS>(k, j, i) -
+                        coords.template Xc<Axis::JAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template Xc<Axis::KAXIS>(k, j, i) - expected_xc_k) > 1e-10)
+        if (Kokkos::abs(cpack.template Xc<Axis::KAXIS>(k, j, i) -
+                        coords.template Xc<Axis::KAXIS>(k, j, i)) > 1e-10)
           nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
 
+  std::cout << n_wrong << "\n";
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CartesianFaceArea) {
-  constexpr int NDIM = 3;
-  constexpr int NXB = 8;
+template <Geometry geom>
+void TestCoordsPackFaceArea(const int ndim) {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
+  constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
-  const Real dx = 1.0 / static_cast<Real>(NXB);
-  const Real expected_fa = dx * dx;
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
   auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
+  cfg->Add(geom);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -273,27 +280,37 @@ TEST(CoordinatePackTest, CartesianFaceArea) {
   auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
   auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
 
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::FaceArea<Axis::IAXIS>(), k, j, i) = dx * dx;
-        pack(0, coords::FaceArea<Axis::JAXIS>(), k, j, i) = dx * dx;
-        pack(0, coords::FaceArea<Axis::KAXIS>(), k, j, i) = dx * dx;
-      });
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] =
+              CoordinateIndexRanges<geom, coords::FaceArea<ax>>(cellbounds);
+          FillCoords<geom, coords::FaceArea<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::FaceArea<ax>(), k, j, i) =
+                    coords.template FaceArea<ax>(k, j, i);
+              },
+              NBLOCKS, jb, ib, kb);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
 
   int n_wrong = 0;
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.template FaceArea<Axis::IAXIS>(k, j, i) - expected_fa) >
-            1e-10)
+        auto cpack = CoordinatePack<geom, FaceAreas>(pack, b);
+        if (Kokkos::abs(cpack.template FaceArea<Axis::IAXIS>(k, j, i) -
+                        coords.template FaceArea<Axis::IAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template FaceArea<Axis::JAXIS>(k, j, i) - expected_fa) >
-            1e-10)
+        if (Kokkos::abs(cpack.template FaceArea<Axis::JAXIS>(k, j, i) -
+                        coords.template FaceArea<Axis::JAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template FaceArea<Axis::KAXIS>(k, j, i) - expected_fa) >
-            1e-10)
+        if (Kokkos::abs(cpack.template FaceArea<Axis::KAXIS>(k, j, i) -
+                        coords.template FaceArea<Axis::KAXIS>(k, j, i)) > 1e-10)
           nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
@@ -301,19 +318,19 @@ TEST(CoordinatePackTest, CartesianFaceArea) {
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CartesianEdgeLength) {
-  constexpr int NDIM = 3;
-  constexpr int NXB = 8;
+template <Geometry geom>
+void TestCoordsPackEdgeLength(const int ndim) {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
+  constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
-  const Real dx = 1.0 / static_cast<Real>(NXB);
 
   auto pkg = std::make_shared<KamayanUnit>("Test Package");
   auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
   auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cartesian);
+  cfg->Add(geom);
   pkg->InitResources(rps, cfg);
 
-  AddCoordFields(pkg.get(), Geometry::cartesian, NXB, NXB, NXB);
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
 
   auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
   auto md = MakeTestMeshData(block_list);
@@ -324,24 +341,37 @@ TEST(CoordinatePackTest, CartesianEdgeLength) {
   auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
   auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
 
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::EdgeLength<Axis::IAXIS>(), k, j, i) = dx;
-        pack(0, coords::EdgeLength<Axis::JAXIS>(), k, j, i) = dx;
-        pack(0, coords::EdgeLength<Axis::KAXIS>(), k, j, i) = dx;
-      });
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] =
+              CoordinateIndexRanges<geom, coords::EdgeLength<ax>>(cellbounds);
+          FillCoords<geom, coords::EdgeLength<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::EdgeLength<ax>(), k, j, i) =
+                    coords.template EdgeLength<ax>(k, j, i);
+              },
+              NBLOCKS, jb, ib, kb);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
 
   int n_wrong = 0;
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.template EdgeLength<Axis::IAXIS>(k, j, i) - dx) > 1e-10)
+        auto cpack = CoordinatePack<geom, AllAxes<coords::EdgeLength>>(pack, b);
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::IAXIS>(k, j, i) -
+                        coords.template EdgeLength<Axis::IAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template EdgeLength<Axis::JAXIS>(k, j, i) - dx) > 1e-10)
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::JAXIS>(k, j, i) -
+                        coords.template EdgeLength<Axis::JAXIS>(k, j, i)) > 1e-10)
           nw += 1;
-        if (Kokkos::abs(cpack.template EdgeLength<Axis::KAXIS>(k, j, i) - dx) > 1e-10)
+        if (Kokkos::abs(cpack.template EdgeLength<Axis::KAXIS>(k, j, i) -
+                        coords.template EdgeLength<Axis::KAXIS>(k, j, i)) > 1e-10)
           nw += 1;
       },
       Kokkos::Sum<int>(n_wrong));
@@ -349,55 +379,29 @@ TEST(CoordinatePackTest, CartesianEdgeLength) {
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CylindricalDxAndVolume) {
-  constexpr int NDIM = 3;
-  constexpr int NXB = 4;
-  constexpr int NBLOCKS = 1;
-
-  auto pkg = std::make_shared<KamayanUnit>("Test Package");
-  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
-  auto cfg = std::make_shared<Config>();
-  cfg->Add(Geometry::cylindrical);
-  pkg->InitResources(rps, cfg);
-
-  AddCoordFields(pkg.get(), Geometry::cylindrical, NXB, NXB, NXB);
-
-  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
-  auto md = MakeTestMeshData(block_list);
-
-  auto pack = GetPack(CoordFields(), pkg.get(), &md);
-
-  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
-  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
-  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(3); }
+TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(2); }
 
-  const Real dr = 0.25;
-  const Real dtheta = 0.7853981633974483;
-  const Real dphi = 1.5707963267948966;
+TEST(CoordinatePackTest, CartesianVolume) { TestCoordsPackVolume<Geometry::cartesian>(); }
+TEST(CoordinatePackTest, CylindricalVolume) {
+  TestCoordsPackVolume<Geometry::cylindrical>();
+}
 
-  parthenon::par_for(
-      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int k, const int j, const int i) {
-        pack(0, coords::Dx<Axis::IAXIS>(), k, j, i) = dr;
-        pack(0, coords::Dx<Axis::JAXIS>(), k, j, i) = dtheta;
-        pack(0, coords::Dx<Axis::KAXIS>(), k, j, i) = dphi;
-        pack(0, coords::Volume(), k, j, i) = dr * dtheta * dphi;
-      });
+TEST(CoordinatePackTest, CartesianXc) { TestCoordsPackXc<Geometry::cartesian>(3); }
+TEST(CoordinatePackTest, CylindricalXc) { TestCoordsPackXc<Geometry::cylindrical>(2); }
 
-  int n_wrong = 0;
-  parthenon::par_reduce(
-      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<Geometry::cylindrical, CoordFields>(pack, b);
-        if (Kokkos::abs(cpack.template Dx<Axis::IAXIS>(k, j, i) - dr) > 1e-10) nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::JAXIS>(k, j, i) - dtheta) > 1e-10)
-          nw += 1;
-        if (Kokkos::abs(cpack.template Dx<Axis::KAXIS>(k, j, i) - dphi) > 1e-10) nw += 1;
-        if (Kokkos::abs(cpack.CellVolume(k, j, i) - dr * dtheta * dphi) > 1e-10) nw += 1;
-      },
-      Kokkos::Sum<int>(n_wrong));
+TEST(CoordinatePackTest, CartesianFaceArea) {
+  TestCoordsPackFaceArea<Geometry::cartesian>(3);
+}
+TEST(CoordinatePackTest, CylindricalFaceArea) {
+  TestCoordsPackFaceArea<Geometry::cylindrical>(2);
+}
 
-  EXPECT_EQ(n_wrong, 0);
+TEST(CoordinatePackTest, CartesianEdgeLength) {
+  TestCoordsPackEdgeLength<Geometry::cartesian>(3);
 }
-#endif
+TEST(CoordinatePackTest, CylindricalEdgeLength) {
+  TestCoordsPackEdgeLength<Geometry::cylindrical>(2);
+}
+
 }  // namespace kamayan::grid

From cad6dbe71c82fece59d6e3c56101150d08b8ddbe Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sat, 4 Apr 2026 22:36:07 -0700
Subject: [PATCH 34/55] big pickle keeps trying to overwrite stupid things

---
 src/grid/coordinates.hpp                 | 103 +++++++++++++++++------
 src/grid/tests/test_coordinates_pack.cpp |  74 ++++++++++++++--
 2 files changed, 143 insertions(+), 34 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 6d133de..85b1a51 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -20,8 +20,10 @@
 #include "interface/variable_state.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/strings.hpp"
+#include "kamayan_utils/type_abstractions.hpp"
 #include "kamayan_utils/type_list.hpp"
 #include "kokkos_types.hpp"
+#include "utils/concepts_lite.hpp"
 
 namespace kamayan::grid {
 
@@ -218,7 +220,7 @@ struct CoordinatePack {
     static_assert(FieldList::template Contains<coords::Dx<ax>>(),
                   "Coordinate Pack must be constructed with required Dx coordinate");
     auto kji = Index_<coords::Dx<ax>>(k, j, i);
-    return Dx_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::Dx<ax>())(kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
@@ -226,7 +228,7 @@ struct CoordinatePack {
     static_assert(FieldList::template Contains<coords::X<ax>>(),
                   "Coordinate Pack must be constructed with required X coordinate");
     auto kji = Index_<coords::X<ax>>(k, j, i);
-    return X_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::X<ax>())(kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
@@ -234,7 +236,7 @@ struct CoordinatePack {
     static_assert(FieldList::template Contains<coords::Xc<ax>>(),
                   "Coordinate Pack must be constructed with required Xc coordinate");
     auto kji = Index_<coords::Xc<ax>>(k, j, i);
-    return Xc_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::Xc<ax>())(kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
@@ -242,7 +244,7 @@ struct CoordinatePack {
     static_assert(FieldList::template Contains<coords::Xf<ax>>(),
                   "Coordinate Pack must be constructed with required Xf coordinate");
     auto kji = Index_<coords::Xf<ax>>(k, j, i);
-    return Xf_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::Xf<ax>())(kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
@@ -251,7 +253,7 @@ struct CoordinatePack {
         FieldList::template Contains<coords::FaceArea<ax>>(),
         "Coordinate Pack must be constructed with required FaceArea coordinate");
     auto kji = Index_<coords::FaceArea<ax>>(k, j, i);
-    return FaceArea_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::FaceArea<ax>())(kji[0], kji[1], kji[2]);
   }
 
   template <Axis ax>
@@ -260,7 +262,7 @@ struct CoordinatePack {
         FieldList::template Contains<coords::EdgeLength<ax>>(),
         "Coordinate Pack must be constructed with required EdgeLength coordinate");
     auto kji = Index_<coords::EdgeLength<ax>>(k, j, i);
-    return EdgeLength_[static_cast<int>(ax)](kji[0], kji[1], kji[2]);
+    return Get_(coords::EdgeLength<ax>())(kji[0], kji[1], kji[2]);
   }
 
   KOKKOS_INLINE_FUNCTION Real CellVolume(const int k, const int j, const int i) const {
@@ -366,7 +368,9 @@ struct CoordinatePack {
   // par array type returned by SparsePack<>(b, V())
   using par_array_t = parthenon::ParArray3D<Real, parthenon::VariableState>;
 
-  par_array_t Dx_[3], X_[3], Xc_[3], Xf_[3], FaceArea_[3], EdgeLength_[3], Volume_;
+  par_array_t Dx1_, Dx2_, Dx3_, X1_, X2_, X3_, Xc1_, Xc2_, Xc3_, Xf1_, Xf2_, Xf3_,
+      FaceArea1_, FaceArea2_, FaceArea3_, EdgeLength1_, EdgeLength2_, EdgeLength3_,
+      Volume_;
 
   template <typename Func, typename... Args>
   KOKKOS_FORCEINLINE_FUNCTION Real AxisOverload(Func function, Axis ax,
@@ -396,7 +400,7 @@ struct CoordinatePack {
     } else if constexpr (shapes::Kcoord::template Contains<T>()) {
       return {k, 0, 0};
     } else {
-      static_assert(false, "Type not handled by CoordShapes");
+      static_assert(always_false<T>, "Type not handled by CoordShapes");
     }
     return {k, j, i};
   }
@@ -405,43 +409,86 @@ struct CoordinatePack {
   requires(AxisCoords::Contains<T>())
   KOKKOS_INLINE_FUNCTION par_array_t &Get_(const T &t) {
     if constexpr (std::is_same_v<T, coords::Dx<Axis::KAXIS>>) {
-      return Dx_[0];
+      return Dx1_;
     } else if constexpr (std::is_same_v<T, coords::Dx<Axis::JAXIS>>) {
-      return Dx_[1];
+      return Dx2_;
     } else if constexpr (std::is_same_v<T, coords::Dx<Axis::IAXIS>>) {
-      return Dx_[2];
+      return Dx3_;
     } else if constexpr (std::is_same_v<T, coords::X<Axis::KAXIS>>) {
-      return X_[0];
+      return X1_;
     } else if constexpr (std::is_same_v<T, coords::X<Axis::JAXIS>>) {
-      return X_[1];
+      return X2_;
     } else if constexpr (std::is_same_v<T, coords::X<Axis::IAXIS>>) {
-      return X_[2];
+      return X3_;
     } else if constexpr (std::is_same_v<T, coords::Xc<Axis::KAXIS>>) {
-      return Xc_[0];
+      return Xc1_;
     } else if constexpr (std::is_same_v<T, coords::Xc<Axis::JAXIS>>) {
-      return Xc_[1];
+      return Xc2_;
     } else if constexpr (std::is_same_v<T, coords::Xc<Axis::IAXIS>>) {
-      return Xc_[2];
+      return Xc3_;
     } else if constexpr (std::is_same_v<T, coords::Xf<Axis::KAXIS>>) {
-      return Xf_[0];
+      return Xf1_;
     } else if constexpr (std::is_same_v<T, coords::Xf<Axis::JAXIS>>) {
-      return Xf_[1];
+      return Xf2_;
     } else if constexpr (std::is_same_v<T, coords::Xf<Axis::IAXIS>>) {
-      return Xf_[2];
+      return Xf3_;
     } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::KAXIS>>) {
-      return FaceArea_[0];
+      return FaceArea1_;
     } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::JAXIS>>) {
-      return FaceArea_[1];
+      return FaceArea2_;
     } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::IAXIS>>) {
-      return FaceArea_[2];
+      return FaceArea3_;
     } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::KAXIS>>) {
-      return EdgeLength_[0];
+      return EdgeLength1_;
     } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::JAXIS>>) {
-      return EdgeLength_[1];
+      return EdgeLength2_;
     } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::IAXIS>>) {
-      return EdgeLength_[2];
+      return EdgeLength3_;
     } else {
-      static_assert(false, "Type not mapped to a coordinate");
+      static_assert(always_false<T>, "Type not mapped to a coordinate");
+    }
+  }
+  template <typename T>
+  requires(AxisCoords::Contains<T>())
+  KOKKOS_INLINE_FUNCTION const par_array_t &Get_(const T &t) const {
+    if constexpr (std::is_same_v<T, coords::Dx<Axis::KAXIS>>) {
+      return Dx1_;
+    } else if constexpr (std::is_same_v<T, coords::Dx<Axis::JAXIS>>) {
+      return Dx2_;
+    } else if constexpr (std::is_same_v<T, coords::Dx<Axis::IAXIS>>) {
+      return Dx3_;
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::KAXIS>>) {
+      return X1_;
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::JAXIS>>) {
+      return X2_;
+    } else if constexpr (std::is_same_v<T, coords::X<Axis::IAXIS>>) {
+      return X3_;
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::KAXIS>>) {
+      return Xc1_;
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::JAXIS>>) {
+      return Xc2_;
+    } else if constexpr (std::is_same_v<T, coords::Xc<Axis::IAXIS>>) {
+      return Xc3_;
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::KAXIS>>) {
+      return Xf1_;
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::JAXIS>>) {
+      return Xf2_;
+    } else if constexpr (std::is_same_v<T, coords::Xf<Axis::IAXIS>>) {
+      return Xf3_;
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::KAXIS>>) {
+      return FaceArea1_;
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::JAXIS>>) {
+      return FaceArea2_;
+    } else if constexpr (std::is_same_v<T, coords::FaceArea<Axis::IAXIS>>) {
+      return FaceArea3_;
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::KAXIS>>) {
+      return EdgeLength1_;
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::JAXIS>>) {
+      return EdgeLength2_;
+    } else if constexpr (std::is_same_v<T, coords::EdgeLength<Axis::IAXIS>>) {
+      return EdgeLength3_;
+    } else {
+      static_assert(always_false<T>, "Type not mapped to a coordinate");
     }
   }
 
@@ -451,7 +498,7 @@ struct CoordinatePack {
     if constexpr (std::is_same_v<T, coords::Volume>) {
       return Volume_;
     } else {
-      static_assert(false, "Type not mapped to a coordinate");
+      static_assert(always_false<T>, "Type not mapped to a coordinate");
     }
   }
 };
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 23cb802..9fce0f2 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -14,6 +14,7 @@
 #include "grid/tests/test_geometry.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan/unit.hpp"
+#include "kamayan_utils/type_abstractions.hpp"
 
 namespace kamayan::grid {
 parthenon::BlockList_t MakeTestBlockList(const std::shared_ptr<KamayanUnit> pkg,
@@ -86,7 +87,7 @@ auto MakeCoords() {
   } else if constexpr (geom == Geometry::cartesian) {
     return MakeCoordinatesCartesian3D();
   } else {
-    static_assert(false, "Can't make coordinates for geometry");
+    static_assert(always_false<Coordinates<geom>>, "Can't make coordinates for geometry");
   }
 
   return MakeCoordinatesCartesian3D();
@@ -188,7 +189,7 @@ void TestCoordsPackVolume() {
   parthenon::par_reduce(
       PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
-        auto cpack = CoordinatePack<geom, ScalarCoords>(pack, b);
+        auto cpack = CoordinatePack<geom>(pack, b);
         if (Kokkos::abs(cpack.CellVolume(k, j, i) - coords.CellVolume(k, j, i)) > 1e-10)
           nw += 1;
       },
@@ -253,7 +254,6 @@ void TestCoordsPackXc(const int ndim) {
       },
       Kokkos::Sum<int>(n_wrong));
 
-  std::cout << n_wrong << "\n";
   EXPECT_EQ(n_wrong, 0);
 }
 
@@ -379,17 +379,79 @@ void TestCoordsPackEdgeLength(const int ndim) {
   EXPECT_EQ(n_wrong, 0);
 }
 
+template <Geometry geom>
+void TestCoordsPackXf(const int ndim) {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(geom);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] = CoordinateIndexRanges<geom, coords::Xf<ax>>(cellbounds);
+          FillCoords<geom, coords::Xf<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::Xf<ax>(), k, j, i) = coords.template Xf<ax>(k, j, i);
+              },
+              NBLOCKS, jb, ib, kb);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<geom, Xface>(pack, b);
+        if (Kokkos::abs(cpack.template Xf<Axis::IAXIS>(k, j, i) -
+                        coords.template Xf<Axis::IAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Xf<Axis::JAXIS>(k, j, i) -
+                        coords.template Xf<Axis::JAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template Xf<Axis::KAXIS>(k, j, i) -
+                        coords.template Xf<Axis::KAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
 TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(3); }
 TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(2); }
 
+TEST(CoordinatePackTest, CartesianXc) { TestCoordsPackXc<Geometry::cartesian>(3); }
+TEST(CoordinatePackTest, CylindricalXc) { TestCoordsPackXc<Geometry::cylindrical>(2); }
+
+TEST(CoordinatePackTest, CartesianXf) { TestCoordsPackXf<Geometry::cartesian>(3); }
+TEST(CoordinatePackTest, CylindricalXf) { TestCoordsPackXf<Geometry::cylindrical>(2); }
+
 TEST(CoordinatePackTest, CartesianVolume) { TestCoordsPackVolume<Geometry::cartesian>(); }
 TEST(CoordinatePackTest, CylindricalVolume) {
   TestCoordsPackVolume<Geometry::cylindrical>();
 }
 
-TEST(CoordinatePackTest, CartesianXc) { TestCoordsPackXc<Geometry::cartesian>(3); }
-TEST(CoordinatePackTest, CylindricalXc) { TestCoordsPackXc<Geometry::cylindrical>(2); }
-
 TEST(CoordinatePackTest, CartesianFaceArea) {
   TestCoordsPackFaceArea<Geometry::cartesian>(3);
 }

From e4ce47fb06238de75a51f85a69ee57f02e0cd76c Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 5 Apr 2026 10:03:35 -0700
Subject: [PATCH 35/55] all better

---
 src/grid/coordinates.hpp                 | 45 +++++++++++----------
 src/grid/tests/test_coordinates_pack.cpp | 51 +++++++++++++-----------
 2 files changed, 53 insertions(+), 43 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 85b1a51..afbddb5 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -147,29 +147,34 @@ struct CoordShapes<Geometry::cylindrical> {
 template <Geometry geom, typename T>
 requires(CoordFields::template Contains<T>())
 std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1,
-                                 const int nghost) {
+                                 const int nghost, const bool reverse = false) {
   using TE = TopologicalElement;
   using shapes = impl::CoordShapes<geom>;
 
-  if constexpr (shapes::Scalars::template Contains<T>()) {
-    return {1, 1, 1};
-  } else if constexpr (shapes::Icoord::template Contains<T>()) {
-    auto N = nx1 + 2 * nghost;
-    N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
-    return {1, 1, N};
-  } else if constexpr (shapes::Jcoord::template Contains<T>()) {
-    auto N = nx2 + 2 * nghost;
-    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
-    return {1, N, 1};
-  } else if constexpr (shapes::Kcoord::template Contains<T>()) {
-    auto N = nx3 + 2 * nghost;
-    N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
-    return {N, 1, 1};
-  }
-
-  PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
-                             T::name(), OptInfo<Geometry>::Label(geom))
-                     .c_str());
+  auto shape = [&]() -> std::vector<int> {
+    if constexpr (shapes::Scalars::template Contains<T>()) {
+      return {1, 1, 1};
+    } else if constexpr (shapes::Icoord::template Contains<T>()) {
+      auto N = nx1 + 2 * nghost;
+      N += (T::element == TE::F1 || T::element == TE::E2 || T::element == TE::E3) ? 1 : 0;
+      return {1, 1, N};
+    } else if constexpr (shapes::Jcoord::template Contains<T>()) {
+      auto N = nx2 + 2 * nghost;
+      N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+      return {1, N, 1};
+    } else if constexpr (shapes::Kcoord::template Contains<T>()) {
+      auto N = nx3 + 2 * nghost;
+      N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+      return {N, 1, 1};
+    }
+
+    PARTHENON_FAIL(std::format("Coordinate Variable {} not handled for geometry {}",
+                               T::name(), OptInfo<Geometry>::Label(geom))
+                       .c_str());
+  }();
+
+  if (reverse) std::reverse(shape.begin(), shape.end());
+  return shape;
 }
 
 template <Geometry geom, typename T>
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 9fce0f2..2d5c8b6 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -43,30 +43,35 @@ void AddCoordFields(KamayanUnit *pkg, Geometry geom, const int nx3, const int nx
   GeometryOptions::dispatch(
       [&]<Geometry g>() {
         const int nghost = 0;
-        auto md = Metadata({Metadata::Cell, Metadata::OneCopy},
-                           CoordinateShape<g, coords::Volume>(nx3, nx2, nx1, nghost));
+        auto md = Metadata(
+            {Metadata::None, Metadata::OneCopy},
+            CoordinateShape<g, coords::Volume>(nx3, nx2, nx1, nghost, /*revers=*/true));
         pkg->AddField<coords::Volume>(md);
         std::vector<MetadataFlag> axis_md{Metadata::None, Metadata::OneCopy};
         [&]<Axis... axes>() {
-          (pkg->AddField<coords::Dx<axes>>(Metadata(
-               axis_md, CoordinateShape<g, coords::Dx<axes>>(nx3, nx2, nx1, nghost))),
+          (pkg->AddField<coords::Dx<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::Dx<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
-          (pkg->AddField<coords::X<axes>>(Metadata(
-               axis_md, CoordinateShape<g, coords::X<axes>>(nx3, nx2, nx1, nghost))),
+          (pkg->AddField<coords::X<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::X<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
-          (pkg->AddField<coords::Xc<axes>>(Metadata(
-               axis_md, CoordinateShape<g, coords::Xc<axes>>(nx3, nx2, nx1, nghost))),
+          (pkg->AddField<coords::Xc<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::Xc<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
-          (pkg->AddField<coords::Xf<axes>>(Metadata(
-               axis_md, CoordinateShape<g, coords::Xf<axes>>(nx3, nx2, nx1, nghost))),
+          (pkg->AddField<coords::Xf<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::Xf<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
           (pkg->AddField<coords::FaceArea<axes>>(
-               Metadata(axis_md, CoordinateShape<g, coords::FaceArea<axes>>(nx3, nx2, nx1,
-                                                                            nghost))),
+               Metadata(axis_md, CoordinateShape<g, coords::FaceArea<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
-          (pkg->AddField<coords::EdgeLength<axes>>(Metadata(
-               axis_md,
-               CoordinateShape<g, coords::EdgeLength<axes>>(nx3, nx2, nx1, nghost))),
+          (pkg->AddField<coords::EdgeLength<axes>>(
+               Metadata(axis_md, CoordinateShape<g, coords::EdgeLength<axes>>(
+                                     nx3, nx2, nx1, nghost, /*revers=*/true))),
            ...);
         }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
       },
@@ -74,8 +79,8 @@ void AddCoordFields(KamayanUnit *pkg, Geometry geom, const int nx3, const int nx
 }
 
 template <Geometry geom, typename T, typename Functor>
-void FillCoords(const Functor &functor, const int nblocks, const parthenon::IndexRange jb,
-                const parthenon::IndexRange ib, const parthenon::IndexRange kb) {
+void FillCoords(const Functor &functor, const int nblocks, const parthenon::IndexRange kb,
+                const parthenon::IndexRange jb, const parthenon::IndexRange ib) {
   par_for(PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
           functor);
 }
@@ -127,7 +132,7 @@ void TestCoordsPackDx(const int ndim) {
               KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
                 pack(b, coords::Dx<ax>(), k, j, i) = coords.template Dx<ax>(k, j, i);
               },
-              NBLOCKS, jb, ib, kb);
+              NBLOCKS, kb, jb, ib);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
@@ -183,7 +188,7 @@ void TestCoordsPackVolume() {
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
         pack(b, coords::Volume(), k, j, i) = coords.CellVolume(k, j, i);
       },
-      NBLOCKS, jb_vol, ib_vol, kb_vol);
+      NBLOCKS, kb_vol, jb_vol, ib_vol);
 
   int n_wrong = 0;
   parthenon::par_reduce(
@@ -232,7 +237,7 @@ void TestCoordsPackXc(const int ndim) {
               KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
                 pack(b, coords::Xc<ax>(), k, j, i) = coords.template Xc<ax>(k, j, i);
               },
-              NBLOCKS, jb, ib, kb);
+              NBLOCKS, kb, jb, ib);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
@@ -293,7 +298,7 @@ void TestCoordsPackFaceArea(const int ndim) {
                 pack(b, coords::FaceArea<ax>(), k, j, i) =
                     coords.template FaceArea<ax>(k, j, i);
               },
-              NBLOCKS, jb, ib, kb);
+              NBLOCKS, kb, jb, ib);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
@@ -354,7 +359,7 @@ void TestCoordsPackEdgeLength(const int ndim) {
                 pack(b, coords::EdgeLength<ax>(), k, j, i) =
                     coords.template EdgeLength<ax>(k, j, i);
               },
-              NBLOCKS, jb, ib, kb);
+              NBLOCKS, kb, jb, ib);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
@@ -413,7 +418,7 @@ void TestCoordsPackXf(const int ndim) {
               KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
                 pack(b, coords::Xf<ax>(), k, j, i) = coords.template Xf<ax>(k, j, i);
               },
-              NBLOCKS, jb, ib, kb);
+              NBLOCKS, kb, jb, ib);
         }.template operator()<axes>(),
         ...);
   }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();

From 00c797b3be9bd0c737f38c19cd91d9e2b5b40f2e Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 5 Apr 2026 11:37:59 -0700
Subject: [PATCH 36/55] test it all

---
 src/grid/tests/test_coordinates_pack.cpp | 92 ++++++++++++++++++++----
 1 file changed, 77 insertions(+), 15 deletions(-)

diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 2d5c8b6..75082d8 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -99,7 +99,7 @@ auto MakeCoords() {
 }
 
 template <Geometry geom>
-void TestCoordsPackDx(const int ndim) {
+void TestCoordsPackDx() {
   constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
@@ -204,7 +204,66 @@ void TestCoordsPackVolume() {
 }
 
 template <Geometry geom>
-void TestCoordsPackXc(const int ndim) {
+void TestCoordsPackX() {
+  constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
+  constexpr int NXB = 8;
+  constexpr int NBLOCKS = 1;
+
+  auto pkg = std::make_shared<KamayanUnit>("Test Package");
+  auto rps = std::make_shared<runtime_parameters::RuntimeParameters>();
+  auto cfg = std::make_shared<Config>();
+  cfg->Add(geom);
+  pkg->InitResources(rps, cfg);
+
+  AddCoordFields(pkg.get(), geom, NXB, NXB, NXB);
+
+  auto block_list = MakeTestBlockList(pkg, NBLOCKS, NXB, NDIM);
+  auto md = MakeTestMeshData(block_list);
+
+  auto pack = GetPack(CoordFields(), pkg.get(), &md);
+
+  auto ib = md.GetBoundsI(parthenon::IndexDomain::interior);
+  auto jb = md.GetBoundsJ(parthenon::IndexDomain::interior);
+  auto kb = md.GetBoundsK(parthenon::IndexDomain::interior);
+
+  auto cellbounds = parthenon::IndexShape(NXB, NXB, NXB, 0);
+  auto coords = Coordinates<geom>(MakeCoords<geom>());
+
+  [&]<Axis... axes>() {
+    (
+        [&]<Axis ax>() {
+          auto [kb, jb, ib] = CoordinateIndexRanges<geom, coords::X<ax>>(cellbounds);
+          FillCoords<geom, coords::Xc<ax>>(
+              KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
+                pack(b, coords::X<ax>(), k, j, i) = coords.template Xi<ax>(k, j, i);
+              },
+              NBLOCKS, kb, jb, ib);
+        }.template operator()<axes>(),
+        ...);
+  }.template operator()<Axis::KAXIS, Axis::JAXIS, Axis::IAXIS>();
+
+  int n_wrong = 0;
+  parthenon::par_reduce(
+      PARTHENON_AUTO_LABEL, 0, NBLOCKS - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, int &nw) {
+        auto cpack = CoordinatePack<geom, Xcenter>(pack, b);
+        if (Kokkos::abs(cpack.template X<Axis::IAXIS>(k, j, i) -
+                        coords.template Xi<Axis::IAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template X<Axis::JAXIS>(k, j, i) -
+                        coords.template Xi<Axis::JAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+        if (Kokkos::abs(cpack.template X<Axis::KAXIS>(k, j, i) -
+                        coords.template Xi<Axis::KAXIS>(k, j, i)) > 1e-10)
+          nw += 1;
+      },
+      Kokkos::Sum<int>(n_wrong));
+
+  EXPECT_EQ(n_wrong, 0);
+}
+
+template <Geometry geom>
+void TestCoordsPackXc() {
   constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
@@ -263,7 +322,7 @@ void TestCoordsPackXc(const int ndim) {
 }
 
 template <Geometry geom>
-void TestCoordsPackFaceArea(const int ndim) {
+void TestCoordsPackFaceArea() {
   constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
@@ -324,7 +383,7 @@ void TestCoordsPackFaceArea(const int ndim) {
 }
 
 template <Geometry geom>
-void TestCoordsPackEdgeLength(const int ndim) {
+void TestCoordsPackEdgeLength() {
   constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = (geom == Geometry::cylindrical) ? 4 : 8;
   constexpr int NBLOCKS = 1;
@@ -385,7 +444,7 @@ void TestCoordsPackEdgeLength(const int ndim) {
 }
 
 template <Geometry geom>
-void TestCoordsPackXf(const int ndim) {
+void TestCoordsPackXf() {
   constexpr int NDIM = (geom == Geometry::cylindrical) ? 2 : 3;
   constexpr int NXB = 8;
   constexpr int NBLOCKS = 1;
@@ -443,14 +502,17 @@ void TestCoordsPackXf(const int ndim) {
   EXPECT_EQ(n_wrong, 0);
 }
 
-TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(3); }
-TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(2); }
+TEST(CoordinatePackTest, CartesianDx) { TestCoordsPackDx<Geometry::cartesian>(); }
+TEST(CoordinatePackTest, CylindricalDx) { TestCoordsPackDx<Geometry::cylindrical>(); }
+
+TEST(CoordinatePackTest, CartesianX) { TestCoordsPackX<Geometry::cartesian>(); }
+TEST(CoordinatePackTest, CylindricalX) { TestCoordsPackX<Geometry::cylindrical>(); }
 
-TEST(CoordinatePackTest, CartesianXc) { TestCoordsPackXc<Geometry::cartesian>(3); }
-TEST(CoordinatePackTest, CylindricalXc) { TestCoordsPackXc<Geometry::cylindrical>(2); }
+TEST(CoordinatePackTest, CartesianXc) { TestCoordsPackXc<Geometry::cartesian>(); }
+TEST(CoordinatePackTest, CylindricalXc) { TestCoordsPackXc<Geometry::cylindrical>(); }
 
-TEST(CoordinatePackTest, CartesianXf) { TestCoordsPackXf<Geometry::cartesian>(3); }
-TEST(CoordinatePackTest, CylindricalXf) { TestCoordsPackXf<Geometry::cylindrical>(2); }
+TEST(CoordinatePackTest, CartesianXf) { TestCoordsPackXf<Geometry::cartesian>(); }
+TEST(CoordinatePackTest, CylindricalXf) { TestCoordsPackXf<Geometry::cylindrical>(); }
 
 TEST(CoordinatePackTest, CartesianVolume) { TestCoordsPackVolume<Geometry::cartesian>(); }
 TEST(CoordinatePackTest, CylindricalVolume) {
@@ -458,17 +520,17 @@ TEST(CoordinatePackTest, CylindricalVolume) {
 }
 
 TEST(CoordinatePackTest, CartesianFaceArea) {
-  TestCoordsPackFaceArea<Geometry::cartesian>(3);
+  TestCoordsPackFaceArea<Geometry::cartesian>();
 }
 TEST(CoordinatePackTest, CylindricalFaceArea) {
-  TestCoordsPackFaceArea<Geometry::cylindrical>(2);
+  TestCoordsPackFaceArea<Geometry::cylindrical>();
 }
 
 TEST(CoordinatePackTest, CartesianEdgeLength) {
-  TestCoordsPackEdgeLength<Geometry::cartesian>(3);
+  TestCoordsPackEdgeLength<Geometry::cartesian>();
 }
 TEST(CoordinatePackTest, CylindricalEdgeLength) {
-  TestCoordsPackEdgeLength<Geometry::cylindrical>(2);
+  TestCoordsPackEdgeLength<Geometry::cylindrical>();
 }
 
 }  // namespace kamayan::grid

From 50c6876f02feec58929831f6ece53be6b33b1706 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 5 Apr 2026 17:46:41 -0700
Subject: [PATCH 37/55] fix prolongation

---
 src/grid/geometry.hpp    | 13 +------------
 src/grid/grid.cpp        |  7 +++++--
 src/grid/grid_update.hpp |  6 +++++-
 3 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/grid/geometry.hpp b/src/grid/geometry.hpp
index 1bf5e53..abafce3 100644
--- a/src/grid/geometry.hpp
+++ b/src/grid/geometry.hpp
@@ -28,18 +28,7 @@ struct Coordinates {
 
   template <Axis ax, TopologicalElement el>
   KOKKOS_FORCEINLINE_FUNCTION Real X(const int idx) const {
-    constexpr int dir = AxisToInt(ax);
-    if constexpr (ax == Axis::IAXIS && TopologicalOffsetI(el)) {
-      return coords_.X<1, el>(idx);
-    } else if constexpr (ax == Axis::JAXIS && TopologicalOffsetJ(el)) {
-      return coords_.X<2, el>(idx);
-    } else if constexpr (ax == Axis::JAXIS && TopologicalOffsetK(el)) {
-      return coords_.X<3, el>(idx);
-    } else {
-      return Xc<ax>(idx);
-    }
-    return 0;  // This should never be reached, but w/o it some compilers generate
-               // warnings
+    return coords_.X<AxisToInt(ax), el>(idx);
   }
 
   // distance between cell centers
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index 93056aa..0e8c88c 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -155,8 +155,11 @@ void InitializeData(KamayanUnit *unit) {
   GeometryOptions::dispatch(
       [&]<Geometry geom>() {
         type_for(CoordFields(), [&]<typename T>(const T) {
-          auto m = Metadata({Metadata::OneCopy, Metadata::None},
-                            CoordinateShape<geom, T>(nx3, nx2, nx1, nghost));
+          // coordinate shape gives us (k,j,i) indexing, parthenon
+          // internally reverses this so expects (i,j,k)
+          auto m = Metadata(
+              {Metadata::OneCopy, Metadata::None},
+              CoordinateShape<geom, T>(nx3, nx2, nx1, nghost, /*reversed=*/true));
           unit->AddField<T>(m);
         });
       },
diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index 4b20111..ff642bc 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -8,6 +8,7 @@
 #include "grid_types.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan_utils/parallel.hpp"
+#include "kamayan_utils/type_list.hpp"
 
 namespace kamayan::grid {
 
@@ -18,6 +19,9 @@ void FluxDivergence(MeshData *md, MeshData *dudt_data) {
   auto u0 = desc_cc.GetPack(md);
   auto dudt = desc_cc.GetPack(dudt_data);
 
+  using Coords = ConcatTypeLists_t<TypeList<coords::Volume>, FaceAreas>;
+  auto cpack = GetPack(Coords(), md);
+
   if (u0.GetMaxNumberOfVars() == 0) return;
 
   const int nblocks = u0.GetNBlocks();
@@ -29,7 +33,7 @@ void FluxDivergence(MeshData *md, MeshData *dudt_data) {
       PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int km, const int jm, const int im) {
         using TE = TopologicalElement;
-        const auto coords = Coordinates<geom>(u0, b);
+        const auto coords = CoordinatePack<geom, Coords>(cpack, b);
         // we have to check the variable bounds for each block in case
         // that we are using sparse fields
         for (int var = u0.GetLowerBound(b); var <= u0.GetUpperBound(b); var++) {

From 04eef6668937cedfe49010ae8da6b8d14e44ac67 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 5 Apr 2026 20:05:57 -0700
Subject: [PATCH 38/55] move over to coordinate packs

---
 src/grid/grid_update.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index ff642bc..97c7de2 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -88,6 +88,8 @@ void FluxStokes(MeshData *md, MeshData *dudt_data) {
   auto u0 = desc_fc.GetPack(md);
   auto dudt = desc_fc.GetPack(dudt_data);
 
+  auto cpack = GetPack(CoordFields(), md);
+
   if (u0.GetMaxNumberOfVars() == 0) return;
 
   const int nblocks = u0.GetNBlocks();
@@ -101,7 +103,7 @@ void FluxStokes(MeshData *md, MeshData *dudt_data) {
       PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int b, const int km, const int jm, const int im) {
         using TE = TopologicalElement;
-        const auto coords = Coordinates<geom>(u0, b);
+        const auto coords = CoordinatePack<geom, CoordFields>(cpack, b);
         // we have to check the variable bounds for each block in case
         // that we are using sparse fields
         for (int var = u0.GetLowerBound(b); var <= u0.GetUpperBound(b); var++) {

From 1fe9f95a9ec390db277666c36ded764651ca6afe Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 8 Apr 2026 22:09:44 -0700
Subject: [PATCH 39/55] magnetic fields

---
 src/physics/hydro/hydro.cpp        | 53 ++++++++++++++++++++++++++++++
 src/physics/hydro/primconsflux.cpp | 20 ++++++-----
 2 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index 7cec8e7..f994d49 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -9,8 +9,10 @@
 
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid.hpp"
+#include "grid/grid_types.hpp"
 #include "grid/refinement_operations.hpp"
 #include "grid/subpack.hpp"
 #include "hydro_types.hpp"
@@ -20,6 +22,7 @@
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
 #include "kamayan_utils/type_list.hpp"
+#include "kokkos_types.hpp"
 #include "physics/hydro/hydro_types.hpp"
 #include "physics/hydro/primconsflux.hpp"
 
@@ -32,6 +35,9 @@ std::shared_ptr<KamayanUnit> ProcessUnit() {
   hydro->InitializeData.Register(InitializeData);
   // need to convert to primitives before calling equation of state
   hydro->PreparePrimitive.Register(PreparePrimitive, /*after=*/{}, /*before=*/{"eos"});
+  // for cylindrical geometry we also need to call prepareprimitive
+  // for the azimuthal magnetic field
+  hydro->PrepareConserved.Register(PrepareConserved, /*after=*/{}, /*before=*/{});
   hydro->PostMeshInitialization.Register(PostMeshInitialization, {"eos"});
   hydro->AddFluxTasks.Register(AddFluxTasks);
   hydro->AddTasksOneStep.Register(AddTasksOneStep);
@@ -229,4 +235,51 @@ TaskID AddTasksOneStep(TaskID prev, TaskList &tl, MeshData *md, MeshData *dudt)
   return final;
 }
 
+struct PrepareConserved_impl {
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
+  using value = TaskStatus;
+  template <HydroTrait hydro_traits, Geometry geom>
+  requires(hydro_traits::MHD == Mhd::off || geom == Geometry::cartesian)
+  value dispatch(MeshData *md) {
+    return TaskStatus::complete;
+  }
+
+  template <HydroTrait hydro_traits, Geometry geom>
+  requires(hydro_traits::MHD != Mhd::off && geom != Geometry::cartesian)
+  value dispatch(MeshData *md) {
+    // for the most part our conserved variables are maintained in separate
+    // fields, e.g., MOMENTUM, ENER, and so there isn't anything to prepare before
+    // advancing the system
+    //
+    // The exception is the angular magnetic field in cylindrical r-z geometry
+    // here we advance B_phi / r, and so need to perform the conversion before updating
+    using Fields = TypeList<MAGC>;
+    using PackVars = ConcatTypeLists_t<Fields, grid::Xcoord>;
+
+    auto pack = grid::GetPack(PackVars(), md);
+    const int nblocks = pack.GetNBlocks();
+    auto ib = md->GetBoundsI(IndexDomain::interior);
+    auto jb = md->GetBoundsJ(IndexDomain::interior);
+    auto kb = md->GetBoundsK(IndexDomain::interior);
+
+    par_for_outer(
+        PARTHENON_AUTO_LABEL, 0, 0, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e,
+        KOKKOS_LAMBDA(parthenon::team_mbr_t team, const int b, const int k, const int j) {
+          auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
+          par_for_inner(team, ib.s, ib.e, [&](const int i) {
+            if constexpr (geom == Geometry::cylindrical) {
+              // in cylindrical advance Bphi / r
+              pack(b, MAGC(2), k, j, i) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
+            }
+          });
+        });
+    return TaskStatus::complete;
+  }
+};
+
+TaskStatus PrepareConserved(MeshData *md) {
+  return Dispatcher<PrepareConserved_impl>(PARTHENON_AUTO_LABEL, GetConfig(md).get())
+      .execute(md);
+}
+
 }  // namespace kamayan::hydro
diff --git a/src/physics/hydro/primconsflux.cpp b/src/physics/hydro/primconsflux.cpp
index bdb387d..9a0d50b 100644
--- a/src/physics/hydro/primconsflux.cpp
+++ b/src/physics/hydro/primconsflux.cpp
@@ -1,6 +1,7 @@
 #include "physics/hydro/primconsflux.hpp"
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
@@ -8,6 +9,7 @@
 #include "kamayan/config.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
+#include "kamayan_utils/type_list.hpp"
 #include "physics/hydro/hydro_types.hpp"
 
 namespace kamayan::hydro {
@@ -20,7 +22,8 @@ struct PrepareConserved_impl {
   template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    auto pack = grid::GetPack(typename hydro_traits::ConsPrim(), md);
+    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::Xcoord>;
+    auto pack = grid::GetPack(Fields(), md);
     const int nblocks = pack.GetNBlocks();
     auto ib = md->GetBoundsI(IndexDomain::interior);
     auto jb = md->GetBoundsJ(IndexDomain::interior);
@@ -50,11 +53,11 @@ struct PrepareConserved_impl {
           Prim2Cons<hydro_traits>(U, U);
           // --8<-- [end:make-idx]
           if constexpr (geom == Geometry::cylindrical) {
-            auto coords = grid::Coordinates<geom>(pack, b);
+            auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
             // conserve angular momentum
-            U(MOMENTUM(2)) *= coords.template Xc<Axis::IAXIS>(i);
+            U(MOMENTUM(2)) *= coords.template Xc<Axis::IAXIS>(k, j, i);
             if constexpr (hydro_traits::MHD != Mhd::off) {
-              U(MAGC(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(i);
+              U(MAGC(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
             }
           }
         });
@@ -70,7 +73,8 @@ struct PreparePrimitive_impl {
   template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    auto pack = grid::GetPack(typename hydro_traits::ConsPrim(), md);
+    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::Xcoord>;
+    auto pack = grid::GetPack(Fields(), md);
     const int nblocks = pack.GetNBlocks();
     auto ib = md->GetBoundsI(IndexDomain::interior);
     auto jb = md->GetBoundsJ(IndexDomain::interior);
@@ -97,11 +101,11 @@ struct PreparePrimitive_impl {
           auto U = SubPack(pack, b, k, j, i);
           Cons2Prim<hydro_traits>(U, U);
           if constexpr (geom == Geometry::cylindrical) {
-            auto coords = grid::Coordinates<geom>(pack, b);
+            auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
             // conserve angular momentum
-            U(VELOCITY(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(i);
+            U(VELOCITY(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
             if constexpr (hydro_traits::MHD != Mhd::off) {
-              U(MAGC(2)) *= coords.template Xc<Axis::IAXIS>(i);
+              U(MAGC(2)) *= coords.template Xc<Axis::IAXIS>(k, j, i);
             }
           }
         });

From 6b5caa7c413db817224b1eef63b6d07f774beabd Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 12 Apr 2026 22:27:39 -0700
Subject: [PATCH 40/55] kind of working

---
 src/grid/coordinates.hpp           | 31 ++++++++++--------
 src/grid/grid.cpp                  | 13 ++++++++
 src/grid/grid_update.hpp           |  3 +-
 src/grid/refinement_operations.hpp |  5 ++-
 src/kamayan/fields.hpp             |  3 ++
 src/physics/hydro/hydro.cpp        | 41 ++++++++++++-----------
 src/physics/hydro/primconsflux.cpp |  4 +--
 src/physics/hydro/primconsflux.hpp |  1 +
 src/problems/mhd_blast.cpp         | 52 ++++++++++++++++++++++--------
 src/problems/mhd_blast.in          | 11 ++++---
 10 files changed, 106 insertions(+), 58 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index afbddb5..10f754b 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -528,29 +528,32 @@ struct CoordinatePackVariant {};
 
 template <Geometry geom, Geometry... geoms>
 struct CoordinatePackVariant<OptList<Geometry, geom, geoms...>> {
-  using type = PortsOfCall::variant<CoordinatePack<geom>, CoordinatePack<geoms>...>;
+  using type = PortsOfCall::variant<CoordinatePack<geom, CoordFields>,
+                                    CoordinatePack<geoms, CoordFields>...>;
 };
 }  // namespace impl
 
 using CoordinatePackVariant = impl::CoordinatePackVariant<GeometryOptions>::type;
 
-struct GenericCoordinatePack {
-  template <typename... Cs, typename... Ts>
-  GenericCoordinatePack(TypeList<Cs...>, const Geometry geometry,
-                        const parthenon::SparsePack<Ts...> &pack, const int b) {
-    GeometryOptions::dispatch(
-        [&]<Geometry geom>() {
-          coords_ = CoordinatePack<geom>(TypeList<Cs...>(), pack, b);
-        },
-        geometry);
+template <typename... Ts>
+CoordinatePackVariant BuildCoordinatePackVariant(const Geometry geometry,
+                                                 const parthenon::SparsePack<Ts...> &pack,
+                                                 const int b) {
+  if (geometry == Geometry::cylindrical) {
+    return CoordinatePack<Geometry::cylindrical, CoordFields>(pack, b);
+  } else if (geometry == Geometry::cartesian) {
+    return CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
   }
 
+  PARTHENON_FAIL("Geometry not recognized for Coordinate Pack Variant");
+  return CoordinatePack<Geometry::cartesian, CoordFields>(pack, b);
+}
+
+struct GenericCoordinatePack {
   template <typename... Ts>
   GenericCoordinatePack(const Geometry geometry, const parthenon::SparsePack<Ts...> &pack,
-                        const int b) {
-    GeometryOptions::dispatch(
-        [&]<Geometry geom>() { coords_ = CoordinatePack<geom>(pack, b); }, geometry);
-  }
+                        const int b)
+      : coords_(BuildCoordinatePackVariant(geometry, pack, b)) {}
 
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Dx(const int k, const int j, const int i) const {
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index 0e8c88c..509828c 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -27,6 +27,9 @@ std::shared_ptr<KamayanUnit> ProcessUnit() {
 }
 
 void SetupParams(KamayanUnit *unit) {
+  // debug fields
+  auto &debug = unit->AddData("debug");
+  debug.AddParm<int>("ndebug", 0, "Number of debug fields to allocate at CC.");
   // Geometry
   auto &geometry = unit->AddData("geometry");
   geometry.AddParm<Geometry>(
@@ -164,6 +167,13 @@ void InitializeData(KamayanUnit *unit) {
         });
       },
       geometry);
+
+  const int ndebug = unit->Data("debug").Get<int>("ndebug");
+  if (ndebug > 0) {
+    unit->AddField<DEBUG>(Metadata(
+        {Metadata::OneCopy, Metadata::Derived, Metadata::Restart, Metadata::Cell},
+        std::vector<int>{ndebug}));
+  }
 }
 
 struct FluxesToDuDt_impl {
@@ -211,6 +221,9 @@ TaskStatus ApplyDuDt_impl(PackDesc_t &desc, const TopologicalElement &te, MeshDa
     auto dudt = desc.GetPack(dudt_data);
     if (pack0.GetMaxNumberOfVars() == 0) return TaskStatus::complete;
 
+    auto pack = GetPack<ENER, DEBUG>(md0);
+    auto enerp = GetPack<ENER, DEBUG>(dudt_data);
+
     const int nblocks = pack0.GetNBlocks();
     auto ib = md0->GetBoundsI(IndexDomain::interior, te);
     auto jb = md0->GetBoundsJ(IndexDomain::interior, te);
diff --git a/src/grid/grid_update.hpp b/src/grid/grid_update.hpp
index 97c7de2..792ba49 100644
--- a/src/grid/grid_update.hpp
+++ b/src/grid/grid_update.hpp
@@ -130,7 +130,8 @@ void FluxStokes(MeshData *md, MeshData *dudt_data) {
                                 u0.flux(b, edges, var, ijk[2], ijk[1], ijk[0]));
               }(),
               ...);
-          dudt(b, Face, var, km, jm, im) *= 1. / coords.Volume(Face, km, jm, im);
+          dudt(b, Face, var, km, jm, im) *=
+              1. / (coords.Volume(Face, km, jm, im) + 1.e-36);
         }
       });
 }
diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index b24cb2d..253b3c1 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -336,8 +336,6 @@ struct ProlongateInternalTothAndRoe {
         // Note step size of 2 for the direction normal to the eidx2/eidx3
         for (const int u : iarr2{0, 2}) {
           for (const int t : iarr2{0, 1}) {
-            // we should multiply by the radial coordinate in cylindrical
-            // coordinates for r-faces
             const auto fine2 =
                 get_fine_permuted(1, v, u, t) * get_geometric_factor(v, u, t);
             const auto fine3 =
@@ -361,7 +359,8 @@ struct ProlongateInternalTothAndRoe {
       for (int ok : iarr2{0, 1}) {
         for (int oj : iarr2{0, 1}) {
           get_fine_permuted(0, ok, oj, 1) =
-              0.5 * (get_fine_permuted(0, ok, oj, 0) + get_fine_permuted(0, ok, oj, 2)) +
+              0.5 * (get_fine_permuted(0, ok, oj, 0) * get_geometric_factor(ok, oj, 0) +
+                     get_fine_permuted(0, ok, oj, 2) * get_geometric_factor(ok, oj, 2)) +
               Uxx + sg(ok) * Vxyz + sg(oj) * Wxyz;
           get_fine_permuted(0, ok, oj, 1) *= 1. / get_geometric_factor(ok, oj, 1);
         }
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index a92df45..06f0c06 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -205,6 +205,9 @@ using PRAD = VariableBase<"prad">;
 
 // derived
 using DIVB = VariableBase<"divb">;
+
+// debug
+using DEBUG = VariableBase<"debug">;
 }  // namespace kamayan
 
 #endif  // KAMAYAN_FIELDS_HPP_
diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index f994d49..4b2c699 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -1,5 +1,7 @@
 #include "physics/hydro/hydro.hpp"
 
+#include <cstdlib>
+#include <format>
 #include <memory>
 #include <string>
 #include <utility>
@@ -11,6 +13,7 @@
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/coordinates.hpp"
 #include "grid/geometry.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/refinement_operations.hpp"
@@ -145,38 +148,41 @@ void InitializeData(KamayanUnit *unit) {
 }
 
 struct FillDerived_impl {
-  using options = OptTypeList<HydroFactory>;
+  using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
   using value = TaskStatus;
 
-  template <typename hydro_traits>
+  template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    auto pack = grid::GetPack(typename hydro_traits::All(), md);
+    using Fields = ConcatTypeLists_t<typename hydro_traits::All, grid::CoordFields>;
+    auto pack = grid::GetPack(Fields(), md);
     const int nblocks = pack.GetNBlocks();
     auto ib = md->GetBoundsI(IndexDomain::interior);
     auto jb = md->GetBoundsJ(IndexDomain::interior);
     auto kb = md->GetBoundsK(IndexDomain::interior);
     const auto ndim = md->GetNDim();
-    const auto geometry = GetConfig(md)->Get<Geometry>();
 
     parthenon::par_for(
         PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
         KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
           capture(ndim);
-          const auto coords = grid::GenericCoordinate(geometry, pack.GetCoordinates(b));
+          const auto coords = grid::CoordinatePack<geom, grid::CoordFields>(pack, b);
           // also need to average the face-fields if doing constrained transport
           if constexpr (hydro_traits::MHD == Mhd::ct) {
             using te = TopologicalElement;
-            if (ndim > 1) {
-              pack(b, DIVB(), k, j, i) = 1. / coords.template Dx<Axis::IAXIS>() *
-                                             (pack(b, te::F1, MAG(), k, j, i + 1) -
-                                              pack(b, te::F1, MAG(), k, j, i)) +
-                                         1. / coords.template Dx<Axis::JAXIS>() *
-                                             (pack(b, te::F2, MAG(), k, j + 1, i) -
-                                              pack(b, te::F2, MAG(), k, j, i));
+            Real divb = 0.;
+            for (int dir = 0; dir < ndim; dir++) {
+              const int kp = k + (dir == 2);
+              const int jp = j + (dir == 1);
+              const int ip = i + (dir == 0);
+              const auto face = static_cast<te>(static_cast<int>(te::F1) + dir);
+              const auto ax = dir == 0   ? Axis::IAXIS
+                              : dir == 1 ? Axis::JAXIS
+                                         : Axis::KAXIS;
+              divb += coords.FaceArea(ax, kp, jp, ip) * pack(b, face, MAG(), kp, jp, ip) -
+                      coords.FaceArea(ax, k, j, i) * pack(b, face, MAG(), k, j, i);
             }
-            // if (ndim > 2) {
-            // }
+            pack(b, DIVB(), k, j, i) = divb / coords.CellVolume(k, j, i);
           }
         });
     return TaskStatus::complete;
@@ -247,12 +253,6 @@ struct PrepareConserved_impl {
   template <HydroTrait hydro_traits, Geometry geom>
   requires(hydro_traits::MHD != Mhd::off && geom != Geometry::cartesian)
   value dispatch(MeshData *md) {
-    // for the most part our conserved variables are maintained in separate
-    // fields, e.g., MOMENTUM, ENER, and so there isn't anything to prepare before
-    // advancing the system
-    //
-    // The exception is the angular magnetic field in cylindrical r-z geometry
-    // here we advance B_phi / r, and so need to perform the conversion before updating
     using Fields = TypeList<MAGC>;
     using PackVars = ConcatTypeLists_t<Fields, grid::Xcoord>;
 
@@ -268,7 +268,6 @@ struct PrepareConserved_impl {
           auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
           par_for_inner(team, ib.s, ib.e, [&](const int i) {
             if constexpr (geom == Geometry::cylindrical) {
-              // in cylindrical advance Bphi / r
               pack(b, MAGC(2), k, j, i) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
             }
           });
diff --git a/src/physics/hydro/primconsflux.cpp b/src/physics/hydro/primconsflux.cpp
index 9a0d50b..2726670 100644
--- a/src/physics/hydro/primconsflux.cpp
+++ b/src/physics/hydro/primconsflux.cpp
@@ -15,7 +15,7 @@
 namespace kamayan::hydro {
 
 // --8<-- [start:impl]
-struct PrepareConserved_impl {
+struct ConvertToConserved_impl {
   using options = OptTypeList<HydroFactory, grid::GeometryOptions>;
   using value = TaskStatus;
 
@@ -116,7 +116,7 @@ struct PreparePrimitive_impl {
 // --8<-- [start:prepare-cons]
 TaskStatus PostMeshInitialization(MeshData *md) {
   auto cfg = GetConfig(md);
-  return Dispatcher<PrepareConserved_impl>(PARTHENON_AUTO_LABEL, cfg.get()).execute(md);
+  return Dispatcher<ConvertToConserved_impl>(PARTHENON_AUTO_LABEL, cfg.get()).execute(md);
 }
 // --8<-- [end:prepare-cons]
 
diff --git a/src/physics/hydro/primconsflux.hpp b/src/physics/hydro/primconsflux.hpp
index 6a94574..ab3ac80 100644
--- a/src/physics/hydro/primconsflux.hpp
+++ b/src/physics/hydro/primconsflux.hpp
@@ -15,6 +15,7 @@ namespace kamayan::hydro {
 
 // ensures prim2cons on start of simulation
 TaskStatus PostMeshInitialization(MeshData *md);
+TaskStatus PrepareConserved(MeshData *md);
 // these will prepare any U <-> V in our data at the end of the hydro cycle
 TaskStatus PreparePrimitive(MeshData *md);
 
diff --git a/src/problems/mhd_blast.cpp b/src/problems/mhd_blast.cpp
index ac49c7b..b8b22bc 100644
--- a/src/problems/mhd_blast.cpp
+++ b/src/problems/mhd_blast.cpp
@@ -2,6 +2,8 @@
 
 #include "Kokkos_Macros.hpp"
 
+#include "grid/coordinates.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan/fields.hpp"
@@ -11,6 +13,7 @@
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/type_list.hpp"
 #include "kamayan_utils/type_list_array.hpp"
+#include "physics/hydro/primconsflux.hpp"
 #include "physics/physics_types.hpp"
 #include "utils/error_checking.hpp"
 
@@ -102,37 +105,60 @@ void ProblemGenerator(MeshBlock *mb) {
   auto jb = cellbounds.GetBoundsJ(IndexDomain::interior);
   auto kb = cellbounds.GetBoundsK(IndexDomain::interior);
 
-  auto coords = mb->coords;
+  // auto coords = mb->coords;
   const int ndim = 1 + (jb.e > jb.s) + (kb.e > kb.s);
   const int k2d = (ndim > 1) ? 1 : 0;
   const int k3d = (ndim > 2) ? 1 : 0;
 
+  const auto geometry = config->Get<Geometry>();
+
   // get our pack
-  auto pack = grid::GetPack(BlastData::pack_variables(), mb);
+  using Fields = ConcatTypeLists_t<BlastData::pack_variables, grid::CoordFields>;
+  auto pack = grid::GetPack(Fields(), mb);
   auto pack_mag = grid::GetPack<MAG>(mb);
   par_for(
       PARTHENON_AUTO_LABEL, kb.s, kb.e + k3d, jb.s, jb.e + k2d, ib.s, ib.e + 1,
       KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        auto coords = grid::GenericCoordinatePack(geometry, pack, 0);
         const Real r2 =
-            coords.Xc<1>(i) * coords.Xc<1>(i) + coords.Xc<2>(j) * coords.Xc<2>(j);
+            coords.Xc<Axis::IAXIS>(k, j, i) * coords.Xc<Axis::IAXIS>(k, j, i) +
+            coords.Xc<Axis::JAXIS>(k, j, i) * coords.Xc<Axis::JAXIS>(k, j, i);
         auto state = mhd_blast_data.State(Kokkos::sqrt(r2));
         type_for(BlastData::variables(), [&]<typename Vars>(const Vars &) {
           for (int comp = 0; comp < Vars::n_comps; comp++) {
             pack(0, Vars(comp), k, j, i) = state(Vars(comp));
           }
+          if (geometry == Geometry::cylindrical) {
+            pack(0, MAGC(0), k, j, i) = 0.0;
+            pack(0, MAGC(1), k, j, i) = state(MAGC(0));
+            pack(0, MAGC(2), k, j, i) = 0.0;
+          }
 
           using TE = TopologicalElement;
           if (ndim == 2) {
-            if (j < jb.e + 1)
-              pack_mag(0, TE::F1, MAG(), k, j, i) =
-                  (mhd_blast_data.Az(coords.Xf<1>(i), coords.Xf<2>(j + 1)) -
-                   mhd_blast_data.Az(coords.Xf<1>(i), coords.Xf<2>(j))) /
-                  coords.Dxc<2>(j);
-            if (i < ib.e + 1)
-              pack_mag(0, TE::F2, MAG(), k, j, i) =
-                  (mhd_blast_data.Az(coords.Xf<1>(i + 1), coords.Xf<2>(j)) -
-                   mhd_blast_data.Az(coords.Xf<1>(i), coords.Xf<2>(j))) /
-                  coords.Dxc<1>(i);
+            if (geometry == Geometry::cartesian) {
+              if (j < jb.e + 1)
+                pack_mag(0, TE::F1, MAG(), k, j, i) =
+                    (mhd_blast_data.Az(coords.Xf<Axis::IAXIS>(k, j, i),
+                                       coords.Xf<Axis::JAXIS>(k, j + 1, i)) -
+                     mhd_blast_data.Az(coords.Xf<Axis::IAXIS>(k, j, i),
+                                       coords.Xf<Axis::JAXIS>(k, j, i))) /
+                    coords.Dx<Axis::JAXIS>(k, j, i);
+              if (i < ib.e + 1)
+                pack_mag(0, TE::F2, MAG(), k, j, i) =
+                    (mhd_blast_data.Az(coords.Xf<Axis::IAXIS>(k, j, i + 1),
+                                       coords.Xf<Axis::JAXIS>(k, j, i)) -
+                     mhd_blast_data.Az(coords.Xf<Axis::IAXIS>(k, j, i),
+                                       coords.Xf<Axis::JAXIS>(k, j, i))) /
+                    coords.Dx<Axis::IAXIS>(k, j, i);
+            } else if (geometry == Geometry::cylindrical) {
+              const Real r2 =
+                  coords.Xc<Axis::IAXIS>(k, j, i) * coords.Xc<Axis::IAXIS>(k, j, i) +
+                  coords.Xf<Axis::JAXIS>(k, j, i) * coords.Xf<Axis::JAXIS>(k, j, i);
+              state = mhd_blast_data.State(Kokkos::sqrt(r2));
+              if (i < ib.e + 1) pack_mag(0, TE::F2, MAG(), k, j, i) = state(MAGC(0));
+              if (j < jb.e + 1) pack_mag(0, TE::F1, MAG(), k, j, i) = 0.0;
+            }
           }
         });
       });
diff --git a/src/problems/mhd_blast.in b/src/problems/mhd_blast.in
index 1cb6976..97a7ba5 100644
--- a/src/problems/mhd_blast.in
+++ b/src/problems/mhd_blast.in
@@ -8,10 +8,10 @@ field = pres
 refinement = adaptive
 numlevel = 3
 
-nx1 = 32
-x1min = -0.5
+nx1 = 16
+x1min = -0.
 x1max = 0.5
-ix1_bc = outflow
+ix1_bc = axisymmetric
 ox1_bc = outflow
 
 nx2 = 32
@@ -54,10 +54,13 @@ gamma = 1.66666667
 <physics>
 MHD = ct
 
+<geometry>
+geometry = cylindrical
+
 <hydro>
 cfl = 0.8
 reconstruction = wenoz
-riemann = hllc
+riemann = hll
 slope_limiter = mc
 
 <mhd_blast>

From e47af1a3f47e8d61c1deb418769a4efe9f68a8b1 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Mon, 13 Apr 2026 20:44:22 -0700
Subject: [PATCH 41/55] does this even work?

---
 src/grid/refinement_operations.hpp | 100 ++++++++++++++++++-----------
 1 file changed, 64 insertions(+), 36 deletions(-)

diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index 253b3c1..91844cc 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -1,6 +1,7 @@
 #ifndef GRID_REFINEMENT_OPERATIONS_HPP_
 #define GRID_REFINEMENT_OPERATIONS_HPP_
 #include <algorithm>
+#include <array>
 
 #include <Kokkos_Core.hpp>
 
@@ -9,6 +10,7 @@
 #include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"
 #include "interface/variable_state.hpp"
+#include <limits>
 namespace kamayan::grid {
 // Parthenon's implementation of non-cartesian coordinates assumes that
 // it is determined at compile time for the entire library. In order
@@ -159,7 +161,17 @@ struct ProlongateSharedGeneral {
     constexpr bool INCLUDE_X3 =
         (DIM > 2) && (el == TE::CC || el == TE::F1 || el == TE::F2 || el == TE::E3);
 
-    const Real fc = coarse(element_idx, l, m, n, k, j, i);
+    constexpr bool SCALE_BY_R =
+        (geom == Geometry::cylindrical) && (el == TE::F1 || el == TE::F2);
+    auto coarse_scaled = [&](int kk, int jj, int ii) {
+      Real val = coarse(element_idx, l, m, n, kk, jj, ii);
+      if constexpr (SCALE_BY_R) {
+        val *= coarse_coords.template Xf<el, Axis::IAXIS>(ii);
+      }
+      return val;
+    };
+
+    const Real fc = coarse_scaled(k, j, i);
 
     Real dx1fm = 0;
     [[maybe_unused]] Real dx1fp = 0;
@@ -169,9 +181,8 @@ struct ProlongateSharedGeneral {
       GetGridSpacings<1, el, geom>(coords, coarse_coords, cib, ib, i, fi, &dx1m, &dx1p,
                                    &dx1fm, &dx1fp);
 
-      Real gx1c =
-          GradMinMod(fc, coarse(element_idx, l, m, n, k, j, i - 1),
-                     coarse(element_idx, l, m, n, k, j, i + 1), dx1m, dx1p, gx1m, gx1p);
+      Real gx1c = GradMinMod(fc, coarse_scaled(k, j, i - 1), coarse_scaled(k, j, i + 1),
+                             dx1m, dx1p, gx1m, gx1p);
       if constexpr (use_minmod_slope) {
         gx1m = gx1c;
         gx1p = gx1c;
@@ -185,9 +196,8 @@ struct ProlongateSharedGeneral {
       Real dx2m, dx2p;
       GetGridSpacings<2, el, geom>(coords, coarse_coords, cjb, jb, j, fj, &dx2m, &dx2p,
                                    &dx2fm, &dx2fp);
-      Real gx2c =
-          GradMinMod(fc, coarse(element_idx, l, m, n, k, j - 1, i),
-                     coarse(element_idx, l, m, n, k, j + 1, i), dx2m, dx2p, gx2m, gx2p);
+      Real gx2c = GradMinMod(fc, coarse_scaled(k, j - 1, i), coarse_scaled(k, j + 1, i),
+                             dx2m, dx2p, gx2m, gx2p);
       if constexpr (use_minmod_slope) {
         gx2m = gx2c;
         gx2p = gx2c;
@@ -201,9 +211,8 @@ struct ProlongateSharedGeneral {
       Real dx3m, dx3p;
       GetGridSpacings<3, el, geom>(coords, coarse_coords, ckb, kb, k, fk, &dx3m, &dx3p,
                                    &dx3fm, &dx3fp);
-      Real gx3c =
-          GradMinMod(fc, coarse(element_idx, l, m, n, k - 1, j, i),
-                     coarse(element_idx, l, m, n, k + 1, j, i), dx3m, dx3p, gx3m, gx3p);
+      Real gx3c = GradMinMod(fc, coarse_scaled(k - 1, j, i), coarse_scaled(k + 1, j, i),
+                             dx3m, dx3p, gx3m, gx3p);
       if constexpr (use_minmod_slope) {
         gx3m = gx3c;
         gx3p = gx3c;
@@ -219,31 +228,35 @@ struct ProlongateSharedGeneral {
       gx3p = 0.0;
     }
 
+    auto set_fine_scaled = [&](int kk, int jj, int ii, Real val) {
+      if constexpr (SCALE_BY_R) {
+        const Real r = coords.template Xf<el, Axis::IAXIS>(ii);
+        val *= 1.0 / (r + std::numeric_limits<Real>::epsilon());
+      }
+      fine(element_idx, l, m, n, kk, jj, ii) = val;
+    };
+
     // KGF: add the off-centered quantities first to preserve FP symmetry
     // JMM: Extraneous quantities are zero
-    fine(element_idx, l, m, n, fk, fj, fi) =
-        fc - (gx1m * dx1fm + gx2m * dx2fm + gx3m * dx3fm);
+    set_fine_scaled(fk, fj, fi, fc - (gx1m * dx1fm + gx2m * dx2fm + gx3m * dx3fm));
     if constexpr (INCLUDE_X1)
-      fine(element_idx, l, m, n, fk, fj, fi + 1) =
-          fc + (gx1p * dx1fp - gx2m * dx2fm - gx3m * dx3fm);
+      set_fine_scaled(fk, fj, fi + 1, fc + (gx1p * dx1fp - gx2m * dx2fm - gx3m * dx3fm));
     if constexpr (INCLUDE_X2)
-      fine(element_idx, l, m, n, fk, fj + 1, fi) =
-          fc - (gx1m * dx1fm - gx2p * dx2fp + gx3m * dx3fm);
+      set_fine_scaled(fk, fj + 1, fi, fc - (gx1m * dx1fm - gx2p * dx2fp + gx3m * dx3fm));
     if constexpr (INCLUDE_X2 && INCLUDE_X1)
-      fine(element_idx, l, m, n, fk, fj + 1, fi + 1) =
-          fc + (gx1p * dx1fp + gx2p * dx2fp - gx3m * dx3fm);
+      set_fine_scaled(fk, fj + 1, fi + 1,
+                      fc + (gx1p * dx1fp + gx2p * dx2fp - gx3m * dx3fm));
     if constexpr (INCLUDE_X3)
-      fine(element_idx, l, m, n, fk + 1, fj, fi) =
-          fc - (gx1m * dx1fm + gx2m * dx2fm - gx3p * dx3fp);
+      set_fine_scaled(fk + 1, fj, fi, fc - (gx1m * dx1fm + gx2m * dx2fm - gx3p * dx3fp));
     if constexpr (INCLUDE_X3 && INCLUDE_X1)
-      fine(element_idx, l, m, n, fk + 1, fj, fi + 1) =
-          fc + (gx1p * dx1fp - gx2m * dx2fm + gx3p * dx3fp);
+      set_fine_scaled(fk + 1, fj, fi + 1,
+                      fc + (gx1p * dx1fp - gx2m * dx2fm + gx3p * dx3fp));
     if constexpr (INCLUDE_X3 && INCLUDE_X2)
-      fine(element_idx, l, m, n, fk + 1, fj + 1, fi) =
-          fc - (gx1m * dx1fm - gx2p * dx2fp - gx3p * dx3fp);
+      set_fine_scaled(fk + 1, fj + 1, fi,
+                      fc - (gx1m * dx1fm - gx2p * dx2fp - gx3p * dx3fp));
     if constexpr (INCLUDE_X3 && INCLUDE_X2 && INCLUDE_X1)
-      fine(element_idx, l, m, n, fk + 1, fj + 1, fi + 1) =
-          fc + (gx1p * dx1fp + gx2p * dx2fp + gx3p * dx3fp);
+      set_fine_scaled(fk + 1, fj + 1, fi + 1,
+                      fc + (gx1p * dx1fp + gx2p * dx2fp + gx3p * dx3fp));
   }
 };
 
@@ -319,9 +332,22 @@ struct ProlongateInternalTothAndRoe {
         const auto [kk, jj, ii] = get_fine_permuted_kji(ok, oj, oi);
         return (*pfine)(eidx, l, m, n, kk, jj, ii);
       };
-      auto get_geometric_factor = [&](int v, int u, int t) {
+      auto safe_inverse = [&](Real radius) {
         if constexpr (geom == Geometry::cylindrical) {
-          return coords.template Xf<fel, Axis::IAXIS>(fi + t);
+          const Real denom = radius + std::numeric_limits<Real>::epsilon();
+          return 1.0 / denom;
+        }
+        return 1.0;
+      };
+      auto get_radial_coord = [&]<int EIDX>(int ok, int oj, int oi) -> Real {
+        if constexpr (geom == Geometry::cylindrical) {
+          const auto [kk, jj, ii] = get_fine_permuted_kji(ok, oj, oi);
+          constexpr TopologicalElement comp_el = static_cast<TopologicalElement>(
+              static_cast<int>(TE::F1) + ((element_idx + EIDX) % 3));
+          if constexpr (DIM <= 2 && comp_el == TE::F3) {
+            return 1.0;
+          }
+          return coords.template Xf<comp_el, Axis::IAXIS>(ii);
         } else {
           return 1.0;
         }
@@ -333,13 +359,12 @@ struct ProlongateInternalTothAndRoe {
       Real Vxyz{0.0};
       Real Wxyz{0.0};
       for (const int v : iarr2{0, 1}) {
-        // Note step size of 2 for the direction normal to the eidx2/eidx3
         for (const int u : iarr2{0, 2}) {
           for (const int t : iarr2{0, 1}) {
-            const auto fine2 =
-                get_fine_permuted(1, v, u, t) * get_geometric_factor(v, u, t);
-            const auto fine3 =
-                get_fine_permuted(2, u, v, t) * get_geometric_factor(v, u, t);
+            const auto fine2 = get_fine_permuted(1, v, u, t) *
+                               get_radial_coord.template operator()<1>(v, u, t);
+            const auto fine3 = get_fine_permuted(2, u, v, t) *
+                               get_radial_coord.template operator()<2>(u, v, t);
             Uxx += sg(t) * sg(u) * (fine2 + fine3);
             Vxyz += sg(t) * sg(u) * sg(v) * fine2;
             Wxyz += sg(t) * sg(u) * sg(v) * fine3;
@@ -359,10 +384,13 @@ struct ProlongateInternalTothAndRoe {
       for (int ok : iarr2{0, 1}) {
         for (int oj : iarr2{0, 1}) {
           get_fine_permuted(0, ok, oj, 1) =
-              0.5 * (get_fine_permuted(0, ok, oj, 0) * get_geometric_factor(ok, oj, 0) +
-                     get_fine_permuted(0, ok, oj, 2) * get_geometric_factor(ok, oj, 2)) +
+              0.5 * (get_fine_permuted(0, ok, oj, 0) *
+                         get_radial_coord.template operator()<0>(ok, oj, 0) +
+                     get_fine_permuted(0, ok, oj, 2) *
+                         get_radial_coord.template operator()<0>(ok, oj, 2)) +
               Uxx + sg(ok) * Vxyz + sg(oj) * Wxyz;
-          get_fine_permuted(0, ok, oj, 1) *= 1. / get_geometric_factor(ok, oj, 1);
+          get_fine_permuted(0, ok, oj, 1) *=
+              safe_inverse(get_radial_coord.template operator()<0>(ok, oj, 1));
         }
       }
     }

From fbbd863ad9fb0e3c02a1d0f60b045cf771b8474c Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 15 Apr 2026 20:50:17 -0700
Subject: [PATCH 42/55] I think this is all working now

---
 src/grid/boundary_conditions.cpp           |   3 +-
 src/grid/refinement_operations.hpp         | 214 ++++++++++++++++++++-
 src/kamayan/pybind/kamayan_manager_py.cpp  |   9 +-
 src/physics/hydro/hydro_add_flux_tasks.cpp |  31 +--
 src/physics/hydro/primconsflux.cpp         |  62 ++++--
 src/physics/hydro/primconsflux.hpp         |   2 +-
 6 files changed, 286 insertions(+), 35 deletions(-)

diff --git a/src/grid/boundary_conditions.cpp b/src/grid/boundary_conditions.cpp
index 3d1b293..f98b393 100644
--- a/src/grid/boundary_conditions.cpp
+++ b/src/grid/boundary_conditions.cpp
@@ -64,7 +64,8 @@ void Axisymmetric(const TE el, std::shared_ptr<MeshBlockData> &mbd, bool coarse)
       PARTHENON_AUTO_LABEL, nb, domain, el, coarse, false,
       KOKKOS_LAMBDA(const int &l, const int &k, const int &j, const int &i) {
         const auto vec_component = q(b, el, l).vector_component;
-        const Real factor = (vec_component == 1 || vec_component == 3) ? -1.0 : 1.0;
+        const Real factor =
+            (vec_component == 1 || vec_component == 3 || el == TE::F1) ? -1.0 : 1.0;
         q(b, el, l, k, j, i) = factor * q(b, el, l, k, j, offset - i);
       });
 }
diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index 91844cc..5ca2b20 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -397,7 +397,219 @@ struct ProlongateInternalTothAndRoe {
   }
 };
 
-// TODO(acreyes): ProlongateInternalAverage
+// TODO(acreyes): ProlongateInternalBalsara - broken implementation, needs fixing
+// template <Geometry geom>
+// struct ProlongateInternalBalsara { ... };
+
+template <Geometry geom>
+struct ProlongateInternalBalsara {
+  static constexpr bool OperationRequired(TopologicalElement fel,
+                                          TopologicalElement cel) {
+    return IsSubmanifold(fel, cel);
+  }
+
+ private:
+  // Helper: Returns offset {i,j,k} for a given direction
+  // DIR: 0=x, 1=y, 2=z
+  // DIM: dimensionality (2 or 3)
+  // mult: multiplier for the offset (default 1)
+  template <int DIR, int DIM, int mult = 1>
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr std::array<int, 3> Offsets() {
+    std::array<int, 3> o = {0, 0, 0};
+    if (DIR == 0 && DIM > 0) {
+      o[0] = mult;
+    } else if (DIR == 1 && DIM > 1) {
+      o[1] = mult;
+    } else if (DIR == 2 && DIM > 2) {
+      o[2] = mult;
+    }
+    return o;
+  }
+
+  // Get face value - uses r*B scaling for cylindrical (scale ALL components)
+  template <int EIDX>
+  KOKKOS_FORCEINLINE_FUNCTION static Real
+  FaceField(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
+            const Coordinates<geom> &coords, int l, int m, int n, int k, int j, int i) {
+    Real val = fine(EIDX, l, m, n, k, j, i);
+    if constexpr (geom == Geometry::cylindrical) {
+      // Scale ALL faces by r (following the proven TothAndRoe approach)
+      val *= coords.Xf(Axis::IAXIS, i);
+    }
+    return val;
+  }
+
+  // Get coarse face average: 4-point in 3D, 2-point in 2D
+  template <int EIDX, int DIR2, int DIR3, int DIM>
+  KOKKOS_FORCEINLINE_FUNCTION static Real
+  GetCoarseFaceVal(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
+                   const Coordinates<geom> &coords, int l, int m, int n, int fk, int fj,
+                   int fi) {
+    Real b = FaceField<EIDX>(fine, coords, l, m, n, fk, fj, fi);
+
+    if constexpr (DIM == 3) {
+      constexpr auto o2 = Offsets<DIR2, DIM>();
+      constexpr auto o3 = Offsets<DIR3, DIM>();
+      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2], fj + o2[1], fi + o2[0]);
+      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o3[2], fj + o3[1], fi + o3[0]);
+      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2] + o3[2], fj + o2[1] + o3[1],
+                           fi + o2[0] + o3[0]);
+      return b * 0.25;
+    } else {
+      // 2D: use DIR2 if valid (I2 < 2 means dimension index less than 2), else DIR3
+      constexpr auto N2 = (DIR2 < 2) ? Offsets<DIR2, DIM>() : Offsets<DIR3, DIM>();
+      b += FaceField<EIDX>(fine, coords, l, m, n, fk + N2[2], fj + N2[1], fi + N2[0]);
+      return b * 0.5;
+    }
+  }
+
+  // Normal difference: d(b1)/d(x2) - d(b1)/d(x3) pattern
+  template <int EIDX, int DIR2, int DIR3, int DIM>
+  KOKKOS_FORCEINLINE_FUNCTION static Real
+  GetFaceNormDif(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
+                 const Coordinates<geom> &coords, int l, int m, int n, int fk, int fj,
+                 int fi) {
+    constexpr auto o2 = Offsets<DIR2, DIM>();
+    constexpr auto o3 = Offsets<DIR3, DIM>();
+    return (FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2] + o3[2], fj + o2[1] + o3[1],
+                            fi + o2[0] + o3[0]) -
+            FaceField<EIDX>(fine, coords, l, m, n, fk, fj, fi) +
+            FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2], fj + o2[1], fi + o2[0]) -
+            FaceField<EIDX>(fine, coords, l, m, n, fk + o3[2], fj + o3[1], fi + o3[0]));
+  }
+
+ public:
+  template <int DIM, TopologicalElement fel = TopologicalElement::CC,
+            TopologicalElement cel = TopologicalElement::CC>
+  KOKKOS_FORCEINLINE_FUNCTION static void
+  Do(const int l, const int m, const int n, const int k, const int j, const int i,
+     const parthenon::IndexRange &ckb, const parthenon::IndexRange &cjb,
+     const parthenon::IndexRange &cib, const parthenon::IndexRange &kb,
+     const parthenon::IndexRange &jb, const parthenon::IndexRange &ib,
+     const parthenon::Coordinates_t &pcoords,
+     const parthenon::Coordinates_t &pcoarse_coords,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *,
+     const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
+    auto coords = Coordinates<geom>(pcoords);
+    auto coarse_coords = Coordinates<geom>(pcoarse_coords);
+
+    if constexpr (!IsSubmanifold(fel, cel)) {
+      return;
+    } else {
+      constexpr int I1 = static_cast<int>(fel) % 3;
+      if constexpr (I1 + 1 > DIM) {
+        return;
+      } else {
+        auto &fine = *pfine;
+
+        const int fi = (DIM > 0) ? (i - cib.s) * 2 + ib.s : ib.s;
+        const int fj = (DIM > 1) ? (j - cjb.s) * 2 + jb.s : jb.s;
+        const int fk = (DIM > 2) ? (k - ckb.s) * 2 + kb.s : kb.s;
+
+        constexpr int I2 = (I1 + 1) % 3;
+        constexpr int I3 = (I1 + 2) % 3;
+
+        const Real d1 = coarse_coords.Dx(AxisFromInt(I1 + 1));
+        const Real d2 = coarse_coords.Dx(AxisFromInt(I2 + 1));
+        const Real d3 = coarse_coords.Dx(AxisFromInt(I3 + 1));
+        const Real id1 = 1.0 / d1;
+        const Real id2 = 1.0 / d2;
+        const Real id3 = 1.0 / d3;
+
+        // Get coarse face values at minus/plus
+        // Note: Offsets<I, DIM, 2> gives {2,0,0} or {0,2,0} or {0,0,2} based on I
+        constexpr auto N1 = Offsets<I1, DIM, 2>();
+        const Real b1m =
+            GetCoarseFaceVal<I1, I2, I3, DIM>(fine, coords, l, m, n, fk, fj, fi);
+        const Real b1p = GetCoarseFaceVal<I1, I2, I3, DIM>(
+            fine, coords, l, m, n, fk + N1[2], fj + N1[1], fi + N1[0]);
+
+        constexpr auto N2 = Offsets<I2, DIM, 2>();
+        const Real b2m =
+            GetCoarseFaceVal<I2, I3, I1, DIM>(fine, coords, l, m, n, fk, fj, fi);
+        const Real b2p = GetCoarseFaceVal<I2, I3, I1, DIM>(
+            fine, coords, l, m, n, fk + N2[2], fj + N2[1], fi + N2[0]);
+
+        constexpr auto N3 = Offsets<I3, DIM, 2>();
+        const Real b3m =
+            GetCoarseFaceVal<I3, I1, I2, DIM>(fine, coords, l, m, n, fk, fj, fi);
+        const Real b3p = GetCoarseFaceVal<I3, I1, I2, DIM>(
+            fine, coords, l, m, n, fk + N3[2], fj + N3[1], fi + N3[0]);
+
+        // Normal differences
+        const Real d1b2p =
+            GetFaceNormDif<I2, I1, I3, DIM>(fine, coords, l, m, n, fk + N2[2], fj + N2[1],
+                                            fi + N2[0]) *
+            id1;
+        const Real d1b2m =
+            GetFaceNormDif<I2, I1, I3, DIM>(fine, coords, l, m, n, fk, fj, fi) * id1;
+
+        const Real d1b3p =
+            GetFaceNormDif<I3, I1, I2, DIM>(fine, coords, l, m, n, fk + N3[2], fj + N3[1],
+                                            fi + N3[0]) *
+            id1;
+        const Real d1b3m =
+            GetFaceNormDif<I3, I1, I2, DIM>(fine, coords, l, m, n, fk, fj, fi) * id1;
+
+        const Real d2b1p =
+            GetFaceNormDif<I1, I2, I3, DIM>(fine, coords, l, m, n, fk + N1[2], fj + N1[1],
+                                            fi + N1[0]) *
+            id2;
+        const Real d2b1m =
+            GetFaceNormDif<I1, I2, I3, DIM>(fine, coords, l, m, n, fk, fj, fi) * id2;
+
+        const Real d3b1p =
+            GetFaceNormDif<I1, I3, I2, DIM>(fine, coords, l, m, n, fk + N1[2], fj + N1[1],
+                                            fi + N1[0]) *
+            id3;
+        const Real d3b1m =
+            GetFaceNormDif<I1, I3, I2, DIM>(fine, coords, l, m, n, fk, fj, fi) * id3;
+
+        // Cross terms (only for 3D)
+        Real a23 = 0.0;
+        if constexpr (DIM == 3) {
+          // Cross difference terms would go here
+          // For 2D R-Z we skip this
+        }
+
+        const Real a2 = 0.5 * (d2b1p + d2b1m);
+        const Real a3 = 0.5 * (d3b1p + d3b1m);
+        const Real b12 = id2 * (d1b2p - d1b2m);
+        const Real c13 = id3 * (d1b3p - d1b3m);
+
+        const Real a11 = -0.5 * (b12 + c13);
+        const Real a0 = 0.5 * (b1p + b1m) - 0.25 * a11 * d1 * d1;
+
+        // n1 is offset by 1 in the normal direction
+        constexpr auto n1 = Offsets<I1, DIM>();
+        // n2 is offset by 1 in the transverse direction (I2 if valid, else I3)
+        constexpr auto n2 = (I2 < DIM) ? Offsets<I2, DIM>() : Offsets<I3, DIM>();
+
+        // Set the two internal face values
+        if constexpr (I2 < DIM) {
+          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) = a0 - 0.25 * d2 * a2;
+          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) =
+              a0 + 0.25 * d2 * a2;
+        } else {
+          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) = a0 - 0.25 * d3 * a3;
+          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) =
+              a0 + 0.25 * d3 * a3;
+        }
+
+        // Divide by r for cylindrical (divide ALL components, matching FaceField scaling)
+        if constexpr (geom == Geometry::cylindrical) {
+          const Real eps = std::numeric_limits<Real>::epsilon();
+          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) /=
+              (coords.Xf(Axis::IAXIS, fi + n1[0]) + eps);
+          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) /=
+              (coords.Xf(Axis::IAXIS, fi + n1[0] + n2[0]) + eps);
+        }
+      }
+    }
+  }
+};
+
+/// TODO(acreyes): ProlongateInternalAverage
 // In principle I guess we should weight the averaging based on the generalized volume of
 // the elements
 
diff --git a/src/kamayan/pybind/kamayan_manager_py.cpp b/src/kamayan/pybind/kamayan_manager_py.cpp
index ba77d8f..80d4f56 100644
--- a/src/kamayan/pybind/kamayan_manager_py.cpp
+++ b/src/kamayan/pybind/kamayan_manager_py.cpp
@@ -69,10 +69,11 @@ void driver_py(nanobind::module_ &m) {
 
   nanobind::class_<KamayanDriver> driver(m, "KamayanDriver");
   driver.def("Execute", [](KamayanDriver &self) {
-        // re-enforce the parthenon signal handlers so that
-        // they are sent to parthenon and not to python
-        parthenon::SignalHandler::SignalHandlerInit();
-        return self.Execute();});
+    // re-enforce the parthenon signal handlers so that
+    // they are sent to parthenon and not to python
+    parthenon::SignalHandler::SignalHandlerInit();
+    return self.Execute();
+  });
 }
 
 void parthenon_manager(nanobind::module_ &m) {
diff --git a/src/physics/hydro/hydro_add_flux_tasks.cpp b/src/physics/hydro/hydro_add_flux_tasks.cpp
index 4706584..44725e9 100644
--- a/src/physics/hydro/hydro_add_flux_tasks.cpp
+++ b/src/physics/hydro/hydro_add_flux_tasks.cpp
@@ -4,6 +4,7 @@
 #include "basic_types.hpp"
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "grid/indexer.hpp"
@@ -351,7 +352,8 @@ struct CalculateFluxesScratch {
   }
 };
 
-template <TopologicalElement edge, EMFAveraging emf_averaging, typename stencil_2d>
+template <TopologicalElement edge, EMFAveraging emf_averaging, Geometry geom,
+          typename stencil_2d>
 requires(EdgeElement<edge> && emf_averaging == EMFAveraging::arithmetic)
 KOKKOS_INLINE_FUNCTION Real GetEdgeEMF(stencil_2d data) {
   using TE = TopologicalElement;
@@ -360,19 +362,21 @@ KOKKOS_INLINE_FUNCTION Real GetEdgeEMF(stencil_2d data) {
   constexpr auto face2 = IncrementTE(TE::F1, edge, 2);
   constexpr auto b2 = static_cast<int>(face2) % 3;
   // Ez = -Fx(By) = Fy(Bx)
-  const Real emf =
-      0.25 * (data.flux(face2, MAGC(b1), -1, 0) + data.flux(face2, MAGC(b1), 0, 0) -
-              data.flux(face1, MAGC(b2), 0, -1) - data.flux(face1, MAGC(b2), 0, 0));
+  // Ephi = -Fz(Br) = Fr(Bz)
+  constexpr Real sign = (geom == Geometry::cartesian) ? 1.0 : -1.0;
+  const Real emf = sign * 0.25 *
+                   (data.flux(face2, MAGC(b1), -1, 0) + data.flux(face2, MAGC(b1), 0, 0) -
+                    data.flux(face1, MAGC(b2), 0, -1) - data.flux(face1, MAGC(b2), 0, 0));
   return emf;
 }
 
 struct CalculateEMF {
-  using options = OptTypeList<MhdOptions, EMFOptions>;
+  using options = OptTypeList<MhdOptions, EMFOptions, grid::GeometryOptions>;
   using value = TaskStatus;
 
   using TE = TopologicalElement;
 
-  template <Mhd mhd, EMFAveraging emf_averaging>
+  template <Mhd mhd, EMFAveraging emf_averaging, Geometry geom>
   value dispatch(MeshData *md) {
     if constexpr (mhd == Mhd::ct) {
       auto pack = grid::GetPack<MAGC, MAG, EELE, EION, ERAD>(md, {PDOpt::WithFluxes});
@@ -388,13 +392,16 @@ struct CalculateEMF {
       par_for(
           PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
           KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
-            pack.flux(b, TE::E3, MAG(), k, j, i) = GetEdgeEMF<TE::E3, emf_averaging>(
-                SubPack<Axis::IAXIS, Axis::JAXIS>(pack, b, k, j, i));
+            pack.flux(b, TE::E3, MAG(), k, j, i) =
+                GetEdgeEMF<TE::E3, emf_averaging, geom>(
+                    SubPack<Axis::IAXIS, Axis::JAXIS>(pack, b, k, j, i));
             if (ndim > 2) {
-              pack.flux(b, TE::E1, MAG(), k, j, i) = GetEdgeEMF<TE::E1, emf_averaging>(
-                  SubPack<Axis::JAXIS, Axis::KAXIS>(pack, b, k, j, i));
-              pack.flux(b, TE::E2, MAG(), k, j, i) = GetEdgeEMF<TE::E2, emf_averaging>(
-                  SubPack<Axis::KAXIS, Axis::IAXIS>(pack, b, k, j, i));
+              pack.flux(b, TE::E1, MAG(), k, j, i) =
+                  GetEdgeEMF<TE::E1, emf_averaging, geom>(
+                      SubPack<Axis::JAXIS, Axis::KAXIS>(pack, b, k, j, i));
+              pack.flux(b, TE::E2, MAG(), k, j, i) =
+                  GetEdgeEMF<TE::E2, emf_averaging, geom>(
+                      SubPack<Axis::KAXIS, Axis::IAXIS>(pack, b, k, j, i));
             }
           });
     }
diff --git a/src/physics/hydro/primconsflux.cpp b/src/physics/hydro/primconsflux.cpp
index 2726670..60b0a33 100644
--- a/src/physics/hydro/primconsflux.cpp
+++ b/src/physics/hydro/primconsflux.cpp
@@ -22,7 +22,7 @@ struct ConvertToConserved_impl {
   template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::Xcoord>;
+    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::CoordFields>;
     auto pack = grid::GetPack(Fields(), md);
     const int nblocks = pack.GetNBlocks();
     auto ib = md->GetBoundsI(IndexDomain::interior);
@@ -35,17 +35,33 @@ struct ConvertToConserved_impl {
         KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
           capture(ndim);
           // also need to average the face-fields if doing constrained transport
+          auto coords = grid::CoordinatePack<geom, grid::CoordFields>(pack, b);
           if constexpr (hydro_traits::MHD == Mhd::ct) {
             using te = TopologicalElement;
             if (ndim > 1) {
-              pack(b, MAGC(0), k, j, i) = 0.5 * (pack(b, te::F1, MAG(), k, j, i + 1) +
-                                                 pack(b, te::F1, MAG(), k, j, i));
-              pack(b, MAGC(1), k, j, i) = 0.5 * (pack(b, te::F2, MAG(), k, j + 1, i) +
-                                                 pack(b, te::F2, MAG(), k, j, i));
+              pack(b, MAGC(0), k, j, i) =
+                  0.5 * coords.template Dx<Axis::IAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::IAXIS>(k, j, i + 1) *
+                       pack(b, te::F1, MAG(), k, j, i + 1) +
+                   coords.template FaceArea<Axis::IAXIS>(k, j, i) *
+                       pack(b, te::F1, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
+              pack(b, MAGC(1), k, j, i) =
+                  0.5 * coords.template Dx<Axis::JAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::JAXIS>(k, j + 1, i) *
+                       pack(b, te::F2, MAG(), k, j + 1, i) +
+                   coords.template FaceArea<Axis::JAXIS>(k, j, i) *
+                       pack(b, te::F2, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
             }
             if (ndim > 2) {
-              pack(b, MAGC(2), k, j, i) = 0.5 * (pack(b, te::F3, MAG(), k + 1, j, i) +
-                                                 pack(b, te::F3, MAG(), k, j, i));
+              pack(b, MAGC(2), k, j, i) =
+                  0.5 * coords.template Dx<Axis::KAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::KAXIS>(k + 1, j, i) *
+                       pack(b, te::F3, MAG(), k + 1, j, i) +
+                   coords.template FaceArea<Axis::KAXIS>(k, j, i) *
+                       pack(b, te::F3, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
             }
           }
           // --8<-- [start:make-idx]
@@ -53,7 +69,6 @@ struct ConvertToConserved_impl {
           Prim2Cons<hydro_traits>(U, U);
           // --8<-- [end:make-idx]
           if constexpr (geom == Geometry::cylindrical) {
-            auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
             // conserve angular momentum
             U(MOMENTUM(2)) *= coords.template Xc<Axis::IAXIS>(k, j, i);
             if constexpr (hydro_traits::MHD != Mhd::off) {
@@ -73,7 +88,7 @@ struct PreparePrimitive_impl {
   template <typename hydro_traits, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::Xcoord>;
+    using Fields = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::CoordFields>;
     auto pack = grid::GetPack(Fields(), md);
     const int nblocks = pack.GetNBlocks();
     auto ib = md->GetBoundsI(IndexDomain::interior);
@@ -85,23 +100,38 @@ struct PreparePrimitive_impl {
         PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
         KOKKOS_LAMBDA(const int b, const int k, const int j, const int i) {
           capture(ndim);
+          auto coords = grid::CoordinatePack<geom, grid::CoordFields>(pack, b);
           if constexpr (hydro_traits::MHD == Mhd::ct) {
             using TE = TopologicalElement;
             if (ndim > 1) {
-              pack(b, MAGC(0), k, j, i) = 0.5 * (pack(b, TE::F1, MAG(), k, j, i + 1) +
-                                                 pack(b, TE::F1, MAG(), k, j, i));
-              pack(b, MAGC(1), k, j, i) = 0.5 * (pack(b, TE::F2, MAG(), k, j + 1, i) +
-                                                 pack(b, TE::F2, MAG(), k, j, i));
+              pack(b, MAGC(0), k, j, i) =
+                  0.5 * coords.template Dx<Axis::IAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::IAXIS>(k, j, i + 1) *
+                       pack(b, TE::F1, MAG(), k, j, i + 1) +
+                   coords.template FaceArea<Axis::IAXIS>(k, j, i) *
+                       pack(b, TE::F1, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
+              pack(b, MAGC(1), k, j, i) =
+                  0.5 * coords.template Dx<Axis::JAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::JAXIS>(k, j + 1, i) *
+                       pack(b, TE::F2, MAG(), k, j + 1, i) +
+                   coords.template FaceArea<Axis::JAXIS>(k, j, i) *
+                       pack(b, TE::F2, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
             }
             if (ndim > 2) {
-              pack(b, MAGC(2), k, j, i) = 0.5 * (pack(b, TE::F3, MAG(), k + 1, j, i) +
-                                                 pack(b, TE::F3, MAG(), k, j, i));
+              pack(b, MAGC(2), k, j, i) =
+                  0.5 * coords.template Dx<Axis::KAXIS>(k, j, i) *
+                  (coords.template FaceArea<Axis::KAXIS>(k + 1, j, i) *
+                       pack(b, TE::F3, MAG(), k + 1, j, i) +
+                   coords.template FaceArea<Axis::KAXIS>(k, j, i) *
+                       pack(b, TE::F3, MAG(), k, j, i)) /
+                  coords.CellVolume(k, j, i);
             }
           }
           auto U = SubPack(pack, b, k, j, i);
           Cons2Prim<hydro_traits>(U, U);
           if constexpr (geom == Geometry::cylindrical) {
-            auto coords = grid::CoordinatePack<geom, grid::Xcoord>(pack, b);
             // conserve angular momentum
             U(VELOCITY(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
             if constexpr (hydro_traits::MHD != Mhd::off) {
diff --git a/src/physics/hydro/primconsflux.hpp b/src/physics/hydro/primconsflux.hpp
index ab3ac80..83a1e9f 100644
--- a/src/physics/hydro/primconsflux.hpp
+++ b/src/physics/hydro/primconsflux.hpp
@@ -154,7 +154,7 @@ KOKKOS_FORCEINLINE_FUNCTION void AddGeometricSource(const Coords &coords, const
     const Real pmag = 0.5 * (V(MAGC(0)) * V(MAGC(0)) + V(MAGC(1)) * V(MAGC(1)) +
                              V(MAGC(2)) * V(MAGC(2)));
     dudt(MOMENTUM(0)) +=
-        (pmag - V(MAGC(2)) * V(MAGC(2))) / coords.template Xc<Axis::IAXIS>();
+        (pmag - V(MAGC(2)) * V(MAGC(2))) / coords.template Xi<Axis::IAXIS>();
   }
 }
 

From ae4b647370333ef96f9c3994c96f4e76a7725f45 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Sun, 19 Apr 2026 17:03:04 -0700
Subject: [PATCH 43/55] looking good

---
 docs/kamayan_docs.cpp                      |   2 +-
 src/driver/kamayan_driver.cpp              |   5 +-
 src/grid/grid.cpp                          |   3 -
 src/grid/refinement_operations.hpp         | 216 ---------------------
 src/kamayan_utils/robust.hpp               |  34 ++++
 src/physics/hydro/hydro_add_flux_tasks.cpp |  38 +++-
 src/physics/hydro/hydro_time_step.cpp      |  19 +-
 src/physics/hydro/primconsflux.cpp         |   6 +-
 src/problems/isentropic_vortex.cpp         |  28 ++-
 src/problems/isentropic_vortex.hpp         |  72 ++++++-
 tests/CMakeLists.txt                       |   2 +-
 tests/test_suites/mhd_blast/mhd_blast.py   |  56 +++++-
 12 files changed, 225 insertions(+), 256 deletions(-)
 create mode 100644 src/kamayan_utils/robust.hpp

diff --git a/docs/kamayan_docs.cpp b/docs/kamayan_docs.cpp
index 30e001c..ec84dff 100644
--- a/docs/kamayan_docs.cpp
+++ b/docs/kamayan_docs.cpp
@@ -61,7 +61,7 @@ int main(int argc_in, char *argv_in[]) {
     // generate all the graphs for the task collection/lists
     // for the driver as well as all the units
     auto driver = kamayan::InitPackages(pman, units);
-    auto pkg = std::make_shared<kamayan::StateDescriptor>("Test Package");
+    auto pkg = std::make_shared<kamayan::KamayanUnit>("Test Package");
     auto block_list = kamayan::MakeTestBlockList(pkg, 1, 8, 3);
     auto tc = driver.MakeTaskCollection(block_list, 1);
     std::cout << tc;
diff --git a/src/driver/kamayan_driver.cpp b/src/driver/kamayan_driver.cpp
index 0fb4117..502333f 100644
--- a/src/driver/kamayan_driver.cpp
+++ b/src/driver/kamayan_driver.cpp
@@ -206,12 +206,13 @@ TaskID KamayanDriver::BuildTaskListRKStage(TaskList &task_list, const Real &dt,
     auto set_fluxes = parthenon::AddFluxCorrectionTasks(
         calc_fluxes, task_list, md0, md0->GetMeshPointer()->multilevel);
 
+    prepare = calc_fluxes;
     units_->AddTasksDAG([](KamayanUnit *u) -> auto & { return u->PrepareConserved; },
                         [&](KamayanUnit *unit) {
                           std::string task_label = unit->Name() + "::PrepareConserved";
-                          prepare = task_list.AddTask(calc_fluxes, task_label,
+                          prepare = task_list.AddTask(prepare, task_label,
                                                       unit->PrepareConserved.callback,
-                                                      md1.get());
+                                                      md0.get());
                         },
                         "PrepareConserved");
 
diff --git a/src/grid/grid.cpp b/src/grid/grid.cpp
index 509828c..de8425c 100644
--- a/src/grid/grid.cpp
+++ b/src/grid/grid.cpp
@@ -221,9 +221,6 @@ TaskStatus ApplyDuDt_impl(PackDesc_t &desc, const TopologicalElement &te, MeshDa
     auto dudt = desc.GetPack(dudt_data);
     if (pack0.GetMaxNumberOfVars() == 0) return TaskStatus::complete;
 
-    auto pack = GetPack<ENER, DEBUG>(md0);
-    auto enerp = GetPack<ENER, DEBUG>(dudt_data);
-
     const int nblocks = pack0.GetNBlocks();
     auto ib = md0->GetBoundsI(IndexDomain::interior, te);
     auto jb = md0->GetBoundsJ(IndexDomain::interior, te);
diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index 5ca2b20..77fea55 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -397,221 +397,5 @@ struct ProlongateInternalTothAndRoe {
   }
 };
 
-// TODO(acreyes): ProlongateInternalBalsara - broken implementation, needs fixing
-// template <Geometry geom>
-// struct ProlongateInternalBalsara { ... };
-
-template <Geometry geom>
-struct ProlongateInternalBalsara {
-  static constexpr bool OperationRequired(TopologicalElement fel,
-                                          TopologicalElement cel) {
-    return IsSubmanifold(fel, cel);
-  }
-
- private:
-  // Helper: Returns offset {i,j,k} for a given direction
-  // DIR: 0=x, 1=y, 2=z
-  // DIM: dimensionality (2 or 3)
-  // mult: multiplier for the offset (default 1)
-  template <int DIR, int DIM, int mult = 1>
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr std::array<int, 3> Offsets() {
-    std::array<int, 3> o = {0, 0, 0};
-    if (DIR == 0 && DIM > 0) {
-      o[0] = mult;
-    } else if (DIR == 1 && DIM > 1) {
-      o[1] = mult;
-    } else if (DIR == 2 && DIM > 2) {
-      o[2] = mult;
-    }
-    return o;
-  }
-
-  // Get face value - uses r*B scaling for cylindrical (scale ALL components)
-  template <int EIDX>
-  KOKKOS_FORCEINLINE_FUNCTION static Real
-  FaceField(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
-            const Coordinates<geom> &coords, int l, int m, int n, int k, int j, int i) {
-    Real val = fine(EIDX, l, m, n, k, j, i);
-    if constexpr (geom == Geometry::cylindrical) {
-      // Scale ALL faces by r (following the proven TothAndRoe approach)
-      val *= coords.Xf(Axis::IAXIS, i);
-    }
-    return val;
-  }
-
-  // Get coarse face average: 4-point in 3D, 2-point in 2D
-  template <int EIDX, int DIR2, int DIR3, int DIM>
-  KOKKOS_FORCEINLINE_FUNCTION static Real
-  GetCoarseFaceVal(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
-                   const Coordinates<geom> &coords, int l, int m, int n, int fk, int fj,
-                   int fi) {
-    Real b = FaceField<EIDX>(fine, coords, l, m, n, fk, fj, fi);
-
-    if constexpr (DIM == 3) {
-      constexpr auto o2 = Offsets<DIR2, DIM>();
-      constexpr auto o3 = Offsets<DIR3, DIM>();
-      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2], fj + o2[1], fi + o2[0]);
-      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o3[2], fj + o3[1], fi + o3[0]);
-      b += FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2] + o3[2], fj + o2[1] + o3[1],
-                           fi + o2[0] + o3[0]);
-      return b * 0.25;
-    } else {
-      // 2D: use DIR2 if valid (I2 < 2 means dimension index less than 2), else DIR3
-      constexpr auto N2 = (DIR2 < 2) ? Offsets<DIR2, DIM>() : Offsets<DIR3, DIM>();
-      b += FaceField<EIDX>(fine, coords, l, m, n, fk + N2[2], fj + N2[1], fi + N2[0]);
-      return b * 0.5;
-    }
-  }
-
-  // Normal difference: d(b1)/d(x2) - d(b1)/d(x3) pattern
-  template <int EIDX, int DIR2, int DIR3, int DIM>
-  KOKKOS_FORCEINLINE_FUNCTION static Real
-  GetFaceNormDif(const parthenon::ParArrayND<Real, parthenon::VariableState> &fine,
-                 const Coordinates<geom> &coords, int l, int m, int n, int fk, int fj,
-                 int fi) {
-    constexpr auto o2 = Offsets<DIR2, DIM>();
-    constexpr auto o3 = Offsets<DIR3, DIM>();
-    return (FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2] + o3[2], fj + o2[1] + o3[1],
-                            fi + o2[0] + o3[0]) -
-            FaceField<EIDX>(fine, coords, l, m, n, fk, fj, fi) +
-            FaceField<EIDX>(fine, coords, l, m, n, fk + o2[2], fj + o2[1], fi + o2[0]) -
-            FaceField<EIDX>(fine, coords, l, m, n, fk + o3[2], fj + o3[1], fi + o3[0]));
-  }
-
- public:
-  template <int DIM, TopologicalElement fel = TopologicalElement::CC,
-            TopologicalElement cel = TopologicalElement::CC>
-  KOKKOS_FORCEINLINE_FUNCTION static void
-  Do(const int l, const int m, const int n, const int k, const int j, const int i,
-     const parthenon::IndexRange &ckb, const parthenon::IndexRange &cjb,
-     const parthenon::IndexRange &cib, const parthenon::IndexRange &kb,
-     const parthenon::IndexRange &jb, const parthenon::IndexRange &ib,
-     const parthenon::Coordinates_t &pcoords,
-     const parthenon::Coordinates_t &pcoarse_coords,
-     const parthenon::ParArrayND<Real, parthenon::VariableState> *,
-     const parthenon::ParArrayND<Real, parthenon::VariableState> *pfine) {
-    auto coords = Coordinates<geom>(pcoords);
-    auto coarse_coords = Coordinates<geom>(pcoarse_coords);
-
-    if constexpr (!IsSubmanifold(fel, cel)) {
-      return;
-    } else {
-      constexpr int I1 = static_cast<int>(fel) % 3;
-      if constexpr (I1 + 1 > DIM) {
-        return;
-      } else {
-        auto &fine = *pfine;
-
-        const int fi = (DIM > 0) ? (i - cib.s) * 2 + ib.s : ib.s;
-        const int fj = (DIM > 1) ? (j - cjb.s) * 2 + jb.s : jb.s;
-        const int fk = (DIM > 2) ? (k - ckb.s) * 2 + kb.s : kb.s;
-
-        constexpr int I2 = (I1 + 1) % 3;
-        constexpr int I3 = (I1 + 2) % 3;
-
-        const Real d1 = coarse_coords.Dx(AxisFromInt(I1 + 1));
-        const Real d2 = coarse_coords.Dx(AxisFromInt(I2 + 1));
-        const Real d3 = coarse_coords.Dx(AxisFromInt(I3 + 1));
-        const Real id1 = 1.0 / d1;
-        const Real id2 = 1.0 / d2;
-        const Real id3 = 1.0 / d3;
-
-        // Get coarse face values at minus/plus
-        // Note: Offsets<I, DIM, 2> gives {2,0,0} or {0,2,0} or {0,0,2} based on I
-        constexpr auto N1 = Offsets<I1, DIM, 2>();
-        const Real b1m =
-            GetCoarseFaceVal<I1, I2, I3, DIM>(fine, coords, l, m, n, fk, fj, fi);
-        const Real b1p = GetCoarseFaceVal<I1, I2, I3, DIM>(
-            fine, coords, l, m, n, fk + N1[2], fj + N1[1], fi + N1[0]);
-
-        constexpr auto N2 = Offsets<I2, DIM, 2>();
-        const Real b2m =
-            GetCoarseFaceVal<I2, I3, I1, DIM>(fine, coords, l, m, n, fk, fj, fi);
-        const Real b2p = GetCoarseFaceVal<I2, I3, I1, DIM>(
-            fine, coords, l, m, n, fk + N2[2], fj + N2[1], fi + N2[0]);
-
-        constexpr auto N3 = Offsets<I3, DIM, 2>();
-        const Real b3m =
-            GetCoarseFaceVal<I3, I1, I2, DIM>(fine, coords, l, m, n, fk, fj, fi);
-        const Real b3p = GetCoarseFaceVal<I3, I1, I2, DIM>(
-            fine, coords, l, m, n, fk + N3[2], fj + N3[1], fi + N3[0]);
-
-        // Normal differences
-        const Real d1b2p =
-            GetFaceNormDif<I2, I1, I3, DIM>(fine, coords, l, m, n, fk + N2[2], fj + N2[1],
-                                            fi + N2[0]) *
-            id1;
-        const Real d1b2m =
-            GetFaceNormDif<I2, I1, I3, DIM>(fine, coords, l, m, n, fk, fj, fi) * id1;
-
-        const Real d1b3p =
-            GetFaceNormDif<I3, I1, I2, DIM>(fine, coords, l, m, n, fk + N3[2], fj + N3[1],
-                                            fi + N3[0]) *
-            id1;
-        const Real d1b3m =
-            GetFaceNormDif<I3, I1, I2, DIM>(fine, coords, l, m, n, fk, fj, fi) * id1;
-
-        const Real d2b1p =
-            GetFaceNormDif<I1, I2, I3, DIM>(fine, coords, l, m, n, fk + N1[2], fj + N1[1],
-                                            fi + N1[0]) *
-            id2;
-        const Real d2b1m =
-            GetFaceNormDif<I1, I2, I3, DIM>(fine, coords, l, m, n, fk, fj, fi) * id2;
-
-        const Real d3b1p =
-            GetFaceNormDif<I1, I3, I2, DIM>(fine, coords, l, m, n, fk + N1[2], fj + N1[1],
-                                            fi + N1[0]) *
-            id3;
-        const Real d3b1m =
-            GetFaceNormDif<I1, I3, I2, DIM>(fine, coords, l, m, n, fk, fj, fi) * id3;
-
-        // Cross terms (only for 3D)
-        Real a23 = 0.0;
-        if constexpr (DIM == 3) {
-          // Cross difference terms would go here
-          // For 2D R-Z we skip this
-        }
-
-        const Real a2 = 0.5 * (d2b1p + d2b1m);
-        const Real a3 = 0.5 * (d3b1p + d3b1m);
-        const Real b12 = id2 * (d1b2p - d1b2m);
-        const Real c13 = id3 * (d1b3p - d1b3m);
-
-        const Real a11 = -0.5 * (b12 + c13);
-        const Real a0 = 0.5 * (b1p + b1m) - 0.25 * a11 * d1 * d1;
-
-        // n1 is offset by 1 in the normal direction
-        constexpr auto n1 = Offsets<I1, DIM>();
-        // n2 is offset by 1 in the transverse direction (I2 if valid, else I3)
-        constexpr auto n2 = (I2 < DIM) ? Offsets<I2, DIM>() : Offsets<I3, DIM>();
-
-        // Set the two internal face values
-        if constexpr (I2 < DIM) {
-          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) = a0 - 0.25 * d2 * a2;
-          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) =
-              a0 + 0.25 * d2 * a2;
-        } else {
-          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) = a0 - 0.25 * d3 * a3;
-          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) =
-              a0 + 0.25 * d3 * a3;
-        }
-
-        // Divide by r for cylindrical (divide ALL components, matching FaceField scaling)
-        if constexpr (geom == Geometry::cylindrical) {
-          const Real eps = std::numeric_limits<Real>::epsilon();
-          fine(I1, l, m, n, fk + n1[2], fj + n1[1], fi + n1[0]) /=
-              (coords.Xf(Axis::IAXIS, fi + n1[0]) + eps);
-          fine(I1, l, m, n, fk + n1[2] + n2[2], fj + n1[1] + n2[1], fi + n1[0] + n2[0]) /=
-              (coords.Xf(Axis::IAXIS, fi + n1[0] + n2[0]) + eps);
-        }
-      }
-    }
-  }
-};
-
-/// TODO(acreyes): ProlongateInternalAverage
-// In principle I guess we should weight the averaging based on the generalized volume of
-// the elements
-
 }  // namespace kamayan::grid
 #endif  // GRID_REFINEMENT_OPERATIONS_HPP_
diff --git a/src/kamayan_utils/robust.hpp b/src/kamayan_utils/robust.hpp
new file mode 100644
index 0000000..8a0a665
--- /dev/null
+++ b/src/kamayan_utils/robust.hpp
@@ -0,0 +1,34 @@
+#ifndef KAMAYAN_UTILS_ROBUST_HPP_
+#define KAMAYAN_UTILS_ROBUST_HPP_
+
+#include <limits>
+#include <type_traits>
+
+#include <Kokkos_Macros.hpp>
+
+namespace kamayan::utils {
+template <typename T>
+KOKKOS_FORCEINLINE_FUNCTION T Tiny(const T &) {
+  return 10.0 * std::numeric_limits<T>::min();
+}
+
+template <typename T>
+KOKKOS_FORCEINLINE_FUNCTION T Eps(const T &) {
+  return 10.0 * std::numeric_limits<T>::epsilon();
+}
+
+template <typename T>
+KOKKOS_FORCEINLINE_FUNCTION int Sgn(const T &val) {
+  if constexpr (std::is_unsigned_v<T>) {
+    return 1;
+  } else {
+    return (T(0) <= val) - (val < T(0));
+  }
+}
+
+template <typename A, typename B>
+KOKKOS_FORCEINLINE_FUNCTION auto Ratio(const A &a, const B &b) {
+  return a / (b + Sgn(b) * Tiny(b));
+}
+}  // namespace kamayan::utils
+#endif  // KAMAYAN_UTILS_ROBUST_HPP_
diff --git a/src/physics/hydro/hydro_add_flux_tasks.cpp b/src/physics/hydro/hydro_add_flux_tasks.cpp
index 44725e9..cd73630 100644
--- a/src/physics/hydro/hydro_add_flux_tasks.cpp
+++ b/src/physics/hydro/hydro_add_flux_tasks.cpp
@@ -1,7 +1,8 @@
 #include <iostream>
 #include <type_traits>
 
-#include "basic_types.hpp"
+#include <basic_types.hpp>
+
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/geometry_types.hpp"
@@ -13,26 +14,26 @@
 #include "kamayan/config.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan_utils/parallel.hpp"
+#include "kamayan_utils/robust.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
 #include "kamayan_utils/type_list.hpp"
-#include "kokkos_abstraction.hpp"
 #include "physics/hydro/hydro.hpp"
 #include "physics/hydro/hydro_types.hpp"
 #include "physics/hydro/reconstruction.hpp"
 #include "physics/hydro/riemann_solver.hpp"
 #include "physics/physics_types.hpp"
-#include "utils/instrument.hpp"
 
 namespace kamayan::hydro {
 
 struct CalculateFluxesNested {
-  using options = OptTypeList<HydroFactory, ReconstructionFactory, RiemannOptions>;
+  using options = OptTypeList<HydroFactory, ReconstructionFactory, RiemannOptions,
+                              grid::GeometryOptions>;
   using value = TaskStatus;
 
   using TE = TopologicalElement;
 
   template <HydroTrait hydro_traits, ReconstructTrait reconstruction_traits,
-            RiemannSolver riemann>
+            RiemannSolver riemann, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
     // could also pack the mass scalars separately...
@@ -102,6 +103,13 @@ struct CalculateFluxesNested {
               vR(MAGC(0)) = pack_indexer(TE::F1, MAG());
             }
             RiemannFlux<TE::F1, riemann, hydro_traits>(pack_indexer, vL, vR);
+            if constexpr (hydro_traits::MHD == Mhd::ct && geom == Geometry::cylindrical) {
+              // in conservative form we evolve Bphi / r and modify our fluxes by 1/r
+              // see Eq 19 in Skinner & Ostriker 2010
+              auto coords = pack_flux.GetCoordinates(b);
+              pack_flux.flux(b, TE::F1, MAGC(2), k, j, i) *=
+                  utils::Ratio(1.0, coords.template Xf<1, 1>(k, j, i));
+            }
           });
           // --8<-- [end:rea]
 
@@ -155,6 +163,14 @@ struct CalculateFluxesNested {
                     vR(MAGC(1)) = pack_indexer(TE::F2, MAG());
                   }
                   RiemannFlux<TE::F2, riemann, hydro_traits>(pack_indexer, vL, vR);
+                  if constexpr (hydro_traits::MHD == Mhd::ct &&
+                                geom == Geometry::cylindrical) {
+                    // in conservative form we evolve Bphi / r and modify our fluxes by
+                    // 1/r see Eq 19 in Skinner & Ostriker 2010
+                    auto coords = pack_flux.GetCoordinates(b);
+                    pack_flux.flux(b, TE::F2, MAGC(2), k, j, i) *=
+                        utils::Ratio(1.0, coords.template Xf<1, 2>(k, j, i));
+                  }
                 });
 
                 member.team_barrier();
@@ -243,13 +259,14 @@ struct CalculateFluxesNested {
   }
 };
 struct CalculateFluxesScratch {
-  using options = OptTypeList<HydroFactory, ReconstructionFactory, RiemannOptions>;
+  using options = OptTypeList<HydroFactory, ReconstructionFactory, RiemannOptions,
+                              grid::GeometryOptions>;
   using value = TaskStatus;
 
   using TE = TopologicalElement;
 
   template <HydroTrait hydro_traits, ReconstructTrait reconstruction_traits,
-            RiemannSolver riemann>
+            RiemannSolver riemann, Geometry geom>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
     using conserved_vars = ConcatTypeLists_t<typename hydro_traits::Conserved,
@@ -323,6 +340,13 @@ struct CalculateFluxesScratch {
               vR(MAGC(dir)) = pack_indexer(face, MAG());
             }
             RiemannFlux<face, riemann, hydro_traits>(pack_indexer, vL, vR);
+            if constexpr (hydro_traits::MHD == Mhd::ct && geom == Geometry::cylindrical) {
+              // in conservative form we evolve Bphi / r and modify our fluxes by
+              // 1/r see Eq 19 in Skinner & Ostriker 2010
+              auto coords = pack_flux.GetCoordinates(b);
+              pack_flux.flux(b, face, MAGC(2), k, j, i) *= utils::Ratio(
+                  1.0, coords.template Xf<1, 1 + static_cast<int>(face) % 3>(k, j, i));
+            }
           });
 
       par_for_outer(
diff --git a/src/physics/hydro/hydro_time_step.cpp b/src/physics/hydro/hydro_time_step.cpp
index 52ab975..25cdfdb 100644
--- a/src/physics/hydro/hydro_time_step.cpp
+++ b/src/physics/hydro/hydro_time_step.cpp
@@ -1,11 +1,15 @@
 #include <Kokkos_MinMax.hpp>
 
 #include "dispatcher/options.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/grid.hpp"
+#include "grid/grid_types.hpp"
 #include "grid/subpack.hpp"
 #include "kamayan/config.hpp"
+#include "kamayan/fields.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
+#include "kamayan_utils/type_list.hpp"
 #include "physics/hydro/hydro.hpp"
 #include "physics/hydro/hydro_types.hpp"
 #include "physics/hydro/primconsflux.hpp"
@@ -19,7 +23,7 @@ struct EstimateTimeStep {
   template <typename hydro_traits>
   requires(NonTypeTemplateSpecialization<hydro_traits, HydroTraits>)
   value dispatch(MeshData *md) {
-    using vars = typename hydro_traits::ConsPrim;
+    using vars = ConcatTypeLists_t<typename hydro_traits::ConsPrim, grid::CoordFields>;
 
     auto pack = grid::GetPack(vars(), md);
     const int ndim = md->GetNDim();
@@ -33,6 +37,8 @@ struct EstimateTimeStep {
     auto jb = md->GetBoundsJ(IndexDomain::interior);
     auto kb = md->GetBoundsK(IndexDomain::interior);
 
+    const auto geometry = GetConfig(md)->Get<Geometry>();
+
     Real dt_min;
     par_reduce(
         PARTHENON_AUTO_LABEL, 0, nblocks - 1, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
@@ -40,15 +46,20 @@ struct EstimateTimeStep {
                       Real &dt_local) {
           auto V = SubPack(pack, b, k, j, i);
 
-          const auto &coords = pack.GetCoordinates(b);
+          const auto coords = grid::GenericCoordinatePack(geometry, pack, b);
           for (int dir = 0; dir < ndim; dir++) {
             const Real cfast = FastSpeed<hydro_traits::MHD>(dir, V);
-            dt_local = Kokkos::min(dt_local, coords.Dx(dir + 1) /
+            dt_local = Kokkos::min(dt_local, coords.Dx(AxisFromInt(dir + 1), k, j, i) /
                                                  (Kokkos::abs(V(VELOCITY(dir))) + cfast));
           }
+
+          if (geometry == Geometry::cylindrical) {
+            dt_local = Kokkos::min(dt_local, coords.template X<Axis::IAXIS>(k, j, i) /
+                                                 pack(b, VELOCITY(2), k, j, i));
+          }
         },
         Kokkos::Min<Real>(dt_min));
-    return dt_min * cfl / ndim;
+    return dt_min * cfl;
   }
 };
 
diff --git a/src/physics/hydro/primconsflux.cpp b/src/physics/hydro/primconsflux.cpp
index 60b0a33..a80e948 100644
--- a/src/physics/hydro/primconsflux.cpp
+++ b/src/physics/hydro/primconsflux.cpp
@@ -8,6 +8,7 @@
 #include "grid/indexer.hpp"
 #include "kamayan/config.hpp"
 #include "kamayan_utils/parallel.hpp"
+#include "kamayan_utils/robust.hpp"
 #include "kamayan_utils/type_abstractions.hpp"
 #include "kamayan_utils/type_list.hpp"
 #include "physics/hydro/hydro_types.hpp"
@@ -71,9 +72,6 @@ struct ConvertToConserved_impl {
           if constexpr (geom == Geometry::cylindrical) {
             // conserve angular momentum
             U(MOMENTUM(2)) *= coords.template Xc<Axis::IAXIS>(k, j, i);
-            if constexpr (hydro_traits::MHD != Mhd::off) {
-              U(MAGC(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
-            }
           }
         });
     return TaskStatus::complete;
@@ -133,7 +131,7 @@ struct PreparePrimitive_impl {
           Cons2Prim<hydro_traits>(U, U);
           if constexpr (geom == Geometry::cylindrical) {
             // conserve angular momentum
-            U(VELOCITY(2)) *= 1.0 / coords.template Xc<Axis::IAXIS>(k, j, i);
+            U(VELOCITY(2)) *= utils::Ratio(1.0, coords.template Xc<Axis::IAXIS>(k, j, i));
             if constexpr (hydro_traits::MHD != Mhd::off) {
               U(MAGC(2)) *= coords.template Xc<Axis::IAXIS>(k, j, i);
             }
diff --git a/src/problems/isentropic_vortex.cpp b/src/problems/isentropic_vortex.cpp
index 2565c3a..b0e7630 100644
--- a/src/problems/isentropic_vortex.cpp
+++ b/src/problems/isentropic_vortex.cpp
@@ -2,6 +2,7 @@
 
 #include <memory>
 
+#include "grid/coordinates.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan/config.hpp"
@@ -107,8 +108,10 @@ void ProblemGenerator(MeshBlock *mb) {
   auto kb = cellbounds.GetBoundsK(IndexDomain::interior);
 
   auto coords = mb->coords;
+  const auto geometry = config->Get<Geometry>();
 
   auto mhd = config->Get<Mhd>();
+  auto cpack = grid::GetPack(grid::CoordFields(), mb);
   const Real entropy =
       vortex_data.pressure / Kokkos::pow(vortex_data.density, vortex_data.gamma);
 
@@ -120,35 +123,48 @@ void ProblemGenerator(MeshBlock *mb) {
     par_for(
         PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
         KOKKOS_LAMBDA(const int k, const int j, const int i) {
+          auto cp = grid::GenericCoordinatePack(geometry, cpack, 0);
           const Real r2 =
               coords.Xc<1>(i) * coords.Xc<1>(i) + coords.Xc<2>(j) * coords.Xc<2>(j);
-          auto state = vortex_data.State(coords.Xc<1>(i), coords.Xc<2>(j));
+          const Real x1 = cp.template Xc<Axis::IAXIS>(k, j, i);
+          const Real x2 = cp.template Xc<Axis::JAXIS>(k, j, i);
+          VortexData::Arr_t state =
+              (geometry == Geometry::cartesian)
+                  ? vortex_data.State<Geometry::cartesian>(x1, x2)
+                  : vortex_data.State<Geometry::cylindrical>(x1, x2);
 
           // --8<-- [start:index]
           pack(0, DENS(), k, j, i) = state(DENS());
           pack(0, PRES(), k, j, i) = state(PRES());
           pack(0, VELOCITY(0), k, j, i) = state(VELOCITY(0));
           pack(0, VELOCITY(1), k, j, i) = state(VELOCITY(1));
+          pack(0, VELOCITY(2), k, j, i) = state(VELOCITY(2));
           // --8<-- [end:index]
         });
   } else {
-    auto pack = grid::GetPack<DENS, VELOCITY, PRES, MAGC>(mb);
+    auto pack = grid::GetPack<DENS, VELOCITY, PRES, MAGC, DEBUG>(mb);
     par_for(
         PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
         KOKKOS_LAMBDA(const int k, const int j, const int i) {
-          const Real r2 =
-              coords.Xc<1>(i) * coords.Xc<1>(i) + coords.Xc<2>(j) * coords.Xc<2>(j);
-          auto state = vortex_data.StateMHD(coords.Xc<1>(i), coords.Xc<2>(j));
+          const Real x1 = coords.Xc<1>(i);
+          const Real x2 = coords.Xc<2>(j);
+          VortexData::Arr_t state =
+              (geometry == Geometry::cartesian)
+                  ? vortex_data.StateMHD<Geometry::cartesian>(x1, x2)
+                  : vortex_data.StateMHD<Geometry::cylindrical>(x1, x2);
 
           pack(0, DENS(), k, j, i) = state(DENS());
           pack(0, PRES(), k, j, i) = state(PRES());
           pack(0, VELOCITY(0), k, j, i) = state(VELOCITY(0));
           pack(0, VELOCITY(1), k, j, i) = state(VELOCITY(1));
+          pack(0, VELOCITY(2), k, j, i) = state(VELOCITY(2));
           pack(0, MAGC(0), k, j, i) = state(MAGC(0));
           pack(0, MAGC(1), k, j, i) = state(MAGC(1));
+          pack(0, MAGC(2), k, j, i) = state(MAGC(2));
         });
   }
-  if (mhd == Mhd::ct && jb.e > jb.s) {  // CT and at least 2D
+  if (mhd == Mhd::ct && jb.e > jb.s &&
+      geometry == Geometry::cartesian) {  // CT and at least 2D cartesian
     // need to initialize div-free face fields from vector potential
     auto pack = grid::GetPack<MAG>(mb);
     auto k3d = kb.e > kb.s ? 1 : 0;
diff --git a/src/problems/isentropic_vortex.hpp b/src/problems/isentropic_vortex.hpp
index f99b875..b0227d8 100644
--- a/src/problems/isentropic_vortex.hpp
+++ b/src/problems/isentropic_vortex.hpp
@@ -4,6 +4,7 @@
 #include <memory>
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan/fields.hpp"
@@ -25,6 +26,8 @@ struct VortexData {
   using variables = TypeList<DENS, VELOCITY, PRES, MAGC>;
   using Arr_t = TypeListArray<variables>;
 
+  template <Geometry geom>
+  requires(geom == Geometry::cartesian)
   KOKKOS_INLINE_FUNCTION Arr_t State(const Real &x, const Real &y) const {
     Arr_t state;
     const Real r2 = x * x + y * y;
@@ -40,10 +43,35 @@ struct VortexData {
     // velocity = v_+ r * dv * \hat{\phi}
     state(VELOCITY(0)) = velx - y * dv;
     state(VELOCITY(1)) = vely + x * dv;
+    state(VELOCITY(2)) = 0.0;
 
     return state;
   }
 
+  template <Geometry geom>
+  requires(geom == Geometry::cylindrical)
+  KOKKOS_INLINE_FUNCTION Arr_t State(const Real &x, const Real &y) const {
+    Arr_t state;
+    const Real r2 = x * x;
+    const Real dv = strength * Kokkos::exp(0.5 * (1.0 - r2)) / (2.0 * M_PI);
+    const Real T = pressure / density - (gamma - 1.0) * strength * strength *
+                                            Kokkos::exp(1.0 - r2) /
+                                            (8.0 * gamma * M_PI * M_PI);
+    // T = P / rho
+    // entropy = constant = P / rho^gamma = T / rho^(gamma - 1)
+    // density = (T)^-(gamma - 1)
+    state(DENS()) = Kokkos::pow(T, 1.0 / (gamma - 1.0));
+    state(PRES()) = T * state(DENS());
+    // velocity = v_+ r * dv * \hat{\phi}
+    state(VELOCITY(0)) = 0.0;
+    state(VELOCITY(1)) = 0.0;
+    state(VELOCITY(2)) = x * dv;
+
+    return state;
+  }
+
+  template <Geometry geom>
+  requires(geom == Geometry::cartesian)
   KOKKOS_INLINE_FUNCTION Arr_t StateMHD(const Real &x, const Real &y) const {
     Arr_t state;
     const Real r2 = x * x + y * y;
@@ -61,12 +89,52 @@ struct VortexData {
     // velocity = v_+ r * dv * \hat{\phi}
     state(VELOCITY(0)) = velx - y * dv;
     state(VELOCITY(1)) = vely + x * dv;
+    state(VELOCITY(2)) = 0.0;
     state(MAGC(0)) = -y * dB;
     state(MAGC(1)) = +x * dB;
+    state(MAGC(2)) = 0.0;
+
+    return state;
+  }
+
+  template <Geometry geom>
+  requires(geom == Geometry::cylindrical)
+  KOKKOS_INLINE_FUNCTION Arr_t StateMHD(const Real &x, const Real &y) const {
+    Arr_t state;
+    const Real r2 = x * x;
+    const Real dv = strength * Kokkos::exp(0.5 * (1.0 - r2)) / (2.0 * M_PI);
+    const Real dB = mhd_strength * Kokkos::exp(0.5 * (1.0 - r2)) / (2.0 * M_PI);
+    const Real exp = Kokkos::exp(1.0 - r2);
+    // from Balsara 2004 we set density to unity
+    // so only pressure (thermal + magnetic), magnetic tension & centrifugal force play
+    // into the balance
+    state(DENS()) = 1.0;
+    state(PRES()) =
+        pressure +
+        (mhd_strength * mhd_strength / (8.0 * M_PI * M_PI)) * (1.0 - r2) * exp -
+        (strength * strength / (8.0 * M_PI * M_PI)) * exp;
+    // velocity = v_+ r * dv * \hat{\phi}
+    state(VELOCITY(0)) = 0.0;
+    state(VELOCITY(1)) = 0.0;
+    state(VELOCITY(2)) = x * dv;
+    state(MAGC(0)) = 0.0;
+    state(MAGC(1)) = 0.0;
+    state(MAGC(2)) = x * dB;
 
     return state;
   }
 
+  KOKKOS_INLINE_FUNCTION Arr_t State(const Geometry geom, const Mhd mhd, const Real &x,
+                                     const Real &y) const {
+    if (mhd == Mhd::off) {
+      return (geom == Geometry::cartesian) ? State<Geometry::cartesian>(x, y)
+                                           : State<Geometry::cylindrical>(x, y);
+    } else {
+      return (geom == Geometry::cartesian) ? StateMHD<Geometry::cartesian>(x, y)
+                                           : StateMHD<Geometry::cylindrical>(x, y);
+    }
+  }
+
   KOKKOS_INLINE_FUNCTION Real Az(const Real &x, const Real &y) const {
     const Real r2 = x * x + y * y;
     const Real exp = Kokkos::exp(0.5 * (1.0 - r2));
@@ -106,6 +174,7 @@ Real ErrorHistory(MeshData *md, const Mhd mhd, const int &component = 0) {
   auto kb = md->GetBoundsK(parthenon::IndexDomain::interior);
 
   const int comp = component;
+  const auto geometry = GetConfig(md)->Get<Geometry>();
 
   Real error = 0.;
   parthenon::par_reduce(
@@ -119,8 +188,7 @@ Real ErrorHistory(MeshData *md, const Mhd mhd, const int &component = 0) {
         // note this only works up to a single perdiod
         // const Real x = x0 > x1_min ? x0 : x1_max + (x0 - x1_min);
         // const Real y = y0 > x1_min ? y0 : x1_max + (y0 - x1_min);
-        auto state =
-            mhd == Mhd::off ? vortex_data.State(x0, y0) : vortex_data.StateMHD(x0, y0);
+        auto state = vortex_data.State(geometry, mhd, x0, y0);
         lerr += Kokkos::abs(state(Var(comp)) - pack(b, Var(comp), k, j, i)) *
                 coords.CellVolume(k, j, i);
       },
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index cdf3840..fbec425 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -92,7 +92,7 @@ setup_test(
 setup_test(
   ${kamayan_NP_TESTING}
   "mhd_blast"
-  "--driver ${PROJECT_BINARY_DIR}/mhd_blast --driver_input ${PROJECT_SOURCE_DIR}/src/problems/mhd_blast.in --num_steps 3"
+  "--driver ${PROJECT_BINARY_DIR}/mhd_blast --driver_input ${PROJECT_SOURCE_DIR}/src/problems/mhd_blast.in --num_steps 4"
   "mhd_blast;baseline")
 
 setup_test(
diff --git a/tests/test_suites/mhd_blast/mhd_blast.py b/tests/test_suites/mhd_blast/mhd_blast.py
index 9bd7fe1..55a4868 100644
--- a/tests/test_suites/mhd_blast/mhd_blast.py
+++ b/tests/test_suites/mhd_blast/mhd_blast.py
@@ -5,6 +5,7 @@
 from pathlib import Path
 
 import sys
+from typing import Literal
 import utils.test_case
 
 import numpy as np
@@ -17,6 +18,8 @@
 
 resolution = 64
 
+_GEO = Literal["cartesian", "cylindrical"]
+
 
 @dataclass
 class BlastConfig:
@@ -29,9 +32,45 @@ class BlastConfig:
     resolution: int = 64
     nxb: int = 32
     numlevel: int = 1
+    geometry: _GEO = "cartesian"
+
+    @property
+    def _cyl(self):
+        return self.geometry == "cylindrical"
+
+    @property
+    def x1min(self):
+        """Left domain boundary."""
+        return 0.0 if self._cyl else -0.5
+
+    @property
+    def ix1_bc(self):
+        """Left domain boundary condition."""
+        return "axisymmetric" if self._cyl else "outflow"
+
+    @property
+    def nx1(self):
+        """Zones across first dimension on base grid."""
+        return self.resolution / 2 if self._cyl else self.resolution
+
+    @property
+    def name(self) -> str:
+        """Name the problem id."""
+        geo_name = f"_{self.geometry}" if self._cyl else ""
+        return (
+            f"mhd_blast_{self.riemann}_N{self.resolution}_"
+            f"n{self.nxb}_l{self.numlevel}{geo_name}"
+        )
 
 
 configs = [
+    BlastConfig(
+        resolution=32,
+        nxb=8,
+        numlevel=3,
+        max_error=5.0e-5,
+        geometry="cylindrical",
+    ),
     BlastConfig(riemann="hll"),
     BlastConfig(riemann="hllc"),
     BlastConfig(
@@ -48,12 +87,6 @@ def analytic_divb(Z, Y, X, t):
 class TestCase(utils.test_case.TestCaseAbs):
     """Test class for sedov."""
 
-    def _test_namer(self, config: BlastConfig) -> str:
-        return (
-            f"mhd_blast_{config.riemann}_N{config.resolution}_"
-            f"n{config.nxb}_l{config.numlevel}"
-        )
-
     def Prepare(self, parameters, step):
         """Configure each run."""
         config = configs[step - 1]
@@ -62,9 +95,9 @@ def Prepare(self, parameters, step):
         if config.numlevel > 1:
             refinement = "adaptive"
         parameters.driver_cmd_line_args = [
-            f"parthenon/job/problem_id={self._test_namer(config)}",
+            f"parthenon/job/problem_id={config.name}",
             f"parthenon/mesh/refinement={refinement}",
-            f"parthenon/mesh/nx1={config.resolution}",
+            f"parthenon/mesh/nx1={config.nx1}",
             f"parthenon/mesh/nx2={config.resolution}",
             f"parthenon/meshblock/nx1={config.nxb}",
             f"parthenon/meshblock/nx2={config.nxb}",
@@ -81,6 +114,9 @@ def Prepare(self, parameters, step):
             "parthenon/output1/dt=1.0",
             "parthenon/output1/variables=divb",
             "physics/MHD=ct",
+            f"parthenon/mesh/x1min={config.x1min}",
+            f"parthenon/mesh/ix1_bc={config.ix1_bc}",
+            f"geometry/geometry={config.geometry}",
         ]
         return parameters
 
@@ -91,7 +127,7 @@ def Analyse(self, parameters) -> bool:
 
         passing = True
         for config in configs:
-            name = self._test_namer(config) + ".out0.final.phdf"
+            name = config.name + ".out0.final.phdf"
             output_file = output_dir / name
             baseline_file = baseline_dir / name
             delta = phdf_diff.compare(
@@ -103,7 +139,7 @@ def Analyse(self, parameters) -> bool:
             # error wrt to gold files
             passing = passing and delta == 0
 
-            name = self._test_namer(config) + ".out1.final.phdf"
+            name = config.name + ".out1.final.phdf"
             output_file = output_dir / name
             # l2 norm of divb
             passing = passing and compare_analytic.compare_analytic(

From ad2c98b15f0a3daea52abeb8a1edce2f38b3da96 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Mon, 20 Apr 2026 22:26:34 -0700
Subject: [PATCH 44/55] order matters

---
 src/driver/kamayan_driver.cpp                 |  22 ++--
 src/physics/hydro/hydro_add_flux_tasks.cpp    |  14 ++-
 src/physics/hydro/hydro_time_step.cpp         |   5 +-
 tests/CMakeLists.txt                          |   2 +-
 .../reconstruction/reconstruction.py          | 117 ++++++++++++++++--
 5 files changed, 128 insertions(+), 32 deletions(-)

diff --git a/src/driver/kamayan_driver.cpp b/src/driver/kamayan_driver.cpp
index 502333f..c36e9fc 100644
--- a/src/driver/kamayan_driver.cpp
+++ b/src/driver/kamayan_driver.cpp
@@ -206,16 +206,6 @@ TaskID KamayanDriver::BuildTaskListRKStage(TaskList &task_list, const Real &dt,
     auto set_fluxes = parthenon::AddFluxCorrectionTasks(
         calc_fluxes, task_list, md0, md0->GetMeshPointer()->multilevel);
 
-    prepare = calc_fluxes;
-    units_->AddTasksDAG([](KamayanUnit *u) -> auto & { return u->PrepareConserved; },
-                        [&](KamayanUnit *unit) {
-                          std::string task_label = unit->Name() + "::PrepareConserved";
-                          prepare = task_list.AddTask(prepare, task_label,
-                                                      unit->PrepareConserved.callback,
-                                                      md0.get());
-                        },
-                        "PrepareConserved");
-
     // now set dudt using flux-divergence / discrete stokes theorem
     build_dudt = task_list.AddTask(set_fluxes, "grid::FluxesToDuDt", grid::FluxesToDuDt,
                                    md0.get(), mdudt.get());
@@ -230,8 +220,18 @@ TaskID KamayanDriver::BuildTaskListRKStage(TaskList &task_list, const Real &dt,
         next = unit->AddTasksOneStep(next, task_list, md0.get(), mdudt.get());
       });
 
+  prepare = next;
+  units_->AddTasksDAG([](KamayanUnit *u) -> auto & { return u->PrepareConserved; },
+                      [&](KamayanUnit *unit) {
+                        std::string task_label = unit->Name() + "::PrepareConserved";
+                        prepare =
+                            task_list.AddTask(prepare, task_label,
+                                              unit->PrepareConserved.callback, md0.get());
+                      },
+                      "PrepareConserved");
+
   if (flux_callbacks.size() + one_step_callbacks.size() > 0) {
-    next = grid::ApplyDuDt(next | prepare, task_list, mbase.get(), md0.get(), md1.get(),
+    next = grid::ApplyDuDt(prepare, task_list, mbase.get(), md0.get(), md1.get(),
                            mdudt.get(), beta, dt);
 
     // now we might need to prepare the conserved vars for the next step
diff --git a/src/physics/hydro/hydro_add_flux_tasks.cpp b/src/physics/hydro/hydro_add_flux_tasks.cpp
index cd73630..2afe90a 100644
--- a/src/physics/hydro/hydro_add_flux_tasks.cpp
+++ b/src/physics/hydro/hydro_add_flux_tasks.cpp
@@ -103,12 +103,16 @@ struct CalculateFluxesNested {
               vR(MAGC(0)) = pack_indexer(TE::F1, MAG());
             }
             RiemannFlux<TE::F1, riemann, hydro_traits>(pack_indexer, vL, vR);
-            if constexpr (hydro_traits::MHD == Mhd::ct && geom == Geometry::cylindrical) {
-              // in conservative form we evolve Bphi / r and modify our fluxes by 1/r
-              // see Eq 19 in Skinner & Ostriker 2010
+            if constexpr (geom == Geometry::cylindrical) {
               auto coords = pack_flux.GetCoordinates(b);
-              pack_flux.flux(b, TE::F1, MAGC(2), k, j, i) *=
-                  utils::Ratio(1.0, coords.template Xf<1, 1>(k, j, i));
+              pack_flux.flux(b, TE::F1, MOMENTUM(2), k, j, i) *=
+                  coords.template Xf<1, 1>(k, j, i);
+              if constexpr (hydro_traits::MHD == Mhd::ct) {
+                // in conservative form we evolve Bphi / r and modify our fluxes by 1/r
+                // see Eq 19 in Skinner & Ostriker 2010
+                pack_flux.flux(b, TE::F1, MAGC(2), k, j, i) *=
+                    utils::Ratio(1.0, coords.template Xf<1, 1>(k, j, i));
+              }
             }
           });
           // --8<-- [end:rea]
diff --git a/src/physics/hydro/hydro_time_step.cpp b/src/physics/hydro/hydro_time_step.cpp
index 25cdfdb..912aa2a 100644
--- a/src/physics/hydro/hydro_time_step.cpp
+++ b/src/physics/hydro/hydro_time_step.cpp
@@ -54,8 +54,9 @@ struct EstimateTimeStep {
           }
 
           if (geometry == Geometry::cylindrical) {
-            dt_local = Kokkos::min(dt_local, coords.template X<Axis::IAXIS>(k, j, i) /
-                                                 pack(b, VELOCITY(2), k, j, i));
+            dt_local =
+                Kokkos::min(dt_local, coords.template X<Axis::IAXIS>(k, j, i) /
+                                          Kokkos::abs(pack(b, VELOCITY(2), k, j, i)));
           }
         },
         Kokkos::Min<Real>(dt_min));
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index fbec425..d099849 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -80,7 +80,7 @@ setup_test(
 setup_test(
   ${kamayan_NP_TESTING}
   "reconstruction"
-  "--driver ${PROJECT_BINARY_DIR}/isentropic_vortex --driver_input ${PROJECT_SOURCE_DIR}/src/problems/isentropic_vortex.in --num_steps 7"
+  "--driver ${PROJECT_BINARY_DIR}/isentropic_vortex --driver_input ${PROJECT_SOURCE_DIR}/src/problems/isentropic_vortex.in --num_steps 9"
   "reconstruction")
 
 setup_test(
diff --git a/tests/test_suites/reconstruction/reconstruction.py b/tests/test_suites/reconstruction/reconstruction.py
index de151bc..d6e2056 100644
--- a/tests/test_suites/reconstruction/reconstruction.py
+++ b/tests/test_suites/reconstruction/reconstruction.py
@@ -2,8 +2,10 @@
 
 # Modules
 from dataclasses import dataclass
-import numpy as np
 from pathlib import Path
+from typing import Literal
+
+import numpy as np
 
 import sys
 import utils.test_case
@@ -11,7 +13,11 @@
 """ To prevent littering up imported folders with .pyc files or __pycache_ folder"""
 sys.dont_write_bytecode = True
 
-resolution = 64
+RES = 64
+resolution = RES
+
+
+_GEO = Literal["cartesian", "cylindrical"]
 
 
 @dataclass
@@ -21,6 +27,78 @@ class ReconstructionConfig:
     recon: str
     slope_limiter: str = "minmod"
     max_error: float = 1.0e-12
+    geometry: _GEO = "cartesian"
+    resolution: int = RES
+    mhd: Literal["off", "ct"] = "off"
+
+    @property
+    def _cyl(self):
+        return self.geometry == "cylindrical"
+
+    @property
+    def x1min(self):
+        return -0.0 if self._cyl else -0.5
+
+    @property
+    def ix1_bc(self):
+        return "axisymmetric" if self._cyl else "outflow"
+
+    @property
+    def x1max(self):
+        return 5.0 if self._cyl else 5.0
+
+    @property
+    def ox1_bc(self):
+        return "outflow" if self._cyl else "periodic"
+
+    @property
+    def x2min(self):
+        return -5.0 if self._cyl else -5.0
+
+    @property
+    def x2max(self):
+        return 5.0 if self._cyl else 5.0
+
+    @property
+    def x2_bc(self):
+        return "periodic" if self._cyl else "periodic"
+
+    @property
+    def nx1(self):
+        return self.resolution
+
+    @property
+    def nx2(self):
+        return 1 if self._cyl else self.resolution
+
+    @property
+    def nx3(self):
+        return 1
+
+    @property
+    def meshblock_nx3(self):
+        return 1
+
+    @property
+    def nghost(self):
+        return 4 if self._cyl else 3
+
+    @property
+    def meshblock_nx1(self):
+        return 8 if self._cyl else self.resolution // 2
+
+    @property
+    def meshblock_nx2(self):
+        return 1 if self._cyl else self.resolution // 2
+
+    @property
+    def name(self) -> str:
+        geo_suffix = f"_{self.geometry}_Mhd-{self.mhd}" if self._cyl else ""
+        return f"isentropic_vortex_{self.recon}_{self.slope_limiter}{geo_suffix}"
+
+    @property
+    def driver_input(self) -> str:
+        return "isen_1d.in" if self._cyl else "isentropic_vortex.in"
 
 
 configs = [
@@ -31,32 +109,45 @@ class ReconstructionConfig:
     ReconstructionConfig("ppm", slope_limiter="minmod", max_error=0.02),
     ReconstructionConfig("ppm", slope_limiter="mc", max_error=0.015),
     ReconstructionConfig("wenoz", max_error=0.005),
+    ReconstructionConfig("wenoz", geometry="cylindrical", max_error=0.3),
+    ReconstructionConfig("wenoz", geometry="cylindrical", mhd="ct", max_error=0.3),
 ]
 
 
 class TestCase(utils.test_case.TestCaseAbs):
     """Test class for sedov."""
 
-    def _test_namer(self, config: ReconstructionConfig) -> str:
-        return f"isentropic_vortex_{config.recon}_{config.slope_limiter}"
-
     def Prepare(self, parameters, step):
         """Configure each run."""
         config = configs[step - 1]
         integrator = "rk2"
-        parameters.driver_cmd_line_args = [
-            f"parthenon/job/problem_id={self._test_namer(config)}",
-            f"parthenon/mesh/nx1={resolution}",
-            f"parthenon/mesh/nx2={resolution}",
-            f"parthenon/meshblock/nx1={resolution / 2}",
-            f"parthenon/meshblock/nx2={resolution / 2}",
-            "parthenon/mesh/nghost=3",
+        args = [
+            f"parthenon/job/problem_id={config.name}",
+            f"parthenon/mesh/nx1={config.nx1}",
+            f"parthenon/mesh/nx2={config.nx2}",
+            f"parthenon/mesh/nx3={config.nx3}",
+            f"parthenon/meshblock/nx1={config.meshblock_nx1}",
+            f"parthenon/meshblock/nx2={config.meshblock_nx2}",
+            f"parthenon/meshblock/nx3={config.meshblock_nx3}",
+            f"parthenon/mesh/nghost={config.nghost}",
             f"parthenon/time/integrator={integrator}",
             f"hydro/reconstruction={config.recon}",
             f"hydro/slope_limiter={config.slope_limiter}",
             "parthenon/output0/file_type=hst",
             "parthenon/output0/dt=1.0",
+            f"physics/MHD={config.mhd}",
         ]
+        if config._cyl:
+            args.extend(
+                [
+                    "geometry/geometry=cylindrical",
+                    "parthenon/mesh/x1min=-0.0",
+                    "parthenon/mesh/x1max=5.0",
+                    "parthenon/mesh/ix1_bc=axisymmetric",
+                    "parthenon/mesh/ox1_bc=outflow",
+                ]
+            )
+        parameters.driver_cmd_line_args = args
         return parameters
 
     def Analyse(self, parameters):
@@ -65,7 +156,7 @@ def Analyse(self, parameters):
         with open("isentropic_vortex_convergence.out", "w") as fid:
             errors = {}
             for config in configs:
-                name = self._test_namer(config)
+                name = config.name
                 history_file = output_dir / f"{name}.out0.hst"
                 data = np.loadtxt(history_file, usecols=4)
                 error = float(data[-1])

From f1bf2ef7b3ad2aefed67a944f82c2bdb945c1aa1 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Mon, 20 Apr 2026 22:44:22 -0700
Subject: [PATCH 45/55] add tests

---
 src/problems/isentropic_vortex.cpp            |  6 +++
 .../reconstruction/reconstruction.py          | 51 ++++++++++++++++---
 2 files changed, 51 insertions(+), 6 deletions(-)

diff --git a/src/problems/isentropic_vortex.cpp b/src/problems/isentropic_vortex.cpp
index b0e7630..867d8a2 100644
--- a/src/problems/isentropic_vortex.cpp
+++ b/src/problems/isentropic_vortex.cpp
@@ -81,6 +81,9 @@ void Initialize(KamayanUnit *unit) {
   history_vars.emplace_back(parthenon::HistoryOutputVar(
       parthenon::UserHistoryOperation::sum,
       [=](MeshData *md) { return ErrorHistory<VELOCITY>(md, mhd, 1); }, "vely error"));
+  history_vars.emplace_back(parthenon::HistoryOutputVar(
+      parthenon::UserHistoryOperation::sum,
+      [=](MeshData *md) { return ErrorHistory<VELOCITY>(md, mhd, 2); }, "velz error"));
   history_vars.emplace_back(parthenon::HistoryOutputVar(
       parthenon::UserHistoryOperation::sum,
       [=](MeshData *md) { return ErrorHistory<PRES>(md, mhd, 0); }, "pressure error"));
@@ -91,6 +94,9 @@ void Initialize(KamayanUnit *unit) {
     history_vars.emplace_back(parthenon::HistoryOutputVar(
         parthenon::UserHistoryOperation::sum,
         [=](MeshData *md) { return ErrorHistory<MAGC>(md, mhd, 1); }, "magy error"));
+    history_vars.emplace_back(parthenon::HistoryOutputVar(
+        parthenon::UserHistoryOperation::sum,
+        [=](MeshData *md) { return ErrorHistory<MAGC>(md, mhd, 2); }, "magz error"));
   }
 
   unit->AddParam<>(parthenon::hist_param_key, history_vars);
diff --git a/tests/test_suites/reconstruction/reconstruction.py b/tests/test_suites/reconstruction/reconstruction.py
index d6e2056..a6d299b 100644
--- a/tests/test_suites/reconstruction/reconstruction.py
+++ b/tests/test_suites/reconstruction/reconstruction.py
@@ -29,77 +29,101 @@ class ReconstructionConfig:
     max_error: float = 1.0e-12
     geometry: _GEO = "cartesian"
     resolution: int = RES
-    mhd: Literal["off", "ct"] = "off"
+    mhd: str = "off"
 
     @property
     def _cyl(self):
+        """Check if geometry is cylindrical."""
         return self.geometry == "cylindrical"
 
     @property
     def x1min(self):
+        """Left domain boundary."""
         return -0.0 if self._cyl else -0.5
 
     @property
     def ix1_bc(self):
+        """Left domain boundary condition."""
         return "axisymmetric" if self._cyl else "outflow"
 
     @property
     def x1max(self):
+        """Right domain boundary."""
         return 5.0 if self._cyl else 5.0
 
     @property
     def ox1_bc(self):
+        """Right domain boundary condition."""
         return "outflow" if self._cyl else "periodic"
 
     @property
     def x2min(self):
+        """x2 domain minimum boundary."""
         return -5.0 if self._cyl else -5.0
 
     @property
     def x2max(self):
+        """x2 domain maximum boundary."""
         return 5.0 if self._cyl else 5.0
 
     @property
     def x2_bc(self):
+        """x2 domain boundary condition."""
         return "periodic" if self._cyl else "periodic"
 
     @property
     def nx1(self):
+        """Number of zones in first dimension."""
         return self.resolution
 
     @property
     def nx2(self):
+        """Number of zones in second dimension."""
         return 1 if self._cyl else self.resolution
 
     @property
     def nx3(self):
+        """Number of zones in third dimension."""
         return 1
 
     @property
     def meshblock_nx3(self):
+        """Meshblock size in third dimension."""
         return 1
 
     @property
     def nghost(self):
+        """Number of ghost zones."""
         return 4 if self._cyl else 3
 
     @property
     def meshblock_nx1(self):
+        """Meshblock size in first dimension."""
         return 8 if self._cyl else self.resolution // 2
 
     @property
     def meshblock_nx2(self):
+        """Meshblock size in second dimension."""
         return 1 if self._cyl else self.resolution // 2
 
     @property
     def name(self) -> str:
+        """Problem ID string for the simulation."""
         geo_suffix = f"_{self.geometry}_Mhd-{self.mhd}" if self._cyl else ""
         return f"isentropic_vortex_{self.recon}_{self.slope_limiter}{geo_suffix}"
 
     @property
     def driver_input(self) -> str:
+        """Input file path for the driver."""
         return "isen_1d.in" if self._cyl else "isentropic_vortex.in"
 
+    @property
+    def column(self) -> int:
+        """Column in the history file to use for error comparison."""
+        if self._cyl:
+            return 7  # azimuthal velocity
+        return 4  # density
+
 
 configs = [
     ReconstructionConfig("fog", max_error=0.3),
@@ -110,15 +134,23 @@ def driver_input(self) -> str:
     ReconstructionConfig("ppm", slope_limiter="mc", max_error=0.015),
     ReconstructionConfig("wenoz", max_error=0.005),
     ReconstructionConfig("wenoz", geometry="cylindrical", max_error=0.3),
-    ReconstructionConfig("wenoz", geometry="cylindrical", mhd="ct", max_error=0.3),
+    ReconstructionConfig("wenoz", geometry="cylindrical", mhd="ct", max_error=0.35),
 ]
 
 
 class TestCase(utils.test_case.TestCaseAbs):
-    """Test class for sedov."""
+    """Test class for reconstruction."""
 
     def Prepare(self, parameters, step):
-        """Configure each run."""
+        """Configure each run with the given configuration.
+
+        Args:
+            parameters: The test parameters object.
+            step: The test step number (1-indexed).
+
+        Returns:
+            The configured parameters object.
+        """
         config = configs[step - 1]
         integrator = "rk2"
         args = [
@@ -151,14 +183,21 @@ def Prepare(self, parameters, step):
         return parameters
 
     def Analyse(self, parameters):
-        """Determine success of test cases."""
+        """Determine success of test cases.
+
+        Args:
+            parameters: The test parameters object.
+
+        Returns:
+            True if all tests pass, False otherwise.
+        """
         output_dir = Path(parameters.output_path)
         with open("isentropic_vortex_convergence.out", "w") as fid:
             errors = {}
             for config in configs:
                 name = config.name
                 history_file = output_dir / f"{name}.out0.hst"
-                data = np.loadtxt(history_file, usecols=4)
+                data = np.loadtxt(history_file, usecols=config.column)
                 error = float(data[-1])
                 errors[name] = (config, error)
                 fid.write(f"{name}: {error} | max error: {config.max_error}\n")

From 81b23c4aaddeaabf83634bb8dc3d0676e1c8cb06 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 21 Apr 2026 19:53:12 -0700
Subject: [PATCH 46/55] clean up vortex problem

---
 src/problems/isentropic_vortex.cpp | 83 +++++++++++-------------------
 src/problems/isentropic_vortex.hpp | 13 +++--
 2 files changed, 38 insertions(+), 58 deletions(-)

diff --git a/src/problems/isentropic_vortex.cpp b/src/problems/isentropic_vortex.cpp
index 867d8a2..b53335b 100644
--- a/src/problems/isentropic_vortex.cpp
+++ b/src/problems/isentropic_vortex.cpp
@@ -113,62 +113,38 @@ void ProblemGenerator(MeshBlock *mb) {
   auto jb = cellbounds.GetBoundsJ(IndexDomain::interior);
   auto kb = cellbounds.GetBoundsK(IndexDomain::interior);
 
-  auto coords = mb->coords;
   const auto geometry = config->Get<Geometry>();
+  const auto mhd = config->Get<Mhd>();
 
-  auto mhd = config->Get<Mhd>();
   auto cpack = grid::GetPack(grid::CoordFields(), mb);
   const Real entropy =
       vortex_data.pressure / Kokkos::pow(vortex_data.density, vortex_data.gamma);
 
-  if (mhd == Mhd::off) {
-    // get our pack
-    // --8<-- [start:pack]
-    auto pack = grid::GetPack<DENS, VELOCITY, PRES>(mb);
-    // --8<-- [end:pack]
-    par_for(
-        PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-        KOKKOS_LAMBDA(const int k, const int j, const int i) {
-          auto cp = grid::GenericCoordinatePack(geometry, cpack, 0);
-          const Real r2 =
-              coords.Xc<1>(i) * coords.Xc<1>(i) + coords.Xc<2>(j) * coords.Xc<2>(j);
-          const Real x1 = cp.template Xc<Axis::IAXIS>(k, j, i);
-          const Real x2 = cp.template Xc<Axis::JAXIS>(k, j, i);
-          VortexData::Arr_t state =
-              (geometry == Geometry::cartesian)
-                  ? vortex_data.State<Geometry::cartesian>(x1, x2)
-                  : vortex_data.State<Geometry::cylindrical>(x1, x2);
-
-          // --8<-- [start:index]
-          pack(0, DENS(), k, j, i) = state(DENS());
-          pack(0, PRES(), k, j, i) = state(PRES());
-          pack(0, VELOCITY(0), k, j, i) = state(VELOCITY(0));
-          pack(0, VELOCITY(1), k, j, i) = state(VELOCITY(1));
-          pack(0, VELOCITY(2), k, j, i) = state(VELOCITY(2));
-          // --8<-- [end:index]
-        });
-  } else {
-    auto pack = grid::GetPack<DENS, VELOCITY, PRES, MAGC, DEBUG>(mb);
-    par_for(
-        PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
-        KOKKOS_LAMBDA(const int k, const int j, const int i) {
-          const Real x1 = coords.Xc<1>(i);
-          const Real x2 = coords.Xc<2>(j);
-          VortexData::Arr_t state =
-              (geometry == Geometry::cartesian)
-                  ? vortex_data.StateMHD<Geometry::cartesian>(x1, x2)
-                  : vortex_data.StateMHD<Geometry::cylindrical>(x1, x2);
-
-          pack(0, DENS(), k, j, i) = state(DENS());
-          pack(0, PRES(), k, j, i) = state(PRES());
-          pack(0, VELOCITY(0), k, j, i) = state(VELOCITY(0));
-          pack(0, VELOCITY(1), k, j, i) = state(VELOCITY(1));
-          pack(0, VELOCITY(2), k, j, i) = state(VELOCITY(2));
+  // get our pack
+  // --8<-- [start:pack]
+  auto pack = grid::GetPack<DENS, VELOCITY, PRES, MAGC>(mb);
+  // --8<-- [end:pack]
+  par_for(
+      PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
+      KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        auto cp = grid::GenericCoordinatePack(geometry, cpack, 0);
+        const Real x1 = cp.template Xc<Axis::IAXIS>(k, j, i);
+        const Real x2 = cp.template Xc<Axis::JAXIS>(k, j, i);
+        auto state = vortex_data.State(geometry, mhd, x1, x2);
+
+        // --8<-- [start:index]
+        pack(0, DENS(), k, j, i) = state(DENS());
+        pack(0, PRES(), k, j, i) = state(PRES());
+        pack(0, VELOCITY(0), k, j, i) = state(VELOCITY(0));
+        pack(0, VELOCITY(1), k, j, i) = state(VELOCITY(1));
+        pack(0, VELOCITY(2), k, j, i) = state(VELOCITY(2));
+        // --8<-- [end:index]
+        if (mhd != Mhd::off) {
           pack(0, MAGC(0), k, j, i) = state(MAGC(0));
           pack(0, MAGC(1), k, j, i) = state(MAGC(1));
           pack(0, MAGC(2), k, j, i) = state(MAGC(2));
-        });
-  }
+        }
+      });
   if (mhd == Mhd::ct && jb.e > jb.s &&
       geometry == Geometry::cartesian) {  // CT and at least 2D cartesian
     // need to initialize div-free face fields from vector potential
@@ -178,16 +154,17 @@ void ProblemGenerator(MeshBlock *mb) {
         PARTHENON_AUTO_LABEL, kb.s, kb.e + k3d, jb.s, jb.e + 1, ib.s, ib.e + 1,
         KOKKOS_LAMBDA(const int k, const int j, const int i) {
           using te = TopologicalElement;
-          const Real xf_x = coords.Xf<1, 1>(k, j, i);
-          const Real xf_y = coords.Xf<2, 1>(k, j, i);
-          const Real xf_dy = coords.Dxf<2>(j);
+          auto cp = grid::GenericCoordinatePack(geometry, cpack, 0);
+          const Real xf_x = cp.template Xf<Axis::IAXIS>(k, j, i);
+          const Real xf_y = cp.template X<Axis::JAXIS>(k, j, i);
+          const Real xf_dy = cp.template Dx<Axis::JAXIS>(k, j, i);
           pack(0, te::F1, MAG(), k, j, i) = 1. / xf_dy *
                                             (vortex_data.Az(xf_x, xf_y + 0.5 * xf_dy) -
                                              vortex_data.Az(xf_x, xf_y - 0.5 * xf_dy));
 
-          const Real yf_x = coords.Xf<1, 2>(k, j, i);
-          const Real yf_y = coords.Xf<2, 2>(k, j, i);
-          const Real yf_dx = coords.Dxf<1>(i);
+          const Real yf_x = cp.template X<Axis::IAXIS>(k, j, i);
+          const Real yf_y = cp.template Xf<Axis::JAXIS>(k, j, i);
+          const Real yf_dx = cp.template Dx<Axis::IAXIS>(k, j, i);
           pack(0, te::F2, MAG(), k, j, i) = -1. / yf_dx *
                                             (vortex_data.Az(yf_x + 0.5 * yf_dx, yf_y) -
                                              vortex_data.Az(yf_x - 0.5 * yf_dx, yf_y));
diff --git a/src/problems/isentropic_vortex.hpp b/src/problems/isentropic_vortex.hpp
index b0227d8..20aaa83 100644
--- a/src/problems/isentropic_vortex.hpp
+++ b/src/problems/isentropic_vortex.hpp
@@ -4,12 +4,14 @@
 #include <memory>
 
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
 #include "kamayan/fields.hpp"
 #include "kamayan/runtime_parameters.hpp"
 #include "kamayan/unit_data.hpp"
+#include "kamayan_utils/type_list.hpp"
 #include "kamayan_utils/type_list_array.hpp"
 #include "physics/physics_types.hpp"
 
@@ -167,7 +169,8 @@ Real ErrorHistory(MeshData *md, const Mhd mhd, const int &component = 0) {
   const Real xc = vortex_data.velx * time;
   const Real yc = vortex_data.vely * time;
 
-  auto pack = grid::GetPack<Var>(md);
+  using Fields = ConcatTypeLists_t<TypeList<Var>, grid::CoordFields>;
+  auto pack = grid::GetPack(Fields(), md);
 
   auto ib = md->GetBoundsI(parthenon::IndexDomain::interior);
   auto jb = md->GetBoundsJ(parthenon::IndexDomain::interior);
@@ -182,15 +185,15 @@ Real ErrorHistory(MeshData *md, const Mhd mhd, const int &component = 0) {
       parthenon::DevExecSpace(), 0, pack.GetNBlocks() - 1, kb.s, kb.e, jb.s, jb.e, ib.s,
       ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, Real &lerr) {
-        auto coords = pack.GetCoordinates(b);
-        const Real x0 = coords.template Xc<1>(i);
-        const Real y0 = coords.template Xc<2>(j);
+        auto cp = grid::GenericCoordinatePack(geometry, pack, 0);
+        const Real x0 = cp.template Xc<Axis::IAXIS>(k, j, i);
+        const Real y0 = cp.template Xc<Axis::JAXIS>(k, j, i);
         // note this only works up to a single perdiod
         // const Real x = x0 > x1_min ? x0 : x1_max + (x0 - x1_min);
         // const Real y = y0 > x1_min ? y0 : x1_max + (y0 - x1_min);
         auto state = vortex_data.State(geometry, mhd, x0, y0);
         lerr += Kokkos::abs(state(Var(comp)) - pack(b, Var(comp), k, j, i)) *
-                coords.CellVolume(k, j, i);
+                cp.CellVolume(k, j, i);
       },
       Kokkos::Sum<Real>(error));
   return error / (size_x1 * size_x2);

From b35219bd23184a0ca7d461cee89f015e5f7c3eca Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 21 Apr 2026 22:17:52 -0700
Subject: [PATCH 47/55] a fix

---
 src/problems/isentropic_vortex.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/problems/isentropic_vortex.hpp b/src/problems/isentropic_vortex.hpp
index 20aaa83..ee0ee8a 100644
--- a/src/problems/isentropic_vortex.hpp
+++ b/src/problems/isentropic_vortex.hpp
@@ -185,7 +185,7 @@ Real ErrorHistory(MeshData *md, const Mhd mhd, const int &component = 0) {
       parthenon::DevExecSpace(), 0, pack.GetNBlocks() - 1, kb.s, kb.e, jb.s, jb.e, ib.s,
       ib.e,
       KOKKOS_LAMBDA(const int b, const int k, const int j, const int i, Real &lerr) {
-        auto cp = grid::GenericCoordinatePack(geometry, pack, 0);
+        auto cp = grid::GenericCoordinatePack(geometry, pack, b);
         const Real x0 = cp.template Xc<Axis::IAXIS>(k, j, i);
         const Real y0 = cp.template Xc<Axis::JAXIS>(k, j, i);
         // note this only works up to a single perdiod

From 89579fe7583d93dd527425d88aacaa13b9fca463 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Tue, 21 Apr 2026 22:27:35 -0700
Subject: [PATCH 48/55] migrate to coord packs

---
 src/grid/coordinates.hpp                   |  5 +++
 src/physics/hydro/hydro_add_flux_tasks.cpp | 36 ++++++++++++----------
 src/problems/sedov.cpp                     |  2 --
 3 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 10f754b..5119036 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -244,6 +244,11 @@ struct CoordinatePack {
     return Get_(coords::Xc<ax>())(kji[0], kji[1], kji[2]);
   }
 
+  template <Axis ax>
+  KOKKOS_INLINE_FUNCTION Real Xi(const int k, const int j, const int i) const {
+    return X<ax>(k, j, i);
+  }
+
   template <Axis ax>
   KOKKOS_INLINE_FUNCTION Real Xf(const int k, const int j, const int i) const {
     static_assert(FieldList::template Contains<coords::Xf<ax>>(),
diff --git a/src/physics/hydro/hydro_add_flux_tasks.cpp b/src/physics/hydro/hydro_add_flux_tasks.cpp
index 2afe90a..98e64d0 100644
--- a/src/physics/hydro/hydro_add_flux_tasks.cpp
+++ b/src/physics/hydro/hydro_add_flux_tasks.cpp
@@ -5,6 +5,7 @@
 
 #include "dispatcher/options.hpp"
 #include "driver/kamayan_driver_types.hpp"
+#include "grid/coordinates.hpp"
 #include "grid/geometry_types.hpp"
 #include "grid/grid.hpp"
 #include "grid/grid_types.hpp"
@@ -45,7 +46,9 @@ struct CalculateFluxesNested {
                                                typename hydro_traits::MassScalars>;
     // --8<-- [start:pack]
     auto pack_recon = grid::GetPack(reconstruct_vars(), md);
-    auto pack_flux = grid::GetPack(conserved_vars(), md, {PDOpt::WithFluxes});
+    // include Xf for cylindrical geometry flux corrections
+    using flux_vars = ConcatTypeLists_t<conserved_vars, grid::Xface>;
+    auto pack_flux = grid::GetPack(flux_vars(), md, {PDOpt::WithFluxes});
     // --8<-- [end:pack]
 
     const int ndim = md->GetNDim();
@@ -104,14 +107,13 @@ struct CalculateFluxesNested {
             }
             RiemannFlux<TE::F1, riemann, hydro_traits>(pack_indexer, vL, vR);
             if constexpr (geom == Geometry::cylindrical) {
-              auto coords = pack_flux.GetCoordinates(b);
+              auto cpack =
+                  grid::CoordinatePack<Geometry::cylindrical, grid::Xface>(pack_flux, b);
               pack_flux.flux(b, TE::F1, MOMENTUM(2), k, j, i) *=
-                  coords.template Xf<1, 1>(k, j, i);
+                  cpack.Xf<Axis::IAXIS>(k, j, i);
               if constexpr (hydro_traits::MHD == Mhd::ct) {
-                // in conservative form we evolve Bphi / r and modify our fluxes by 1/r
-                // see Eq 19 in Skinner & Ostriker 2010
                 pack_flux.flux(b, TE::F1, MAGC(2), k, j, i) *=
-                    utils::Ratio(1.0, coords.template Xf<1, 1>(k, j, i));
+                    utils::Ratio(1.0, cpack.Xf<Axis::IAXIS>(k, j, i));
               }
             }
           });
@@ -169,11 +171,10 @@ struct CalculateFluxesNested {
                   RiemannFlux<TE::F2, riemann, hydro_traits>(pack_indexer, vL, vR);
                   if constexpr (hydro_traits::MHD == Mhd::ct &&
                                 geom == Geometry::cylindrical) {
-                    // in conservative form we evolve Bphi / r and modify our fluxes by
-                    // 1/r see Eq 19 in Skinner & Ostriker 2010
-                    auto coords = pack_flux.GetCoordinates(b);
+                    auto cpack = grid::CoordinatePack<Geometry::cylindrical, grid::Xface>(
+                        pack_flux, b);
                     pack_flux.flux(b, TE::F2, MAGC(2), k, j, i) *=
-                        utils::Ratio(1.0, coords.template Xf<1, 2>(k, j, i));
+                        utils::Ratio(1.0, cpack.Xf<Axis::JAXIS>(k, j, i));
                   }
                 });
 
@@ -281,7 +282,8 @@ struct CalculateFluxesScratch {
     using plus = RiemannScratch::Plus;
 
     auto pack_recon = grid::GetPack(reconstruct_vars(), md);
-    auto pack_flux = grid::GetPack(conserved_vars(), md, {PDOpt::WithFluxes});
+    using flux_vars = ConcatTypeLists_t<conserved_vars, grid::Xface>;
+    auto pack_flux = grid::GetPack(flux_vars(), md, {PDOpt::WithFluxes});
 
     auto hydro = md->GetMeshPointer()->packages.Get("hydro");
     const auto riemann_scratch = hydro->Param<RiemannScratch::type>("riemann_scratch");
@@ -345,11 +347,13 @@ struct CalculateFluxesScratch {
             }
             RiemannFlux<face, riemann, hydro_traits>(pack_indexer, vL, vR);
             if constexpr (hydro_traits::MHD == Mhd::ct && geom == Geometry::cylindrical) {
-              // in conservative form we evolve Bphi / r and modify our fluxes by
-              // 1/r see Eq 19 in Skinner & Ostriker 2010
-              auto coords = pack_flux.GetCoordinates(b);
-              pack_flux.flux(b, face, MAGC(2), k, j, i) *= utils::Ratio(
-                  1.0, coords.template Xf<1, 1 + static_cast<int>(face) % 3>(k, j, i));
+              auto cpack =
+                  grid::CoordinatePack<Geometry::cylindrical, grid::Xface>(pack_flux, b);
+              const Axis ax = (face == TE::F1)   ? Axis::IAXIS
+                              : (face == TE::F2) ? Axis::JAXIS
+                                                 : Axis::KAXIS;
+              pack_flux.flux(b, face, MAGC(2), k, j, i) *=
+                  utils::Ratio(1.0, cpack.Xf(ax, k, j, i));
             }
           });
 
diff --git a/src/problems/sedov.cpp b/src/problems/sedov.cpp
index decb367..e9a2a5c 100644
--- a/src/problems/sedov.cpp
+++ b/src/problems/sedov.cpp
@@ -112,8 +112,6 @@ void ProblemGenerator(MeshBlock *mb) {
   auto jb = cellbounds.GetBoundsJ(IndexDomain::interior);
   auto kb = cellbounds.GetBoundsK(IndexDomain::interior);
 
-  auto coords = grid::GenericCoordinate(mb);
-
   auto nspecies = mb->packages.Get("material")->Param<std::size_t>("nspecies");
   if (nspecies > 1) {
     for (int s = 0; s < nspecies; s++) {

From 9f3234ef9da59515696744b652ef72fea63548a1 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 09:40:54 -0700
Subject: [PATCH 49/55] robustness

---
 src/grid/pybind/grid_bindings.cpp | 5 +++++
 src/kamayan/kamayan.cpp           | 6 +++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/grid/pybind/grid_bindings.cpp b/src/grid/pybind/grid_bindings.cpp
index d01a53f..358ee67 100644
--- a/src/grid/pybind/grid_bindings.cpp
+++ b/src/grid/pybind/grid_bindings.cpp
@@ -50,6 +50,11 @@ struct SparsePack_py {
 
   grid::GenericCoordinate GetCoordinates(const int b) const {
     auto cfg = config_.lock();
+    if (!cfg) {
+      PARTHENON_FAIL(
+          "Config not available in SparsePack_py::GetCoordinates. "
+          "Ensure InitializeData is called after the Config package is registered.");
+    }
     const Geometry geometry = cfg->Get<Geometry>();
     return grid::GenericCoordinate(geometry, pack.GetCoordinates(b));
   }
diff --git a/src/kamayan/kamayan.cpp b/src/kamayan/kamayan.cpp
index e6b6cdc..ea97258 100644
--- a/src/kamayan/kamayan.cpp
+++ b/src/kamayan/kamayan.cpp
@@ -47,11 +47,15 @@ KamayanDriver InitPackages(std::shared_ptr<ParthenonManager> pman,
     kamayan_unit.second->SetUnits(units);
     // At this point we can allow params in our units
     kamayan_unit.second->UnlockParams();
+
+    // Always initialize resources first - this sets config_ which is needed
+    // by InitializeData even if SetupParams is not registered
+    kamayan_unit.second->InitResources(runtime_parameters, config);
+
     // TODO(acreyes): these callbacks should not depend on the order of execution
     // so we should add a CallBackRegistration constructor that raises a runtime
     // error if someone tries to suggest an order
     if (kamayan_unit.second->SetupParams.IsRegistered()) {
-      kamayan_unit.second->InitResources(runtime_parameters, config);
       kamayan_unit.second->SetupParams(kamayan_unit.second.get());
       // Sync UnitData parameters from RuntimeParameters (input file takes precedence)
       for (auto &[name, ud] : kamayan_unit.second->AllData()) {

From d93781a3a23cefe65acba99d8904f2e05d28a81c Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 09:41:00 -0700
Subject: [PATCH 50/55] update baselines

---
 tests/baselines/baseline_versions.json | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/baselines/baseline_versions.json b/tests/baselines/baseline_versions.json
index 81b3c27..d8b8c20 100644
--- a/tests/baselines/baseline_versions.json
+++ b/tests/baselines/baseline_versions.json
@@ -29,6 +29,12 @@
       "git_sha": "c2181d2680e60c1529689b82bac8cd483338927a",
       "tar_sha": "7fc9e7933d6d8e8fb7610b189b145fade9584975dfbac444b38913442dbe527f5bce3df2655a1dbeaed123ae412c68cbf96369bb55037606f7d2dc6c21b3bd20",
       "comment": "shock tube + multispecies sedov"
+    },
+    "6": {
+      "version": 6,
+      "git_sha": "89579fe7583d93dd527425d88aacaa13b9fca463",
+      "tar_sha": "a1190c53a2570b0c1e017ddf4734477bd290b344971912330d752d92a8e8537fee2859a5794aa36b11acb8bb9a7cd38d7f483091b06afcdc9e19db306e8d9ca6",
+      "comment": "added cylindrical coordinates & coordinate packs"
     }
   }
 }
\ No newline at end of file

From 23dd3e6e3c11808300492460ff71dc9836c3b6b6 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 11:15:40 -0700
Subject: [PATCH 51/55] baselines

---
 tests/baselines/baseline_versions.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/baselines/baseline_versions.json b/tests/baselines/baseline_versions.json
index d8b8c20..02fa294 100644
--- a/tests/baselines/baseline_versions.json
+++ b/tests/baselines/baseline_versions.json
@@ -32,8 +32,8 @@
     },
     "6": {
       "version": 6,
-      "git_sha": "89579fe7583d93dd527425d88aacaa13b9fca463",
-      "tar_sha": "a1190c53a2570b0c1e017ddf4734477bd290b344971912330d752d92a8e8537fee2859a5794aa36b11acb8bb9a7cd38d7f483091b06afcdc9e19db306e8d9ca6",
+      "git_sha": "d93781a3a23cefe65acba99d8904f2e05d28a81c",
+      "tar_sha": "1e13a028b5c20b5776af679355088331910ef3d76cface17a65155d6fbc67ceb93b2811b85f935fdb1dded665b37baac3fe509ebaec856da8354941b5890093f",
       "comment": "added cylindrical coordinates & coordinate packs"
     }
   }

From a2b803673183065a2357c20da1c497d175facca6 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 11:20:14 -0700
Subject: [PATCH 52/55] linting

---
 src/grid/grid.hpp                        | 2 +-
 src/grid/pybind/grid_bindings.cpp        | 3 +--
 src/grid/refinement_operations.hpp       | 2 +-
 src/grid/tests/test_coordinates_pack.cpp | 1 -
 src/kamayan/fields.hpp                   | 2 +-
 src/physics/hydro/hydro.cpp              | 2 +-
 src/physics/hydro/primconsflux.hpp       | 1 -
 7 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/grid/grid.hpp b/src/grid/grid.hpp
index 5b0f2ef..a4c91fc 100644
--- a/src/grid/grid.hpp
+++ b/src/grid/grid.hpp
@@ -136,4 +136,4 @@ TaskID ApplyDuDt(TaskID prev, TaskList &tl, MeshData *mbase, MeshData *md0, Mesh
 
 }  // namespace kamayan::grid
 
-#endif  // GRID_GRID_HPP_
\ No newline at end of file
+#endif  // GRID_GRID_HPP_
diff --git a/src/grid/pybind/grid_bindings.cpp b/src/grid/pybind/grid_bindings.cpp
index 358ee67..e905e47 100644
--- a/src/grid/pybind/grid_bindings.cpp
+++ b/src/grid/pybind/grid_bindings.cpp
@@ -1,8 +1,8 @@
 #include "grid/pybind/grid_bindings.hpp"
 
+#include <memory>
 #include <set>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include <pack/make_pack_descriptor.hpp>
@@ -17,7 +17,6 @@
 #include "kamayan/config.hpp"
 #include "kamayan_utils/parallel.hpp"
 #include "kamayan_utils/type_list.hpp"
-#include "kokkos_abstraction.hpp"
 #include "pack/pack_utils.hpp"
 #include "pack/sparse_pack_base.hpp"
 
diff --git a/src/grid/refinement_operations.hpp b/src/grid/refinement_operations.hpp
index 77fea55..ad82aef 100644
--- a/src/grid/refinement_operations.hpp
+++ b/src/grid/refinement_operations.hpp
@@ -2,6 +2,7 @@
 #define GRID_REFINEMENT_OPERATIONS_HPP_
 #include <algorithm>
 #include <array>
+#include <limits>
 
 #include <Kokkos_Core.hpp>
 
@@ -10,7 +11,6 @@
 #include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"
 #include "interface/variable_state.hpp"
-#include <limits>
 namespace kamayan::grid {
 // Parthenon's implementation of non-cartesian coordinates assumes that
 // it is determined at compile time for the entire library. In order
diff --git a/src/grid/tests/test_coordinates_pack.cpp b/src/grid/tests/test_coordinates_pack.cpp
index 75082d8..97012d6 100644
--- a/src/grid/tests/test_coordinates_pack.cpp
+++ b/src/grid/tests/test_coordinates_pack.cpp
@@ -1,4 +1,3 @@
-#include <format>
 #include <gtest/gtest.h>
 
 #include <memory>
diff --git a/src/kamayan/fields.hpp b/src/kamayan/fields.hpp
index 06f0c06..7c177d9 100644
--- a/src/kamayan/fields.hpp
+++ b/src/kamayan/fields.hpp
@@ -114,7 +114,7 @@ void AddField(KamayanUnit *pkg, std::vector<MetadataFlag> m,
       std::cerr << "Variable: " << T::name() << std::endl;
       throw;
     }
-  };
+  };  // NOLINT(readability/braces)
   const auto handled = md.HasRefinementOps()
                            ? grid::GeometryOptions::dispatch(register_ops, geometry)
                            : true;
diff --git a/src/physics/hydro/hydro.cpp b/src/physics/hydro/hydro.cpp
index 4b2c699..6e0fa0e 100644
--- a/src/physics/hydro/hydro.cpp
+++ b/src/physics/hydro/hydro.cpp
@@ -111,7 +111,7 @@ struct InitializeHydro {
         m.RegisterRefinementOps<grid::ProlongateSharedMinMod<geom>,
                                 grid::RestrictAverage<geom>,
                                 grid::ProlongateInternalTothAndRoe<geom>>();
-      };
+      };  // NOLINT(readability/braces)
       const auto geometry = unit->Configuration()->Get<Geometry>();
       const auto handled = grid::GeometryOptions::dispatch(register_ops, geometry);
       PARTHENON_REQUIRE_THROWS(handled,
diff --git a/src/physics/hydro/primconsflux.hpp b/src/physics/hydro/primconsflux.hpp
index 83a1e9f..73efd49 100644
--- a/src/physics/hydro/primconsflux.hpp
+++ b/src/physics/hydro/primconsflux.hpp
@@ -2,7 +2,6 @@
 #define PHYSICS_HYDRO_PRIMCONSFLUX_HPP_
 #include <Kokkos_Core.hpp>
 
-#include "Kokkos_Macros.hpp"
 #include "driver/kamayan_driver_types.hpp"
 #include "grid/geometry.hpp"
 #include "grid/grid_types.hpp"

From 3341a55a3df8062c2ef9911ff015a2ea420471b3 Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 11:22:43 -0700
Subject: [PATCH 53/55] codex comments

---
 src/grid/coordinates.hpp                 | 2 +-
 tests/test_suites/mhd_blast/mhd_blast.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/grid/coordinates.hpp b/src/grid/coordinates.hpp
index 5119036..ca6d582 100644
--- a/src/grid/coordinates.hpp
+++ b/src/grid/coordinates.hpp
@@ -160,7 +160,7 @@ std::vector<int> CoordinateShape(const int nx3, const int nx2, const int nx1,
       return {1, 1, N};
     } else if constexpr (shapes::Jcoord::template Contains<T>()) {
       auto N = nx2 + 2 * nghost;
-      N += (T::element == TE::F3 || T::element == TE::E2 || T::element == TE::E1) ? 1 : 0;
+      N += (T::element == TE::F2 || T::element == TE::E3 || T::element == TE::E1) ? 1 : 0;
       return {1, N, 1};
     } else if constexpr (shapes::Kcoord::template Contains<T>()) {
       auto N = nx3 + 2 * nghost;
diff --git a/tests/test_suites/mhd_blast/mhd_blast.py b/tests/test_suites/mhd_blast/mhd_blast.py
index 55a4868..0f2ca10 100644
--- a/tests/test_suites/mhd_blast/mhd_blast.py
+++ b/tests/test_suites/mhd_blast/mhd_blast.py
@@ -51,7 +51,7 @@ def ix1_bc(self):
     @property
     def nx1(self):
         """Zones across first dimension on base grid."""
-        return self.resolution / 2 if self._cyl else self.resolution
+        return int(self.resolution / 2) if self._cyl else self.resolution
 
     @property
     def name(self) -> str:

From e4358c4b3907fa0d9ab71dd5e5192e59341f8b6b Mon Sep 17 00:00:00 2001
From: Adam C Reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 13:04:31 -0700
Subject: [PATCH 54/55] Apply suggestion from @acreyes

Signed-off-by: Adam C Reyes <adam.c.reyes@gmail.com>
---
 tests/test_suites/mhd_blast/mhd_blast.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_suites/mhd_blast/mhd_blast.py b/tests/test_suites/mhd_blast/mhd_blast.py
index 0f2ca10..cf432e0 100644
--- a/tests/test_suites/mhd_blast/mhd_blast.py
+++ b/tests/test_suites/mhd_blast/mhd_blast.py
@@ -74,7 +74,7 @@ def name(self) -> str:
     BlastConfig(riemann="hll"),
     BlastConfig(riemann="hllc"),
     BlastConfig(
-        resolution=32, nxb=8, numlevel=3, max_error=5.0e-5
+        resolution=32, nxb=8, numlevel=3, max_error=1.0e-4
     ),  # I should really investigate more why this is so flakey
 ]
 

From a482c1aee6c244ebbde8f917f80921ff7feb7f0a Mon Sep 17 00:00:00 2001
From: adam reyes <adam.c.reyes@gmail.com>
Date: Wed, 22 Apr 2026 18:59:07 -0700
Subject: [PATCH 55/55] docs

---
 docs/grid.md                       | 85 ++++++++++++++++++++++++++++++
 src/problems/isentropic_vortex.cpp |  2 +
 2 files changed, 87 insertions(+)

diff --git a/docs/grid.md b/docs/grid.md
index 2bf7e6e..a4b0274 100644
--- a/docs/grid.md
+++ b/docs/grid.md
@@ -126,5 +126,90 @@ The alias `FirstDer` is pulled out of the `ScratchVariableList` can then be used
     `scratch_firstder` will be registered.
 
 
+## Coordinates
+
+Kamayan builds on Parthenon's mesh and coordinate layout (currently
+`parthenon::UniformCartesian`), but wraps it behind a small geometry layer so that
+code can be written against a consistent coordinate/metric API while the geometry
+is selected at runtime.
+
+At the moment the grid unit supports:
+
+- `Geometry::cartesian`: standard 1D/2D/3D Cartesian
+- `Geometry::cylindrical`: 2D axisymmetric r-z with an implicit azimuthal direction
+  (the third direction uses `dphi = 2*pi`)
+
+### `CoordinateSystem`
+
+The coordinate wrappers implement the `CoordinateSystem` concept
+(`src/grid/geometry.hpp`), which is the practical "contract" used throughout the code.
+It includes both compile-time and runtime axis dispatch:
+
+- Compile-time: `template <Axis ax> Dx()`, `Xc(idx)`, `Xf(idx)`, `FaceArea(k,j,i)`, ...
+- Runtime: `Dx(Axis)`, `Xc(Axis, idx)`, `Xf(Axis, idx)`, `FaceArea(Axis,k,j,i)`, ...
+
+The main coordinate wrapper is `grid::Coordinates<geom>` (`src/grid/geometry.hpp`). It is
+a thin layer over Parthenon's coordinates that provides geometry-specific fixes for
+metric factors:
+
+- `X`/`Xi`: coordinate at the Parthenon cell-center location
+- `Xc`: coordinate at the cell centroid (differs from `Xi` for cylindrical r)
+- `Xf`: coordinate at the face location
+
+- In Cartesian geometry, methods delegate to Parthenon.
+- In cylindrical geometry:
+  - `Dx<Axis::KAXIS>()` returns `2*pi` (implicit azimuthal direction)
+  - `Xc<Axis::IAXIS>(idx)` computes the radial *centroid* of the cell (not just the
+    midpoint); `Xi<Axis::IAXIS>(idx)` remains the "cell center" value from Parthenon
+  - `FaceArea`, `EdgeLength`, and `CellVolume` use r-z metric factors (e.g.
+    `V = 0.5 * dphi * (r_{i+1/2}^2 - r_{i-1/2}^2) * dz`)
+
+### CoordinatePacks
+
+Parthenon's coordinate methods are largely inline calculations. For geometry-dependent
+metric factors (areas, volumes, centroids, etc.) it is often cheaper and simpler to
+precompute them once per `MeshBlock` and store them as normal fields.
+
+The grid unit registers and fills these coordinate fields:
+
+- Field types live in `src/grid/coordinates.hpp` under `kamayan::grid::coords::*` and
+  the full list is `grid::CoordFields`.
+- The fields are allocated with geometry-aware *degenerate* shapes via
+  `grid::CoordinateShape`:
+  - Cartesian: `Dx*`, `FaceArea*`, `EdgeLength*`, `Volume` are scalars; `X*`, `Xc*`, `Xf*`
+    are 1D arrays per-axis.
+  - Cylindrical: `Dx*` are scalars; r-dependent quantities (`Volume`, `FaceArea*`,
+    `EdgeLength*`, and `X*`/`Xc*`/`Xf*` for r) are stored as 1D arrays in the radial direction.
+- `grid::CalculateCoordinates` (`src/grid/coordinates.cpp`) fills all `CoordFields` for each
+  block (using `grid::CoordinateIndexRanges` to respect degenerate/face extents), and is
+  called from the grid unit's `InitMeshBlockData` callback.
+
+`grid::CoordinatePack<geom, ...>` (`src/grid/coordinates.hpp`) wraps a `SparsePack` holding
+these `geom.*` fields and exposes the same API as `grid::Coordinates<geom>` but indexed by
+`(k,j,i)`. Internally it maps `(k,j,i)` onto the degenerate storage layout (scalar/1D), so
+call sites do not need to care about how each metric is stored.
+
+Example usage (runtime geometry):
+
+```cpp title="problems/isentropic_vortex.cpp:isen_coords_pack"
+--8<-- "problems/isentropic_vortex.cpp:isen_coords_pack"
+```
+
+### Generic Coordinates (Packs)
+
+When the geometry is only known at runtime, Kamayan provides variant-based wrappers:
+
+- `grid::GenericCoordinate` (`src/grid/geometry.hpp`) wraps `grid::Coordinates<geom>` in a
+  `variant` and forwards calls via `visit`.
+- `grid::GenericCoordinatePack` (`src/grid/coordinates.hpp`) does the same for
+  `grid::CoordinatePack<geom, ...>`.
+
+In practice `GenericCoordinatePack` is constructed from a coordinate-field pack (e.g.
+`grid::GetPack(grid::CoordFields(), ...)`) and then used like a normal coordinate object.
+
+These are convenient in code like problem generators, but they do add a small overhead
+compared to templating on `Geometry`. For performance-critical kernels prefer templating
+on `geom` and constructing the matching `grid::Coordinates<geom>`/`grid::CoordinatePack<geom>`.
+
 ## Parameters
 {!assets/generated/grid_parms.md!}
diff --git a/src/problems/isentropic_vortex.cpp b/src/problems/isentropic_vortex.cpp
index b53335b..ea818e0 100644
--- a/src/problems/isentropic_vortex.cpp
+++ b/src/problems/isentropic_vortex.cpp
@@ -127,9 +127,11 @@ void ProblemGenerator(MeshBlock *mb) {
   par_for(
       PARTHENON_AUTO_LABEL, kb.s, kb.e, jb.s, jb.e, ib.s, ib.e,
       KOKKOS_LAMBDA(const int k, const int j, const int i) {
+        // --8<-- [start:isen_coords_pack]
         auto cp = grid::GenericCoordinatePack(geometry, cpack, 0);
         const Real x1 = cp.template Xc<Axis::IAXIS>(k, j, i);
         const Real x2 = cp.template Xc<Axis::JAXIS>(k, j, i);
+        // --8<-- [end:isen_coords_pack]
         auto state = vortex_data.State(geometry, mhd, x1, x2);
 
         // --8<-- [start:index]