From b74c4742281f137d6f13ef1b5c806b9384388e55 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 2 May 2024 12:22:09 -0400
Subject: [PATCH 01/65] initial update

---
 pyro/_defaults                 |  1 +
 pyro/advection/simulation.py   | 13 ++++-
 pyro/compressible/interface.py |  4 +-
 pyro/mesh/patch.py             | 88 ++++++++++++++++++++++++++++++----
 pyro/simulation_null.py        | 23 +++++++--
 5 files changed, 113 insertions(+), 16 deletions(-)

diff --git a/pyro/_defaults b/pyro/_defaults
index f982131ac..ff2427904 100644
--- a/pyro/_defaults
+++ b/pyro/_defaults
@@ -25,6 +25,7 @@ store_images = 0           ; store vis images to files (1=yes, 0=no)
 
 [mesh]
 
+grid_type = Cartesian2d   ; Geometry of the Grid ('Cartesian2d' or 'SphericalPolar')
 xmin = 0.0                ; domain minimum x-coordinate
 xmax = 1.0                ; domain maximum x-coordinate
 ymin = 0.0                ; domain minimum y-coordinate
diff --git a/pyro/advection/simulation.py b/pyro/advection/simulation.py
index cb4e47796..429944f74 100644
--- a/pyro/advection/simulation.py
+++ b/pyro/advection/simulation.py
@@ -67,6 +67,7 @@ def evolve(self):
         dtdx = self.dt/self.cc_data.grid.dx
         dtdy = self.dt/self.cc_data.grid.dy
 
+
         flux_x, flux_y = flx.unsplit_fluxes(self.cc_data, self.rp, self.dt, "density", linear_interface)
 
         """
@@ -80,7 +81,17 @@ def evolve(self):
 
         dens = self.cc_data.get_var("density")
 
-        dens.v()[:, :] = dens.v() + dtdx*(flux_x.v() - flux_x.ip(1)) + \
+        Ax_l = self.cc_data.grid.area_x[self.cc_data.grid.ilo:grid.ihi+1]
+        Ax_r = self.cc_data.grid.area_x[grid.ilo+1:grid.ihi+2]
+        Ay_l = self.cc_data.grid.area_y[grid.ilo:grid.ihi+1]
+        Ay_r = self.cc_data.grid.area_y[grid.ilo+1:grid.ihi+2]
+
+        dens.v()[:, :] = dens.v() \
+            + dtV*(Ax_l*flux_x.v() - Ax_r*flux_x.ip(1)) + \
+                                    dtdy*(flux_y.v() - flux_y.jp(1))
+
+        dens.v()[:, :] = dens.v() \
+            + dtdx*(flux_x.v() - flux_x.ip(1)) + \
                                     dtdy*(flux_y.v() - flux_y.jp(1))
 
         if self.particles is not None:
diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index d96438d9f..6f4646863 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -201,8 +201,8 @@ def states(idir, ng, dx, dt,
 
             # construct the states
             for m in range(nvar):
-                sum_l = np.dot(betal, rvec[:, m])
-                sum_r = np.dot(betar, rvec[:, m])
+                sum_l = np.dot(betal, np.ascontiguousarray(rvec[:, m]))
+                sum_r = np.dot(betar, np.ascontiguousarray(rvec[:, m]))
 
                 if idir == 1:
                     q_l[i + 1, j, m] = q_l[i + 1, j, m] + sum_l
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index a430fbef7..87407cbf7 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -133,15 +133,22 @@ def __init__(self, nx, ny, ng=1,
         self.yr = (np.arange(self.qy) + 1.0 - ng)*self.dy + ymin
         self.y = 0.5*(self.yl + self.yr)
 
-        # 2-d versions of the zone coordinates (replace with meshgrid?)
-        x2d = np.repeat(self.x, self.qy)
-        x2d.shape = (self.qx, self.qy)
-        self.x2d = x2d
-
-        y2d = np.repeat(self.y, self.qx)
-        y2d.shape = (self.qy, self.qx)
-        y2d = np.transpose(y2d)
-        self.y2d = y2d
+        # 2-d versions of the zone coordinates
+        self.x2d, self.y2d = np.meshgrid(self.x, self.y, indexing='ij')
+        self.xl2d, self.yl2d = np.meshgrid(self.xl, self.yl, indexing='ij')
+        self.xr2d, self.yr2d = np.meshgrid(self.xr, self.yr, indexing='ij')
+
+        # x2d = np.repeat(self.x, self.qy)
+        # x2d.shape = (self.qx, self.qy)
+        # self.x2d = x2d
+
+        # y2d = np.repeat(self.y, self.qx)
+        # y2d.shape = (self.qy, self.qx)
+        # y2d = np.transpose(y2d)
+        # self.y2d = y2d
+        # print(self.x2d)
+        # print(self.x2dt)
+        # assert (self.x2dt == self.x2d).all() and (self.y2dt == self.y2d).all()
 
     def scratch_array(self, nvar=1):
         """
@@ -186,6 +193,69 @@ def __eq__(self, other):
         return result
 
 
+class Cartesian2d(Grid2d):
+    """
+    This class defines a 2D Cartesian Grid.
+
+    Define:
+    x = x
+    y = y
+    """
+
+    def __init__(self, nx, ny, ng=1,
+                 xmin=0.0, xmax=1.0, ymin=0.0, ymax=1.0):
+
+        super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
+
+        # This is length of the side that is perpendicular to x.
+        self.area_x = np.full((self.qx, self.qy), self.dy)
+
+        # This is length of the side that is perpendicular to y.
+        self.area_y = np.full((self.qx, self.qy), self.dx)
+
+        # Volume (Area) of the cell.
+        self.vol = np.full((self.qx, self.qy), self.dx * self.dy)
+
+class SphericalPolar(Grid2d):
+    """
+    This class defines a spherical polar grid.
+    This is technically a 2D geometry but assumes azimuthal symmetry.
+
+    Define:
+    r = x
+    theta = y
+    """
+
+    def __init__(self, nx, ny, ng=1,
+                 xmin=0.0, xmax=1.0, ymin=0.0, ymax=1.0):
+
+        # Make sure theta is within [0, PI]
+
+        assert ymin >= 0.0 and ymax <= np.pi
+        super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
+
+        # Returns an array of the face area that points in the r(x) direction.
+        # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
+        # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
+        self.area_x =  -2.0 * np.pi * self.xl2d**2 * \
+                       (np.cos(self.yr2d) - np.cos(self.yl2d))
+
+        # Returns an array of the face area that points in the theta(y) direction.
+        # dL_phi x dL_r = dr * r * sin(theta) * dphi
+        # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
+        self.area_y =  0.5 * np.pi * np.sin(self.yl2d) * \
+                       (self.xr2d**2 - self.xl2d**2)
+
+
+        # Returns an array of the volume of each cell.
+        # dV = dL_r * dL_theta * dL_phi
+        #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
+        # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
+        self.vol = -0.6666666666666667 * np.pi * \
+                   (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
+                   (self.xr2d**3 - self.xl2d**3)
+
+
 class CellCenterData2d:
     """
     A class to define cell-centered data that lives on a grid.  A
diff --git a/pyro/simulation_null.py b/pyro/simulation_null.py
index 43c96a220..7dce37e84 100644
--- a/pyro/simulation_null.py
+++ b/pyro/simulation_null.py
@@ -34,11 +34,26 @@ def grid_setup(rp, ng=1):
         ymax = rp.get_param("mesh.ymax")
     except KeyError:
         ymax = 1.0
-        msg.warning("mesh.ynax not set, defaulting to 1.0")
+        msg.warning("mesh.ymax not set, defaulting to 1.0")
+
+    try:
+        grid_type = rp.get_param("mesh.grid_type")
+    except KeyError:
+        grid_type = "Cartesian2d"
+        msg.warning("mesh.grid_type not set, defaulting to Cartesian2D")
+
+    if grid_type == "Cartesian2d":
+        create_grid = patch.Cartesian2d
+    elif grid_type == "SphericalPolar":
+        create_grid = patch.SphericalPolar
+    else:
+        raise ValueError("Unsupported grid type!")
+
+    my_grid = create_grid(nx, ny,
+                          xmin=xmin, xmax=xmax,
+                          ymin=ymin, ymax=ymax,
+                          ng=ng)
 
-    my_grid = patch.Grid2d(nx, ny,
-                           xmin=xmin, xmax=xmax,
-                           ymin=ymin, ymax=ymax, ng=ng)
     return my_grid
 
 

From b37fbe85cbb284aa8939fe8fb2731bc7a45a1740 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 2 May 2024 15:21:37 -0400
Subject: [PATCH 02/65] update

---
 pyro/advection/simulation.py | 30 ++++++------
 pyro/mesh/patch.py           | 93 +++++++++++++++++++++++++++++++-----
 2 files changed, 96 insertions(+), 27 deletions(-)

diff --git a/pyro/advection/simulation.py b/pyro/advection/simulation.py
index 429944f74..21970be50 100644
--- a/pyro/advection/simulation.py
+++ b/pyro/advection/simulation.py
@@ -52,8 +52,14 @@ def method_compute_timestep(self):
         v = self.rp.get_param("advection.v")
 
         # the timestep is min(dx/|u|, dy/|v|)
-        xtmp = self.cc_data.grid.dx/max(abs(u), self.SMALL)
-        ytmp = self.cc_data.grid.dy/max(abs(v), self.SMALL)
+        dx_min = np.min(self.cc_data.grid.V() / \
+                        self.cc_data.grid.A_x())
+
+        dy_min = np.min(self.cc_data.grid.V() / \
+                        self.cc_data.grid.A_y())
+
+        xtmp = dx_min/max(abs(u), self.SMALL)
+        ytmp = dy_min/max(abs(v), self.SMALL)
 
         self.dt = cfl*min(xtmp, ytmp)
 
@@ -64,9 +70,7 @@ def evolve(self):
         is part of the Simulation.
         """
 
-        dtdx = self.dt/self.cc_data.grid.dx
-        dtdy = self.dt/self.cc_data.grid.dy
-
+        myg = self.cc_data.grid
 
         flux_x, flux_y = flx.unsplit_fluxes(self.cc_data, self.rp, self.dt, "density", linear_interface)
 
@@ -81,18 +85,14 @@ def evolve(self):
 
         dens = self.cc_data.get_var("density")
 
-        Ax_l = self.cc_data.grid.area_x[self.cc_data.grid.ilo:grid.ihi+1]
-        Ax_r = self.cc_data.grid.area_x[grid.ilo+1:grid.ihi+2]
-        Ay_l = self.cc_data.grid.area_y[grid.ilo:grid.ihi+1]
-        Ay_r = self.cc_data.grid.area_y[grid.ilo+1:grid.ihi+2]
+        dens.v()[:, :] = dens.v() + self.dt / myg.V() * \
+                         (myg.A_x()*flux_x.v() - myg.A_x(1)*flux_x.ip(1) + \
+                          myg.A_y()*flux_y.v() - myg.A_y(1)*flux_y.jp(1))
 
-        dens.v()[:, :] = dens.v() \
-            + dtV*(Ax_l*flux_x.v() - Ax_r*flux_x.ip(1)) + \
-                                    dtdy*(flux_y.v() - flux_y.jp(1))
 
-        dens.v()[:, :] = dens.v() \
-            + dtdx*(flux_x.v() - flux_x.ip(1)) + \
-                                    dtdy*(flux_y.v() - flux_y.jp(1))
+        # dens.v()[:, :] = dens.v() \
+        #     + dtdx*(flux_x.v() - flux_x.ip(1)) + \
+        #                             dtdy*(flux_y.v() - flux_y.jp(1))
 
         if self.particles is not None:
             myg = self.cc_data.grid
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 87407cbf7..8ece4391b 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -138,18 +138,6 @@ def __init__(self, nx, ny, ng=1,
         self.xl2d, self.yl2d = np.meshgrid(self.xl, self.yl, indexing='ij')
         self.xr2d, self.yr2d = np.meshgrid(self.xr, self.yr, indexing='ij')
 
-        # x2d = np.repeat(self.x, self.qy)
-        # x2d.shape = (self.qx, self.qy)
-        # self.x2d = x2d
-
-        # y2d = np.repeat(self.y, self.qx)
-        # y2d.shape = (self.qy, self.qx)
-        # y2d = np.transpose(y2d)
-        # self.y2d = y2d
-        # print(self.x2d)
-        # print(self.x2dt)
-        # assert (self.x2dt == self.x2d).all() and (self.y2dt == self.y2d).all()
-
     def scratch_array(self, nvar=1):
         """
         return a standard numpy array dimensioned to have the size
@@ -209,12 +197,53 @@ def __init__(self, nx, ny, ng=1,
 
         # This is length of the side that is perpendicular to x.
         self.area_x = np.full((self.qx, self.qy), self.dy)
+        # self.area_x = self.dy
 
         # This is length of the side that is perpendicular to y.
         self.area_y = np.full((self.qx, self.qy), self.dx)
+        # self.area_y = self.dx
 
         # Volume (Area) of the cell.
         self.vol = np.full((self.qx, self.qy), self.dx * self.dy)
+        # self.vol = self.dx * self.dy
+
+    def A_x(self, i=0, buf=0):
+        """
+        Returns the area in the x(r)-direction
+
+        parameter:
+        ----------
+        i : shifts the array in the x-direction by index i
+        buf : increases the buffer size.
+        """
+        return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
+                           self.jlo+buf:self.jhi+1+buf]
+
+
+    def A_y(self, j=0, buf=0):
+        """
+        Returns the area in the y(theta)-direction
+        parameter:
+        ----------
+        j : shifts the array in the y-direction by index j
+        buf : increases the buffer size.
+        """
+        assert buf <= self.ng
+        return self.area_y[self.ilo+buf:self.ihi+1+buf,
+                           self.jlo+j+buf:self.jhi+1+j+buf]
+
+    def V(self, i=0, j=0, buf=0):
+        """
+        Returns the area
+        parameter:
+        -----------
+        i : shifts the array in the x-direction by index i
+        j : shifts the array in the y-direction by index j
+        buf : increases the buffer size
+        """
+        assert buf <= self.ng
+        return self.vol[self.ilo+i+buf:self.ihi+1+i+buf,
+                        self.jlo+j+buf:self.jhi+1+j+buf]
 
 class SphericalPolar(Grid2d):
     """
@@ -255,6 +284,46 @@ def __init__(self, nx, ny, ng=1,
                    (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
                    (self.xr2d**3 - self.xl2d**3)
 
+    def A_x(self, i=0, buf=0):
+        """
+        Returns the area in the x(r)-direction
+        parameter:
+        ----------
+        i : shifts the array in the x-direction by index i
+        buf : increases the buffer size.
+        """
+        assert buf <= self.ng
+        return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
+                           self.jlo+buf:self.jhi+1+buf]
+
+
+    def A_y(self, j=0, buf=0):
+        """
+        Returns the area in the y(theta)-direction
+        parameter:
+        ----------
+        j : shifts the array in the y-direction by index j
+        buf : increases the buffer size.
+        """
+        assert buf <= self.ng
+        return self.area_y[self.ilo+buf:self.ihi+1+buf,
+                           self.jlo+j+buf:self.jhi+1+j+buf]
+
+    def Vol(self, i=0, j=0, buf=0):
+        """
+        Returns the area
+        parameter:
+        -----------
+        i : shifts the array in the x-direction by index i
+        j : shifts the array in the y-direction by index j
+        buf : increases the buffer size
+        """
+        assert buf <= self.ng
+        return self.vol[self.ilo+i+buf:self.ihi+1+i+buf,
+                        self.jlo+j+buf:self.jhi+1+j+buf]
+
+
+
 
 class CellCenterData2d:
     """

From 62423e1227f07f8a95dbee596aeddfb750d6120f Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Mon, 20 May 2024 13:40:57 -0400
Subject: [PATCH 03/65] update

---
 pyro/advection/interface.py | 21 +++++++++++++++++----
 pyro/mesh/patch.py          |  2 +-
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/pyro/advection/interface.py b/pyro/advection/interface.py
index 7b6af135b..58ce835a8 100644
--- a/pyro/advection/interface.py
+++ b/pyro/advection/interface.py
@@ -19,15 +19,24 @@ def linear_interface(a, myg, rp, dt):
     ldelta_ax = reconstruction.limit(a, myg, 1, limiter)
     ldelta_ay = reconstruction.limit(a, myg, 2, limiter)
 
+    ldelta_Fx = reconstruction.limit(u*a, myg, 1, limiter)
+    ldelta_Fy = reconstruction.limit(v*a, myg, 2, limiter)
+
+    # x-direction
     a_x = myg.scratch_array()
 
     # upwind
     if u < 0:
         # a_x[i,j] = a[i,j] - 0.5*(1.0 + cx)*ldelta_a[i,j]
-        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cx)*ldelta_ax.v(buf=1)
+        # a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cx)*ldelta_ax.v(buf=1)
+        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dx*ldelta_ax.v(buf=1) \
+                                        - 0.5*dt*ldelta_Fx.v(buf=1)
+
     else:
         # a_x[i,j] = a[i-1,j] + 0.5*(1.0 - cx)*ldelta_a[i-1,j]
-        a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*(1.0 - cx)*ldelta_ax.ip(-1, buf=1)
+        # a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*(1.0 - cx)*ldelta_ax.ip(-1, buf=1)
+        a_x.v(buf=1)[:, :] = a.v(buf=1) + 0.5*myg.dy*ldelta_ax.ip(-1, buf=1)
+                                        - 0.5*dt*ldelta_Fx.ip(-1, buf=1)
 
     # y-direction
     a_y = myg.scratch_array()
@@ -35,9 +44,13 @@ def linear_interface(a, myg, rp, dt):
     # upwind
     if v < 0:
         # a_y[i,j] = a[i,j] - 0.5*(1.0 + cy)*ldelta_a[i,j]
-        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cy)*ldelta_ay.v(buf=1)
+        # a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cy)*ldelta_ay.v(buf=1)
+        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dy*ldelta_ay.v(buf=1) \
+                                        - 0.5*dt*ldelta_Fy.v(buf=1)
     else:
         # a_y[i,j] = a[i,j-1] + 0.5*(1.0 - cy)*ldelta_a[i,j-1]
-        a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*(1.0 - cy)*ldelta_ay.jp(-1, buf=1)
+        # a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*(1.0 - cy)*ldelta_ay.jp(-1, buf=1)
+        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dy*ldelta_ay.jp(-1, buf=1) \
+                                        - 0.5*dt*ldelta_Fy.jp(-1, buf=1)
 
     return u, v, a_x, a_y
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 8ece4391b..67ec3e79e 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -309,7 +309,7 @@ def A_y(self, j=0, buf=0):
         return self.area_y[self.ilo+buf:self.ihi+1+buf,
                            self.jlo+j+buf:self.jhi+1+j+buf]
 
-    def Vol(self, i=0, j=0, buf=0):
+    def V(self, i=0, j=0, buf=0):
         """
         Returns the area
         parameter:

From 829d164a991ee856aae19e833f48ebb1f148fac1 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 28 May 2024 23:36:54 -0400
Subject: [PATCH 04/65] make advection interface more readable

---
 pyro/advection/interface.py | 31 ++++++++++++-------------------
 pyro/mesh/patch.py          |  7 +++----
 2 files changed, 15 insertions(+), 23 deletions(-)

diff --git a/pyro/advection/interface.py b/pyro/advection/interface.py
index 58ce835a8..a3fba92fc 100644
--- a/pyro/advection/interface.py
+++ b/pyro/advection/interface.py
@@ -7,9 +7,6 @@ def linear_interface(a, myg, rp, dt):
     u = rp.get_param("advection.u")
     v = rp.get_param("advection.v")
 
-    cx = u*dt/myg.dx
-    cy = v*dt/myg.dy
-
     # --------------------------------------------------------------------------
     # monotonized central differences
     # --------------------------------------------------------------------------
@@ -27,30 +24,26 @@ def linear_interface(a, myg, rp, dt):
 
     # upwind
     if u < 0:
-        # a_x[i,j] = a[i,j] - 0.5*(1.0 + cx)*ldelta_a[i,j]
-        # a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cx)*ldelta_ax.v(buf=1)
-        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dx*ldelta_ax.v(buf=1) \
-                                        - 0.5*dt*ldelta_Fx.v(buf=1)
+        # a_x[i,j] = a[i,j] - 0.5*ldelta_ax[i,j] - 0.5*dt/dx*ldelta_Fx[i,j]
+        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*ldelta_ax.v(buf=1) \
+                                        - 0.5*dt/myg.dx*ldelta_Fx.v(buf=1)
 
     else:
-        # a_x[i,j] = a[i-1,j] + 0.5*(1.0 - cx)*ldelta_a[i-1,j]
-        # a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*(1.0 - cx)*ldelta_ax.ip(-1, buf=1)
-        a_x.v(buf=1)[:, :] = a.v(buf=1) + 0.5*myg.dy*ldelta_ax.ip(-1, buf=1)
-                                        - 0.5*dt*ldelta_Fx.ip(-1, buf=1)
+        # a_x[i,j] = a[i-1,j] + 0.5*ldelta_ax[i-1,j] - 0.5*dt/dx*ldelta_Fx[i-1,j]
+        a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*ldelta_ax.ip(-1, buf=1) \
+                                             - 0.5*dt/myg.dx*ldelta_Fx.ip(-1, buf=1)
 
     # y-direction
     a_y = myg.scratch_array()
 
     # upwind
     if v < 0:
-        # a_y[i,j] = a[i,j] - 0.5*(1.0 + cy)*ldelta_a[i,j]
-        # a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cy)*ldelta_ay.v(buf=1)
-        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dy*ldelta_ay.v(buf=1) \
-                                        - 0.5*dt*ldelta_Fy.v(buf=1)
+        # a_y[i,j] = a[i,j] - 0.5*ldelta_ay[i,j] - 0.5*dt/dy*ldelta_Fy[i,j]
+        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*ldelta_ay.v(buf=1) \
+                                        - 0.5*dt/myg.dy*ldelta_Fy.v(buf=1)
     else:
-        # a_y[i,j] = a[i,j-1] + 0.5*(1.0 - cy)*ldelta_a[i,j-1]
-        # a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*(1.0 - cy)*ldelta_ay.jp(-1, buf=1)
-        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*myg.dy*ldelta_ay.jp(-1, buf=1) \
-                                        - 0.5*dt*ldelta_Fy.jp(-1, buf=1)
+        # a_y[i,j] = a[i,j-1] + 0.5*ldelta_ay[i,j-1] - 0.5*dt/dy*ldelta_Fy[i,j-1]
+        a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*ldelta_ay.jp(-1, buf=1) \
+                                        - 0.5*dt/myg.dy*ldelta_Fy.jp(-1, buf=1)
 
     return u, v, a_x, a_y
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 67ec3e79e..72703f77b 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -234,7 +234,7 @@ def A_y(self, j=0, buf=0):
 
     def V(self, i=0, j=0, buf=0):
         """
-        Returns the area
+        Returns the volume
         parameter:
         -----------
         i : shifts the array in the x-direction by index i
@@ -245,6 +245,7 @@ def V(self, i=0, j=0, buf=0):
         return self.vol[self.ilo+i+buf:self.ihi+1+i+buf,
                         self.jlo+j+buf:self.jhi+1+j+buf]
 
+
 class SphericalPolar(Grid2d):
     """
     This class defines a spherical polar grid.
@@ -311,7 +312,7 @@ def A_y(self, j=0, buf=0):
 
     def V(self, i=0, j=0, buf=0):
         """
-        Returns the area
+        Returns the volume
         parameter:
         -----------
         i : shifts the array in the x-direction by index i
@@ -323,8 +324,6 @@ def V(self, i=0, j=0, buf=0):
                         self.jlo+j+buf:self.jhi+1+j+buf]
 
 
-
-
 class CellCenterData2d:
     """
     A class to define cell-centered data that lives on a grid.  A

From 4f2d04eb78c1dcc127779407c1e63bc7c3f28e7b Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Fri, 12 Jul 2024 12:34:57 -0400
Subject: [PATCH 05/65] revert advection files

---
 pyro/advection/interface.py  | 28 +++++++++++-----------------
 pyro/advection/simulation.py | 23 ++++++-----------------
 2 files changed, 17 insertions(+), 34 deletions(-)

diff --git a/pyro/advection/interface.py b/pyro/advection/interface.py
index a3fba92fc..7b6af135b 100644
--- a/pyro/advection/interface.py
+++ b/pyro/advection/interface.py
@@ -7,6 +7,9 @@ def linear_interface(a, myg, rp, dt):
     u = rp.get_param("advection.u")
     v = rp.get_param("advection.v")
 
+    cx = u*dt/myg.dx
+    cy = v*dt/myg.dy
+
     # --------------------------------------------------------------------------
     # monotonized central differences
     # --------------------------------------------------------------------------
@@ -16,34 +19,25 @@ def linear_interface(a, myg, rp, dt):
     ldelta_ax = reconstruction.limit(a, myg, 1, limiter)
     ldelta_ay = reconstruction.limit(a, myg, 2, limiter)
 
-    ldelta_Fx = reconstruction.limit(u*a, myg, 1, limiter)
-    ldelta_Fy = reconstruction.limit(v*a, myg, 2, limiter)
-
-    # x-direction
     a_x = myg.scratch_array()
 
     # upwind
     if u < 0:
-        # a_x[i,j] = a[i,j] - 0.5*ldelta_ax[i,j] - 0.5*dt/dx*ldelta_Fx[i,j]
-        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*ldelta_ax.v(buf=1) \
-                                        - 0.5*dt/myg.dx*ldelta_Fx.v(buf=1)
-
+        # a_x[i,j] = a[i,j] - 0.5*(1.0 + cx)*ldelta_a[i,j]
+        a_x.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cx)*ldelta_ax.v(buf=1)
     else:
-        # a_x[i,j] = a[i-1,j] + 0.5*ldelta_ax[i-1,j] - 0.5*dt/dx*ldelta_Fx[i-1,j]
-        a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*ldelta_ax.ip(-1, buf=1) \
-                                             - 0.5*dt/myg.dx*ldelta_Fx.ip(-1, buf=1)
+        # a_x[i,j] = a[i-1,j] + 0.5*(1.0 - cx)*ldelta_a[i-1,j]
+        a_x.v(buf=1)[:, :] = a.ip(-1, buf=1) + 0.5*(1.0 - cx)*ldelta_ax.ip(-1, buf=1)
 
     # y-direction
     a_y = myg.scratch_array()
 
     # upwind
     if v < 0:
-        # a_y[i,j] = a[i,j] - 0.5*ldelta_ay[i,j] - 0.5*dt/dy*ldelta_Fy[i,j]
-        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*ldelta_ay.v(buf=1) \
-                                        - 0.5*dt/myg.dy*ldelta_Fy.v(buf=1)
+        # a_y[i,j] = a[i,j] - 0.5*(1.0 + cy)*ldelta_a[i,j]
+        a_y.v(buf=1)[:, :] = a.v(buf=1) - 0.5*(1.0 + cy)*ldelta_ay.v(buf=1)
     else:
-        # a_y[i,j] = a[i,j-1] + 0.5*ldelta_ay[i,j-1] - 0.5*dt/dy*ldelta_Fy[i,j-1]
-        a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*ldelta_ay.jp(-1, buf=1) \
-                                        - 0.5*dt/myg.dy*ldelta_Fy.jp(-1, buf=1)
+        # a_y[i,j] = a[i,j-1] + 0.5*(1.0 - cy)*ldelta_a[i,j-1]
+        a_y.v(buf=1)[:, :] = a.jp(-1, buf=1) + 0.5*(1.0 - cy)*ldelta_ay.jp(-1, buf=1)
 
     return u, v, a_x, a_y
diff --git a/pyro/advection/simulation.py b/pyro/advection/simulation.py
index 21970be50..cb4e47796 100644
--- a/pyro/advection/simulation.py
+++ b/pyro/advection/simulation.py
@@ -52,14 +52,8 @@ def method_compute_timestep(self):
         v = self.rp.get_param("advection.v")
 
         # the timestep is min(dx/|u|, dy/|v|)
-        dx_min = np.min(self.cc_data.grid.V() / \
-                        self.cc_data.grid.A_x())
-
-        dy_min = np.min(self.cc_data.grid.V() / \
-                        self.cc_data.grid.A_y())
-
-        xtmp = dx_min/max(abs(u), self.SMALL)
-        ytmp = dy_min/max(abs(v), self.SMALL)
+        xtmp = self.cc_data.grid.dx/max(abs(u), self.SMALL)
+        ytmp = self.cc_data.grid.dy/max(abs(v), self.SMALL)
 
         self.dt = cfl*min(xtmp, ytmp)
 
@@ -70,7 +64,8 @@ def evolve(self):
         is part of the Simulation.
         """
 
-        myg = self.cc_data.grid
+        dtdx = self.dt/self.cc_data.grid.dx
+        dtdy = self.dt/self.cc_data.grid.dy
 
         flux_x, flux_y = flx.unsplit_fluxes(self.cc_data, self.rp, self.dt, "density", linear_interface)
 
@@ -85,14 +80,8 @@ def evolve(self):
 
         dens = self.cc_data.get_var("density")
 
-        dens.v()[:, :] = dens.v() + self.dt / myg.V() * \
-                         (myg.A_x()*flux_x.v() - myg.A_x(1)*flux_x.ip(1) + \
-                          myg.A_y()*flux_y.v() - myg.A_y(1)*flux_y.jp(1))
-
-
-        # dens.v()[:, :] = dens.v() \
-        #     + dtdx*(flux_x.v() - flux_x.ip(1)) + \
-        #                             dtdy*(flux_y.v() - flux_y.jp(1))
+        dens.v()[:, :] = dens.v() + dtdx*(flux_x.v() - flux_x.ip(1)) + \
+                                    dtdy*(flux_y.v() - flux_y.jp(1))
 
         if self.particles is not None:
             myg = self.cc_data.grid

From d501d70f1105eee50114ce5598d75231cb382fd9 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Fri, 12 Jul 2024 12:59:00 -0400
Subject: [PATCH 06/65] fix flake8

---
 pyro/mesh/patch.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index abab4bb47..41cf19f88 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -219,7 +219,6 @@ def A_x(self, i=0, buf=0):
         return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
                            self.jlo+buf:self.jhi+1+buf]
 
-
     def A_y(self, j=0, buf=0):
         """
         Returns the area in the y(theta)-direction
@@ -267,15 +266,14 @@ def __init__(self, nx, ny, ng=1,
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
         # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        self.area_x =  -2.0 * np.pi * self.xl2d**2 * \
-                       (np.cos(self.yr2d) - np.cos(self.yl2d))
+        self.area_x = -2.0 * np.pi * self.xl2d**2 * \
+                      (np.cos(self.yr2d) - np.cos(self.yl2d))
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
         # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        self.area_y =  0.5 * np.pi * np.sin(self.yl2d) * \
-                       (self.xr2d**2 - self.xl2d**2)
-
+        self.area_y = 0.5 * np.pi * np.sin(self.yl2d) * \
+                      (self.xr2d**2 - self.xl2d**2)
 
         # Returns an array of the volume of each cell.
         # dV = dL_r * dL_theta * dL_phi
@@ -297,7 +295,6 @@ def A_x(self, i=0, buf=0):
         return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
                            self.jlo+buf:self.jhi+1+buf]
 
-
     def A_y(self, j=0, buf=0):
         """
         Returns the area in the y(theta)-direction

From 11f26d6d61810270dac2d588e44266f0b0bec8f3 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Fri, 12 Jul 2024 13:04:38 -0400
Subject: [PATCH 07/65] update example

---
 examples/examples.ipynb | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/examples/examples.ipynb b/examples/examples.ipynb
index dfd1b529e..0494c0f85 100644
--- a/examples/examples.ipynb
+++ b/examples/examples.ipynb
@@ -99,6 +99,7 @@
       "io.do_io = 1\n",
       "io.dt_out = 0.2\n",
       "io.n_out = 10000\n",
+      "mesh.grid_type = Cartesian2d\n",
       "mesh.nx = 32\n",
       "mesh.ny = 32\n",
       "mesh.xlboundary = periodic\n",
@@ -140,7 +141,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -187,7 +188,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -227,7 +228,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAHLCAYAAAAeIEj+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKI0lEQVR4nO3deXxU5dnw8d99zmzZAwSysIR9E1kEUUAENywq1bZWa1u3R9ta26q1tpXa1+3pU7pYa62i1arUnbaKtdVWcGFREQUBERBQAiQhIWSdrLOd+/0jJBAzmcxkOTMp17ef+djM3Gfm4mRyznWuezlKa60RQgghhLCZEe8AhBBCCHF8kiRECCGEEHEhSYgQQggh4kKSECGEEELEhSQhQgghhIgLSUKEEEIIEReShAghhBAiLiQJEUIIIURcSBIihBBCiLiQJEQIIYToBXfeeSdKqbjGsGzZMpRS7Nu3r/W5Z599lvvuuy9uMR1LkhAhhBDiv9T555/P+vXryc3NbX0ukZIQR7wDEEIIIUTvGDhwIAMHDox3GB2SSogQQgjRTa+88gpTp07F7XYzYsQI7rnnnnZttNYsXbqUqVOnkpSURL9+/bj44ovZu3dvm3bz589n0qRJfPDBB8ydO5fk5GRGjhzJr371KyzLam1nWRa/+MUvGDduHElJSWRmZjJ58mT+8Ic/tLb5fHfM/PnzeeWVV9i/fz9KqdaH1poxY8Zw7rnntou7rq6OjIwMvve97/XQ3jpKkhAhhBCiG9544w0uvPBC0tLSeP755/ntb3/LX//6V5544ok27b7zne9w0003cfbZZ/PSSy+xdOlStm/fzuzZszl06FCbtqWlpXzjG9/gm9/8Ji+//DILFy5k8eLFPP30061tfvOb33DnnXdy2WWX8corr7B8+XKuueYaqqurO4x16dKlzJkzh5ycHNavX9/6UErxgx/8gFWrVrFnz5422zz55JN4vd5eSULQQgghhOiyU045Refl5enGxsbW57xer+7fv79uOc2uX79eA/p3v/tdm20LCwt1UlKS/slPftL63Lx58zSgN2zY0KbtxIkT9bnnntv68wUXXKCnTp0aMbYnnnhCA7qgoKD1ufPPP1/n5+e3a+v1enVaWpq+8cYb233uGWecEfFzukoqIUIIIUQX1dfX88EHH/DlL38Zj8fT+nxaWhqLFi1q/flf//oXSim++c1vEgwGWx85OTlMmTKF1atXt3nfnJwcZs6c2ea5yZMns3///tafZ86cydatW7n++ut57bXX8Hq93fq3pKWlcfXVV7Ns2TLq6+sBePPNN9mxYwff//73u/XeHZEkRAghhOiiqqoqLMsiJyen3WvHPnfo0CG01mRnZ+N0Ots83nvvPcrLy9tsO2DAgHbv53a7aWxsbP158eLF3HPPPbz33nssXLiQAQMGcNZZZ7Fx48Yu/3t+8IMfUFtbyzPPPAPAAw88wJAhQ7jwwgu7/J6RyOwYIYQQoov69euHUorS0tJ2rx37XFZWFkop1q1bh9vtbtc23HOdcTgc3Hzzzdx8881UV1fz+uuv87Of/Yxzzz2XwsJCkpOTY37P0aNHs3DhQh588EEWLlzIyy+/zF133YVpmjG/VzSkEiKEEEJ0UUpKCjNnzuTFF1+kqamp9fna2lr++c9/tv58wQUXoLWmuLiYGTNmtHuceOKJ3YojMzOTiy++mO9973tUVla2WZzs8z5fUfm8G2+8kY8++ogrr7wS0zT51re+1a3YIpFKiBBCCNEN//u//8sXvvAFzjnnHH70ox8RCoX49a9/TUpKCpWVlQDMmTOHb3/721x99dVs3LiR008/nZSUFEpKSnj77bc58cQT+e53vxvT5y5atIhJkyYxY8YMBg4cyP79+7nvvvvIz89nzJgxHW534okn8uKLL/LQQw8xffp0DMNgxowZra+fc845TJw4kbfeeotvfvObDBo0qGs7JgqShAghhBDdcM455/DSSy/x85//nEsvvZScnByuv/56Ghsbueuuu1rb/elPf+LUU0/lT3/6E0uXLsWyLPLy8pgzZ067QajROOOMM3jhhRf485//jNfrJScnh3POOYf/9//+H06ns8PtbrzxRrZv387PfvYzampq0FqjtW7T5pJLLuHOO+/stQGpLZT+/CcLIYQQ4rg2Y8YMlFJ88MEHvfo5UgkRQgghBF6vl48//ph//etfbNq0iRUrVvT6Z0oSIoQQQgg+/PBDzjjjDAYMGMAdd9zBRRdd1OufKd0xQgghhIgLmaLbRWvXrmXRokXk5eWhlOKll17qdJs1a9Ywffp0PB4PI0eO5OGHH+79QIUQQogEJUlIF9XX1zNlyhQeeOCBqNoXFBRw3nnnMXfuXDZv3szPfvYzbrjhBl544YVejlQIIYRITNId0wOUUqxYsSJi/9lPf/pTXn75ZXbu3Nn63HXXXcfWrVtZv369DVEKIYQQiUUGptpk/fr1LFiwoM1z5557Lo899hiBQCDsnG6fz4fP52v92bIsKisrGTBgAEqpXo9ZCCFEz9JaU1tbS15eHobRvjOiqakJv9/fI5/lcrna3FQvEUkSYpPS0lKys7PbPJednU0wGKS8vJzc3Nx22yxZsqTNQjdCCCH+OxQWFjJkyJA2zzU1NTEiP5XSslCPfEZOTg4FBQUJnYhIEmKjz1cvWnrCOqpqLF68mJtvvrn155qaGoYNG8ZpnIeDjlfD600jp+Tz+7X/2+HrwUCIt1/cwO+/bd+g27Enj+L2FTd3+HooEGLNX9/j8Z8+a1tM42eP5vqHr+w4pmCItc9vYMVv/m1bTOPmjOTiO8/r8HUrZPHu8g9Z88R7tsU04tTBzP32jA5ftyzN1pc+Ydu/dtsWU85J/Rlz/pAO/y611uxdWULxhsO2xZR+gpsBM1MixlT+bj21u3xhX+8NargPNTJApKKstd2NLrXvWFWZeZCa9DKIENPAw8NJbci0LaZP2UYRe9s9n5aW1u45v99PaVmI/ZuGk57WvSGb3lqL/On78Pv9koSI5oz083dZLCsrw+FwhL1lMzTfZCjcnRUdOHGo+CQhBz46yNZVO5hz0UwMs+0fSSgYIuAP8o/7XrM1vr0bD7DnvX1MPWsSZpiYfI1+Vj6yxtaYPnvvAAe3lzF6xghMR/uYmup9vPPMRltjKthQROU+L4PHZ4f53Vk01jax9Z+f2BpT8aZyGg/76TckvV1MVsiisbqJvWuKbY2p8uM6rHmKpP5uDLPt2cwKaXw1fsq3em2NqXGPxpjiwJFqoIzPXcxYmoA3RNNey97jwkEHRn49uDTqc+dLbQH1BqosiYhZSg/rX5dHQ3o1IRVsn4hocPuTyWjMsrU7e7geTymFBAk2B3FEpBjS0wzS03rnrrWJRmbH2GTWrFmsWrWqzXMrV65kxowZEdf4T0RLvnk/K59cjRWy0JYmFGwuHR4urOAnZ9/NgZ1Ftsf02yuW8s4LG7AsC8vSWCELgEP7DnP7+b+mdG+ZrfForfnjt55gy6qP0ZZGHxtTQTm/uXQplQerbY3JCmme+tGL7F5f0BzjMTEdLijnseuXU1dRb29MQYtX/28tBz8ua41JW80H6op91fzr7jX46nqmfzzqmAKazX/eTc3+unYxeYvq+fDPuwn5LFtj0gFN0cs1NJUFm38+5l4fjaVBiv9Zgw7aGhIEFNYHyVBrHImp+QFApYm1MQm0vWPXHCEneSXjcPmTmp/QtJ73kxszyD00BhWpTNILPCqZGcwnhdSot7HQWN3+X9+YcyKzY7qorq6OTz/9FIBp06Zx7733csYZZ9C/f3+GDRvG4sWLKS4u5sknnwSap+hOmjSJ73znO3zrW99i/fr1XHfddTz33HN85StfieozvV4vGRkZzOfCuFVCjjUgrz+nXnAS7mQ3BdsOsOXNj9vdBMluA4cO4KQFJ+J0Oyn46ADb394V13gAsob2Z9K8cThcDvZvK2LPBwXxDon+QzIZfcpwTFNRtL2Uwu0l8Q6JzLw08iYNQpmKQ7sqKN9bFe+QSMn20G9kc9m8el8ddSUd3/7cLq4BJkm5zX//jQcD+Ct7ZvxAt6SHUJkh0KArTaiP71W8RuNz19PkrkdpRVJjOq5gfLsktNbUUEElh9nLdmpqakhPT2/TpuUYX7Yrv0e6YwaN2x/2cxKJJCFdtHr1as4444x2z1955ZUsW7aMq666in379rF69erW19asWcMPf/hDtm/fTl5eHj/96U+57rrrov7MREtChBBCxCaoA6zmH5KEHCFjQrpo/vz5Ea/6ly1b1u65efPm8eGHH/ZiVEIIIfq65u6Y7tUH+kp3jCQhQgghRAJpHtPR/ffoC2RgqhBCCCHiQiohQgghRAIJaU2om8M1u7u9XSQJEUIIIRLI8TQmRLpjhBBCCBEXUgkRQgghEoiFJnScVEIkCRFCCCESiHTHCCGEEEL0MqmECCGEEAlEZscIIYQQIi6sI4/uvkdfIEmIEEIIkUBCPTAwtbvb20XGhAghhBAiLqQSIoQQQiSQkG5+dPc9+gJJQoQQQogEcjyNCZHuGCGEEELEhVRChBBCiARioQihuv0efYEkIUIIIUQCsXTzo7vv0RdId4wQQggh4kIqIUIIIUQCCfVAd0x3t7eLJCFCCCFEAjmekhDpjhFCCCFEXEglRAghhEggllZYupuzY7q5vV0kCRFCCCESyPHUHSNJiBBCCJFAQhiEujlaItRDsfQ2SUJElzldDiacOhZ3sov9O4ooO1Ae75Bwuh2MPXkULreTAzuLqThYFe+QcHmcjJw2DNPpoOiTEmrKvPEOCVeSkyETczBMg5I9h6mvaoh3SDiTHAwc1R9lKCoKqmiq9cc7JBwek7TBySgF3uIGgo3xP7QbboV7oAM0+A4HsfwJsCCE04J0CzRQY0Io/lfhQSOA39UAKDy+FAxtxjskfLqRairiHUZCkSREdMnFP1rEZbd+ifQBaQBoS/P+vz/k/u/9OS7JiFKKL//ofC76wRdIyUwGwLIsNv57K4/86CkqS6rtj8lQLLrhHM6+ei5JaZ7mmEIWH772Mc/euYLa8jrbYzJMg7O+NZtTLp6KK8kFQChosf3NXbzy+7do9DbZH5PD4OSvTWLC2SNxuJsPSVbQ4tN3DrD+L1sINAbjEJNi1BcGkzcjC9NptMZUsrmST18tIuS3/84cygFZs1JIH+dBmc0neSuk8e5souK9enQ88iOHRo1rQuUGUUcu3HUIdKETvccNcRiXEDKClPc/QF1KFS09EsoyyKgdSP+qwag4dFP4dROfsJkyiqNqr3tgTIjuI2NClNY6AdJoEQ2v10tGRgbzuRCHcsYtjmt//U0u/fGF7Z4PBkLUlHv53oyfUlFibwXi2t9+g4XfOhOl2v7hhYIhKkuq+fG8u/FW1Noa01W/voTZX5mBMtrHVFFUxf9ddD8N3kZbY7rk7vOZeMZYjHYxWVQUVvHIt5/F3xCwLyAFC26Zw9CpOe32kxWyqDxQwz/vXE3Ib98ZVhkw5arR9BuR1i4mbWm8hfV8+NgetJ23KTVg8KIMPIMcYWNqLAlw8BVvcyXCtpg0xskNkGa1JiCtMWmg3MTanAQ2nvQtFaIo9xMCzqb2H6shpSGT7MMjbU1EAtrP+7xBEw3oY35BNTU1pKent2nbcoxfuS2flLTudcfU11osOHF/2M9JJDJFV8Qkd2R22AQEwOE0ycxK52uLv2RrTMMmDOa8b5/VLgEBMB0m/XMzufCGc22Nafjkocz56sntThgtMWUN7c+ZV86xN6ZpQ5h01rh2CUhzTAZZ+f05+cLJtsY0ZEoOw07KDbufDNNgwPBMxs7LtzWmrAmZ9B+VHjYmZSgy8lPJntzP1pjSRrtJynF2GFPyYBcpI1y2xqTyApDePgEBUArUwBBk2Vue8aaVh09AABTUp1TT5LG3AlnIpzRS3yYBEUdJEiJisuCq+QQDHR9YTKfJF64+A8O076t15jdOIxQpJofJOVfOsy0egDlfPZlQsOOYDNPg9K+famNEMO38EyLGpIAZNich484YjhWK0LWhYfyZI+0LCMibMQAd4cYb2tLknZxlY0SQPt7TaUwZ4z02RgRqSOSKmbbAGGzvuB5v2uHIDTR4U+3tLi6mIOZtQtrokUdfIGNCREwGDcmis5qvJ8VDSnoytVX2XHEMGNI/7BXisVL7peB0Owj47Blf0D83E9MReSBc5kB7S6SZOekRY1KGIn1Qqo0RQdrAlIgJqzIUKVnJNkYEnn7uiN8nZSg8mfZWHRxpRqcxObpZvo+ZxyJM8bGVMkAn2Xv1HzQDkXt/FAQdPtviAfARe5erhcLqZo3A6iOVl76RKomEUV3upbM+3oAvQEOtfWMdvOW1WJ3cMrKp3mdbAgJQW1kXseoAUF9t74yU+sqGyFUHoKHa3oGpDVVNEWPSWtNUY29M/rpA5KqD1vjrbBw3A4QaLSIN39OWJtRo80nHr4g0olBrwGfv4EjT6uS6WoMZsnc8nRN7E9a+RpIQEZM3nl6Lw9nx1XQwEOKt597p9ATck9Y8/27EmEKBEKufe8e2eADee+nDiFWHUDDEO3//wMaIYOtrOyNWHayQxYevfGxjRPDpuv2Ru+407F6z376AgNIPKzodS1n6YaU9wRxRu6uTq3cF3l32Jmv6YOSTuVKgS+w94afVDYhcqFVH2tgoj+HEOji3ZbGy7j76AklCREz2frSf159Zi2W1v3oNBUP4m/w8u+RFW2PavXEvG/65KewVdSgYorGuiRV/+LetMX3y7qd8vGZXhzE11DSy6vF1tsa0e30B+7YUdRCTRV1VAxte2GJrTAUfFFP2aWXYmKyQRV1FA5+8udfWmA59VEVdaSNWmNkvVkjTWOGj5EN713rw7moiUBMKW6HRlsZfFaLuU3u7GXSRCxoVOkwhS1ugawz0IXt7/DO8A5srHeESEQ2ephSSGzNsjWkYY45UQ6JPCo6nMSF9I0qRUO65eikvP/gawUBz90ZLmbhodwk3z7ud4j0ltsf0u//5E68/uba1AtMSU+HOg9z2hSUcPmD/AkEPffcvvPfSh60n2NaYdhzk15c8aPuiZdrSPP3jFWx/c3fryawlpuKdpfz5uudpqLZ3yrAOaf6zZB37Nx1sjaXlv4d2V/DPO1fjr7e368MKajY/tofKPTVH4zwSU3VBLR8+utv2dUJ0EIpfrqGxONAmHoCGQj/F/6yxf52QoML6IBmqzSMxcfS/h02sTcm2rxNiWk4Gl47D7Us5Egyt/02pzyT30Bjb1wlxqyROZj5pZNr6uX2FrBPShyTKOiEtMrLSmXHuFNzJbvZ9fIAd63fHOyQyB6Uz9cxJOD1OCj46wKcfxj4yvcdjyk5n4mljMZ0m+z8u4sDH0S1Y1JvSB6UyakY+hmlQtLOEQ5/Gf7Xb1IHJ5J0wCGUoynZXUFUU/5Vlk/q7yRyRCgpq9tXRUG5vtSEcZ6ZJUo4DraGpJEDAa//Cae2khFCZIdAKXWVCY/yvb33OBnzuekCR1JiOMxT/sRleXUUV5exha8R1Ql7YOpaUtO6t8FpfG+IrU3Yn/DohkoT0IYmWhAghhIhNUAdYzT8iJiF/2zqe5G4mIQ21Ib465ZOET0Jkiq4QQgiRQHpiTEeoj9QX4l8zE0IIIcRxSSohQgghRAKxMI6bxcokCRFCCCESSEgrQt2cWdTd7e0i3TFCCCGEiAuphAghhBAJJIRBqJs1gpB0xwghhBAiVpY2sLo5O8aS2TFCCCGEEB2TSogQQgiRQKQ7RgghhBBxYdH92S0JsJh/VKQ7RgghhBBxIZUQIYQQIoH0zGJlfaPGIEmIEEIIkUB65t4xkoQIIYQQIkYWCovujgnpGyumShIihIid6sUDnOobV3Dt6F4cCthH1nwQIlaShAghhBAJRLpjhBBCCBEXPbNOSN9IQvpGlEIIIYT4ryNJiBBCCJFALK165BGLtWvXsmjRIvLy8lBK8dJLL3W6zTPPPMOUKVNITk4mNzeXq6++moqKipg+V5IQIYQQIoFYR7pjuvOIdZ2Q+vp6pkyZwgMPPBBV+7fffpsrrriCa665hu3bt/O3v/2NDz74gGuvvTamz5UxIUIIIcRxbuHChSxcuDDq9u+99x7Dhw/nhhtuAGDEiBF85zvf4Te/+U1MnyuVECGEECKBWNrokQeA1+tt8/D5fD0S4+zZsykqKuLVV19Fa82hQ4f4+9//zvnnnx/T+0gSIoQQQiSQEKpHHgBDhw4lIyOj9bFkyZIeiXH27Nk888wzXHrppbhcLnJycsjMzOSPf/xjTO8jSYgQQgjxX6qwsJCamprWx+LFi3vkfXfs2MENN9zA7bffzqZNm/jPf/5DQUEB1113XUzvI2NChBBCiARybHdKd94DID09nfT09J4Iq40lS5YwZ84cfvzjHwMwefJkUlJSmDt3Lr/4xS/Izc2N6n0kCRFd5k5yMXneRNzJbvZ9XEjR7oPxDglPipuJs8fi9DjZv72I0r1l8Q4JT6qbsTNHYjpNCrcXU15UZc8HR1ha3ZPmJn/yYAxTcXBXGTVl9bG9tRHD9D/TjKqZO8VJ9pj+GKbB4b3VNFQ3xRRTb3AkGWQMSQYF3uJG/HXBjhtbsS2trkOhGFofXRLeTFJ4BjUfupsOBQk1hflcu5d5d1uQEQKtoNqEQPzvWxIw/fjc9Sit8PhSMa34n+4adT3VlHfaLgSt3SldFcu3qysaGhpwONruU/PI37qO4fsX/9+K6HOUUnzj51/hqz/6IsnpSa3Pb129nd9/+2GKPy21PSbDNPjazy7igu+egyfFfTSmt7az9IZlHD4Q29z1nmA6DL50y0LOuGIOLo8TAG1pPl67iycX/43qQ177Y3KanHv9XGZceCIOl6M1pk/e2cvLv32T+qoG+2NymZxy2UTGzh2G6Wi+erMszf5NJbz7l2346gP2x+RUjD43h+zJmRhm88lAW5pD22vY82oJQV8v3iemA4ZTkXVaCmmjXK1JoLY0tXt8HH63Hm3/bgKnRk1oQmUHW3NebYEudqB3ecCyPxkJGgEOD9hPQ3INredxrUivzSKrcggqDqMQmnQjO9lEBdEdG3uyEhKturo6Pv3009afCwoK2LJlC/3792fYsGEsXryY4uJinnzySQAWLVrEt771LR566CHOPfdcSkpKuOmmm5g5cyZ5eXlRf66MCemGpUuXMmLECDweD9OnT2fdunUR2/fEwi6J4Po/XM0Vd17SJgEBmHTaeP7w7v8xcGiW7TF99w9X8pWbz2+TgLTE9KtVt9EvO8P2mP7n3ss459rTWxMQaK4gTDxtDLf+/fuk9ku2PaZL//d8Zn5lSmsC0hLT2FkjuHbpV/GkumyNRyk458aTGTcvvzUBATAMRf5JOZy3eDYOd3SVlB6LyYDJXx9GzpSjCUjz84rsEzKYevnwNs/bEpMJeRekt0lAWmJKG+Mmb2G6/UdzU2PMaEANCrYpuikD1JAgxrRGwN6KTEiFOJi7q20CAqA03rTDlA76DG1zTH7tYyNvUckhWz83Vhs3bmTatGlMmzYNgJtvvplp06Zx++23A1BSUsKBAwda21911VXce++9PPDAA0yaNImvfvWrjBs3jhdffDGmz5UkpIuWL1/OTTfdxG233cbmzZuZO3cuCxcubPNLOlZPLewSb0PG5nHR9xeiwpT6TYdJSkYKly3+kq0xDT9xKGddPjdsF4HpNEnPSuPCH3zB1phGnZTPzAumYhjt/8RMh0lmdgZnXTXX1phGzhjG+NNGdRCTQb+8dE6+cLKtMQ2dks3gEwZihPndGaZBZm4qY+cOtTWmgRPSyRiWEvb7pAxFaq6H7Mn2JrWpo924s8wOY0rKcZI6wuYEMi8AqVbYmx4rBWpACAZG6L7qBd60wwQcPsL2ZChoSPbS6Km1NaZCPqWJxpiSn5Yb2HX3EYv58+ejtW73WLZsGQDLli1j9erVbbb5wQ9+wPbt22loaODgwYM8/fTTDB48OKbPlSSki+69916uueYarr32WiZMmMB9993H0KFDeeihh8K2P3ZhlxEjRnDaaafxne98h40bN9ocefcsuHIewUDHvY0Op8mCK+ZhmPZ9tc78+mkRYzIdJmddYe8Jf/ZXZhAKRorJYO6lM22MCKYtnEgo2HE3glKK6Ysm2RgRjJk7FCsUuWtj7OnDbIqmWc7UTHSk8R0acqf1sy8gIH28O2JRQVu6uY2N1JDI/T/aAmOwvX1E3rROxltoqE3tfExGTyqmgFgrQhqF1c2H7uaYErtIEtIFfr+fTZs2sWDBgjbPL1iwgHfffTfsNl1Z2MXn87VbaCbeBuT277SNO9lNSrp9XQ39cjPDXkkfKyUjGafbviFQmdkZmI7I3QhpWak2RdMsY1Bamy6Pz1NKkZaVYmNEkDogKWLCqgxFSj+PjRGBJ90ZceCtMhSedGeHr/cGR4rRaUyOVHu7rXBbkcY+N1dIPDZ3x5iB8FWQFgqCDr9t8QD4if8A60QmSUgXlJeXEwqFyM7ObvN8dnY2paXhBx51ZWGXJUuWtFlkZuhQe8vS4VQequ60jb/JT0NtY+8Hc0T1oRqsTmYmNNY1EfDZVxquOeyNWAkBqLN5EKi3vC5iJURrTV2lvTHVVzVFrIRorWmo6ZkVHqPlqw1ErIRorfHV2tvNEKq3Is440JYmWG/zYFmfEXESjrYAn71X42bIEbnooMEM2dtt5SL2ClU8umPipW9EmaA+Py5Cax12rAR0bWGXxYsXt1lkprCwsEfj74rXn1qDw9nxFVcwEOL1p9d2egLuSauffzdiTKFgiDeeijxouKetf3FTxEpIKBji7b++b2NEsOU/OyJWQrSl+fBfH9sYEex5uzBy152G3WvDj7PqLaVbazqdglyyxaZp1kd4d0dOxJShqN1l7xW3Lo5cDVIGWAftrRil13UyKF5BWt0Ae4I5Io/hRC7PtBePu+jGiyQhXZCVlYVpmu2qHmVlZe2qIy2OXdhl8uTJnHvuuSxdupTHH3+ckpKSsNu43e7WhWZ6a8GZWO3fUcSrf34jbOUhFAzRVNfEc79cYWtMn23ex7q/vYdltb8SDAVD1FU38I/7/2NrTHs+KGDzyo/DXuWHgiFqK+p4/Ql7E6PP3t/Ppxv2dRCThfdwHe+v+MjWmA5sPkTprgqsUPvvkxWy8JbVs3utvcl32fYavAcbw1ZDrJCm/rCP0q3VtsZUu9uHvzIUNiZtaZoOB6n9zN5uBl3shAbVXPH4/GsadJUBZfauApFeOxBH0BW+GqIhqTGN5EZ7j6PDGIMLN6qPjNGwmyQhXeByuZg+fTqrVq1q8/yqVauYPXt22G0aGhrazUroysIuieAP332Ev/72H/ga2x70Pt2yj5vm/pzSffYvEHb/dY/xykOvE/C1HQi3Z1MBPzvn/6g4aO+VK8AjNzzNmmffIxhoW7r/dNM+fnXxg9SW19kaj9bw3M/+yeZ/72jXLbNvSxF/vv5vNNba2/WhLc1r927gs/eK2iVHxdvLeWXJuwSa7O360BZsfXo/h3d62/xtaq2p2FPL5r/swwra+zerQ1D8Ly/1+/3tYqor8HPwFe+x65nZI6SwPkiGCrNNt4zWoEscWB8mNy9eZiPTcjC4dBxJTWltX9DNFZCcstG2JwMu5eFkziCD6CswIYweefQFSve1M2CCWL58OZdffjkPP/wws2bN4pFHHuHRRx9l+/bt5Ofnt1vYZdmyZXzrW9/i/vvvb7Owi2EYbNiwIarP9Hq9ZGRkMJ8LcSh7y5zhJKcnc9JZk1pXTP1s6754h0RqvxROPH08TreTfR8XcmBHcbxDIrVfMuNnjcZ0OjiwvYiST21K0iKMGkzpl8yIaUMwTIPiT0qpKIpt0HNvrJialOEmd/wAlGFw+LMqag/bv3Da57lSTTKGJYNSeAsbaKqJMNujN1dMPabc4Eg18GQfWTG1NBh+LIjdh/UkC5XR/O/RVSb44n8C9Duajq6Y2pSGw4r/MbNee6minE/4kJqamnbV7ZZj/A1vX4g7tXvx+uoC3H/aP8J+TiKRFVO76NJLL6WiooK7776bkpISJk2axKuvvkp+fj4QfmGX2tpaHnjgAX70ox+RmZnJmWeeya9//et4/RO6rcHbwNsr7B3X0Jm6qnrW/2NTvMNoo66qgY2v2tvN0Zn6qgY+fnP30SfCLfZgs8YaH3s3HOxwXFU8+GqDlG2P/6y0YwXrLOrq7O166VSjgW6M/3foWK6gB1fQ3plVnUlR6bh1Ep/wYbxDSRhSCelDEq0SImwW48lZRVmBAFCOGK9HnNF//2J+71jbx1KVibFagRVDtSIQW7eR9kefSOhO1lJp375rVZbo2sspozuCOsBqwlcoWo7x33/7Sz1SCXngtBVSCRFCCCFE9EJaEermeJrubm8XSUKEEEKIBNITU2xliq4QQgghRARSCRFCCCESiNYGVjdXPNV9ZMVUSUKEEEKIBBJCEermeibd3d4ufSNVEkIIIcR/HamECCGEEAnE0t0fWBrrbPR4kSRECCGESCBWD4wJ6e72dukbUQohhBDiv45UQoQQQogEYqGwujmwtLvb20WSECGEECKByIqpQgh7xHA/mFjuBQOgXK7o27rdsb13clLUbXVSbO+NK7Z7Zmgj+l5lFet9T/wR7pr7+fduivGmco2NMbRtiu29YwhFx3Cbma5tIETHJAkRQgghEsjxNDBVkhAhhBAigVj0wL1jZEyIEEIIIWKle2Bgqu4jSUjfqNcIIYQQ4r+OVEKEEEKIBGLpHuiOkdkxQgghhIjV8TQwtW9EKYQQQoj/OlIJEUIIIRKIdMcIIYQQIi6Op2XbpTtGCCGEEHEhlRAhelIMy7BDbEuxx7IMO8S2tLpKS43pva2MlKjbBjI9Mb13IDW2w5KOpXmMq7Y766JfotxZ44vpvY3q6Jenj3XJfurqo28b42rzWluxbhBbeyHdMUIIIYSID0lChIhCcnoyJ519Ip5kNwXbDvDZ1n3xDonUfimcOG8CTpeDfR8XcmBHcbxDIrVfMuNnjcZ0mhzYXkzJp2XxDomUDA/DT8zBMBXFeyqoqo3x6rYXJCeb5OZ6sJJMSsv9eOuC8Q4Jt1vTL7P5/1fXQFNT/A/sjiSNewCgoakSQo3xj4kkC5URAg262gRf/Hv6/Y4mfO56lFZ4mtJwWLHdGLE31GsvVZTHO4yEIkmIiJlhGlz9i8v48g3n4Uo62kWwa+Nn/PaqB9i/o8j2mEyHyRV3f5UvXHsGTvfRg80nGz7lj9f9mZK99p/4HS6TS3/+RU675GQczqN/ars27OWJHy+norgqLjEt/PYpTDlzFKZ59ESx9+ND/OORTdRWxnBn1x7idCpOOy2L0aNTMYyjJ9R9xY28+V4FDU32J0gOU3PicIvc/kd72LSGsnLNjk8gELD/xG84NVnTNMm5bWOqP6ip2KKw4hATLgtjYiNq4NFuK61BlzrQO5MgZH9MQdNPWdY+GpNqjz6pIa1uAFmVwzDisH5Go65nOx9QHWUCcjxVQuKfroo+58aHvs0lP76wTQICMHrqcO5b9wtyRgyyPaYbHr6G8797dpsEBGDM9BH8ctVtDMjrZ3tM3/7DNzj9a6e0SUAARk/P59a/XU/agNjGYXSbgq/97Aymfi4BAcifMJCrb5+HJ8Xeq0WlYOHCnHYJCMCwXA9fOicbp8Peg6lSmlPGhcjpr9sM8VEKBg6AGdPAMOwd56BMTe5pmuQc2sWUkgs5szXYHBOmxpjRAAPajptRClROEOOkBlD2xhQyghTn7KLRU9v2BQW1qRWUDvoUHevAoG7y6yY+4C1qqIh6m5YkpLuPvkCSEBGT/IlDOO/as9qdMKC5GuFJ9XDZ4i/ZGtOoacOZ+9VTMYz2X2fTYZKamcyFN3zB1pjGnDyCaQsmYZjhY0obkMrZV59ma0yjpuYxatrg8DGZBun9kzn57FG2xjR8eDK5uUlhv0+GochMc3DCaHuTtbz+msxUCBMShgGpKZCXY2tIpA4FZzqoMEdsZYC7H6QOtjcmNdgPyVb4mBSozBAMtLdLzZt2mKDDT9jZqQoak2ppSPLaGtMB9uDHF1Pyozk6Tberj74yHFiSEBGTsy+fRzDQ8YwBh9Pk7G+ejumIcTR/N8z/2uyIMZkOk7Mun2tbPACzvjSdUDByTKddMtPGiGDKGaMIhTru2lAKps0fbl9AwNixaVhW5MPlxFHRz8TpCUMGWnQSEoPz7ImlReqwyAFpq/M2PU3lBSK+ri0w8mKcetNN3tROujt0c0XETgfZR8zTso4jMiZExKR/dmanbVweF8lpSdRW1fV+QEBmdkbYK+ljJaV6cLodBHz2XJllDEzrNBFL7ZdsSywt0gYkt+uGOZZSipSM2KbTdldKiiPi704pRXKSfQktgMcZvgrSQilwxzZbutscnsizv5UBjuhnZPcMt+40Ju22uTvGDIavgrRQEDLtTYz8xDZ1G2RMiBAdqiip7LSNr8FHvbfBhmiaVZVUd3o1XV/TYFsCAlBd5o1YCQGoLbcnSWvhLa8nFOy4EqK1pq7K3oGpdXXBiL87rTV1DdGv1dETGv2Rl7bQGppiP690S7Cpk5gsCNo9ptinOo2JJntPMWbIGbnooMERtDeDdBF7Yi9jQoTowMq/rMHh7PjKNBgIsfLJNVgRyv497c1n344YUygY4o0n19kWD8C7L2yMWAkJBS3W/fV9GyOCLW9+huno+E9ea/hwdYGNEcGuXbWdVrF2fGZvslZ02Oh0zbnig/bE0qJ2f+SAlNF5m56miyOfzJUB1kF7Bzqn12ZFbqAgra6TNj1sMCOIXJ45vkkSImJStPsgLz3wb3SYS6BQMERddT3PLVlha0z7thXyxlPr0GGuqEPBEN7yWv7xx//YGtNnH+7n/X9twbLaJ2OhYIjqQzW8sextW2Mq2FrCrvcLw1YeQiGLqrJ6Nr5hbxJy4EADRUUNYWOyLE1lTYCdn8Ww+mcPKKlSVNaGrzxoDbW1UHLI1pCoLwR/9ZHqwudjsqCpAuptXhJHFzuhzggfkwZdYcJhe3v802sH4gy6w1dDNCQ3pJPUlGZrTEMZjYckVAyJiFRChIhg6Y1P8OSdf6XB27b++/Hbn3DTnNs4XGj/YjwP3bCMv//uXzTVN7V5ftvaT7j1nP+j6lCN7TE9/qPnWfXYOvyNR/ugtaXZvm43v/rqg9RV2ddl1eJvv17NB6/sJOg/Zl0HS7NncwnL7l6NryHyYMOepjX85z+H2LmzllDo6JnD0pq9hQ2sWFVGIGjvuAKtFe/vMikqVxybQ2rdnHxs3AKWZXPVwVKUvKOoK2qbiGgL6gqh9F0Fdp90LIW1KRld5miTsGmrOUGxtiRjdwXA1CZ5JeNIbshom4hoRXrtQHLKRsWUDPQEl3JzMmcwgOyotzmekhClw13SioTk9XrJyMhgPhfiUPFf/c+d5OLE0yfiSXaxb3sRRbttrlGH4UlxM3H2WJweJ/u3F1Fq9yJlRvsuGE+qm7Enj8B0mhTuOEh50dFFypQz+itFIzm2gawqo+MrPneyk/xxWShTUVJQRZURWz95Y070oyDrs6MbWOpxGAzJdBFMVRxs8FMbiK5LL5aFMFWMvYRpXosBLguloMJn0BQh+Ug+HNubJ5c0dd7oCEfZ0WmlpsvCnd6cRDbVmFiBMNeS1dFPQ9Wx3GcGsPxhElW3BenB5kSoxoRjY4rlXjM9eDoKmn6aWlZM9aViWvGfh9Go66mmnO18QE1NDenp6W1ebznGn/by93CkuLv1WcF6H29/8cGwn5NI4v9bEX2Wr9HPxte2xDuMNprqfXy4alu8w2ijqc7HR299Eu8w2vA1BNi9ueToEwNtnu4RRlPQ4tPyJnxxWGWzIz5LcbDJ3tk5nQn5DRrKE6yI7TPgcPy/Q8dyhFykNiRWTEkqBafuPCatFbqblYzubm8XSUKEEEKIBNKy4Fh336MvSLB0WgghhBDHC6mECCGEEAnkeFqsTJIQIYQQIoHImBAhhBBCxMXxVAmRMSFCCCGEiAuphAghhBAJRLpjhBBCCBEXuge6Y/pKEiLdMUIIIYSIC6mECBFJZ7dT/XzzTu4I2669I/o/QeWJbRlnKyMl6raN2dEvww7gzY8+7tr82Jbi1rmx3ZPe5Q5G3TYUjO26q/FQ9PslmBLryqrR3+I99Zh7/UTD9MVwD6Bwy7BHoGK8Q7YO2ndH7f8Wmu6vYN9X7sciSYgQQgiRQCxUt2+0JyumCiGEEEJEIJUQIYQQIoHI7BghhBBCxIWlFUoWKxNCCCGE6D1SCRFCCCESiNY9MDumj0yPkSRECCGESCAyJkQIIYQQcXE8JSEyJkQIIYQQcSGVECGEECKByOwYIYQQQsRFy8DU7j5isXbtWhYtWkReXh5KKV566aVOt/H5fNx2223k5+fjdrsZNWoUjz/+eEyfK5UQIXqSii2vV84Y/gRjvHdMMC369o1Zsd33pG5I9Ee4lDHVMb33vCGfxtR+sDv6968NRX+/FoA3MsdG3baMgTG9t6M++u+Kuzq2371R44q+cUOMpwFfjFfYsfxN6NjukSN6Tn19PVOmTOHqq6/mK1/5SlTbXHLJJRw6dIjHHnuM0aNHU1ZWRjAY/b2cQJIQIYQQIqE0VzK6OzA1tvYLFy5k4cKFUbf/z3/+w5o1a9i7dy/9+/cHYPjw4bF9KNIdI4QQQiSUltkx3X0AeL3eNg+fz9cjMb788svMmDGD3/zmNwwePJixY8dyyy230NgY212wpRIihBBC/JcaOnRom5/vuOMO7rzzzm6/7969e3n77bfxeDysWLGC8vJyrr/+eiorK2MaFyJJiOiyjKx0Tv7CVNzJLgq2HWDH+t3xDonMQelMPWsSTreTfdsK2bNpb7xDInNQOhPmjMLhdLB/ezEHth+Md0hkZLoZNbo/hqEoKvRSQ/z74jMtJ/lWCjk1+Xg9lTS4a+MdEilNBll1zeNlKlJD1HmsOEcELmeApKQm0NDQ5CEQcMY7JEgOQvqRsQDVTmiKbYxRb/A5G/C56wFFUmM6zlAM42R6iVdXUUV5p+30kUd3tGxfWFhIenp66/Nud2zjizpiWRZKKZ555hkyMjIAuPfee7n44ot58MEHSUpKiup9JAkRMXM4HXznniu44LpzcDgdaK1RSrF/RxFLvvkHPtuyz/6YXA6u/e3XOeubczEdZmtM+7YV8vtr/0ThJ/af+F0eJ9+484uc8sWpGKZxTExF/PmWv1K2r8L+mFwmF31lPJMmD8IwVGtMew/V8uRbe6io7ZlSbSzc2mCRfzDjrDQUCl2Wh0JR4ynnk5xN+J1NtseE3yRpy0jOOZwGgEajUJSlBdg0vBGf0/41sU0zRG52OanJTWgN6siQgbp6DyWHsghZcTjxu0KoCbWozGBrTFoD5S707lQI2t/jH3D4OJRVgM9T33wmVoCGlPpMBlUMx9D276cGXcs23qeWqqja9+RiZenp6W2SkJ6Sm5vL4MGDWxMQgAkTJqC1pqioiDFjxkT1PjImpBuWLl3KiBEj8Hg8TJ8+nXXr1kVs3xPTmRLBjx7/Ll/83rk4jszsUEeOhkPG5nLvmrsZPCY3DjF9h7MvPx3TYbaJaeiEPP7vtcUMHDbA9piue+DrrQlI25hy+elz3yFzUM8fGCJRCq64ekprAnJsTPkDU/jhokmkeuy9LjE0fMOXz9gjCQjQ+t+0pv5MKZqLI2TzlX5IkfzeeMzyowfXlpiyah3M3Z2Cw+bCkVIWwwaXkpLUdOTno6+lJDcxbPAhlLK5SmNaqKk1rRWQlpiUArL8qMk1oOxN1kJGgOKcXUcqIEDLflJQn1JNSfYedLdrDLHx6UY+YDW1VNv6ub1tzpw5HDx4kLq6utbndu/ejWEYDBkyJOr3kSSki5YvX85NN93EbbfdxubNm5k7dy4LFy7kwIEDHW5zySWX8MYbb/DYY4+xa9cunnvuOcaPH29j1N03cnI+Z3/jdAyj/VfHdJi4PC6+vvjLtsY0dsZITlk0vfVk//mYklI8fOnG6Ed994Txp45k0tyxHcaUnO7hrKtm2xrT2PEDGD4yszUBaROTYZCW5OT0iTm2xjQ+lE6eTsagfUwGBu5gEjk1+bbG5Dg4AKM2KexiUQaKFJ/BsAp7S/sZ6XW4nME2yUcLpcDlCpCe2mBrTOQ1gccKOwNXKVBpIcjy2xpSTfphQmaAMF8nUNDkqachqcbWmA6whwB+Yupg0T30iEFdXR1btmxhy5YtABQUFLBly5bWc9rixYu54oorWtt//etfZ8CAAVx99dXs2LGDtWvX8uMf/5j/+Z//iborBiQJ6bJ7772Xa665hmuvvZYJEyZw3333MXToUB566KGw7VumM7366qucffbZDB8+nJkzZzJ7dscnIp/P125kc7yd9c3TCQY6vgx0OE3OuGxOa0XCDvO+NjtiTKbTZP5lc2yLB+CUL04lFIwQk8NkzpdPsjEimDotByvU8ZHJMBSnjhtkY0RwYigTq5OjZbZ3mE3RNHMWdV41sz0JSavvvE16XadtepLKjtx1pzWobHu70mpTK8InIC30kTY2Osg+Ys4IemJmTIzdORs3bmTatGlMmzYNgJtvvplp06Zx++23A1BSUtLmIjs1NZVVq1ZRXV3NjBkz+MY3vsGiRYu4//77Y/pcGRPSBX6/n02bNnHrrbe2eX7BggW8++67Ybc5djrTU089RUpKCl/84hf53//93w6zxiVLlnDXXXf1ePzdkZmVTmd/UE63k+S0JGqr7Dkopmelhb26P5YnxY3T7SDgi20hna5KG5DSaSKWkpFsSywtUtNcGGbk/ZRic3dMqnaErYK0UCicoZ4ZSBct5XO2dr+EfR2FO2jvktgOMxS2CtJCqeY2tnJZncak3fZ2EYWMTv6+Fc2VEhs1V0Fi05UVT8O9Ryzmz5+PjrDRsmXL2j03fvx4Vq1aFWNkbUklpAvKy8sJhUJkZ2e3eT47O5vS0tKw27RMZ/r4449ZsWIF9913H3//+9/53ve+1+HnLF68mJqamtZHYWFhj/47uqKsqJzIlxrQVN9Evde+0nBFUSXaivwXV1dVb1sCAlBZUhOxEgJQc9je2R/VVU2EQh2fFLTWVNfbWz6vVn5CEZJajcbniG3dge7SSf6I4wYsNA0ue0+ugaAj4klF6+Y2tmoyOo3J7lkyjpAz8jWSBkfQ3qTWTfRdE8cjqYR0g/rcZUDLTINwujKdye1299h0qp6yctlqvvnzizt8PRQI8Z8n3sKKcLLraW8+8zZf/MG5HccUDLHqL2u69uYxLsPOkYrMuys+ZP5lp3TYzApZrPnrB2BGf5DWrtgGaAZT2v55f/BxGdOmdzxoWANr9pXhy+z8Kj/YSSn+WHMGF3T4mr++HrNkZoevK2Dk4DeYnhW+wggwMoajWKXVeSJ6YOJh3ll7XoevGyiSRx3grNy2Zf2/VqdGHwjgL02Jum1FVTpDkw53+LpSUO5LJ5Da/H1yx/JdMWJLFFqPcaVJMLrjaqdSoEtjWya/u9JrB1LRr6jjBgrS67LsCwgYzAj2siOmbXpydkyik0pIF2RlZWGaZruqR1lZWbvqSIvOpjP1FSV7D7H8t/8I+1owEKK63MvzS1bYGtOBncW8+sgbYUuJoWCIypJq/nH/a7bGtG9bMe+8uClshSYUDFFeVMVbT6+3Naa9+2v4aHsZVrj9ZGlKvY2s3XvI1pgqk8soTz7UQeXBwp1STMbA922NacjQz8jOOQC0T6Q1mmBmLcG8SltjqmlKpd7vDlt50BrqfB68vuiTmh5xyAN14Ss0WoOucEKlvWNn0muzcAY84ashR6bpeppiSxa7ayijSSIlYhdfOy1jOrr76AMkCekCl8vF9OnT2/WFrVq1qsOBpj01nSkR/PmnT/OnHz+Jt+Jod4K2NJtWbuGGWT+joiS6ufA96bGfPMuz//si9dVHu4Esy2Ljf7Zy69n/1yZWuzz5/17iXw+9RWPd0cF5Vshi8+s7+PXXH6HBa//6F8+v2MWadwrx+Y92FYVCFhsLy/nt6h34gjZP81Twce4mCjP3ElLHdF+pEOkDNzF04sMYpn3daACGoTn9jH8yZtw2tHF0f2hlERh6mMZTdoNp7zRPjWJfVS6VjWkcm9daWlHZkM6+qhw66ybtcZaCjzLgkBt9zNdGh4DiJNiRYXtMhjYZXDqO1Pr+bRIRZRlkerPJPjwytmSgBziVi5M5g4EMxvbfUR+gdKSRKKJDy5cv5/LLL+fhhx9m1qxZPPLIIzz66KNs376d/Px8Fi9eTHFxMU8++STQPP1pwoQJnHrqqdx1112Ul5dz7bXXMm/ePB599NGoPtPr9ZKRkcF8LsSh4r9KosPpYMKpY3Anuzmws4iyA52vBNjbnG4HY08ehcvt5MDOYioOdjMhirVUHeauuC6PkxFThuJwmhTtKm0zFsRIjeHqNat/TLE0Ds/s8DWn02DYkHQMQ1FSWseBYbEdHL1Tou+OWThpe1TtTMskvakfF2R8hDulGIez8xkh0PPdMcd65NBpmNXNv6NQRj24Oh7n89edsc12cm2N/nfff+fRuE0VIsnZvP8bAm6sMItvpX4awzTUstiqOro2TELvsCAt2Hzir3VA6Oj1reWPYSCo1XODa4NGAL+rAVB4fClxWaTs83y6kWoq2MZ71NTUtFtErOUYn//n/4eR3L2uLKuhif3X/m/Yz0kkMiakiy699FIqKiq4++67KSkpYdKkSbz66qvk5zevadDRdKYf/OAHzJgxgwEDBnDJJZfwi1/8Il7/hG4LBoJsW7cz3mG0EfAF2f72rniH0Ya/KcCuDfFfPv5YgYDFZwXVxzwT/yWtQ0aIquRyUjLjv/x/K2eI0MD4T40/Vkib1PntnVnVqaABVfH/Dh3LYTlxNGV03tBGbpXEAB2+y76Nnly3PcFJEtIN119/Pddff33Y13prOpMQQgjx30KSECGEECKBHE+zYyQJEUIIIRJNH+lO6S6ZHSOEEEKIuJBKiBBCCJFApDtGCCGEEPEhs2OEEEIIER+K7i9sJpUQIfo+bfMKoj0p0i1OP0fHODpMxbBiaIoZ/cJmAJmd3Qn1c1KNWJbhjm2V2jQz+vamI7bvSkz7PMbziY7hd686uQO1EL1JkhAhhBAikUh3jBBCCCHi4jhKQmSKrhBCCCHiQiohQgghRCLRqvnR3ffoAyQJEUIIIRKI1s2P7r5HXyDdMUIIIYSIC6mECCGEEInkOBqYKkmIEEIIkUiOozEh0h0jhBBCiLiQSogQQgiRQJRufnT3PfoCSUKEiCcrhiNFjMPdVQzvbQRiemu0z4y67SFfWkzvvS8YyzLsAHVRt6y2YjvkFfsyo27r98X23skx7HMV20r2KCuGJeRj+Q4Ke8iYECGEEELEhYwJEUIIIYToXVIJEUIIIRKJdMcIIYQQIi6OoyREumOEEEIIERdSCRFCCCESyXFUCZEkRHRZ1uD+nHrBdNzJbgq2HWDzG9vQcb5r0sChAzhpwYk43U72bSvk43WfxDUegKwh/Zh0+lgcTpN9Hxfz6ab98Q6JrP5JjBnVD8NQFBZ7qcQX75BI9aeQ1dSfemsWrrQDOFOL4x0Sjlo37srmKcP+fvUE0pviHBF4nD5SXE1ooN7nwRd0xzskSA1ARqB5RkaVExrje2rRaHzueprc9SitSGpMxxX0xDcmrammnCrKo2h8/MyOkSRExMzpdnLD0mtZcMV8UKAtjekwKS0o45ff+AM739tte0yuJBfX338lp118Cs1BaQzT4OCnpdz7Pw+zd+sB22NyJ7u46pdf5qRzTmi+KGmNqYxHb15O8Z5Dtsfk8Ti45KJxTBg3AK01WtOciFTV8+i7ezhUa/9J1hVyMu3wiQxqykKjqascBxg4UorJGP08Dk+V7TH5GpPY8vY5ZJcNQR+5pFQofBn1VE0pJJQU48IqPcBhBBna/xApbl/rkjFKNScihZWDCMa4BkqP8IRggheVFmwTk650wq50CNjf4+93NHFo4F787saj1QAFyQ3pDCofgRmH/VSna9jGe9RTa/tnJzoZEyJitvjpG1hwxXwM08AwDExH88JVA4cO4Dev386wCUNsj+nHT17PnK+cgmEYGIbCMJu/2tnDB3L3Kz8lZ+QgW+NRSvH9h77J1LMnogz1uZgGcMtT19I/N8PWmAwFV39jEmPH9G+N0TCar5byMpK55awTSPc47Y1JK04tnUFW05GYULQcloL1OVTt+BZWIMnWmEJBBxtev4iqw3mtMTXHBS5vMlnvj0TZfHI1lMXIgQdJdjVXrJRqfgAku5oYkVWCUjEsUNYTHBZMqYaUYLuY6BeAE6ttX7YzaAYozt2F39XY/IQ68gAakryUZO9pTSrt0qQb2Mhq6mNYVK9lxdTuPvqC4yoJueqqq1i7dm28w+jTxpw0krlfObX1hHos02HicDr4+s++bGtM408dw/QFkzE7iMntcXHRjQttjWnC7FGMmzmyw5g8KS7OvnK2rTGNHzeAYUPSMY32ZVrTUKS4HJwxJsfWmHLrs8kIpGGEPRSZWIFUGspm2hrTwX1jqPdmonX7mJRWmE1Okov72RpTv+RanGbw6En+2JgUuBwBMpOiP8n1iNxGcFmoML86pUClhmCgvd18NWllWEawNfFoGxT43A3UJ1fbGtMB9hAiSEyDNHQPPfqA4yoJqa2tZcGCBYwZM4Zf/vKXFBfHv8+5rznz66cRDHS8hrTDaTLvq7NwOO0reZ5+yakEA6EOXzedJvMunWVbPAAzL5hCKBghJofJrIum2RgRTJ00CCvCct6moZg1YqCNEcGQ+txOrkwVTeX27qfivePo7AiefNDeJCQzufMyfjRtelR25ARDa2CQvd17takV4ROQFhrqUiptiwfgIPttr770JcfVmJAXXniBiooKnn76aZYtW8Ydd9zB2WefzTXXXMOFF16I02lvKbovSu/f+X1AHC4HnhQ3ddUx3vCii9L6p7Z2K3TEneTC4XIQ9PdyTEfuw5GamdTaTdWRpDQPhDpOVD5P+WMbh+Coa9s+1ePAMCJfd6S4TNzVnR8wXYeiP3R8kJnf4WvTg2mtXR3hKRr96fz50Okdtsh2R3/yrQ91Pogzr34AzgjXZwpFsNHNmqLRbZ8viW3go7sq+hOTQ4XCVkFaP1uBU4Vw1h35fsfyXQnG9jfRMvhcOa1OY9JOC7R93USW0cnfk4KQac9xqUUQv62f19ccV5UQgAEDBnDjjTeyefNm3n//fUaPHs3ll19OXl4eP/zhD9mzZ0+8Q0xopfvLUJGOPECDt5EGb6NNEUHZgXJ0Jzfh8lbU9n4CcoyKouqIlRCtNdWlXtviAaisaCQU6viEYGlNZa295fNK5ScU4SpRo2lw2Hs1HUj2R7xytdDUuey9sg0EHBHvX6g1+P02X1M2GpFjsoCm6G902BMcQVfkIpY+0sZGHpJj3kbRA2NCev6f0iuOuySkRUlJCStXrmTlypWYpsl5553H9u3bmThxIr///e/jHV7CWrlsdcSr6VAwxL8ffyNi2b+nvfnUOkxnxwe7UDDEyifW2BYPwDsvbIpYCdGWZu3yD2yMCD784GDYMSrHeneHvTN2NqkazE4Ol/vTCm2KplndkOqI1RkDxaf9oq9g9YTq6tROqw41NbHefbh7dEnkAcPKAB1jdai70muzIjdQUbTpYYMZGftGLVN0u/voA46rJCQQCPDCCy9wwQUXkJ+fz9/+9jd++MMfUlJSwl/+8hdWrlzJU089xd133x3vUBPWof2Heeb/XgBotyZIMBCi4mAVzy9ZYWtMxXtK+ccf/xP2tVAwRNmBcl5+4DVbYzqw4yCrn90Qdt2UUDBEaUE5bz613t6Y9tWweePB8DFZmuLyBt7dWWZrTJ+pBrYrb9jKg0ZT5a6hKPWgrTE1DqylIau2w5hKk0Psz7A3CamtTaa+3h228qA11NV5qKuzdxYRh9zgDV+h0Rr0YVfzmiE2Sq8biMufFL4aoiG1rj8en73J2lBGkUI6fac2Ya/jakxIbm4ulmVx2WWX8f777zN16tR2bc4991wyMzNtj60v+csdy6ksreLrP/sKWYObp1aGgiHeWbGBh364jOrD9nYzAPzl53+loriKL998HpmDmqe+BgMh3l3xPk8sfp66qnrbY3ru7n9ScbCKc6+ZS2q/lNaY3v/nVv76q1dpqvdhJNl7pbjirzuprGhk1txhJCc3nyCCQYsNuw/zj/f24w/aPM1Twd+MEuZbfk7V/fDQXD0KqRAHUovZ2W8Plt1zDRUcnlpI5qeDSD4wAKfVfPIIKs2n/UJszQ7E4SJTUVw8kKysGjIz6zCM5n1iWYrq6lTKyzOx/SSnFfqjDNTIenROE+pI4U8HFRR70PuTbY/J0AaDS8dR3r/oyCDV5v1khEwyvIPoV5PbyRiknudQTmbo+exmK6UciG6Q6nG0YqrS8V7i0kZPPfUUX/3qV/F44rtyXld5vV4yMjKYz4U4VPwH0RqGwaipw3EnuyjaXUJ1WU28Q8J0mIyYPBSn20nRrhJqK7s5bbGT8S/tmjva/15Mp8mwCbmYTpODn5bRUHN0vEwsSYjqnxlTLIG8jmdwmKYid3AahqEoK63n0ODY+smrx0Xf1hgX3e/AoRW5uJk48BBeVy3BzgYZHtHTA1OP9V7hCPo1NReMq90WwQhDHOr3ZMb03pm7Ymj76dGxOkpZeDwBtAafzxl2KrGrKIYF3iqqo28LWA0N7Z80LUg58vuqc4B19O9G+2MYmNmDp6OQEcTvbEIBbl8yKgEK/wHtp4YKtvAONTU1pKent3m95Rif/8v/w+jmecpqamL/z24L+zmJ5LiqhFx++eXxDuG/imVZ7Plwb7zDaCMUDPHph/viHUYboUCIgo+K4h1GG6GQpujAsRUrewfrhRNUmkKayPFUxzuUViEDypNtrg51QmuDxsYEWKr9WCEDvPE/yR/LtBwk2dz10hmncpGp7R2TkuiOqyRECCGESHQ9seJpX1kxVZIQIYQQIpEcR2NCEqt+JoQQQojjhlRChBBCiERyHFVCJAkRQgghEoiMCRFCdE2M98nQsdy3ozG25csdNdG3Tz4c2+yYYFL0h446YpuhsC6W+b+Acke/cJgOxTbl2nEo+v2SVhTbe6cciv5376yO7XevGqNfft+K8d4xsdzvSIjOSBIihBBCJJKeWHa9jyzbLkmIEEIIkUhkTIgQQggh4uF4GhMiU3SFEEIIERdSCRFCCCESiXTHCCGEECIueqA7pq8kIdIdI4QQQoi4kEqIEEIIkUikO0YIIYQQcXEcJSHSHSOEEEKIuJBKiBCR6NguJ7QV4+VHIPols1WMy7Yrb33UbT2lZkzvDSlRt3Q0xnaY8R1yxtTeckbfXsW2qj7u6uh/n0nlsS1/nnSoMeq2Rk30v0sA3RD9exMIxPbesX7HY/wbErJOiBBCCCFEr5MkRAghhBBxId0xQgghRCI5jgamShIihBBCJJDjaUyIJCFCCCFEoukjSUR3yZgQIYQQ4ji3du1aFi1aRF5eHkopXnrppai3feedd3A4HEydOjXmz5UkRAghhEgkuoceMaivr2fKlCk88MADMW1XU1PDFVdcwVlnnRXbBx4h3TFCCCFEAonHmJCFCxeycOHCmD/nO9/5Dl//+tcxTTOm6kkLSUJEl+WNymHWF2fgTnZRsO0AG175ECsU42pQPWzwmBxmfGEKDreTfdsK2bzqI6xYF1fqYXljBjFp3ngcTpP924vZsW4POs4LOGUPy2DUlBwM06D40wr2ljbFfU2p7HQn+VluQkmKolo/B7z++AaEpp/bYmCyhQLKGw0qmhSg4hqTO9PC0y8EGpqqTHw1Rtxjol8QldEck650QG18Ty0aTaOnFp+7HrQiuSkdtz85vjFpTSWHqKbc1s/1er1tfna73bjd7h557yeeeILPPvuMp59+ml/84hddeg9JQkTMPMlufvTY9cy/dDZWyMKyLBxOBxUlVfzy6/fx0Zod9seU6uHGP13LKRecdCQmjcNpUl5UyT1XPcTuDz6zPabk9CSu/f3XOHHeOKyQhdYa02FSXljJQ99/hgPbi+2PKc3NV248lRGTsptjAkzToKKsnuWPbqbsYJ3tMaW4Db44rT+D+7uxjmRChlIcbgjwwq4qKhpjW4m0JyQbmtPS/WQN1LTksIYKUe1TvHfQSX3Q/pO+I8li4BQf7nQLbQEKlArgqzEo2+om1BSH3vXkEMbkelTq0ZgMBbraxPooBfz2x+RzNnJo0GcEnL7WLolKVYynMZWcwyMxrdhW5O0JXl3FR6yniYboNujBKbpDhw5t8/Qdd9zBnXfe2c03hz179nDrrbeybt06HI6upxIyJqQbli5dyogRI/B4PEyfPp1169ZFtV13BvEkgtue/yFzv3IKAIZp4HA2fwEzB6Wz5N8/Z+TkfNtjWvzsD5jxhSnHxNS8DHm/nAzu/MctDB6TY2s8ylDc8NhVTJwzujUm03EkptxMbnnmW2QN7W9rTIap+OZtpzNswsCjMZnNh4DMAUlcfdNM0jN75gopWqYBl5ySRW6mqzkmpTBU8wm+v8fB5ScMINlp72HKgeasTD/9HS0JUfMDIN2lOX2IH6dhb9nIcGhyTm7CldpcaVQGHNlNuNIscmY0oUybS1lOC2N6HSS3j4n0UPNrNu+noOnnYM4uAg5f8xPHFK6aPHUczNmDxt5qbaOuZxNraCL6pfRbumO6+wAoLCykpqam9bF48eJu/5tCoRBf//rXueuuuxg7dmy33ksqIV20fPlybrrpJpYuXcqcOXP405/+xMKFC9mxYwfDhg3rcLtjB/EcOnTIxoh7xviZozn1gulhXzNNE23BZYu/zP9d9nvbYpo0dzwnzpsQPiaHidZw0Y0LefD7T/R+MNpqjWnUtPDJmOkwcHmcnHP1HJ67+5/Rv7U/xu6Jurb3Gxk3Zzg5w/uFj8k0cHscnHJKLm88+1Gnb50UCEUdhtPr6fC1MePTGJAa/srUNBRJDoPTHG42flzT4XtoI4aqRBR9TkNzNalZ+ugJ9RiGgiSHZkKgif0FbV9z1Pqij4PY7geTkluP6QYVJihlNFdJUvrXU7u3+Tntiz4WHYyx0nTkO66G+MAVfj8pA3Syhcr2oYvtqzzUpJdhGaHwvVMK/K5G6pOrSW2w7wJgP7uxCBGvObfp6emkp6f36HvW1tayceNGNm/ezPe//30ALKu52utwOFi5ciVnnnlmVO8llZAuuvfee7nmmmu49tprmTBhAvfddx9Dhw7loYceirhdyyCeWbNmdfoZPp8Pr9fb5hFv8782h2CEm645nCZzv3IKTpd9+e1pX5lJMMJJ0eE0mfvVU22LB+DkC6YQCnYck+kwOfWik2yMCE6YNyLimB3DNJg8194q1uhxaRHH7BiGYuyoVBsjgrxBnZ8scvLs7Y5J7fi6JqY2PUnl+sMmIG3a5MR2c7zuqk2pjDw8Rh9pY6NSDqBjTUDiMDsmFunp6Wzbto0tW7a0Pq677jrGjRvHli1bOOWUU6J+L0lCusDv97Np0yYWLFjQ5vkFCxbw7rvvdrhdyyCeO+64I6rPWbJkCRkZGa2Pz/ftxUNaZucnBNNh4k62r6yfkpmC0cnVsMvjxGFjYpSSkdza/dIRT6q9XR/JaR4MM/KfvCfZ3v5yj8fs9Hfndtl7mHI6iXhyVUoRw417e4TpCl8FaaGUwnTZGBB0WkdXCnDae/VvGZ1U6BRYZvRVvJ4QpAuJWBySkLq6utaEAqCgoIAtW7Zw4MABABYvXswVV1wBgGEYTJo0qc1j0KBBeDweJk2aREpK9HfZliSkC8rLywmFQmRnZ7d5Pjs7m9LS0rDbtAzieeaZZ6IexLN48eI2fXmFhYXdjr27Du4tjXgwBKirrqfBG8OtxLuptKCs09km1WU1BP32DXAsO1ARsRKiLU3lwWrb4gGoPFhDKNhxJURbmqqy2G4Z313V1QGsUMe/O8vS1NTaOzC1vgGsCMMGtNY0RDm+sKcE6pp/Px3RlsZv95jiBiNi75a2QDfYPJ4n6Ip88tXgDNib/CcR/Qm5RU+OCYnWxo0bmTZtGtOmTQPg5ptvZtq0adx+++0AlJSUtCYkPUmSkG74/MlYax32BN3VQTxut7u1P683+vW6YuWy1RGTkFAwxKt/fgMr0lG8h7351LqIVYdQyOK1x1fbFg/A2399P2JMWmtWP7Pexojgw9d2Yzoi/Mkr2PS6vbOIPvm4BsOMdIUPO3bV2hgRFJUqjEi7SSmKC+29wq/d2zzYuSPKUNQWdPhyr9BFkctBygBdbG95JqN2YOQGCtLrsuwJ5ojBjLT187pq/vz5aK3bPZYtWwbAsmXLWL16dYfb33nnna1VlFhIEtIFWVlZmKbZrupRVlbWrjoCRwfxfP/738fhcOBwOLj77rvZunUrDoeDN998067Qu+1wUQWP//w5oP2VWSgQonTfYZ7/1QpbYyrZW8Zff/0yQLvxBaFgiIN7Svnngyttjal4Vymv/XkNQLsqTShoUfRJCW891XHXXa/EtLucja9+0npwOZYVsijaU8GHb+61NaaS4kZ2f+INW8myLM3B0iZ2f2bvJf7hSig9HH4Mq9aa8jJNWfiCZ6+pL4b6kva/t5aY6os1jSX2xqRLnVBpdrCfwDrogMrIXZI9La0uC7cvpX015Ej3RFrtkddtNJRRpJFJTGu5JPiYkJ4kSUgXuFwupk+fzqpVq9o8v2rVKmbPnt2ufU8O4kkEy3/9Er+56gFKCo7O7gn4Arz+9FpunH0btZX2rzXx/C9f4qEb/0JF8dFBZ/6mAG88/TY/O/eXtnYPtfj7kld49s6XqD50dECxv9HP2ufe47dffxh/o72D9gBeeWg9qx7/gLqqo/vD3xjg/dc+5en/W0MoYP9ic2tfP8QH6ytobDja7eL3W3y03csrq8oido30DsXWnYpP9ysC/qNH8kBAs+8z2PqhjsvCbmXroeYTCB0TU8ivqd4JZRvsjwetsLYko/e70Mf0mGm/Qn/qRm9Pwu5F1AxtkHdoDBneQSjr6OnNDDkYUDWYgRXDUDbHZCoH05nHEEZiEGVSdhwlIUrHe+nGPmr58uVcfvnlPPzww8yaNYtHHnmERx99lO3bt5Ofn8/ixYspLi7mySefDLv9nXfeyUsvvRRT+crr9ZKRkcF8LsSh7F9wJ5xh4wfjTnZz8LNS6mts7igPQynFkHG5OD1OSveW2Z98hJ1CqcgbnY3pMjlUUI6v3nfsi1G/teGK7XeukpI6fs1QDByWiWEaVBTVEHTG1k+u06O/mgxmdDxFt21M0K+/CyvFSXV1gGCEsSJtYunhKbrHcjYGSUlp/rXW10UeK9KbU3T1MdOtlQHOtOb/76+FcMte6Ibov/exTv3WoTBjnQwNKVbzia/eAH3M7yROpxhLhVoXLHMFkmxPPsIJ6gC1VLOJNdTU1LTrYm85xo+78ZeY7uj+bjoS8jWx6w8/C/s5iUTWCemiSy+9lIqKCu6++25KSkqYNGkSr776Kvn5zVMce2sQT6I58In9q35GorWm8JOD8Q6jDW1pinfbXL/vhLY0ZfuqWn9WMSYhvUFbUFnuJ9iUONdF2oI6e4ekdEpb4O942ZT4sBTU2tv10hlDm3Ffqv3zHMpJms7stF087h0TL1IJ6UMSsRIiPqezhRPatY9PJaRd29TY+sl7oxLS2r6Dxcs6jKUXKyGO+uhn5thVCYmqvd2VkIgbyCnmWEEdYDX/iFgJGf+DnqmEfPLHxK+EyJgQIYQQQsSFdMcI0ZNivuqLftRlzMtrN8YwHibWq9sYrp6d9bFd0TlirPjEXH2K5a39MQweboqtEqJjaB/LMuwQW3VDKhuJ53jqjpEkRAghhEgkPTG7pY8kIdIdI4QQQoi4kEqIEEIIkUiOo0qIJCFCCCFEAlF0f5m3+K+KEh1JQoQQQohEchxVQmRMiBBCCCHiQiohQgghRAKRKbpCCCGEiA/pjhFCCCGE6F1SCRFCCCESTR+pZHSXJCFCCCFEApExIUIIe8RwH45Y7/GhrejfW4Wiv4cNgIrlPjaNTTG9N2aMt4SP5S66MYpln+tAbPf2ieleQLH+7mNpL/eCEXEkSYgQQgiRSI6jgamShAghhBAJ5HjqjpHZMUIIIYSIC6mECCGEEIlEumOEEEIIEQ/HU3eMJCFCCCFEIjmOKiEyJkQIIYQQcSGVECGEECKRHEeVEElChBBCiARyPI0Jke4YIYQQQsSFVEJElw2fNIzZF87Ak+ymYNsB3l7xPgFfIK4xjZg8jBlfmILT7WTfx4W8/68PCQZiW/K6pw2fPIQT50/AdJrs/7iIj97YQSgY2zLpQBeW1+74M4aekMvoU/IxTIOiHaXs2bAfKxTD++vo4492OfPssf3JO2Eghqko+6yKoo/K4r6ieGZ+Mv2GpwBQfaCBqr11HZe5Y9gnzc27tr+TBjtJynWAhsaSAI0Hw+xfW3echqwQKjMEGnSlCVUm0HvL6XcekaYhqYYmdz0KRXJjOm5fCiqOMVnaopwSqinvvLF0xwjRseS0JBY/cyOnXjCdUDCEZWmcLgfeilqWfOMPbFy51faYUjKTuWXZd5lyxgmEgiG0pXG4HNSUe7nnyofY/vYu22NK7Z/Cd5dewdiZI5tj0uBwmlSXeXn4+if57MP99sc0IIXLfrmIoSfkNidCWmM6TWrKanl28b8o2V1me0wp/T2c88OZDMjPxApZoMFwGNQebmDVH96nqqjW9pg8mU5O/NowUgd5WpOz4aaiocLHtuf201Dutz0mZ4ZB7rlpuDId6JAGBf2nJ+OrDFLyWi3B2i4ktt2VGsKY2ohK1q15kjEKtNfA2pIETfYX232uBkoGfUrIEQCtAE1VZgluXzI5ZaNwhFy2x1SjK9jKevxEdx8lpTWqm4lkd7e3i3THiJjd8cItnPyFqQCYDhOnqzmXTc1M4e6Xb2XMSSNtjUcpxW3Lb2TS3PGtMTlaYuqXyv974YcMmzDY1pgM0+CmZdcy6qT8ozE5m2/Mlj4glR8++W0GDc+yNSbTYXDVfV8mb1x268/mkZjSBqRw9f1fJiM7zd6YXCbnLZ5DvyHpQPN+MxzNh6WU/h7Ou3U2SRlum2MymHblCJIHuI/EpDDM5itoT6aLaVeNxJkc4032uslwKwYvysCZ3vy5ylSoIzfuc2WaDF6UjuG0+SrfZWHMaABP88lOGc0PAFKPvGbaeyIMmH6Kc3YRMo9UZJVuLcj4XA0czN6DjlAh7A0Nuo4PWRt1AnK8kSRExOSE2eM46ezJmI72B2HDNFBKcdnPvmxrTJPnT2D8qWPCxmSaBoZpctFNC22N6cQzJpA/aUiH+8nhMllw7em2xjRx/hgGjcjCdLT/szdMA6fbyakXT7U1plGnDiZtUDKGGT4mV5KDCWcNtzWmnKmZuNMdrYlH25gUzmST3JP62RpT+ng3pudo4nEsZSgcKQZp4+xN1tTQADiPSTzaxAQkaVSOvd2zNellaGWF7wlSEHA1UZdSbWtM+9mNFWvio3vo0QdIEiJiMu+S2QQj9PE7nCazLzy5tTpih9lfOjniuA+H02TOl2eilH1XiiefP5lQsOOYTIfJzC9Osy0egElnjm3u7uiA6TCYsmCcjRHByFmDIw5fMEyD0bOG2BcQkD0pI3IDBdmTM22JpUXaaHenQyzSRtvbzaByA3T2J6VyohsP1FPqUioi7ycNdSmVtsUDUMoBdIwZQcvsmO4++gJJQkRMUtKTO21jmgbuZPuuypLTkzHCXCEey+lytHY92CEpLSlsFeRY7mR7TxqeNHfYisOx7I7JneLs/HeXZO/QNafHjJiwKqVwuO3vjuksJsNl8+HcEfkspxTgtPdMaBmdVBwUWIa9A9VD2JuI9TWShIiYFO052GlFwVtZR4O30aaI4OCnpegIl9NaaypLqgn67TsYHCo4HLESYlkW5YX2XpGV76/qNKaKomr7AgKqi2sjVmcsS1NTWmdjRFB/2BdxppBlaRrKfTZGBIGqUMTZNNrS+KttngVWb0SsYmkLdL29pxhnwB25G0KDM+CxLR6AJFJj30i6Y4QIb+Wy1RFfDwVDvPLIKizLvsFfbzy1DsPo+KusLc1rj71lWzwA65Zv6LQSsvrp9TZF02zjP7dFjEkpxfsvbbMxIvjkrf0RqzOGofjkTXtnER38sDLseJAWhqE4uMneBLJmpy/seJAWylB4d9o78FEXuSJ2xygDdJHTvoCAjNqBkRsoSK+1d0D4UEbFvI10xwjRgYqSKv50y5MA7a5gQ8EQRbsP8vyvXrI1prL95Tzzvy80x2S1j2nfx4X8c+lKW2Mq+bSMf/3x9SMxtT0aWCGLgi2FrH76XXtj2lXGO89v6jCmfVuK2fzKdltjOrS7kp1v7gNoV83Slqbwo0N89l6xrTFVflZPydZqtNbtY9KawztqOLzTa2tM9fv81O71hY1Ha413j4+GQnsHgepSB/qw2a4aonXzwypyHFkvxD5pdQPwNKW2rwIc+TnDOwiPP8XWmAYzkgz6x7bRcVQJkXVCRMxW3P8qFQcr+ebtX2XEpGEANNU38dqy1Sz7f8/T4G2wPaYX732V8sJKLv7JIoaMzQWgsa6J1/+ylueXvERTvb3lc4B//P41yosqWfjdM8k+Mh23sbaJNc++xz/vX0nAZ39f8WsPrKWisJq535xBv9yM1pjeX/ERa/7yftcWUeumd//yEdXFtZx43mhSByQB0FTrZ8cbBWz9557YFvXqIZ+8XEx9WRNDTx2AO635at5fF6RoQwUH3jkclwP8oTfq8E/xkDEpCUdy8/VjqEFTva2R6m1xmP6pFdaWJNQIPwzzo1qGE/kUep8LfcCJ3QuWKQxyy8ZQlVGCN+0wltncReUIusj05theBQEwlclJ+nT2soMi9soYkc9ROlJnukgoXq+XjIwM5nMhDmVvmbMjg4Zl4Ul2U3agnKYG+0/04QzKz8LpdnL4QDn+pviu4Npi4LABmE6T8sJK+8amRBzICP3yMjBMg6oSL6FgjKP3OxlM+rnG0TVTkDYoBeUwqC2rj20F116i0Hj6NZ9dm6r8kRdFtWnFVBQ405v3acBrhU+I7D6sKw1JRz6zQRHP1VJbaCwCTj9KgyPojutqqS1COkQdNXzAm9TU1JCent7m9ZZj/PRL/w/T1b2xKyF/E5uW3xb2cxKJVEJEt5QdiGIJYpuV7U+8mA4fqIh3CG1oDZXFNUefiDJR6E1ag/dQPcSS4PQybUFjhf2ro0akIVATh9VRI9HqSPKROBQGLpsHoXbGVCYpOooFAXuiOyX+OXxUJAkR4r9VLFfDOraZFVrHcsKJ77172og12YqxuhHbe/eRs4QQvUiSECGEECLB9JXZLd0lSYgQQgiRSFqmGHX3PfqA+HcECyGEEOK4JJUQIYQQIoH0xGJjfaU7R5IQIYQQIpEcR7NjpDtGCCGEEHEhlRAhhBAigSir+dHd9+gLJAkRQgghEslx1B0jSYgQQgiRQI6ngakyJkQIIYQQcSGVECGEECKRHEeLlUkSIoSIXR85wLUT4z1yhIgH6Y4RQgghhOhlUgkRQgghEonMjhFCCCFEPEh3jBBCCCFEL5NKiBBCCJFIZHaMEEIIIeJBumOEEEIIIXqZVEKEEEKIRCKzY4QQQggRD8dTd4wkIUIIIUQisXTzo7vv0QfImBAhhBBCxIUkIUIIIUQi0T30iMHatWtZtGgReXl5KKV46aWXIrZ/8cUXOeeccxg4cCDp6enMmjWL1157LbYPRbpjRDeMO3k0cy46GXeym4JtB1i9/F2a6pviGtP4U0YzY+FUnC4H+z4u5J0VH+Bv9Mc1prEzR3LiGeMxnSb7txWz6d8fEfQH4xrTyOlDGX3KcAzToGhHKTvX7CEUtOIXkILBJ2YzeNIglKEo21PBvo0H0aE4lpQVDBibTr8RaaCgel8dFbtq0HHcTShIyXfhyXECmsaDARoKA/EdhKg0DAqiMppvDqgrHFBhNgcbJxqL+uRqmtz1KBRJjekkNaWh4hhTSIcoo4hqKjptq+iBMSExtq+vr2fKlClcffXVfOUrX+m0/dq1aznnnHP45S9/SWZmJk888QSLFi1iw4YNTJs2Lfo4te4jK5oIvF4vGRkZzOdCHMoZtzhSM1O4/e+3MO3MSQQDQbQGh8Oksb6JX11+P+tf3mh7TOkD0rj1uR8w/pTRBAMh0BrTadLgbeTeqx9m8xsf2x5TxsA0vv/o1QyfPLQ5JjQOp4O66gYevv5Jdr33me0xpQ9K5Zu//RI5owcSCoZAg+k0qatq4Llb/0HhxyW2x5Q2KIVzfzKHzMHprYmQ6TCor2pk1T3vUr63yvaYkrPcTL5iFMkDPFih5pgM06Cp2s/WJz+j/lCj7TG5+pvkfiEdZ5rZmpwpU+H3hij5t5dAdRzuEJwWwpjWiPLo1uRMGaDrFdaHydBof7G9yV1H6aDPCJlB0ArQoMDl95BzaAzOkMv2mKr0YT5iPQGOXhDV1NSQnp7epl3LMX7O2XfhcHi69ZnBYBPvvH5H2M/pjFKKFStWcNFFF8W03QknnMCll17K7bffHvU20h3TDUuXLmXEiBF4PB6mT5/OunXrOmzbU6WrRHD3P37K5NMnAOBwOnC6HChD4Ulxc8ffb2HCqWNtjUcpxf974YeMmT7iSEwmDpcDpRRJqR4WP38DIyYPszUm02Hww6e+zdCJeUdjcjYXHpPTPNz4+DXkjh5ka0wOl8nV93+VgcMHHInRxHSazTGle7jyvovpNzjD3pjcJuf/v3mk56QeicnAdDQflpLS3Zx321xS+ifZG5PHZNq1Y/FkuoHm5MMwm2NypTk56doxOFPsLSKbHsXgRRk4UprjUKZCmc3Xus5Ug8GLMjBcNl/luy2MGQ3gOpIQGc0PAJI0xskNYNp7jRtw+DiYvYeQcaTSqHRrScDvbOJgzi4sZW8pq1572cy6NglIp1pWTO3ug+bE5tiHz+frlX+nZVnU1tbSv3//mLaTJKSLli9fzk033cRtt93G5s2bmTt3LgsXLuTAgQNh27eUrl599VU2bdrEGWecwaJFi9i8ebPNkXfP5NMncuLcCZgOs91rhmGgNVy2+Eu2xjT1rEmMmjY8fEymAUrxpZsW2hrTlHNOYPDYnA5jMhwG51xzuq0xnXDmWAYM7dd6kv98TKbTZNZXT7I1ptFz80kZkNR6kv98TA63g4kLRtkaU+70AbhSHRhm+5O6YSocHpPBM7NsjSl9ogfDpVBG+5iUoTCTFOnju3flHCs1NACOYxKPNjEBbo3KDdgaU016GVpZ4fsiFASdfuqS7a2s7Wc3Osb+spYput19AAwdOpSMjIzWx5IlS3rhXwm/+93vqK+v55JLLolpO0lCuujee+/lmmuu4dprr2XChAncd999DB06lIceeihs+/vuu4+f/OQnnHzyyYwZM4Zf/vKXjBkzhn/+858dfobP52uXxcbb3ItPjTieweE0OeW8k3C67esumnXRjCPdHR3HdOoXp6OUfVeK079wYnN3RwdMh8nJF0y1LR6AE+aPbe1aCMd0GJx49jgbI4KRpw6JOJ7BMA1Gzh5qX0DAoBP7RXxdGYrsyZHb9LTUUe5OO/lTR9vbzaByAnT2J6Vy7B37VJtSGXk/aahPqbQtHoBDFMWchPSkwsJCampqWh+LFy/u8c947rnnuPPOO1m+fDmDBsVW4ZUkpAv8fj+bNm1iwYIFbZ5fsGAB7777blTvEU3pasmSJW0y2KFD7T0Yh5OU4un0YGiYBu4k+w6ISSlujDBXiMdyOB2tXQ92cCe7w17dH8uVZO+4HneKK+FiciY5wl7dt2njsbfrw+ExO01YTbd93yUAw6kixqSUwnDa3B3Tya9FKcBh78lXd9bVosAy7O2OCdGFsTo9ODsmPT29zcPtdnfr3/N5y5cv55prruGvf/0rZ599dszbSxLSBeXl5YRCIbKzs9s8n52dTWlpaVTvEU3pavHixW0y2MLCwm7F3RMKdxVjGJG/NtWHvdTXNNgUERTtLiHS+GqtNeXFlbbOSCn9rCxi1cGyLMoKym2LB6CsoCLiDBgrZHF4v71XiVWF3sj7KWRRXVxrY0RQf6gRK8KsHCukbR+Y6q8KoSMsPqUtjb/S5oGpdUbEmULaAl1n7ynGGfBEnimkmweo2imZ1Ji3UVr3yKO3Pffcc1x11VU8++yznH/++V16D0lCuuHzVyZa66hK/tGWrtxud7ssNt5eW7Y64kkjFAzxr4dXRkwKetobT62LuN+1pfn3o2/aFg/AuuUbwo4HOUrx1lPRVc16ysaXPwo7HqSFMhTvv7jVxojgkzf2RqzOGKbBjlX2ziIq3lAedjxIC8NUFL9vbwJZs6MpYsVIGYqaHfZOj9dFzrDjQVooA3ShvV1EGbUDIzdQkF7XSZseNhR7xzR1VV1dHVu2bGHLli0AFBQUsGXLltZxjosXL+aKK65obf/cc89xxRVX8Lvf/Y5TTz2V0tJSSktLqampielzJQnpgqysLEzTbFf1KCsra1cd+bzulq7irbqshgdueAyA0OeSkVAwRMHHB/jrb/9ha0zlRZUsu205QLsEKRSy+PTDAl55+HVbYzpUUM6Ke/4dNiYrZLHn/b2sff49e2P6tJw1y5o/0/rcVbVlWXy6YR9b/r3D1pjK9lSy7dU9AG2u9LXWaEtT8H4RBevtrQBW7a2l+IPD4WPSmtItlZR/EtuBtrsa9vvx7m5qjeHYmABqdjbRWGzvIFBd6kAfMo+diHEkpub/WvudUGNvt1Va3QCSGtPbV0OO/JxZnYPbn2xrTIMZST9iTHysHnrEYOPGjUybNq11jY+bb76ZadOmtU63LSkpaTPx4k9/+hPBYJDvfe975Obmtj5uvPHGmD5X1gnpolNOOYXp06ezdOnS1ucmTpzIhRde2OHo4+eee47/+Z//4bnnnot5/jUkzjohAKecfxLfuO1iJpw6BoC66npeefR1nv3FCzTU2r+GAsApi07i4lsuYNTU4QDUVtXx2mOr+fs9/4rbgmUnXzCF864/kyHjm6fq1lbW89ZT7/Dvh96K24JlU74wgbnfnMmgEc1Tdesq6nnv75t559mNcVuwbNwZw5m8aBwZuWkA1Fc2sv0/e9j2yp6I3RC9afApWQw7LZuk/s196E3VfgrfKaNwfVncFgfLmOQhc3ISzrTmk3vAG6L6o0ZqtsdpkUClUfkB1DA/ytO8U3S9Qu9zoYudxGPBMo1FdcYhatLKCDma/8acfg+ZNTmk1fePy4JlIR1iP7so5NPWqbqR1gk5fe7tPbJOyNp1d3dpnRA7SRLSRcuXL+fyyy/n4YcfZtasWTzyyCM8+uijbN++nfz8fBYvXkxxcTFPPvkkcLR09Yc//IEvf/nLre+TlJRERkZ0azMkUhLSInNgOq4kF5Ul1QQD8V0FtEXGwHRcHieVJdURZ6jYKWNgGqbTpKbMG9+VSY+RlpWCYRrUltdFHANhp+R+HpShaKhsJCGOTArcaU5Q4PPGeWXSYzhSDDQQqk+M7xJocB/ZOT5FPFdLbaHRBM0ACjBDzriultrC0hb1eNnA65GTkNN6KAl5O/GTEFm2vYsuvfRSKioquPvuuykpKWHSpEm8+uqr5OfnA5FLV9/73vdan7/yyitZtmyZ3eH3mOrD8Z82/Hk1CRmTvYMro1FbXh/vENppqIrvsv/t6CPJR4IJJkzy0UIdST4Sh0LFZXXUSAxlkKRT4h1GQpEkpBuuv/56rr/++rCvfT6xWL16de8HJIQQou/7/ECbrr5HHyBJiBBCCJFAjl3xtDvv0RfI7BghhBBCxIVUQoQQQohEIt0xQgghhIgHZTU/uvsefYF0xwghhBAiLqQSIoQQQiQS6Y4RQgghRFwccxfcbr1HHyDdMUIIIYSIC6mECCGEEAlEaY3qZndKd7e3iyQhQgghRCKRMSFCCCGEiAsNdHeKbd/IQWRMiBBCCCHiQyohQgghRAKRMSFCCCGEiA9ND4wJ6ZFIep10xwghhBAiLqQSIoQQQiQSmR0jhBBCiLiwANUD79EHSHeMEEIIIeJCKiFCCCFEApHZMUIIIYSIj+NoTIh0xwghhBAiLqQSIoQQQiSS46gSIkmIEEIIkUgkCRFCCCFEXBxHU3QlCRFdNmX+Ccy5aCbuZBcF2w7w+lNrqauuj1s8Sikmz5/AjC9Mxelxsm/bAdYsX09jbVNcYzrh9LGceMYEHE6TfduKeP/lzfga/PGLyVCMnTWC0acMxzANinaU8PHruwj4gnGNKX96LnknZqOUomxPBXvXFxIKxO9IqkzFwAkZZI5MQymoLqijbHs1OhTHK0wDUke6Scp1gIbGgwHq9vnje8IxNCo7CJkhAHSFCYcdoLt7Fu06S1nUpVTic9eDViQ3ppPcmIHq9pm964I6SCkHqKEibjEkIqV1H6nZCLxeLxkZGcznQhzKGbc4MrLS+d9/3sqEU8YQ9DefuAyHQcAX5J7/eZDVy9+1PaZ+2Rnc9rebGDkln2CgOSbTNPE1+rnvW4/w/iubbY+pf14mNz5+DXljcwgGmg/QpsPAV+/nTz94io/X7LI9pn6DM7jid19mwNB+hI7EZByJ6bnFL1PwYaHtMWXkpfGFW08jbWAKoWDz2dR0GDTV+lh1z7sc2m3/QTsl28OUK0fjyXBhhZpjMkwDf12ArU9+Rm1xg+0xubNMchdm4Eg2WhMhZSqC9SEOvurFXxmyPSYyQhjTGlAu0EcSIWWAblRYHyZBvWl7SI2eWkoHfoZlHLM/FDgCbvIOjcYZ9NgeU4Uu5SPeI8TRRL+mpob09PQ27VqO8WePvRmH6e7WZwZDPl7ffW/Yz0kkMjtGxOwX/7qVsSeNBMDhcuBwOTAMA6fbyeKnb+TEuRNsjccwFLev+BH5E4c0x+R04HA6UIbCleTkx09ez+iTRtgak+k0ufmpb5M9cuCRmEwcThOlmmP63iNXMXh8rq0xOd0OrvrDxWTmZrTGaLbElOzkm/d8iQHD+tkbU5KD839+Oin9k5pjchiYjubDkivFxRcWzyU1K9nWmBxJJtOuGYsrtTnRN0wDw2yOyZHsYNr/jMaVZu9FgJmsyLsgA9PTfCWvTIUym/+/mWQweFEGhsfmq3yPhTG9AY7sCmU0PwBwa4wZjeCw9xrX72iiZNCe5gREcfQBBB0+inN2Yyl7y0Z1uoYtvNsmAelUy5iQ7j76AElCREymnTmJ8TPHYDrbX+EYhkJrzddu/ZKtMZ20YDL5JwzpICYDreFLNy20N6ZzJ5E9YiCmI0xMpoFSigX/c7qtMU06exyZOemtJ/k2MRkGhqmY9dVptsY0Zm4+SZme1pN825gUptNg4rmjbY0pb0YWziQTw2x/UjcMhekyGTwzy9aYMiYmYTgVymgfkzIUhluRPs7eK3w1zA8GqDC5jzIAl0blBmyNqSa9DK10+PEUCkJmgLqUSltj2s9u+swtbeNAkhARkzlfOqW1CyYc02Ey49ypON32XSmecsFJrd0d4TicJjPPm4YKd7TsJVPPmUQo1PEVl+kwmX7eZNviAZg4bzSRel9Nh8mks8bZGBEMnzk44vHZMA1GnjrEvoCAQZMyIw4KVIZi0In2VoxSRrjCJiDHSh3lsimaZio7eLTy0VGbHHvHGdWlVHU6oLM+ucqeYI4ooxgdaxJi6Z559AGShIiYeJLdnf6RG4bC5bEvCfGkuDE6OUC3dD3YxZ3s6jQmp9veceGuJBeGEflP3uGyNyZnkqPTk6vDbe+4AtNtdpqwmk57D52GM3I8SqlO2/S4Tn4tSgGmvSdC3VlXiwLLsLc7JkQXxupId4wQ4e3bUdjpiayytJoGb6NNEcGBncURrzMsS3No/+GIFZyednBPaeuAxvAxWZTuLbMtHoBDn5W3DvwMxwpZlBWU2xgRVO6ribyfQhaVB2psjAjqShqwIsyAsUKaulL7vt8AvoogOsKVrbY0vgqbB6bWGq2DUcPRFuhae08xroAncs+HBpc/ybZ4AFJIs/Xz+hpJQkRMVi5bTShkdVjWt0IWLy/9T8Syf09746l1nWT9mn8/8qZt8QCse/79iMmaQvHmk/bOIvrgHx+FHQ/SwjANNrywxb6AgJ1v7A07HqSFYRrsWPmZjRFB8YbysONBWhimonjDYRsjAu+OpogVI2UovNvtnYpuFTojdscoA3ShvV1EGd5BkSu1CtJrB9oWD8BQujKmqSeqIFIJEf+FvBW1/P7bD4OGULDtlVcoZLHrg8/4++/+aWtMlSXVPHrL080xHBOT1horZLHjnd28+sgbtsZ0+EAFf/1l83449kpfa41lWWxft4u3l2+wN6aCCl7/09vtY7I02tLsWLOHj1Z+YmtM5Xur2LJiZ3NMx1zpa0ujtebTtw+w74NiW2Oq3lfHgXcOtcZxbEwAxR+UU7Hba2tMDYUBanY0V1+OTfBb/n/1tkYaS+wdBEqZA+ugo13lv+X/W3td4LW3Ky21vj8p9ZnN599jz8FH/n//qjzcAXsrIXkMZwDZsW10HHXHyDohfUiirBMCzbNkvrb4y5x01okAVJfV8PJDr/HX3/wDX2N8FuKadvaJfPnm8zhhTvPgyqrSal599E3+cf9/bO2KOdaUsyay8LtnMOqk4UdiquGNZW/z+hPrWtfpsNvE+WM47ZsnM2RCTnNMJTW897fNbPj75ojdEL1p1OyhTF40jgHDMwHwHqrj41f3sGPVZ3G7oMuZ1p9hc7NJzW4+adUfbqLwnTIOfmBvl9Wx0se7yZyShCuzeeyOrzJI9dZGanf74hSRRg0NoPL9qOTmX5SuNdAFLnSpg+4v+9mViDQ16WXUpJURdDYfi1y+ZPrV5JDaYO+A4haWtjjAHgr5FB/NyWTEdUJG/ACH0c11Qiwfrxf8MeHXCZEkpA9JpCSkhSfFg8vjpK6qHstKjHWCPakenC4HdVX1tnYLReJJdeNwmtRXNyZMTO4UF4Zp0OiN34qyn+dKdqIMha8ufivKfp7DY4KCYGN8ksZwDLcCDZY/Mb5LoI+uvx2M36qkx9Lo5vVCtMLU9i+aFo7WmkbqeZf/RE5C8r/fM0nI/gcSPgmRZdtFtzTVN9FUnzgnMYCmuiYSKyJoqovXlWrHfPWJc6Jv4W+wuUshCsGmxEk+Wli+REk+WihiWYvLDgqFaSXWKU4phUtHkVxoi4ijfqPR3e1tkli/ISGEEOJ4dxzdRVcGpgohhBAiLqQSIoQQQiQSqwem2PaRFVMlCRFCCCESiXTHCCGEEEL0LqmECCGEEIlE0wOVkB6JpNdJEiKEEEIkEumOEUIIIYToXVIJEUIIIRKJZQHdXGwsQVaw7owkIUIIIUQike4YIYQQQojeJZUQIYQQIpEcR5UQSUKEEEKIRCIrpgohhBAiHrS20N28C253t7eLjAkRQgghRFxIJUQIIYRIJFp3vztFxoQIIYQQIma6B8aE9JEkRLpjhBBCCBEXUgkRQgghEollgermwNI+MjBVkhAhhBAikUh3jBBCCCFE75JKiBBCCJFAtGWhu9kd01fWCZEkRAghhEgk0h0jhBBCCNG7pBIihBBCJBJLgzo+KiGShAghhBCJRGugu1N0+0YSIt0x3bB06VJGjBiBx+Nh+vTprFu3LmL7NWvWMH36dDweDyNHjuThhx+2KVIhhBB9hbZ0jzxisXbtWhYtWkReXh5KKV566aVOt+mJc5okIV20fPlybrrpJm677TY2b97M3LlzWbhwIQcOHAjbvqCggPPOO4+5c+eyefNmfvazn3HDDTfwwgsv2By5EEII0VZ9fT1TpkzhgQceiKp9T53TlNZ9pGaTYE455RROOukkHnroodbnJkyYwEUXXcSSJUvatf/pT3/Kyy+/zM6dO1ufu+6669i6dSvr16+P6jO9Xi8ZGRnM50Icytn9f4QQQghbBXWA1fyDmpoa0tPT27zWcow/w/xyt4/xQR3grdCLYT+nM0opVqxYwUUXXdRhm544p4GMCekSv9/Ppk2buPXWW9s8v2DBAt59992w26xfv54FCxa0ee7cc8/lscceIxAI4HS2/8L5fD58Pl/rzzU1NQAECXR79pYQQgj7BQkAEOn6P2D50d08yLd8jtfrbfO82+3G7XZ3672ha+e0cCQJ6YLy8nJCoRDZ2dltns/Ozqa0tDTsNqWlpWHbB4NBysvLyc3NbbfNkiVLuOuuu9o9/zavdiN6IYQQ8VZRUUFGRkab51wuFzk5Obxd+q8e+YzU1FSGDh3a5rk77riDO++8s9vv3ZVzWjiShHSDUqrNz1rrds911j7c8y0WL17MzTff3PpzdXU1+fn5HDhwoN2XVxzl9XoZOnQohYWFMZchjyeyn6Ij+yk6sp+iU1NTw7Bhw+jfv3+71zweDwUFBfj9/h75rHDnpJ6ogrSI9ZwWjiQhXZCVlYVpmu2qHmVlZe0ywxY5OTlh2zscDgYMGBB2m47KZhkZGfJHHoX09HTZT1GQ/RQd2U/Rkf0UHcMIPy/E4/Hg8XhsjiZ2XTmnhSOzY7rA5XIxffp0Vq1a1eb5VatWMXv27LDbzJo1q137lStXMmPGjKj7zoQQQohE0FPnNElCuujmm2/mz3/+M48//jg7d+7khz/8IQcOHOC6664DmrtSrrjiitb21113Hfv37+fmm29m586dPP744zz22GPccsst8fonCCGEEADU1dWxZcsWtmzZAjRPwd2yZUvrshO9dk7TossefPBBnZ+fr10ulz7ppJP0mjVrWl+78sor9bx589q0X716tZ42bZp2uVx6+PDh+qGHHorp85qamvQdd9yhm5qaeiL8/1qyn6Ij+yk6sp+iI/spOom6n956662Wu+a1eVx55ZVa6945p2mttawTIoQQQoi4kO4YIYQQQsSFJCFCCCGEiAtJQoQQQggRF5KECCGEECIuJAkRQgghRFxIEpJgli5dyogRI/B4PEyfPp1169ZFbL9mzRqmT5+Ox+Nh5MiRPPzwwzZFGl+x7KcXX3yRc845h4EDB5Kens6sWbN47bXXbIw2fmL9PrV45513cDgcTJ06tXcDTBCx7iefz8dtt91Gfn4+brebUaNG8fjjj9sUbfzEup+eeeYZpkyZQnJyMrm5uVx99dVUVFTYFK391q5dy6JFi8jLy0MpxUsvvdTpNsfrMbxVtycXix7z/PPPa6fTqR999FG9Y8cOfeONN+qUlBS9f//+sO337t2rk5OT9Y033qh37NihH330Ue10OvXf//53myO3V6z76cYbb9S//vWv9fvvv693796tFy9erJ1Op/7www9tjtxese6nFtXV1XrkyJF6wYIFesqUKfYEG0dd2U9f/OIX9SmnnKJXrVqlCwoK9IYNG/Q777xjY9T2i3U/rVu3ThuGof/whz/ovXv36nXr1ukTTjhBX3TRRTZHbp9XX31V33bbbfqFF17QgF6xYkXE9sfrMfxYkoQkkJkzZ+rrrruuzXPjx4/Xt956a9j2P/nJT/T48ePbPPed73xHn3rqqb0WYyKIdT+FM3HiRH3XXXf1dGgJpav76dJLL9U///nP9R133HFcJCGx7qd///vfOiMjQ1dUVNgRXsKIdT/99re/1SNHjmzz3P3336+HDBnSazEmkmiSkOP1GH4s6Y5JEH6/n02bNrFgwYI2zy9YsIB333037Dbr169v1/7cc89l48aNBAKBXos1nrqynz7Psixqa2vD3sXyv0VX99MTTzzBZ599xh133NHbISaEruynl19+mRkzZvCb3/yGwYMHM3bsWG655RYaGxvtCDkuurKfZs+eTVFREa+++ipaaw4dOsTf//53zj//fDtC7hOOx2P458lddBNEeXk5oVCo3V14s7Oz292psEVpaWnY9sFgkPLycnJzc3st3njpyn76vN/97nfU19dzySWX9EaICaEr+2nPnj3ceuutrFu3Dofj+Dg0dGU/7d27l7fffhuPx8OKFSsoLy/n+uuvp7Ky8r92XEhX9tPs2bN55plnuPTSS2lqaiIYDPLFL36RP/7xj3aE3Cccj8fwz5NKSIJRSrX5WWvd7rnO2od7/r9NrPupxXPPPcedd97J8uXLGTRoUG+FlzCi3U+hUIivf/3r3HXXXYwdO9au8BJGLN8ny7JQSvHMM88wc+ZMzjvvPO69916WLVv2X10Ngdj2044dO7jhhhu4/fbb2bRpE//5z38oKChovcmnaHa8HsNbHB+XO31AVlYWpmm2u6ooKytrlym3yMnJCdve4XAwYMCAXos1nrqyn1osX76ca665hr/97W+cffbZvRlm3MW6n2pra9m4cSObN2/m+9//PtB8stVa43A4WLlyJWeeeaYtsdupK9+n3NxcBg8eTEZGRutzEyZMQGtNUVERY8aM6dWY46Er+2nJkiXMmTOHH//4xwBMnjyZlJQU5s6dyy9+8Yvj4iq/M8fjMfzzpBKSIFwuF9OnT2fVqlVtnl+1ahWzZ88Ou82sWbPatV+5ciUzZszA6XT2Wqzx1JX9BM0VkKuuuopnn332uOiTjnU/paens23bttZbeW/ZsoXrrruOcePGsWXLFk455RS7QrdVV75Pc+bM4eDBg9TV1bU+t3v3bgzDYMiQIb0ab7x0ZT81NDRgGG1PMaZpAkev9o93x+MxvJ04DYgVYbRMgXvsscf0jh079E033aRTUlL0vn37tNZa33rrrfryyy9vbd8yveuHP/yh3rFjh37ssceOi+ldse6nZ599VjscDv3ggw/qkpKS1kd1dXW8/gm2iHU/fd7xMjsm1v1UW1urhwwZoi+++GK9fft2vWbNGj1mzBh97bXXxuufYItY99MTTzyhHQ6HXrp0qf7ss8/022+/rWfMmKFnzpwZr39Cr6utrdWbN2/Wmzdv1oC+99579ebNm1unMcsxvD1JQhLMgw8+qPPz87XL5dInnXSSXrNmTetrV155pZ43b16b9qtXr9bTpk3TLpdLDx8+XD/00EM2RxwfseynefPmaaDd48orr7Q/cJvF+n061vGShGgd+37auXOnPvvss3VSUpIeMmSIvvnmm3VDQ4PNUdsv1v10//3364kTJ+qkpCSdm5urv/GNb+iioiKbo7bPW2+9FfFYI8fw9pTWUhcTQgghhP1kTIgQQggh4kKSECGEEELEhSQhQgghhIgLSUKEEEIIEReShAghhBAiLiQJEUIIIURcSBIihBBCiLiQJEQIIYQQcSFJiBBCCCHiQpIQIYQQQsSFJCFCiLg6fPgwOTk5/PKXv2x9bsOGDbhcLlauXBnHyIQQvU3uHSOEiLtXX32Viy66iHfffZfx48czbdo0zj//fO677754hyaE6EWShAghEsL3vvc9Xn/9dU4++WS2bt3KBx98gMfjiXdYQoheJEmIECIhNDY2MmnSJAoLC9m4cSOTJ0+Od0hCiF4mY0KEEAlh7969HDx4EMuy2L9/f7zDEULYIKYkZP78+dx00029FEr3vfDCC0ycOBG3283EiRNZsWJFp9ts27aNefPmkZSUxODBg7n77rs5tji0evVqlFLtHp988knMn7106VJGjBiBx+Nh+vTprFu3rs3rWmvuvPNO8vLySEpKYv78+Wzfvr2Le0OIvsPv9/ONb3yDSy+9lF/84hdcc801HDp0KN5hCSF62X9NJWT9+vVceumlXH755WzdupXLL7+cSy65hA0bNnS4jdfr5ZxzziEvL48PPviAP/7xj9xzzz3ce++97dru2rWLkpKS1seYMWNi+uzly5dz0003cdttt7F582bmzp3LwoULOXDgQGub3/zmN9x777088MADfPDBB+Tk5HDOOedQW1vbQ3tJiMR02223UVNTw/33389PfvITJkyYwDXXXBPvsIQQvU1H6corr9RAm0dBQUG0m/e6Sy65RH/hC19o89y5556rv/a1r3W4zdKlS3VGRoZuampqfW7JkiU6Ly9PW5altdb6rbfe0oCuqqrq1mfPnDlTX3fddW3ajB8/Xt96661aa60ty9I5OTn6V7/6VevrTU1NOiMjQz/88MMdfrYQfd1bb72lHQ6HXrduXetz+/fv1xkZGXrp0qVxjEwI0duiroT84Q9/YNasWXzrW99qrQYMHTo0bNvrrruO1NTUiI9jKwA9Yf369SxYsKDNc+eeey7vvvtuxG3mzZuH2+1us83BgwfZt29fm7bTpk0jNzeXs846i7feeiumz/b7/WzatKldmwULFrS2KSgooLS0tE0bt9vNvHnzIv4bhOjr5s+fTyAQ4LTTTmt9btiwYVRXV/Pd7343jpEJIXqbI9qGGRkZuFwukpOTycnJidj27rvv5pZbbonYJi8vL9qPjkppaSnZ2dltnsvOzqa0tDTiNsOHD2+3TctrI0aMIDc3l0ceeYTp06fj8/l46qmnOOuss1i9ejWnn356VJ9dXl5OKBSK2Kblv+HayCA9IYQQ/42iTkJiMWjQIAYNGtQbbx2RUqrNz1rrds9Fs82xz48bN45x48a1vj5r1iwKCwu55557WpOQaD+7p9oIIYQQ/w16ZWBqPLpjcnJy2lU9ysrK2lUWotkG2lckjnXqqaeyZ8+eqD87KysL0zQjtmmpLsX6bxBCCCH6qpiSEJfLRSgU6rTd3XffzZYtWyI+ero7ZtasWaxatarNcytXrmT27NkRt1m7di1+v7/NNnl5ee26aY61efNmcnNzo/5sl8vF9OnT27VZtWpVa5sRI0aQk5PTpo3f72fNmjUR/w1CCCFEnxXLKNZvfetb+uSTT9YFBQX68OHDOhQK9cJY2a555513tGma+le/+pXeuXOn/tWvfqUdDod+7733Wtv88Y9/1GeeeWbrz9XV1To7O1tfdtlletu2bfrFF1/U6enp+p577mlt8/vf/16vWLFC7969W3/88cf61ltv1YB+4YUXYvrs559/XjudTv3YY4/pHTt26JtuukmnpKToffv2tbb51a9+pTMyMvSLL76ot23bpi+77DKdm5urvV5vb+02IYQQIm5iSkJ27dqlTz31VJ2UlJRwU3S11vpvf/ubHjdunHY6nXr8+PFtEgWttb7jjjt0fn5+m+c++ugjPXfuXO12u3VOTo6+8847W6fnaq31r3/9az1q1Cjt8Xh0v3799GmnnaZfeeWVmD9ba60ffPBBnZ+fr10ulz7ppJP0mjVr2rxuWZa+4447dE5Ojna73fr000/X27Zt68YeEUIIIRKX3DtGCCGEEHHxX7NiqhBCCCH6FklChBBCCBEXkoQIIYQQIi4kCRFCCCFEXEgSIoQQQoi4kCRECCGEEHEhSYgQQggh4kKSECGEEELEhSQhQgghhIgLSUKEEEIIEReShAghhBAiLv4/BpXF6Gt+iZEAAAAASUVORK5CYII=\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -285,14 +286,14 @@
       "   11    1.00000    0.00000\n",
       "\u001b[33moutputting...\u001b[0m\n",
       "\u001b[33moutputting...\u001b[0m\n",
-      "vis:  0.38307738304138184\n",
-      "main:  0.06256771087646484\n"
+      "vis:  0.8160436153411865\n",
+      "main:  0.08573126792907715\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "<pyro.advection.simulation.Simulation at 0x7f606e692550>"
+       "<pyro.advection.simulation.Simulation at 0x7f0b76d20fb0>"
       ]
      },
      "execution_count": 8,
@@ -325,7 +326,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -483,7 +484,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,

From c9a084b2d256c7f1c2ab6f2f521d27756c509e71 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sun, 14 Jul 2024 17:23:48 -0400
Subject: [PATCH 08/65] use ArrayIndexer for area and volume

---
 pyro/mesh/patch.py | 101 +++++++++------------------------------------
 1 file changed, 19 insertions(+), 82 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 41cf19f88..cfca95844 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -196,54 +196,22 @@ def __init__(self, nx, ny, ng=1,
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
         # This is length of the side that is perpendicular to x.
-        self.area_x = np.full((self.qx, self.qy), self.dy)
         # self.area_x = self.dy
 
+        area_x = np.full((self.qx, self.qy), self.dy)
+        self.Ax = ArrayIndexer(area_x, grid=self)
+
         # This is length of the side that is perpendicular to y.
-        self.area_y = np.full((self.qx, self.qy), self.dx)
         # self.area_y = self.dx
 
+        area_y = np.full((self.qx, self.qy), self.dx)
+        self.Ay = ArrayIndexer(area_y, grid=self)
+
         # Volume (Area) of the cell.
-        self.vol = np.full((self.qx, self.qy), self.dx * self.dy)
         # self.vol = self.dx * self.dy
 
-    def A_x(self, i=0, buf=0):
-        """
-        Returns the area in the x(r)-direction
-
-        parameter:
-        ----------
-        i : shifts the array in the x-direction by index i
-        buf : increases the buffer size.
-        """
-        return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
-                           self.jlo+buf:self.jhi+1+buf]
-
-    def A_y(self, j=0, buf=0):
-        """
-        Returns the area in the y(theta)-direction
-        parameter:
-        ----------
-        j : shifts the array in the y-direction by index j
-        buf : increases the buffer size.
-        """
-        assert buf <= self.ng
-        return self.area_y[self.ilo+buf:self.ihi+1+buf,
-                           self.jlo+j+buf:self.jhi+1+j+buf]
-
-    def V(self, i=0, j=0, buf=0):
-        """
-        Returns the volume
-        parameter:
-        -----------
-        i : shifts the array in the x-direction by index i
-        j : shifts the array in the y-direction by index j
-        buf : increases the buffer size
-        """
-        assert buf <= self.ng
-        return self.vol[self.ilo+i+buf:self.ihi+1+i+buf,
-                        self.jlo+j+buf:self.jhi+1+j+buf]
-
+        volume = np.full((self.qx, self.qy), self.dx * self.dy)
+        self.V = ArrayIndexer(volume, grid=self)
 
 class SphericalPolar(Grid2d):
     """
@@ -266,59 +234,28 @@ def __init__(self, nx, ny, ng=1,
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
         # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        self.area_x = -2.0 * np.pi * self.xl2d**2 * \
-                      (np.cos(self.yr2d) - np.cos(self.yl2d))
+
+        area_x = -2.0 * np.pi * self.xl2d**2 * \
+                 (np.cos(self.yr2d) - np.cos(self.yl2d))
+        self.Ax = ArrayIndexer(area_x, grid=self)
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
         # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        self.area_y = 0.5 * np.pi * np.sin(self.yl2d) * \
-                      (self.xr2d**2 - self.xl2d**2)
+
+        area_y = 0.5 * np.pi * np.sin(self.yl2d) * \
+                 (self.xr2d**2 - self.xl2d**2)
+        self.Ay = ArrayIndexer(area_y, grid=self)
 
         # Returns an array of the volume of each cell.
         # dV = dL_r * dL_theta * dL_phi
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
-        self.vol = -0.6666666666666667 * np.pi * \
+
+        volume =  -0.6666666666666667 * np.pi * \
                    (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
                    (self.xr2d**3 - self.xl2d**3)
-
-    def A_x(self, i=0, buf=0):
-        """
-        Returns the area in the x(r)-direction
-        parameter:
-        ----------
-        i : shifts the array in the x-direction by index i
-        buf : increases the buffer size.
-        """
-        assert buf <= self.ng
-        return self.area_x[self.ilo+i+buf:self.ihi+1+i+buf,
-                           self.jlo+buf:self.jhi+1+buf]
-
-    def A_y(self, j=0, buf=0):
-        """
-        Returns the area in the y(theta)-direction
-        parameter:
-        ----------
-        j : shifts the array in the y-direction by index j
-        buf : increases the buffer size.
-        """
-        assert buf <= self.ng
-        return self.area_y[self.ilo+buf:self.ihi+1+buf,
-                           self.jlo+j+buf:self.jhi+1+j+buf]
-
-    def V(self, i=0, j=0, buf=0):
-        """
-        Returns the volume
-        parameter:
-        -----------
-        i : shifts the array in the x-direction by index i
-        j : shifts the array in the y-direction by index j
-        buf : increases the buffer size
-        """
-        assert buf <= self.ng
-        return self.vol[self.ilo+i+buf:self.ihi+1+i+buf,
-                        self.jlo+j+buf:self.jhi+1+j+buf]
+        self.V = ArrayIndexer(volume, grid=self)
 
 
 class CellCenterData2d:

From 8f26cb14a41c22ca90b3cc9cb6cb864939b17b12 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sun, 14 Jul 2024 17:32:31 -0400
Subject: [PATCH 09/65] fix flake8

---
 pyro/mesh/patch.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index cfca95844..c3272ed6b 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -213,6 +213,7 @@ def __init__(self, nx, ny, ng=1,
         volume = np.full((self.qx, self.qy), self.dx * self.dy)
         self.V = ArrayIndexer(volume, grid=self)
 
+
 class SphericalPolar(Grid2d):
     """
     This class defines a spherical polar grid.
@@ -252,9 +253,9 @@ def __init__(self, nx, ny, ng=1,
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
-        volume =  -0.6666666666666667 * np.pi * \
-                   (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
-                   (self.xr2d**3 - self.xl2d**3)
+        volume = -0.6666666666666667 * np.pi * \
+                 (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
+                 (self.xr2d**3 - self.xl2d**3)
         self.V = ArrayIndexer(volume, grid=self)
 
 

From c823b37ebcf03f2cc693826d5092618f974f17ff Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 16 Jul 2024 15:34:16 -0400
Subject: [PATCH 10/65] add unit test to cartesian2d and spherical polar

---
 pyro/mesh/patch.py            |  2 +-
 pyro/mesh/tests/test_patch.py | 83 +++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index c3272ed6b..b5e5aa2ee 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -253,7 +253,7 @@ def __init__(self, nx, ny, ng=1,
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
-        volume = -0.6666666666666667 * np.pi * \
+        volume = -2.0 * np.pi / 3.0 * \
                  (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
                  (self.xr2d**3 - self.xl2d**3)
         self.V = ArrayIndexer(volume, grid=self)
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index ebad931ff..27d1db9d5 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -68,6 +68,89 @@ def test_equality(self):
         assert g2 != self.g
 
 
+# Cartesian2d tests
+class TestCartesian2d:
+    @classmethod
+    def setup_class(cls):
+        """ this is run once for each class before any tests """
+
+    @classmethod
+    def teardown_class(cls):
+        """ this is run once for each class after all tests """
+
+    def setup_method(self):
+        """ this is run before each test """
+        self.g = patch.Cartesian2d(4, 10, ng=2)
+
+    def teardown_method(self):
+        """ this is run after each test """
+        self.g = None
+
+    def test_Ax(self):
+        assert np.all(self.g.Ax.v() == 0.1)
+
+    def test_Ay(self):
+        assert np.all(self.g.Ay.v() == 0.25)
+
+    def test_V(self):
+        assert np.all(self.g.V.v() == 0.1 * 0.25)
+
+
+# SphericalPolar Grid tests
+class TestSphericalPolar:
+    @classmethod
+    def setup_class(cls):
+        """ this is run once for each class before any tests """
+
+    @classmethod
+    def teardown_class(cls):
+        """ this is run once for each class after all tests """
+
+    def setup_method(self):
+        """ this is run before each test """
+        self.g = patch.SphericalPolar(4, 10, ymax=np.pi, ng=2)
+
+    def teardown_method(self):
+        """ this is run after each test """
+        self.g = None
+
+    def test_Ax(self):
+        ilo = self.g.ilo
+        ihi = self.g.ihi
+        jlo = self.g.jlo
+        jhi = self.g.jhi
+
+        area_x = -2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 * \
+                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
+                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]))
+
+        assert_array_equal(self.g.Ax.v(), area_x)
+
+    def test_Ay(self):
+        ilo = self.g.ilo
+        ihi = self.g.ihi
+        jlo = self.g.jlo
+        jhi = self.g.jhi
+
+        area_y = 0.5 * np.pi * np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]) * \
+                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
+                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2)
+        assert_array_equal(self.g.Ay.v(), area_y)
+
+    def test_V(self):
+        ilo = self.g.ilo
+        ihi = self.g.ihi
+        jlo = self.g.jlo
+        jhi = self.g.jhi
+
+        volume = -2.0 * np.pi / 3.0 * \
+                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
+                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) * \
+                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**3 -
+                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**3)
+        assert_array_equal(self.g.V.v(), volume)
+
+
 # CellCenterData2d tests
 class TestCellCenterData2d:
     @classmethod

From c921ebbb766e41e3cfd16a582ce0e76db88b62c7 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 16 Jul 2024 18:31:58 -0400
Subject: [PATCH 11/65] add __str__ and update mesh-example to demonstrate
 sphericalPolar grid with a simple pcolormesh plot

---
 pyro/mesh/mesh-examples.ipynb | 131 ++++++++++++++++++++++++++++++++--
 pyro/mesh/patch.py            |  33 ++++++---
 pyro/mesh/tests/test_patch.py |  14 ++--
 3 files changed, 159 insertions(+), 19 deletions(-)

diff --git a/pyro/mesh/mesh-examples.ipynb b/pyro/mesh/mesh-examples.ipynb
index a678b8555..c6d824442 100644
--- a/pyro/mesh/mesh-examples.ipynb
+++ b/pyro/mesh/mesh-examples.ipynb
@@ -68,7 +68,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2-d grid: nx = 4, ny = 6, ng = 2\n"
+      "2-D Grid: nx = 4, ny = 6, ng = 2\n"
      ]
     }
    ],
@@ -384,7 +384,7 @@
     {
      "data": {
       "text/plain": [
-       "np.float64(0.5749769043407793)"
+       "0.5749769043407793"
       ]
      },
      "execution_count": 10,
@@ -742,9 +742,9 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 960x720 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -865,6 +865,127 @@
    "source": [
     "f.pretty_print(fmt=\"%6.2g\")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Spherical Polar Grid"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Demonstrating the grid with matplotlib pcolormesh"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = patch.SphericalPolar(4, 8, xmin=1.0, xmax=2.0, ymin=0.0, ymax=np.pi, ng=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Spherical Polar 2D Grid: Define x : r, y : θ. xmin (r) = 1.0, xmax= 2.0, ymin = 0.0, ymax = 3.141592653589793, nx = 4, ny = 8, ng = 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[31m     0.13\u001b[0m\u001b[31m     0.26\u001b[0m\u001b[31m     0.43\u001b[0m\u001b[31m     0.65\u001b[0m\u001b[31m      0.9\u001b[0m\u001b[31m      1.2\u001b[0m\u001b[31m      1.5\u001b[0m\u001b[31m      1.9\u001b[0m \n",
+      "\u001b[31m    0.047\u001b[0m\u001b[31m    0.092\u001b[0m\u001b[31m     0.15\u001b[0m\u001b[31m     0.23\u001b[0m\u001b[31m     0.32\u001b[0m\u001b[31m     0.42\u001b[0m\u001b[31m     0.54\u001b[0m\u001b[31m     0.68\u001b[0m \n",
+      "\u001b[31m    0.047\u001b[0m\u001b[31m    0.092\u001b[0m     0.15     0.23     0.32     0.42\u001b[31m     0.54\u001b[0m\u001b[31m     0.68\u001b[0m \n",
+      "\u001b[31m     0.13\u001b[0m\u001b[31m     0.26\u001b[0m     0.43     0.65      0.9      1.2\u001b[31m      1.5\u001b[0m\u001b[31m      1.9\u001b[0m \n",
+      "\u001b[31m      0.2\u001b[0m\u001b[31m     0.39\u001b[0m     0.65     0.97      1.3      1.8\u001b[31m      2.3\u001b[0m\u001b[31m      2.9\u001b[0m \n",
+      "\u001b[31m     0.24\u001b[0m\u001b[31m     0.46\u001b[0m     0.76      1.1      1.6      2.1\u001b[31m      2.7\u001b[0m\u001b[31m      3.4\u001b[0m \n",
+      "\u001b[31m     0.24\u001b[0m\u001b[31m     0.46\u001b[0m     0.76      1.1      1.6      2.1\u001b[31m      2.7\u001b[0m\u001b[31m      3.4\u001b[0m \n",
+      "\u001b[31m      0.2\u001b[0m\u001b[31m     0.39\u001b[0m     0.65     0.97      1.3      1.8\u001b[31m      2.3\u001b[0m\u001b[31m      2.9\u001b[0m \n",
+      "\u001b[31m     0.13\u001b[0m\u001b[31m     0.26\u001b[0m     0.43     0.65      0.9      1.2\u001b[31m      1.5\u001b[0m\u001b[31m      1.9\u001b[0m \n",
+      "\u001b[31m    0.047\u001b[0m\u001b[31m    0.092\u001b[0m     0.15     0.23     0.32     0.42\u001b[31m     0.54\u001b[0m\u001b[31m     0.68\u001b[0m \n",
+      "\u001b[31m    0.047\u001b[0m\u001b[31m    0.092\u001b[0m\u001b[31m     0.15\u001b[0m\u001b[31m     0.23\u001b[0m\u001b[31m     0.32\u001b[0m\u001b[31m     0.42\u001b[0m\u001b[31m     0.54\u001b[0m\u001b[31m     0.68\u001b[0m \n",
+      "\u001b[31m     0.13\u001b[0m\u001b[31m     0.26\u001b[0m\u001b[31m     0.43\u001b[0m\u001b[31m     0.65\u001b[0m\u001b[31m      0.9\u001b[0m\u001b[31m      1.2\u001b[0m\u001b[31m      1.5\u001b[0m\u001b[31m      1.9\u001b[0m \n",
+      "\n",
+      "         ^ y\n",
+      "         |\n",
+      "         +---> x\n",
+      "        \n"
+     ]
+    }
+   ],
+   "source": [
+    "g.V.pretty_print(fmt=\"%9.2g\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_437854/1203560559.py:8: UserWarning: The input coordinates to pcolormesh are interpreted as cell centers, but are not monotonically increasing or decreasing. This may lead to incorrectly calculated cell edges, in which case, please supply explicit cell edges to pcolormesh.\n",
+      "  plt.pcolormesh(x, y, g.V.v(), cmap='viridis', shading='auto')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "r = g.x2d[g.ilo:g.ihi+1, g.jlo:g.jhi+1]\n",
+    "theta = g.y2d[g.ilo:g.ihi+1, g.jlo:g.jhi+1]\n",
+    "\n",
+    "x = r*np.sin(theta)\n",
+    "y = r*np.cos(theta)\n",
+    "\n",
+    "plt.figure(figsize=(6, 6))\n",
+    "plt.pcolormesh(x, y, g.V.v(), cmap='viridis', shading='auto')\n",
+    "plt.colorbar(label='Volume')\n",
+    "plt.title('Spherical Polar Grid')\n",
+    "plt.xlabel('X')\n",
+    "plt.ylabel('Y')\n",
+    "plt.axis('equal')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -884,7 +1005,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index b5e5aa2ee..f6da241b3 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -169,7 +169,7 @@ def fine_like(self, N):
 
     def __str__(self):
         """ print out some basic information about the grid object """
-        return f"2-d grid: nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
+        return f"2-D Grid: nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
 
     def __eq__(self, other):
         """ are two grids equivalent? """
@@ -213,6 +213,12 @@ def __init__(self, nx, ny, ng=1,
         volume = np.full((self.qx, self.qy), self.dx * self.dy)
         self.V = ArrayIndexer(volume, grid=self)
 
+    def __str__(self):
+        """ print out some basic information about the grid object """
+        return f"Cartesian 2D Grid: xmin = {self.xmin}, xmax = {self.xmax}, " + \
+               f"ymin = {self.ymin}, ymax = {self.ymax}, " + \
+               f"nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
+
 
 class SphericalPolar(Grid2d):
     """
@@ -225,26 +231,30 @@ class SphericalPolar(Grid2d):
     """
 
     def __init__(self, nx, ny, ng=1,
-                 xmin=0.0, xmax=1.0, ymin=0.0, ymax=1.0):
+                 xmin=0.2, xmax=1.0, ymin=0.0, ymax=1.0):
 
         # Make sure theta is within [0, PI]
+        assert ymin >= 0.0 and ymax <= np.pi, "y or \u03b8 should be within [0, \u03c0]."
+
+        # Make sure the ghost cells doesn't extend out negative x(r)
+        assert xmin - ng*(xmax-xmin)/nx >= 0.0, \
+            "xmin (r-direction), must be large enough so ghost cell doesn't have negative x."
 
-        assert ymin >= 0.0 and ymax <= np.pi
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
         # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
 
-        area_x = -2.0 * np.pi * self.xl2d**2 * \
-                 (np.cos(self.yr2d) - np.cos(self.yl2d))
+        area_x = np.abs(-2.0 * np.pi * self.xl2d**2 * \
+                 (np.cos(self.yr2d) - np.cos(self.yl2d)))
         self.Ax = ArrayIndexer(area_x, grid=self)
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
         # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
 
-        area_y = 0.5 * np.pi * np.sin(self.yl2d) * \
+        area_y = 0.5 * np.pi * np.abs(np.sin(self.yl2d)) * \
                  (self.xr2d**2 - self.xl2d**2)
         self.Ay = ArrayIndexer(area_y, grid=self)
 
@@ -253,11 +263,18 @@ def __init__(self, nx, ny, ng=1,
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
-        volume = -2.0 * np.pi / 3.0 * \
+        volume = np.abs(-2.0 * np.pi / 3.0 * \
                  (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
-                 (self.xr2d**3 - self.xl2d**3)
+                 (self.xr2d**3 - self.xl2d**3))
         self.V = ArrayIndexer(volume, grid=self)
 
+    def __str__(self):
+        """ print out some basic information about the grid object """
+        return f"Spherical Polar 2D Grid: Define x : r, y : \u03b8. " + \
+               f"xmin (r) = {self.xmin}, xmax= {self.xmax}, " + \
+               f"ymin = {self.ymin}, ymax = {self.ymax}, " + \
+               f"nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
+
 
 class CellCenterData2d:
     """
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index 27d1db9d5..3f5cc390d 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -108,7 +108,8 @@ def teardown_class(cls):
 
     def setup_method(self):
         """ this is run before each test """
-        self.g = patch.SphericalPolar(4, 10, ymax=np.pi, ng=2)
+        self.g = patch.SphericalPolar(4, 10, xmin=1.0, xmax=2.0,
+                                      ymax=np.pi, ng=2)
 
     def teardown_method(self):
         """ this is run after each test """
@@ -120,9 +121,9 @@ def test_Ax(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_x = -2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 * \
+        area_x = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 * \
                  (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
-                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]))
+                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
 
         assert_array_equal(self.g.Ax.v(), area_x)
 
@@ -132,7 +133,8 @@ def test_Ay(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_y = 0.5 * np.pi * np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]) * \
+        area_y = 0.5 * np.pi * \
+                 np.abs(np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) * \
                  (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
                   self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2)
         assert_array_equal(self.g.Ay.v(), area_y)
@@ -143,11 +145,11 @@ def test_V(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        volume = -2.0 * np.pi / 3.0 * \
+        volume = np.abs(-2.0 * np.pi / 3.0 * \
                  (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
                   np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) * \
                  (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**3 -
-                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**3)
+                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**3))
         assert_array_equal(self.g.V.v(), volume)
 
 

From 2174795224fbf421a73f78f628e83e4e011e4479 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 16 Jul 2024 18:34:25 -0400
Subject: [PATCH 12/65] fix flake8

---
 pyro/mesh/patch.py            | 12 ++++++------
 pyro/mesh/tests/test_patch.py | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index f6da241b3..0025410a2 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -246,7 +246,7 @@ def __init__(self, nx, ny, ng=1,
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
         # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
 
-        area_x = np.abs(-2.0 * np.pi * self.xl2d**2 * \
+        area_x = np.abs(-2.0 * np.pi * self.xl2d**2 *
                  (np.cos(self.yr2d) - np.cos(self.yl2d)))
         self.Ax = ArrayIndexer(area_x, grid=self)
 
@@ -254,8 +254,8 @@ def __init__(self, nx, ny, ng=1,
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
         # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
 
-        area_y = 0.5 * np.pi * np.abs(np.sin(self.yl2d)) * \
-                 (self.xr2d**2 - self.xl2d**2)
+        area_y = np.abs(0.5 * np.pi * np.sin(self.yl2d) *
+                 (self.xr2d**2 - self.xl2d**2))
         self.Ay = ArrayIndexer(area_y, grid=self)
 
         # Returns an array of the volume of each cell.
@@ -263,14 +263,14 @@ def __init__(self, nx, ny, ng=1,
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
-        volume = np.abs(-2.0 * np.pi / 3.0 * \
-                 (np.cos(self.yr2d) - np.cos(self.yl2d)) * \
+        volume = np.abs(-2.0 * np.pi / 3.0 *
+                 (np.cos(self.yr2d) - np.cos(self.yl2d)) *
                  (self.xr2d**3 - self.xl2d**3))
         self.V = ArrayIndexer(volume, grid=self)
 
     def __str__(self):
         """ print out some basic information about the grid object """
-        return f"Spherical Polar 2D Grid: Define x : r, y : \u03b8. " + \
+        return "Spherical Polar 2D Grid: Define x : r, y : \u03b8. " + \
                f"xmin (r) = {self.xmin}, xmax= {self.xmax}, " + \
                f"ymin = {self.ymin}, ymax = {self.ymax}, " + \
                f"nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index 3f5cc390d..9fdc1a3c6 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -121,7 +121,7 @@ def test_Ax(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_x = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 * \
+        area_x = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 *
                  (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
                   np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
 
@@ -133,10 +133,10 @@ def test_Ay(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_y = 0.5 * np.pi * \
-                 np.abs(np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) * \
+        area_y = np.abs(0.5 * np.pi *
+                 np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]) *
                  (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
-                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2)
+                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2))
         assert_array_equal(self.g.Ay.v(), area_y)
 
     def test_V(self):
@@ -145,9 +145,9 @@ def test_V(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        volume = np.abs(-2.0 * np.pi / 3.0 * \
+        volume = np.abs(-2.0 * np.pi / 3.0 *
                  (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
-                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) * \
+                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) *
                  (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**3 -
                   self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**3))
         assert_array_equal(self.g.V.v(), volume)

From c0e9164bd452f5ad6b6c593dbd8a43abec26b1cc Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 16 Jul 2024 18:46:51 -0400
Subject: [PATCH 13/65] fix pytest

---
 pyro/mesh/mesh-examples.ipynb | 16 +++++-----------
 pyro/mesh/patch.py            |  2 +-
 2 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/pyro/mesh/mesh-examples.ipynb b/pyro/mesh/mesh-examples.ipynb
index c6d824442..53581b624 100644
--- a/pyro/mesh/mesh-examples.ipynb
+++ b/pyro/mesh/mesh-examples.ipynb
@@ -24,6 +24,8 @@
     "import pyro.mesh.boundary as bnd\n",
     "import pyro.mesh.patch as patch\n",
     "import matplotlib.pyplot as plt\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
     "%matplotlib inline\n",
     "\n",
     "# for unit testing, we want to ensure the same random numbers\n",
@@ -68,7 +70,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2-D Grid: nx = 4, ny = 6, ng = 2\n"
+      "2-d grid: nx = 4, ny = 6, ng = 2\n"
      ]
     }
    ],
@@ -742,7 +744,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -944,17 +946,9 @@
    "execution_count": 30,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_437854/1203560559.py:8: UserWarning: The input coordinates to pcolormesh are interpreted as cell centers, but are not monotonically increasing or decreasing. This may lead to incorrectly calculated cell edges, in which case, please supply explicit cell edges to pcolormesh.\n",
-      "  plt.pcolormesh(x, y, g.V.v(), cmap='viridis', shading='auto')\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
       ]
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 0025410a2..619e7e66d 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -169,7 +169,7 @@ def fine_like(self, N):
 
     def __str__(self):
         """ print out some basic information about the grid object """
-        return f"2-D Grid: nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
+        return f"2-d grid: nx = {self.nx}, ny = {self.ny}, ng = {self.ng}"
 
     def __eq__(self, other):
         """ are two grids equivalent? """

From 1de6124a36c658649776981b6cc39dbcc19a473f Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 16 Jul 2024 18:52:54 -0400
Subject: [PATCH 14/65] update notebook

---
 pyro/mesh/mesh-examples.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyro/mesh/mesh-examples.ipynb b/pyro/mesh/mesh-examples.ipynb
index 53581b624..aa4f48b7b 100644
--- a/pyro/mesh/mesh-examples.ipynb
+++ b/pyro/mesh/mesh-examples.ipynb
@@ -386,7 +386,7 @@
     {
      "data": {
       "text/plain": [
-       "0.5749769043407793"
+       "np.float64(0.5749769043407793)"
       ]
      },
      "execution_count": 10,

From b93c18714d478b210492ff3489c2d240edd8293b Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Fri, 19 Jul 2024 23:50:12 -0400
Subject: [PATCH 15/65] add left and right area

---
 pyro/mesh/patch.py            | 31 ++++++++++++++++++++-----------
 pyro/mesh/tests/test_patch.py | 24 ++++++++++++++++++------
 2 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 619e7e66d..1bb9539e0 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -196,19 +196,18 @@ def __init__(self, nx, ny, ng=1,
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
         # This is length of the side that is perpendicular to x.
-        # self.area_x = self.dy
 
         area_x = np.full((self.qx, self.qy), self.dy)
-        self.Ax = ArrayIndexer(area_x, grid=self)
+        self.Ax_l = ArrayIndexer(area_x, grid=self)
+        self.Ax_r = ArrayIndexer(area_x, grid=self)
 
         # This is length of the side that is perpendicular to y.
-        # self.area_y = self.dx
 
         area_y = np.full((self.qx, self.qy), self.dx)
-        self.Ay = ArrayIndexer(area_y, grid=self)
+        self.Ay_l = ArrayIndexer(area_y, grid=self)
+        self.Ay_r = ArrayIndexer(area_y, grid=self)
 
         # Volume (Area) of the cell.
-        # self.vol = self.dx * self.dy
 
         volume = np.full((self.qx, self.qy), self.dx * self.dy)
         self.V = ArrayIndexer(volume, grid=self)
@@ -244,19 +243,29 @@ def __init__(self, nx, ny, ng=1,
 
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
-        # dA_r = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
 
-        area_x = np.abs(-2.0 * np.pi * self.xl2d**2 *
+        # dAr_l = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
+        area_x_l = np.abs(-2.0 * np.pi * self.xl2d**2 *
                  (np.cos(self.yr2d) - np.cos(self.yl2d)))
-        self.Ax = ArrayIndexer(area_x, grid=self)
+        self.Ax_l = ArrayIndexer(area_x_l, grid=self)
+
+        # dAr_r = - r{i+1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
+        area_x_r = np.abs(-2.0 * np.pi * self.xr2d**2 *
+                 (np.cos(self.yr2d) - np.cos(self.yl2d)))
+        self.Ax_r = ArrayIndexer(area_x_r, grid=self)
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
-        # dA_theta = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
 
-        area_y = np.abs(0.5 * np.pi * np.sin(self.yl2d) *
+        # dAtheta_l = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
+        area_y_l = np.abs(0.5 * np.pi * np.sin(self.yl2d) *
+                 (self.xr2d**2 - self.xl2d**2))
+        self.Ay_l = ArrayIndexer(area_y_l, grid=self)
+
+        # dAtheta_r = 0.5 * pi * sin(theta{i+1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
+        area_y_r = np.abs(0.5 * np.pi * np.sin(self.yr2d) *
                  (self.xr2d**2 - self.xl2d**2))
-        self.Ay = ArrayIndexer(area_y, grid=self)
+        self.Ay_r = ArrayIndexer(area_y_r, grid=self)
 
         # Returns an array of the volume of each cell.
         # dV = dL_r * dL_theta * dL_phi
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index 9fdc1a3c6..fb6a108b5 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -87,10 +87,12 @@ def teardown_method(self):
         self.g = None
 
     def test_Ax(self):
-        assert np.all(self.g.Ax.v() == 0.1)
+        assert np.all(self.g.Ax_l.v() == 0.1)
+        assert np.all(self.g.Ax_r.v() == 0.1)
 
     def test_Ay(self):
-        assert np.all(self.g.Ay.v() == 0.25)
+        assert np.all(self.g.Ay_l.v() == 0.25)
+        assert np.all(self.g.Ay_r.v() == 0.25)
 
     def test_V(self):
         assert np.all(self.g.V.v() == 0.1 * 0.25)
@@ -121,11 +123,15 @@ def test_Ax(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_x = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 *
+        area_x_l = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 *
                  (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
                   np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
+        assert_array_equal(self.g.Ax_l.v(), area_x_l)
 
-        assert_array_equal(self.g.Ax.v(), area_x)
+        area_x_r = np.abs(-2.0 * np.pi * self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 *
+                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
+                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
+        assert_array_equal(self.g.Ax_r.v(), area_x_r)
 
     def test_Ay(self):
         ilo = self.g.ilo
@@ -133,11 +139,17 @@ def test_Ay(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_y = np.abs(0.5 * np.pi *
+        area_y_l = np.abs(0.5 * np.pi *
                  np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]) *
                  (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
                   self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2))
-        assert_array_equal(self.g.Ay.v(), area_y)
+        assert_array_equal(self.g.Ay_l.v(), area_y_l)
+
+        area_y_r = np.abs(0.5 * np.pi *
+                 np.sin(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) *
+                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
+                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2))
+        assert_array_equal(self.g.Ay_r.v(), area_y_r)
 
     def test_V(self):
         ilo = self.g.ilo

From 1bdecc7b60d9603e80f2f57eeea1d3d237ee9d4b Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sat, 20 Jul 2024 00:23:45 -0400
Subject: [PATCH 16/65] update conservative update

---
 pyro/compressible/interface.py  | 7 ++++---
 pyro/compressible/simulation.py | 9 ++++-----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 6f4646863..7057a5d8e 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -133,13 +133,13 @@ def states(idir, ng, dx, dt,
                                  q[irho] / cs, 0.0, 0.5 / (cs * cs)]
                 lvec[1, :ns] = [1.0, 0.0,
                                  0.0, -1.0 / (cs * cs)]
-                lvec[2, :ns] = [0.0, 0.0,             1.0, 0.0]
+                lvec[2, :ns] = [0.0, 0.0, 1.0, 0.0]
                 lvec[3, :ns] = [0.0, 0.5 *
                                  q[irho] / cs,  0.0, 0.5 / (cs * cs)]
 
                 rvec[0, :ns] = [1.0, -cs / q[irho], 0.0, cs * cs]
-                rvec[1, :ns] = [1.0, 0.0,       0.0, 0.0]
-                rvec[2, :ns] = [0.0, 0.0,       1.0, 0.0]
+                rvec[1, :ns] = [1.0, 0.0, 0.0, 0.0]
+                rvec[2, :ns] = [0.0, 0.0, 1.0, 0.0]
                 rvec[3, :ns] = [1.0, cs / q[irho],  0.0, cs * cs]
 
                 # now the species -- they only have a 1 in their corresponding slot
@@ -194,6 +194,7 @@ def states(idir, ng, dx, dt,
             for m in range(nvar):
                 asum = np.dot(lvec[m, :], dq)
 
+                # Should we change to max(e_val[3], 0.0) and min(e_val[0], 0.0)?
                 betal[m] = dtdx4 * (e_val[3] - e_val[m]) * \
                     (np.copysign(1.0, e_val[m]) + 1.0) * asum
                 betar[m] = dtdx4 * (e_val[0] - e_val[m]) * \
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index d308f1665..0b2594583 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -207,15 +207,14 @@ def evolve(self):
         old_ymom = ymom.copy()
 
         # conservative update
-        dtdx = self.dt/myg.dx
-        dtdy = self.dt/myg.dy
+        dtdV = self.dt / g.V.v(n=n)
 
         for n in range(self.ivars.nvar):
             var = self.cc_data.get_var_by_index(n)
 
-            var.v()[:, :] += \
-                dtdx*(Flux_x.v(n=n) - Flux_x.ip(1, n=n)) + \
-                dtdy*(Flux_y.v(n=n) - Flux_y.jp(1, n=n))
+            var.v()[:, :] += dtdV * \
+                (Flux_x.v(n=n)*g.Ax_l.v(n=n) - Flux_x.ip(1, n=n)*g.Ax_r.v(n=n) +
+                 Flux_y.v(n=n)*g.Ay_l.v(n=n) - Flux_y.jp(1, n=n)*g.Ay_r.v(n=n))
 
         # gravitational source terms
         ymom[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav

From 1dab7aec9d536010a36e5d4204802b0a6e47527d Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sat, 20 Jul 2024 00:47:20 -0400
Subject: [PATCH 17/65] change x2d y2d to arrayindexer

---
 pyro/mesh/patch.py            | 38 +++++++++++++++++++++++------------
 pyro/mesh/tests/test_patch.py | 26 +++++++++---------------
 2 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 1bb9539e0..32ff7c92d 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -134,9 +134,17 @@ def __init__(self, nx, ny, ng=1,
         self.y = 0.5*(self.yl + self.yr)
 
         # 2-d versions of the zone coordinates
-        self.x2d, self.y2d = np.meshgrid(self.x, self.y, indexing='ij')
-        self.xl2d, self.yl2d = np.meshgrid(self.xl, self.yl, indexing='ij')
-        self.xr2d, self.yr2d = np.meshgrid(self.xr, self.yr, indexing='ij')
+        x2d, y2d = np.meshgrid(self.x, self.y, indexing='ij')
+        self.x2d = ArrayIndexer(d=x2d, grid=self)
+        self.y2d = ArrayIndexer(d=y2d, grid=self)
+
+        xl2d, yl2d = np.meshgrid(self.xl, self.yl, indexing='ij')
+        self.xl2d = ArrayIndexer(d=xl2d, grid=self)
+        self.yl2d = ArrayIndexer(d=yl2d, grid=self)
+
+        xr2d, yr2d = np.meshgrid(self.xr, self.yr, indexing='ij')
+        self.xr2d = ArrayIndexer(d=xr2d, grid=self)
+        self.yr2d = ArrayIndexer(d=yr2d, grid=self)
 
     def scratch_array(self, nvar=1):
         """
@@ -245,26 +253,30 @@ def __init__(self, nx, ny, ng=1,
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
 
         # dAr_l = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        area_x_l = np.abs(-2.0 * np.pi * self.xl2d**2 *
-                 (np.cos(self.yr2d) - np.cos(self.yl2d)))
+        area_x_l = np.abs(-2.0 * np.pi * self.xl2d.v(buf=self.ng)**2 *
+                 (np.cos(self.yr2d.v(buf=self.ng)) -
+                  np.cos(self.yl2d.v(buf=self.ng))))
         self.Ax_l = ArrayIndexer(area_x_l, grid=self)
 
         # dAr_r = - r{i+1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        area_x_r = np.abs(-2.0 * np.pi * self.xr2d**2 *
-                 (np.cos(self.yr2d) - np.cos(self.yl2d)))
+        area_x_r = np.abs(-2.0 * np.pi * self.xr2d.v(buf=self.ng)**2 *
+                 (np.cos(self.yr2d.v(buf=self.ng)) -
+                  np.cos(self.yl2d.v(buf=self.ng))))
         self.Ax_r = ArrayIndexer(area_x_r, grid=self)
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
 
         # dAtheta_l = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        area_y_l = np.abs(0.5 * np.pi * np.sin(self.yl2d) *
-                 (self.xr2d**2 - self.xl2d**2))
+        area_y_l = np.abs(0.5 * np.pi * np.sin(self.yl2d.v(buf=self.ng)) *
+                 (self.xr2d.v(buf=self.ng)**2 -
+                  self.xl2d.v(buf=self.ng)**2))
         self.Ay_l = ArrayIndexer(area_y_l, grid=self)
 
         # dAtheta_r = 0.5 * pi * sin(theta{i+1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        area_y_r = np.abs(0.5 * np.pi * np.sin(self.yr2d) *
-                 (self.xr2d**2 - self.xl2d**2))
+        area_y_r = np.abs(0.5 * np.pi * np.sin(self.yr2d.v(buf=self.ng)) *
+                 (self.xr2d.v(buf=self.ng)**2 -
+                  self.xl2d.v(buf=self.ng)**2))
         self.Ay_r = ArrayIndexer(area_y_r, grid=self)
 
         # Returns an array of the volume of each cell.
@@ -273,8 +285,8 @@ def __init__(self, nx, ny, ng=1,
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
         volume = np.abs(-2.0 * np.pi / 3.0 *
-                 (np.cos(self.yr2d) - np.cos(self.yl2d)) *
-                 (self.xr2d**3 - self.xl2d**3))
+                 (np.cos(self.yr2d.v(buf=self.ng)) - np.cos(self.yl2d.v(buf=self.ng))) *
+                 (self.xr2d.v(buf=self.ng)**3 - self.xl2d.v(buf=self.ng)**3))
         self.V = ArrayIndexer(volume, grid=self)
 
     def __str__(self):
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index fb6a108b5..fa94db390 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -123,14 +123,12 @@ def test_Ax(self):
         jlo = self.g.jlo
         jhi = self.g.jhi
 
-        area_x_l = np.abs(-2.0 * np.pi * self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2 *
-                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
-                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
+        area_x_l = np.abs(-2.0 * np.pi * self.g.xl2d.v()**2 *
+                 (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())))
         assert_array_equal(self.g.Ax_l.v(), area_x_l)
 
-        area_x_r = np.abs(-2.0 * np.pi * self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 *
-                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
-                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])))
+        area_x_r = np.abs(-2.0 * np.pi * self.g.xr2d.v()**2 *
+                 (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())))
         assert_array_equal(self.g.Ax_r.v(), area_x_r)
 
     def test_Ay(self):
@@ -140,15 +138,13 @@ def test_Ay(self):
         jhi = self.g.jhi
 
         area_y_l = np.abs(0.5 * np.pi *
-                 np.sin(self.g.yl2d[ilo:ihi+1, jlo:jhi+1]) *
-                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
-                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2))
+                 np.sin(self.g.yl2d.v()) *
+                 (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
         assert_array_equal(self.g.Ay_l.v(), area_y_l)
 
         area_y_r = np.abs(0.5 * np.pi *
-                 np.sin(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) *
-                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**2 -
-                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**2))
+                 np.sin(self.g.yr2d.v()) *
+                 (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
         assert_array_equal(self.g.Ay_r.v(), area_y_r)
 
     def test_V(self):
@@ -158,10 +154,8 @@ def test_V(self):
         jhi = self.g.jhi
 
         volume = np.abs(-2.0 * np.pi / 3.0 *
-                 (np.cos(self.g.yr2d[ilo:ihi+1, jlo:jhi+1]) -
-                  np.cos(self.g.yl2d[ilo:ihi+1, jlo:jhi+1])) *
-                 (self.g.xr2d[ilo:ihi+1, jlo:jhi+1]**3 -
-                  self.g.xl2d[ilo:ihi+1, jlo:jhi+1]**3))
+                 (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())) *
+                 (self.g.xr2d.v()**3 - self.g.xl2d.v()**3))
         assert_array_equal(self.g.V.v(), volume)
 
 

From 1ebe1ad2629620798b25b25d20227ddb0aa90bf3 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sat, 20 Jul 2024 10:04:01 -0400
Subject: [PATCH 18/65] remove unused variable

---
 pyro/mesh/tests/test_patch.py | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index fa94db390..7ad296b9c 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -118,11 +118,6 @@ def teardown_method(self):
         self.g = None
 
     def test_Ax(self):
-        ilo = self.g.ilo
-        ihi = self.g.ihi
-        jlo = self.g.jlo
-        jhi = self.g.jhi
-
         area_x_l = np.abs(-2.0 * np.pi * self.g.xl2d.v()**2 *
                  (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())))
         assert_array_equal(self.g.Ax_l.v(), area_x_l)
@@ -132,11 +127,6 @@ def test_Ax(self):
         assert_array_equal(self.g.Ax_r.v(), area_x_r)
 
     def test_Ay(self):
-        ilo = self.g.ilo
-        ihi = self.g.ihi
-        jlo = self.g.jlo
-        jhi = self.g.jhi
-
         area_y_l = np.abs(0.5 * np.pi *
                  np.sin(self.g.yl2d.v()) *
                  (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
@@ -148,11 +138,6 @@ def test_Ay(self):
         assert_array_equal(self.g.Ay_r.v(), area_y_r)
 
     def test_V(self):
-        ilo = self.g.ilo
-        ihi = self.g.ihi
-        jlo = self.g.jlo
-        jhi = self.g.jhi
-
         volume = np.abs(-2.0 * np.pi / 3.0 *
                  (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())) *
                  (self.g.xr2d.v()**3 - self.g.xl2d.v()**3))

From acc3a307b5a140f5079cf6842fd047923006d645 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Sat, 20 Jul 2024 22:24:31 -0400
Subject: [PATCH 19/65] fix dtdV

---
 pyro/compressible/simulation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 0b2594583..45f8b90c5 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -207,7 +207,7 @@ def evolve(self):
         old_ymom = ymom.copy()
 
         # conservative update
-        dtdV = self.dt / g.V.v(n=n)
+        dtdV = self.dt / g.V.v()
 
         for n in range(self.ivars.nvar):
             var = self.cc_data.get_var_by_index(n)

From bb91e21cf2ae643eab04c5bd68d09078dcd82d4a Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 11:21:08 -0400
Subject: [PATCH 20/65] add differential length of each direction

---
 pyro/mesh/patch.py | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 32ff7c92d..55f09b25b 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -203,22 +203,27 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
-        # This is length of the side that is perpendicular to x.
+        # Length of the side in x- and y-direction
 
-        area_x = np.full((self.qx, self.qy), self.dy)
-        self.Ax_l = ArrayIndexer(area_x, grid=self)
-        self.Ax_r = ArrayIndexer(area_x, grid=self)
+        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
+                                 grid=self)
+        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
+                                 grid=self)
 
-        # This is length of the side that is perpendicular to y.
+        # This is area of the side that is perpendicular to x.
 
-        area_y = np.full((self.qx, self.qy), self.dx)
-        self.Ay_l = ArrayIndexer(area_y, grid=self)
-        self.Ay_r = ArrayIndexer(area_y, grid=self)
+        self.Ax_l = self.Ly.copy()
+        self.Ax_r = self.Ly.copy()
 
-        # Volume (Area) of the cell.
+        # This is area of the side that is perpendicular to y.
 
-        volume = np.full((self.qx, self.qy), self.dx * self.dy)
-        self.V = ArrayIndexer(volume, grid=self)
+        self.Ay_l = self.Lx.copy()
+        self.Ay_r = self.Lx.copy()
+
+        # Volume of the cell.
+
+        self.V = ArrayIndexer(np.full((self.qx, self.qy), self.dx * self.dy),
+                              grid=self)
 
     def __str__(self):
         """ print out some basic information about the grid object """
@@ -249,6 +254,16 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
+        # Length of the side along r-direction, dr
+
+        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
+                               grid=self)
+
+        # Length of the side along theta-direction, r*dtheta
+
+        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.x2d*self.dy),
+                               grid=self)
+
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
 

From 372bd6357999467eebe203a94afcd2ab9719b00e Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 17:37:06 -0400
Subject: [PATCH 21/65] update with spherical polar source terms

---
 pyro/compressible/interface.py      | 25 +++++------
 pyro/compressible/simulation.py     | 22 ++++++---
 pyro/compressible/unsplit_fluxes.py | 69 ++++++++++++++++++++++++-----
 3 files changed, 83 insertions(+), 33 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 7057a5d8e..877c88790 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -3,7 +3,7 @@
 
 
 @njit(cache=True)
-def states(idir, ng, dx, dt,
+def states(idir, grid, dt,
            irho, iu, iv, ip, ix, nspec,
            gamma, qv, dqv):
     r"""
@@ -65,10 +65,8 @@ def states(idir, ng, dx, dt,
     ----------
     idir : int
         Are we predicting to the edges in the x-direction (1) or y-direction (2)?
-    ng : int
-        The number of ghost cells
-    dx : float
-        The cell spacing
+    grid : Grid2d, Cartesian2d, or SphericalPolar
+        The grid object.
     dt : float
         The timestep
     irho, iu, iv, ip, ix : int
@@ -94,16 +92,13 @@ def states(idir, ng, dx, dt,
     q_l = np.zeros_like(qv)
     q_r = np.zeros_like(qv)
 
-    nx = qx - 2 * ng
-    ny = qy - 2 * ng
-    ilo = ng
-    ihi = ng + nx
-    jlo = ng
-    jhi = ng + ny
-
     ns = nvar - nspec
 
-    dtdx = dt / dx
+    if idir == 1:
+        dtdx = dt / grid.Lx.v()
+    else:
+        dtdx = dt / grid.Ly.v()
+
     dtdx4 = 0.25 * dtdx
 
     lvec = np.zeros((nvar, nvar))
@@ -113,8 +108,8 @@ def states(idir, ng, dx, dt,
     betar = np.zeros(nvar)
 
     # this is the loop over zones.  For zone i, we see q_l[i+1] and q_r[i]
-    for i in range(ilo - 2, ihi + 2):
-        for j in range(jlo - 2, jhi + 2):
+    for i in range(grid.ilo - 2, grid.ihi + 2):
+        for j in range(grid.jlo - 2, grid.jhi + 2):
 
             dq = dqv[i, j, :]
             q = qv[i, j, :]
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 0b2594583..ed0b420ae 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -145,6 +145,8 @@ def initialize(self, extra_vars=None, ng=4):
         # some auxiliary data that we'll need to fill GC in, but isn't
         # really part of the main solution
         aux_data = self.data_class(my_grid)
+        aux_data.register_var("dens_src", bc)
+        aux_data.register_var("xmom_src", bc_xodd)
         aux_data.register_var("ymom_src", bc_yodd)
         aux_data.register_var("E_src", bc)
         aux_data.create()
@@ -204,21 +206,29 @@ def evolve(self):
                                             self.ivars, self.solid, self.tc, self.dt)
 
         old_dens = dens.copy()
+        old_xmom = xmom.copy()
         old_ymom = ymom.copy()
 
         # conservative update
-        dtdV = self.dt / g.V.v(n=n)
+        dtdV = self.dt / g.V.v()
 
         for n in range(self.ivars.nvar):
             var = self.cc_data.get_var_by_index(n)
 
             var.v()[:, :] += dtdV * \
-                (Flux_x.v(n=n)*g.Ax_l.v(n=n) - Flux_x.ip(1, n=n)*g.Ax_r.v(n=n) +
-                 Flux_y.v(n=n)*g.Ay_l.v(n=n) - Flux_y.jp(1, n=n)*g.Ay_r.v(n=n))
+                (Flux_x.v(n=n)*g.Ax_l.v() - Flux_x.ip(1, n=n)*g.Ax_r.v() +
+                 Flux_y.v(n=n)*g.Ay_l.v() - Flux_y.jp(1, n=n)*g.Ay_r.v())
 
-        # gravitational source terms
-        ymom[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
-        ener[:, :] += 0.5*self.dt*(ymom[:, :] + old_ymom[:, :])*grav
+        # Apply source terms
+
+        if isinstance(g, SphericalPolar):
+            xmom[:, :] += 0.5*self.dt*()
+            ymom[:, :] +=
+            ener[:, :] +=
+        else:
+            # gravitational source terms
+            ymom[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
+            ener[:, :] += 0.5*self.dt*(ymom[:, :] + old_ymom[:, :])*grav
 
         if self.particles is not None:
             self.particles.update_particles(self.dt)
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index bed82da57..feff8aa0f 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -174,9 +174,6 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     # =========================================================================
     # Q = (rho, u, v, p, {X})
 
-    dens = my_data.get_var("density")
-    ymom = my_data.get_var("y-momentum")
-
     q = comp.cons_to_prim(my_data.data, gamma, ivars, myg)
 
     # =========================================================================
@@ -217,7 +214,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     tm_states = tc.timer("interfaceStates")
     tm_states.begin()
 
-    V_l, V_r = ifc.states(1, myg.ng, myg.dx, dt,
+    V_l, V_r = ifc.states(1, myg, dt,
                           ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
                           ivars.naux,
                           gamma,
@@ -236,7 +233,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     # left and right primitive variable states
     tm_states.begin()
 
-    _V_l, _V_r = ifc.states(2, myg.ng, myg.dy, dt,
+    _V_l, _V_r = ifc.states(2, myg, dt,
                             ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
                             ivars.naux,
                             gamma,
@@ -253,29 +250,77 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     # =========================================================================
     # apply source terms
     # =========================================================================
-    grav = rp.get_param("compressible.grav")
 
-    ymom_src = my_aux.get_var("ymom_src")
-    ymom_src.v()[:, :] = dens.v()*grav
-    my_aux.fill_BC("ymom_src")
+    dens = my_data.get_var("density")
+    xmom = my_data.get_var("x-momentum")
+    ymom = my_data.get_var("y-momentum")
+    E = my_data.get_var("energy")
 
+    dens_src = my_aux.get_var("dens_src")
+    xmom_src = my_aux.get_var("xmom_src")
+    ymom_src = my_aux.get_var("ymom_src")
     E_src = my_aux.get_var("E_src")
-    E_src.v()[:, :] = ymom.v()*grav
+
+    grav = rp.get_param("compressible.grav")
+
+    # src = [0.0 for n in range(ivars.nvar)]
+
+    # Calculate external source terms
+    if isinstance(myg, SphericalPolar):
+        # assume gravity points in r-direction in spherical
+        dens_src.v()[:, :] = 0.0
+        xmom_src.v()[:, :] = dens.v()*grav
+        ymom_src.v()[:, :] = 0.0
+        E_src.v()[:, :] = xmom.v()*grav
+
+    else:
+        # assume gravity points in y-direction in cartesian
+        dens_src.v()[:, :] = 0.0
+        xmom_src.v()[:, :] = 0.0
+        ymom_src.v()[:, :] = dens.v()*grav
+        E_src.v()[:, :] = ymom.v()*grav
+
+    # Calculate geometric+ expanded divergence terms for spherical geometry
+    if isinstance(myg, SphericalPolar):
+        dens_src.v()[:, :] += (-2.0*xmom.v()[:, :] -
+                               np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]) \
+                               / myg.x2d.v()[:, :]
+
+        xmom_src.v()[:, :] += (ymom.v()[:, :]**2 - xmom.v()[:, :]**2 -
+                               np.cot(myg.y2d.v()[:, :])*xmom.v()[:, :]*ymom.v()[:, :]) \
+                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
+
+        ymom_src.v()[:, :] += (-3.0*xmom.v()[:, :]*ymom.v()[:, :] -
+                               np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]**2) \
+                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
+
+        E_src.v()[:, :] += (-2.0*xmom.v()[:, :] * (E.v()[:, :] + q.v(n=ivars.ip)[:, :])
+                            - np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :] *
+                            (E.v()[:, :] + q.v(n=ivars.ip)[:, :])) \
+                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
+
+    my_aux.fill_BC("dens_src")
+    my_aux.fill_BC("xmom_src")
+    my_aux.fill_BC("ymom_src")
     my_aux.fill_BC("E_src")
 
     # ymom_xl[i,j] += 0.5*dt*dens[i-1,j]*grav
+    U_xl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.ip(-1, buf=1)
     U_xl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.ip(-1, buf=1)
     U_xl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.ip(-1, buf=1)
 
     # ymom_xr[i,j] += 0.5*dt*dens[i,j]*grav
+    U_xr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
     U_xr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
     U_xr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
 
     # ymom_yl[i,j] += 0.5*dt*dens[i,j-1]*grav
+    U_yl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.jp(-1, buf=1)
     U_yl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.jp(-1, buf=1)
     U_yl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.jp(-1, buf=1)
 
     # ymom_yr[i,j] += 0.5*dt*dens[i,j]*grav
+    U_yr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
     U_yr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
     U_yr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
 
@@ -360,8 +405,8 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     tm_transverse = tc.timer("transverse flux addition")
     tm_transverse.begin()
 
-    dtdx = dt/myg.dx
-    dtdy = dt/myg.dy
+    dtdx = dt/myg.Lx
+    dtdy = dt/myg.Ly
 
     b = (2, 1)
 

From 9ff7e647a23c2cff9ad06f671225c4fcc84a68cb Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 20:35:08 -0400
Subject: [PATCH 22/65] more update

---
 pyro/compressible/simulation.py     | 22 +++++++++++++++++++---
 pyro/compressible/unsplit_fluxes.py |  4 +---
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index ed0b420ae..d0cc3bd18 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -195,6 +195,7 @@ def evolve(self):
         tm_evolve.begin()
 
         dens = self.cc_data.get_var("density")
+        xmom = self.cc_data.get_var("x-momentum")
         ymom = self.cc_data.get_var("y-momentum")
         ener = self.cc_data.get_var("energy")
 
@@ -208,6 +209,7 @@ def evolve(self):
         old_dens = dens.copy()
         old_xmom = xmom.copy()
         old_ymom = ymom.copy()
+        old_pres = derive_primitives(self.cc_data, "pressure")
 
         # conservative update
         dtdV = self.dt / g.V.v()
@@ -219,12 +221,26 @@ def evolve(self):
                 (Flux_x.v(n=n)*g.Ax_l.v() - Flux_x.ip(1, n=n)*g.Ax_r.v() +
                  Flux_y.v(n=n)*g.Ay_l.v() - Flux_y.jp(1, n=n)*g.Ay_r.v())
 
+        # Get updated pressure from energy.
+
+        pres = derive_primitives(self.cc_data, "pressure")
+
         # Apply source terms
 
         if isinstance(g, SphericalPolar):
-            xmom[:, :] += 0.5*self.dt*()
-            ymom[:, :] +=
-            ener[:, :] +=
+            xmom[:, :] += 0.5*self.dt* \
+                ((dens[:, :] + old_dens[:, :])*grav +
+                 (ymom[:, :]**2 / dens[:, :] +
+                  old_ymom[:, :]**2 / old_dens[:, :] +
+                  2.0*(old_pres[:, :] + pres[:, :])) / g.x2d[:, :])
+
+            ymom[:, :] += 0.5*self.dt* \
+                ((old_pres[:, :] + pres[:, :])*np.cot(g.y2d[:, :]) -
+                 (xmom[:, :]*ymom[:, :] / dens[:, :] +
+                  old_xmom[:, :]*old_ymom[:, :]) / old_dens[:, :]) / g.x2d[:, :]
+
+            ener[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
+
         else:
             # gravitational source terms
             ymom[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index feff8aa0f..f9f9ddc8e 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -263,8 +263,6 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
 
     grav = rp.get_param("compressible.grav")
 
-    # src = [0.0 for n in range(ivars.nvar)]
-
     # Calculate external source terms
     if isinstance(myg, SphericalPolar):
         # assume gravity points in r-direction in spherical
@@ -280,7 +278,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
         ymom_src.v()[:, :] = dens.v()*grav
         E_src.v()[:, :] = ymom.v()*grav
 
-    # Calculate geometric+ expanded divergence terms for spherical geometry
+    # Calculate geometric + expanded divergence terms for spherical geometry
     if isinstance(myg, SphericalPolar):
         dens_src.v()[:, :] += (-2.0*xmom.v()[:, :] -
                                np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]) \

From 5731d07ed2a0715645bb496d50d93149be8c7f0c Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 20:54:42 -0400
Subject: [PATCH 23/65] fix flake8

---
 pyro/compressible/simulation.py     | 23 ++++++++++++-----------
 pyro/compressible/unsplit_fluxes.py |  6 ++++--
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index d0cc3bd18..a8a3f5d14 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -6,6 +6,7 @@
 
 import pyro.compressible.unsplit_fluxes as flx
 import pyro.mesh.boundary as bnd
+from pyro.mesh.patch import SphericalPolar
 from pyro.compressible import BC, derives, eos
 from pyro.particles import particles
 from pyro.simulation_null import NullSimulation, bc_setup, grid_setup
@@ -209,35 +210,35 @@ def evolve(self):
         old_dens = dens.copy()
         old_xmom = xmom.copy()
         old_ymom = ymom.copy()
-        old_pres = derive_primitives(self.cc_data, "pressure")
+        old_pres = derives.derive_primitives(self.cc_data, "pressure")
 
         # conservative update
-        dtdV = self.dt / g.V.v()
+        dtdV = self.dt / myg.V.v()
 
         for n in range(self.ivars.nvar):
             var = self.cc_data.get_var_by_index(n)
 
             var.v()[:, :] += dtdV * \
-                (Flux_x.v(n=n)*g.Ax_l.v() - Flux_x.ip(1, n=n)*g.Ax_r.v() +
-                 Flux_y.v(n=n)*g.Ay_l.v() - Flux_y.jp(1, n=n)*g.Ay_r.v())
+                (Flux_x.v(n=n)*myg.Ax_l.v() - Flux_x.ip(1, n=n)*myg.Ax_r.v() +
+                 Flux_y.v(n=n)*myg.Ay_l.v() - Flux_y.jp(1, n=n)*myg.Ay_r.v())
 
         # Get updated pressure from energy.
 
-        pres = derive_primitives(self.cc_data, "pressure")
+        pres = derives.derive_primitives(self.cc_data, "pressure")
 
         # Apply source terms
 
-        if isinstance(g, SphericalPolar):
-            xmom[:, :] += 0.5*self.dt* \
+        if isinstance(myg, SphericalPolar):
+            xmom[:, :] += 0.5*self.dt * \
                 ((dens[:, :] + old_dens[:, :])*grav +
                  (ymom[:, :]**2 / dens[:, :] +
                   old_ymom[:, :]**2 / old_dens[:, :] +
-                  2.0*(old_pres[:, :] + pres[:, :])) / g.x2d[:, :])
+                  2.0*(old_pres[:, :] + pres[:, :])) / myg.x2d[:, :])
 
-            ymom[:, :] += 0.5*self.dt* \
-                ((old_pres[:, :] + pres[:, :])*np.cot(g.y2d[:, :]) -
+            ymom[:, :] += 0.5*self.dt * \
+                ((old_pres[:, :] + pres[:, :])*np.cot(myg.y2d[:, :]) -
                  (xmom[:, :]*ymom[:, :] / dens[:, :] +
-                  old_xmom[:, :]*old_ymom[:, :]) / old_dens[:, :]) / g.x2d[:, :]
+                  old_xmom[:, :]*old_ymom[:, :]) / old_dens[:, :]) / myg.x2d[:, :]
 
             ener[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
 
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index f9f9ddc8e..41f507d01 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -122,9 +122,11 @@
 
 """
 
+import numpy as np
 import pyro.compressible as comp
 import pyro.compressible.interface as ifc
 import pyro.mesh.array_indexer as ai
+from pyro.mesh.patch import SphericalPolar
 from pyro.mesh import reconstruction
 from pyro.util import msg
 
@@ -292,8 +294,8 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
                                np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]**2) \
                                / (dens.v()[:, :] * myg.x2d.v()[:, :])
 
-        E_src.v()[:, :] += (-2.0*xmom.v()[:, :] * (E.v()[:, :] + q.v(n=ivars.ip)[:, :])
-                            - np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :] *
+        E_src.v()[:, :] += (-2.0*xmom.v()[:, :] * (E.v()[:, :] + q.v(n=ivars.ip)[:, :]) -
+                            np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :] *
                             (E.v()[:, :] + q.v(n=ivars.ip)[:, :])) \
                                / (dens.v()[:, :] * myg.x2d.v()[:, :])
 

From eacef13735d749b417f43628a08f4f0bc13a1fd6 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 20:55:30 -0400
Subject: [PATCH 24/65] fix isort

---
 pyro/compressible/simulation.py     | 2 +-
 pyro/compressible/unsplit_fluxes.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index a8a3f5d14..2d4f8054f 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -6,8 +6,8 @@
 
 import pyro.compressible.unsplit_fluxes as flx
 import pyro.mesh.boundary as bnd
-from pyro.mesh.patch import SphericalPolar
 from pyro.compressible import BC, derives, eos
+from pyro.mesh.patch import SphericalPolar
 from pyro.particles import particles
 from pyro.simulation_null import NullSimulation, bc_setup, grid_setup
 from pyro.util import plot_tools
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 41f507d01..9c5a04493 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -123,11 +123,12 @@
 """
 
 import numpy as np
+
 import pyro.compressible as comp
 import pyro.compressible.interface as ifc
 import pyro.mesh.array_indexer as ai
-from pyro.mesh.patch import SphericalPolar
 from pyro.mesh import reconstruction
+from pyro.mesh.patch import SphericalPolar
 from pyro.util import msg
 
 

From e6b1e005855ae0a08906b4d88d0546c7e51ca9c6 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 21:12:49 -0400
Subject: [PATCH 25/65] revert interface.state back to old interface

---
 pyro/compressible/interface.py      | 25 +++++++++++++++----------
 pyro/compressible/unsplit_fluxes.py |  4 ++--
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 877c88790..dbff86b61 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -3,7 +3,7 @@
 
 
 @njit(cache=True)
-def states(idir, grid, dt,
+def states(idir, ng, dx, dt,
            irho, iu, iv, ip, ix, nspec,
            gamma, qv, dqv):
     r"""
@@ -65,8 +65,10 @@ def states(idir, grid, dt,
     ----------
     idir : int
         Are we predicting to the edges in the x-direction (1) or y-direction (2)?
-    grid : Grid2d, Cartesian2d, or SphericalPolar
-        The grid object.
+    ng : int
+        The number of ghost cells
+    dx : ndarray
+        The cell spacing
     dt : float
         The timestep
     irho, iu, iv, ip, ix : int
@@ -92,13 +94,16 @@ def states(idir, grid, dt,
     q_l = np.zeros_like(qv)
     q_r = np.zeros_like(qv)
 
-    ns = nvar - nspec
+    nx = qx - 2 * ng
+    ny = qy - 2 * ng
+    ilo = ng
+    ihi = ng + nx
+    jlo = ng
+    jhi = ng + ny
 
-    if idir == 1:
-        dtdx = dt / grid.Lx.v()
-    else:
-        dtdx = dt / grid.Ly.v()
+    ns = nvar - nspec
 
+    dtdx = dt / dx
     dtdx4 = 0.25 * dtdx
 
     lvec = np.zeros((nvar, nvar))
@@ -108,8 +113,8 @@ def states(idir, grid, dt,
     betar = np.zeros(nvar)
 
     # this is the loop over zones.  For zone i, we see q_l[i+1] and q_r[i]
-    for i in range(grid.ilo - 2, grid.ihi + 2):
-        for j in range(grid.jlo - 2, grid.jhi + 2):
+    for i in range(ilo - 2, ihi + 2):
+        for j in range(jlo - 2, jhi + 2):
 
             dq = dqv[i, j, :]
             q = qv[i, j, :]
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 9c5a04493..7e93e6ea9 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -217,7 +217,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     tm_states = tc.timer("interfaceStates")
     tm_states.begin()
 
-    V_l, V_r = ifc.states(1, myg, dt,
+    V_l, V_r = ifc.states(1, myg.ng, myg.Lx, dt,
                           ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
                           ivars.naux,
                           gamma,
@@ -236,7 +236,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     # left and right primitive variable states
     tm_states.begin()
 
-    _V_l, _V_r = ifc.states(2, myg, dt,
+    _V_l, _V_r = ifc.states(2, myg.ng, myg.Ly, dt,
                             ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
                             ivars.naux,
                             gamma,

From 43db3165854ae3911f50c167a240cb8abee92167 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 21:24:47 -0400
Subject: [PATCH 26/65] change Lx and Ly to 1d array or float

---
 pyro/mesh/patch.py | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 55f09b25b..6807c4a23 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -205,20 +205,20 @@ def __init__(self, nx, ny, ng=1,
 
         # Length of the side in x- and y-direction
 
-        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
-                                 grid=self)
-        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
-                                 grid=self)
+        self.Lx = self.dx
+        self.Ly = self.dy
 
         # This is area of the side that is perpendicular to x.
 
-        self.Ax_l = self.Ly.copy()
-        self.Ax_r = self.Ly.copy()
+        self.Ax_l = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
+                                 grid=self)
+        self.Ax_r = self.Ax_l.copy()
 
         # This is area of the side that is perpendicular to y.
 
-        self.Ay_l = self.Lx.copy()
-        self.Ay_r = self.Lx.copy()
+        self.Ay_l = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
+                                 grid=self)
+        self.Ay_r = self.Ay_l.copy()
 
         # Volume of the cell.
 
@@ -254,15 +254,10 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
-        # Length of the side along r-direction, dr
-
-        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
-                               grid=self)
-
-        # Length of the side along theta-direction, r*dtheta
+        # Length of the side along r-direction, dr and θ-direction, r*dθ
 
-        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.x2d*self.dy),
-                               grid=self)
+        self.Lx = self.dx
+        self.Ly = self.x * self.dy
 
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi

From e40a8a544cff99ace85f5ab4a55765a4e9576c8b Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 21:44:01 -0400
Subject: [PATCH 27/65] update BC with dens_src and xmom_src

---
 pyro/compressible/BC.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/pyro/compressible/BC.py b/pyro/compressible/BC.py
index 812ae2db2..8b841d9b5 100644
--- a/pyro/compressible/BC.py
+++ b/pyro/compressible/BC.py
@@ -53,7 +53,9 @@ def user(bc_name, bc_edge, variable, ccdata):
 
             # we will take the density to be constant, the velocity to
             # be outflow, and the pressure to be in HSE
-            if variable in ["density", "x-momentum", "y-momentum", "ymom_src", "E_src", "fuel", "ash"]:
+            if variable in ["density", "x-momentum", "y-momentum",
+                            "dens_src", "xmom_src", "ymom_src", "E_src",
+                            "fuel", "ash"]:
                 v = ccdata.get_var(variable)
                 j = myg.jlo-1
                 while j >= 0:
@@ -99,7 +101,9 @@ def user(bc_name, bc_edge, variable, ccdata):
 
             # we will take the density to be constant, the velocity to
             # be outflow, and the pressure to be in HSE
-            if variable in ["density", "x-momentum", "y-momentum", "ymom_src", "E_src", "fuel", "ash"]:
+            if variable in ["density", "x-momentum", "y-momentum",
+                            "dens_src", "xmom_src", "ymom_src", "E_src",
+                            "fuel", "ash"]:
                 v = ccdata.get_var(variable)
                 for j in range(myg.jhi+1, myg.jhi+myg.ng+1):
                     v[:, j] = v[:, myg.jhi]

From 0151d78b7c2238425adea1f7ed99281c274101d6 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 21:47:51 -0400
Subject: [PATCH 28/65] revert

---
 pyro/mesh/patch.py | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 6807c4a23..55f09b25b 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -205,20 +205,20 @@ def __init__(self, nx, ny, ng=1,
 
         # Length of the side in x- and y-direction
 
-        self.Lx = self.dx
-        self.Ly = self.dy
+        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
+                                 grid=self)
+        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
+                                 grid=self)
 
         # This is area of the side that is perpendicular to x.
 
-        self.Ax_l = ArrayIndexer(np.full((self.qx, self.qy), self.dy),
-                                 grid=self)
-        self.Ax_r = self.Ax_l.copy()
+        self.Ax_l = self.Ly.copy()
+        self.Ax_r = self.Ly.copy()
 
         # This is area of the side that is perpendicular to y.
 
-        self.Ay_l = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
-                                 grid=self)
-        self.Ay_r = self.Ay_l.copy()
+        self.Ay_l = self.Lx.copy()
+        self.Ay_r = self.Lx.copy()
 
         # Volume of the cell.
 
@@ -254,10 +254,15 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
-        # Length of the side along r-direction, dr and θ-direction, r*dθ
+        # Length of the side along r-direction, dr
+
+        self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
+                               grid=self)
+
+        # Length of the side along theta-direction, r*dtheta
 
-        self.Lx = self.dx
-        self.Ly = self.x * self.dy
+        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.x2d*self.dy),
+                               grid=self)
 
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi

From 083ce8d050c890c0db078efa8b87cae5c467f2b6 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 21:56:26 -0400
Subject: [PATCH 29/65] fix dtdx and dtdy indexing

---
 pyro/compressible/interface.py      | 12 ++++++------
 pyro/compressible/unsplit_fluxes.py |  8 ++++----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index dbff86b61..ed89590ad 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -174,20 +174,20 @@ def states(idir, ng, dx, dt,
             if idir == 1:
                 # this is one the right face of the current zone,
                 # so the fastest moving eigenvalue is e_val[3] = u + c
-                factor = 0.5 * (1.0 - dtdx * max(e_val[3], 0.0))
+                factor = 0.5 * (1.0 - dtdx[i, j] * max(e_val[3], 0.0))
                 q_l[i + 1, j, :] = q + factor * dq
 
                 # left face of the current zone, so the fastest moving
                 # eigenvalue is e_val[3] = u - c
-                factor = 0.5 * (1.0 + dtdx * min(e_val[0], 0.0))
+                factor = 0.5 * (1.0 + dtdx[i, j] * min(e_val[0], 0.0))
                 q_r[i,  j, :] = q - factor * dq
 
             else:
 
-                factor = 0.5 * (1.0 - dtdx * max(e_val[3], 0.0))
+                factor = 0.5 * (1.0 - dtdx[i, j] * max(e_val[3], 0.0))
                 q_l[i, j + 1, :] = q + factor * dq
 
-                factor = 0.5 * (1.0 + dtdx * min(e_val[0], 0.0))
+                factor = 0.5 * (1.0 + dtdx[i, j] * min(e_val[0], 0.0))
                 q_r[i, j, :] = q - factor * dq
 
             # compute the Vhat functions
@@ -195,9 +195,9 @@ def states(idir, ng, dx, dt,
                 asum = np.dot(lvec[m, :], dq)
 
                 # Should we change to max(e_val[3], 0.0) and min(e_val[0], 0.0)?
-                betal[m] = dtdx4 * (e_val[3] - e_val[m]) * \
+                betal[m] = dtdx4[i, j] * (e_val[3] - e_val[m]) * \
                     (np.copysign(1.0, e_val[m]) + 1.0) * asum
-                betar[m] = dtdx4 * (e_val[0] - e_val[m]) * \
+                betar[m] = dtdx4[i, j] * (e_val[0] - e_val[m]) * \
                     (1.0 - np.copysign(1.0, e_val[m])) * asum
 
             # construct the states
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 7e93e6ea9..be6d342d7 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -415,19 +415,19 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
 
         # U_xl[i,j,:] = U_xl[i,j,:] - 0.5*dt/dy * (F_y[i-1,j+1,:] - F_y[i-1,j,:])
         U_xl.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdy*(F_y.ip_jp(-1, 1, buf=b, n=n) - F_y.ip(-1, buf=b, n=n))
+            - 0.5*dtdy.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n) - F_y.ip(-1, buf=b, n=n))
 
         # U_xr[i,j,:] = U_xr[i,j,:] - 0.5*dt/dy * (F_y[i,j+1,:] - F_y[i,j,:])
         U_xr.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdy*(F_y.jp(1, buf=b, n=n) - F_y.v(buf=b, n=n))
+            - 0.5*dtdy.v(buf=b)*(F_y.jp(1, buf=b, n=n) - F_y.v(buf=b, n=n))
 
         # U_yl[i,j,:] = U_yl[i,j,:] - 0.5*dt/dx * (F_x[i+1,j-1,:] - F_x[i,j-1,:])
         U_yl.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdx*(F_x.ip_jp(1, -1, buf=b, n=n) - F_x.jp(-1, buf=b, n=n))
+            - 0.5*dtdx.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n) - F_x.jp(-1, buf=b, n=n))
 
         # U_yr[i,j,:] = U_yr[i,j,:] - 0.5*dt/dx * (F_x[i+1,j,:] - F_x[i,j,:])
         U_yr.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdx*(F_x.ip(1, buf=b, n=n) - F_x.v(buf=b, n=n))
+            - 0.5*dtdx.v(buf=b)*(F_x.ip(1, buf=b, n=n) - F_x.v(buf=b, n=n))
 
     tm_transverse.end()
 

From 987b098bcd6e5450c65df54a7fdfceb294677d33 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 24 Jul 2024 23:07:17 -0400
Subject: [PATCH 30/65] update Ly for sphericalpolar

---
 pyro/mesh/patch.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 55f09b25b..8c87cf393 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -261,8 +261,7 @@ def __init__(self, nx, ny, ng=1,
 
         # Length of the side along theta-direction, r*dtheta
 
-        self.Ly = ArrayIndexer(np.full((self.qx, self.qy), self.x2d*self.dy),
-                               grid=self)
+        self.Ly = ArrayIndexer(self.x2d*self.dy, grid=self)
 
         # Returns an array of the face area that points in the r(x) direction.
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi

From b409f9dad3c2fb2387d4661d6a2ab9fb3abcf30e Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 25 Jul 2024 12:59:50 -0400
Subject: [PATCH 31/65] update np.cot to 1/np.tan also update visualization to
 be compatibile with spherical polar using pcolormesh

---
 pyro/compressible/simulation.py     | 32 ++++++++++++++++++++++-------
 pyro/compressible/unsplit_fluxes.py |  8 ++++----
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 2d4f8054f..5cb084e2c 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -236,7 +236,7 @@ def evolve(self):
                   2.0*(old_pres[:, :] + pres[:, :])) / myg.x2d[:, :])
 
             ymom[:, :] += 0.5*self.dt * \
-                ((old_pres[:, :] + pres[:, :])*np.cot(myg.y2d[:, :]) -
+                ((old_pres[:, :] + pres[:, :]) / np.tan(myg.y2d[:, :]) -
                  (xmom[:, :]*ymom[:, :] / dens[:, :] +
                   old_xmom[:, :]*old_ymom[:, :]) / old_dens[:, :]) / myg.x2d[:, :]
 
@@ -288,15 +288,28 @@ def dovis(self):
         fields = [rho, magvel, p, e]
         field_names = [r"$\rho$", r"U", "p", "e"]
 
+        x = myg.scratch_array()
+        y = myg.scratch_array()
+
+        if isinstance(myg, SphericalPolar):
+            x.v()[:, :] = myg.x2d.v()[:, :]*np.sin(myg.y2d.v()[:, :])
+            y.v()[:, :] = myg.x2d.v()[:, :]*np.cos(myg.y2d.v()[:, :])
+        else :
+            x.v()[:, :] = myg.x2d.v()[:, :]
+            y.v()[:, :] = myg.y2d.v()[:, :]
+
         _, axes, cbar_title = plot_tools.setup_axes(myg, len(fields))
 
         for n, ax in enumerate(axes):
             v = fields[n]
 
-            img = ax.imshow(np.transpose(v.v()),
-                            interpolation="nearest", origin="lower",
-                            extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax],
-                            cmap=self.cm)
+            # img = ax.imshow(np.transpose(v.v()),
+            #                 interpolation="nearest", origin="lower",
+            #                 extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax],
+            #                 cmap=self.cm)
+
+            img = ax.pcolormesh(x.v(), y.v(), v.v(),
+                                shading="nearest", cmap=self.cm)
 
             ax.set_xlabel("x")
             ax.set_ylabel("y")
@@ -321,8 +334,13 @@ def dovis(self):
             # plot particles
             ax.scatter(particle_positions[:, 0],
                 particle_positions[:, 1], s=5, c=colors, alpha=0.8, cmap="Greys")
-            ax.set_xlim([myg.xmin, myg.xmax])
-            ax.set_ylim([myg.ymin, myg.ymax])
+
+            if isinstance(myg, SphericalPolar):
+                ax.set_xlim([np.min(x), np.max(x)])
+                ax.set_ylim([np.min(y), np.max(y)])
+            else:
+                ax.set_xlim([myg.xmin, myg.xmax])
+                ax.set_ylim([myg.ymin, myg.ymax])
 
         plt.figtext(0.05, 0.0125, f"t = {self.cc_data.t:10.5g}")
 
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index be6d342d7..7348cc200 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -284,19 +284,19 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     # Calculate geometric + expanded divergence terms for spherical geometry
     if isinstance(myg, SphericalPolar):
         dens_src.v()[:, :] += (-2.0*xmom.v()[:, :] -
-                               np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]) \
+                               ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :])) \
                                / myg.x2d.v()[:, :]
 
         xmom_src.v()[:, :] += (ymom.v()[:, :]**2 - xmom.v()[:, :]**2 -
-                               np.cot(myg.y2d.v()[:, :])*xmom.v()[:, :]*ymom.v()[:, :]) \
+                               xmom.v()[:, :]*ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :])) \
                                / (dens.v()[:, :] * myg.x2d.v()[:, :])
 
         ymom_src.v()[:, :] += (-3.0*xmom.v()[:, :]*ymom.v()[:, :] -
-                               np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :]**2) \
+                               ymom.v()[:, :]**2 / np.tan(myg.y2d.v()[:, :])) \
                                / (dens.v()[:, :] * myg.x2d.v()[:, :])
 
         E_src.v()[:, :] += (-2.0*xmom.v()[:, :] * (E.v()[:, :] + q.v(n=ivars.ip)[:, :]) -
-                            np.cot(myg.y2d.v()[:, :])*ymom.v()[:, :] *
+                            ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :]) *
                             (E.v()[:, :] + q.v(n=ivars.ip)[:, :])) \
                                / (dens.v()[:, :] * myg.x2d.v()[:, :])
 

From 8c1e92dac0e5be42fd48b2d409da89ce4e2e7b99 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 25 Jul 2024 13:30:39 -0400
Subject: [PATCH 32/65] fix flake8 and remove comment

---
 pyro/compressible/simulation.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 5cb084e2c..9b15cf502 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -294,7 +294,7 @@ def dovis(self):
         if isinstance(myg, SphericalPolar):
             x.v()[:, :] = myg.x2d.v()[:, :]*np.sin(myg.y2d.v()[:, :])
             y.v()[:, :] = myg.x2d.v()[:, :]*np.cos(myg.y2d.v()[:, :])
-        else :
+        else:
             x.v()[:, :] = myg.x2d.v()[:, :]
             y.v()[:, :] = myg.y2d.v()[:, :]
 
@@ -303,11 +303,6 @@ def dovis(self):
         for n, ax in enumerate(axes):
             v = fields[n]
 
-            # img = ax.imshow(np.transpose(v.v()),
-            #                 interpolation="nearest", origin="lower",
-            #                 extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax],
-            #                 cmap=self.cm)
-
             img = ax.pcolormesh(x.v(), y.v(), v.v(),
                                 shading="nearest", cmap=self.cm)
 

From 194f7c4da805f072b67d7ff4dc75d3ab59425359 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 30 Jul 2024 23:34:06 -0400
Subject: [PATCH 33/65] update to use new conservative form, by not grouping
 pressure inside flux

---
 pyro/compressible/interface.py      |  1 +
 pyro/compressible/simulation.py     | 28 ++++++++---------
 pyro/compressible/unsplit_fluxes.py | 47 +++++++++++------------------
 3 files changed, 32 insertions(+), 44 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index ed89590ad..858025d62 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -503,6 +503,7 @@ def riemann_cgf(idir, ng,
             F[i, j, idens] = rho_state * un_state
 
             if idir == 1:
+                if isinstance()
                 F[i, j, ixmom] = rho_state * un_state**2 + p_state
                 F[i, j, iymom] = rho_state * ut_state * un_state
             else:
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 9b15cf502..14ea50f6d 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -222,30 +222,30 @@ def evolve(self):
                 (Flux_x.v(n=n)*myg.Ax_l.v() - Flux_x.ip(1, n=n)*myg.Ax_r.v() +
                  Flux_y.v(n=n)*myg.Ay_l.v() - Flux_y.jp(1, n=n)*myg.Ay_r.v())
 
-        # Get updated pressure from energy.
+        # Get pressure using the interface flux
 
         pres = derives.derive_primitives(self.cc_data, "pressure")
 
-        # Apply source terms
+        # Apply external source (gravity) and geometric terms
 
         if isinstance(myg, SphericalPolar):
-            xmom[:, :] += 0.5*self.dt * \
-                ((dens[:, :] + old_dens[:, :])*grav +
-                 (ymom[:, :]**2 / dens[:, :] +
-                  old_ymom[:, :]**2 / old_dens[:, :] +
-                  2.0*(old_pres[:, :] + pres[:, :])) / myg.x2d[:, :])
+            xmom.v()[:, :] += 0.5*self.dt * \
+                ((dens.v() + old_dens.v())*grav +
+                 (ymom.v()**2 / dens.v() +
+                  old_ymom.v()**2 / old_dens.v()) / myg.x2d.v()) - \
+                self.dt * (pres.ip(1) - pres.v()) / myg.Lx.v()
 
-            ymom[:, :] += 0.5*self.dt * \
-                ((old_pres[:, :] + pres[:, :]) / np.tan(myg.y2d[:, :]) -
-                 (xmom[:, :]*ymom[:, :] / dens[:, :] +
-                  old_xmom[:, :]*old_ymom[:, :]) / old_dens[:, :]) / myg.x2d[:, :]
+            ymom.v()[:, :] += 0.5*self.dt * \
+                (-xmom.v()*ymom.v() / dens.v() -
+                 old_xmom.v()*old_ymom.v() / old_dens.v()) / myg.x2d.v() - \
+                self.dt * (pres.jp(1) - pres.v()) / myg.Ly.v()
 
-            ener[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
+            ener.v()[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
 
         else:
             # gravitational source terms
-            ymom[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
-            ener[:, :] += 0.5*self.dt*(ymom[:, :] + old_ymom[:, :])*grav
+            ymom.v()[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
+            ener.v()[:, :] += 0.5*self.dt*(ymom[:, :] + old_ymom[:, :])*grav
 
         if self.particles is not None:
             self.particles.update_particles(self.dt)
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 7348cc200..3485727ee 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -258,6 +258,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     xmom = my_data.get_var("x-momentum")
     ymom = my_data.get_var("y-momentum")
     E = my_data.get_var("energy")
+    pres = my_data.get_var("pressure")
 
     dens_src = my_aux.get_var("dens_src")
     xmom_src = my_aux.get_var("xmom_src")
@@ -266,12 +267,15 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
 
     grav = rp.get_param("compressible.grav")
 
-    # Calculate external source terms
+    # Calculate external source (gravity), geometric, and pressure terms
     if isinstance(myg, SphericalPolar):
-        # assume gravity points in r-direction in spherical
+        # assume gravity points in r-direction in spherical.
         dens_src.v()[:, :] = 0.0
-        xmom_src.v()[:, :] = dens.v()*grav
-        ymom_src.v()[:, :] = 0.0
+        xmom_src.v()[:, :] = dens.v()*grav + \
+            ymom.v()**2 / (dens.v()*myg.x2d.v()) - \
+            (pres.ip(1) - pres.v()) / myg.Lx.v()
+        ymom_src.v()[:, :] = -(pres.jp(1) - pres.v()) / myg.Ly.v() - \
+            dens.v()*xmom.v()*ymom.v() / (dens.v()*myg.x2d.v())
         E_src.v()[:, :] = xmom.v()*grav
 
     else:
@@ -281,25 +285,6 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
         ymom_src.v()[:, :] = dens.v()*grav
         E_src.v()[:, :] = ymom.v()*grav
 
-    # Calculate geometric + expanded divergence terms for spherical geometry
-    if isinstance(myg, SphericalPolar):
-        dens_src.v()[:, :] += (-2.0*xmom.v()[:, :] -
-                               ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :])) \
-                               / myg.x2d.v()[:, :]
-
-        xmom_src.v()[:, :] += (ymom.v()[:, :]**2 - xmom.v()[:, :]**2 -
-                               xmom.v()[:, :]*ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :])) \
-                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
-
-        ymom_src.v()[:, :] += (-3.0*xmom.v()[:, :]*ymom.v()[:, :] -
-                               ymom.v()[:, :]**2 / np.tan(myg.y2d.v()[:, :])) \
-                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
-
-        E_src.v()[:, :] += (-2.0*xmom.v()[:, :] * (E.v()[:, :] + q.v(n=ivars.ip)[:, :]) -
-                            ymom.v()[:, :] / np.tan(myg.y2d.v()[:, :]) *
-                            (E.v()[:, :] + q.v(n=ivars.ip)[:, :])) \
-                               / (dens.v()[:, :] * myg.x2d.v()[:, :])
-
     my_aux.fill_BC("dens_src")
     my_aux.fill_BC("xmom_src")
     my_aux.fill_BC("ymom_src")
@@ -406,28 +391,30 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     tm_transverse = tc.timer("transverse flux addition")
     tm_transverse.begin()
 
-    dtdx = dt/myg.Lx
-    dtdy = dt/myg.Ly
-
     b = (2, 1)
+    hdtV = 0.5*dt / myg.V
 
     for n in range(ivars.nvar):
 
         # U_xl[i,j,:] = U_xl[i,j,:] - 0.5*dt/dy * (F_y[i-1,j+1,:] - F_y[i-1,j,:])
         U_xl.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdy.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n) - F_y.ip(-1, buf=b, n=n))
+            - hdtV.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n)*myg.Ay_r.ip(-1, buf=b) -
+                             F_y.ip(-1, buf=b, n=n)*myg.Ay_l.ip(-1, buf=b))
 
         # U_xr[i,j,:] = U_xr[i,j,:] - 0.5*dt/dy * (F_y[i,j+1,:] - F_y[i,j,:])
         U_xr.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdy.v(buf=b)*(F_y.jp(1, buf=b, n=n) - F_y.v(buf=b, n=n))
+            - hdtV.v(buf=b)*(F_y.jp(1, buf=b, n=n)*myg.Ay_r.v(buf=b) -
+                             F_y.v(buf=b, n=n)*myg.Ay_l.v(buf=b))
 
         # U_yl[i,j,:] = U_yl[i,j,:] - 0.5*dt/dx * (F_x[i+1,j-1,:] - F_x[i,j-1,:])
         U_yl.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdx.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n) - F_x.jp(-1, buf=b, n=n))
+            - hdtV.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n)*myg.Ax_r.jp(-1, buf=b) -
+                             F_x.jp(-1, buf=b, n=n)*myg.Ax_l.jp(-1, buf=b))
 
         # U_yr[i,j,:] = U_yr[i,j,:] - 0.5*dt/dx * (F_x[i+1,j,:] - F_x[i,j,:])
         U_yr.v(buf=b, n=n)[:, :] += \
-            - 0.5*dtdx.v(buf=b)*(F_x.ip(1, buf=b, n=n) - F_x.v(buf=b, n=n))
+            - hdtV.v(buf=b)*(F_x.ip(1, buf=b, n=n)*myg.Ax_r.v(buf=b) -
+                             F_x.v(buf=b, n=n)*myg.Ax_l.v(buf=b))
 
     tm_transverse.end()
 

From a6ac3d67a2c1e812db08559a980e91abb67ec09e Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 30 Jul 2024 23:39:00 -0400
Subject: [PATCH 34/65] add coord_type to grid class

---
 pyro/mesh/patch.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 55f09b25b..481a0f316 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -203,6 +203,8 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
+        self.coord_type = 0
+
         # Length of the side in x- and y-direction
 
         self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),
@@ -254,6 +256,8 @@ def __init__(self, nx, ny, ng=1,
 
         super().__init__(nx, ny, ng, xmin, xmax, ymin, ymax)
 
+        self.coord_type = 1
+
         # Length of the side along r-direction, dr
 
         self.Lx = ArrayIndexer(np.full((self.qx, self.qy), self.dx),

From 5b16f4eb84afd7c8339ce1af525fffd000e6a090 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 10:12:56 -0400
Subject: [PATCH 35/65] update

---
 pyro/compressible/interface.py      | 64 ++++++++++++++++++++++-------
 pyro/compressible/unsplit_fluxes.py | 42 +++++++++++--------
 2 files changed, 76 insertions(+), 30 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 858025d62..feef23296 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -216,7 +216,7 @@ def states(idir, ng, dx, dt,
 
 
 @njit(cache=True)
-def riemann_cgf(idir, ng,
+def riemann_cgf(idir, ng, coord_type,
                 idens, ixmom, iymom, iener, irhoX, nspec,
                 lower_solid, upper_solid,
                 gamma, U_l, U_r):
@@ -503,12 +503,20 @@ def riemann_cgf(idir, ng,
             F[i, j, idens] = rho_state * un_state
 
             if idir == 1:
-                if isinstance()
-                F[i, j, ixmom] = rho_state * un_state**2 + p_state
+                F[i, j, ixmom] = rho_state * un_state**2
                 F[i, j, iymom] = rho_state * ut_state * un_state
+
+                # if Cartesian2d, then add pressure to xmom flux
+                if coord_type == 0:
+                    F[i, j, ixmom] += p_state
+
             else:
                 F[i, j, ixmom] = rho_state * ut_state * un_state
-                F[i, j, iymom] = rho_state * un_state**2 + p_state
+                F[i, j, iymom] = rho_state * un_state**2
+
+                # if Cartesian2d, then add pressure to ymom flux
+                if coord_type == 0:
+                    F[i, j, iymom] += p_state
 
             F[i, j, iener] = rhoe_state * un_state + \
                 0.5 * rho_state * (un_state**2 + ut_state**2) * un_state + \
@@ -517,7 +525,17 @@ def riemann_cgf(idir, ng,
             if nspec > 0:
                 F[i, j, irhoX:irhoX + nspec] = xn * rho_state * un_state
 
-    return F
+            # update conserved state
+            U_out[i, j, idens] = rho_state
+            U_out[i, j, ixmom] = rho_state * un_state
+            U_out[i, j, iymom] = rho_state * vn_state
+            U_out[i, j, iener] = rhoe_state + \
+                0.5 * rho_state * (un_state**2 + ut_state**2)
+
+            if nspec > 0:
+                U_out[i, j, irhoX:irhoX + nspec] = xn * rho_state
+
+    return F, U_out
 
 
 @njit(cache=True)
@@ -804,7 +822,7 @@ def riemann_prim(idir, ng,
 
 
 @njit(cache=True)
-def riemann_hllc(idir, ng,
+def riemann_hllc(idir, ng, coord_type,
                  idens, ixmom, iymom, iener, irhoX, nspec,
                  lower_solid, upper_solid,  # pylint: disable=unused-argument
                  gamma, U_l, U_r):
@@ -844,6 +862,7 @@ def riemann_hllc(idir, ng,
     smallc = 1.e-10
     smallp = 1.e-10
 
+    U_out = np.zeros((qx, qy, nvar))
     U_state = np.zeros(nvar)
 
     nx = qx - 2 * ng
@@ -995,7 +1014,8 @@ def riemann_hllc(idir, ng,
                 # R region
                 U_state[:] = U_r[i, j, :]
 
-                F[i, j, :] = consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec,
+                F[i, j, :] = consFlux(idir, coord_type, gamma,
+                                      idens, ixmom, iymom, iener, irhoX, nspec,
                                       U_state)
 
             elif S_c <= 0.0 < S_r:
@@ -1020,7 +1040,8 @@ def riemann_hllc(idir, ng,
                         U_r[i, j, irhoX:irhoX + nspec] / rho_r
 
                 # find the flux on the right interface
-                F[i, j, :] = consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec,
+                F[i, j, :] = consFlux(idir, coord_type, gamma,
+                                      idens, ixmom, iymom, iener, irhoX, nspec,
                                       U_r[i, j, :])
 
                 # correct the flux
@@ -1048,7 +1069,8 @@ def riemann_hllc(idir, ng,
                         U_l[i, j, irhoX:irhoX + nspec] / rho_l
 
                 # find the flux on the left interface
-                F[i, j, :] = consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec,
+                F[i, j, :] = consFlux(idir, coord_type, gamma,
+                                      idens, ixmom, iymom, iener, irhoX, nspec,
                                       U_l[i, j, :])
 
                 # correct the flux
@@ -1058,16 +1080,22 @@ def riemann_hllc(idir, ng,
                 # L region
                 U_state[:] = U_l[i, j, :]
 
-                F[i, j, :] = consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec,
+                F[i, j, :] = consFlux(idir, coord_type, gamma,
+                                      idens, ixmom, iymom, iener, irhoX, nspec,
                                       U_state)
 
+            # update the output conserved state
+            U_out[i, j, :] = U_state[:]
+
             # we should deal with solid boundaries somehow here
 
-    return F
+    return F, U_out
 
 
 @njit(cache=True)
-def consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec, U_state):
+def consFlux(idir, coord_type, gamma,
+             idens, ixmom, iymom, iener, irhoX, nspec,
+             U_state):
     r"""
     Calculate the conservative flux.
 
@@ -1100,7 +1128,11 @@ def consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec, U_state):
 
     if idir == 1:
         F[idens] = U_state[idens] * u
-        F[ixmom] = U_state[ixmom] * u + p
+        F[ixmom] = U_state[ixmom] * u
+        # if Cartesian2d, then add pressure to xmom flux
+        if coord_type == 0:
+            F[ixmom] += p
+
         F[iymom] = U_state[iymom] * u
         F[iener] = (U_state[iener] + p) * u
 
@@ -1110,7 +1142,11 @@ def consFlux(idir, gamma, idens, ixmom, iymom, iener, irhoX, nspec, U_state):
     else:
         F[idens] = U_state[idens] * v
         F[ixmom] = U_state[ixmom] * v
-        F[iymom] = U_state[iymom] * v + p
+        F[iymom] = U_state[iymom] * v
+        # if Cartesian2d, then add pressure to ymom flux
+        if coord_type == 0:
+            F[iymom] += p
+
         F[iener] = (U_state[iener] + p) * v
 
         if nspec > 0:
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 3485727ee..7073518d8 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -326,15 +326,15 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     else:
         msg.fail("ERROR: Riemann solver undefined")
 
-    _fx = riemannFunc(1, myg.ng,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.xl, solid.xr,
-                      gamma, U_xl, U_xr)
+    _fx, _ux = riemannFunc(1, myg.ng, myg.coord_type,
+                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                           solid.xl, solid.xr,
+                           gamma, U_xl, U_xr)
 
-    _fy = riemannFunc(2, myg.ng,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.yl, solid.yr,
-                      gamma, U_yl, U_yr)
+    _fy, _uy = riemannFunc(2, myg.ng, myg.coord_type,
+                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                           solid.yl, solid.yr,
+                           gamma, U_yl, U_yr)
 
     F_x = ai.ArrayIndexer(d=_fx, grid=myg)
     F_y = ai.ArrayIndexer(d=_fy, grid=myg)
@@ -427,21 +427,31 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
 
     tm_riem.begin()
 
-    _fx = riemannFunc(1, myg.ng,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.xl, solid.xr,
-                      gamma, U_xl, U_xr)
+    _fx, _ux = riemannFunc(1, myg.ng, myg.coord_type,
+                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                           solid.xl, solid.xr,
+                           gamma, U_xl, U_xr)
 
-    _fy = riemannFunc(2, myg.ng,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.yl, solid.yr,
-                      gamma, U_yl, U_yr)
+    _fy, _uy = riemannFunc(2, myg.ng, myg.coord_type,
+                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                           solid.yl, solid.yr,
+                           gamma, U_yl, U_yr)
 
     F_x = ai.ArrayIndexer(d=_fx, grid=myg)
     F_y = ai.ArrayIndexer(d=_fy, grid=myg)
 
     tm_riem.end()
 
+    #
+    # Since conservative update of SphericalPolar Geometry need
+    # pressure term specifically, update pressure here.
+    #
+    # Use F_x to get p_{i +/- 1/2, j} and F_y to get p_{i,j +/- 1/2}
+
+    q_x = comp.cons_to_prim
+    p_x =
+    p_y =
+
     # =========================================================================
     # apply artificial viscosity
     # =========================================================================

From 3cc217c22a7cdc4178b8459b402828cc311e001e Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 16:20:56 -0400
Subject: [PATCH 36/65] update

---
 pyro/compressible/interface.py      | 135 +++++---
 pyro/compressible/simulation.py     |  92 +++++-
 pyro/compressible/unsplit_fluxes.py | 479 ++++++++++++++++++++++++++--
 3 files changed, 619 insertions(+), 87 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index feef23296..9ebcc7e36 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -1,6 +1,8 @@
 import numpy as np
 from numba import njit
 
+from pyro.util import msg
+
 
 @njit(cache=True)
 def states(idir, ng, dx, dt,
@@ -216,10 +218,10 @@ def states(idir, ng, dx, dt,
 
 
 @njit(cache=True)
-def riemann_cgf(idir, ng, coord_type,
-                idens, ixmom, iymom, iener, irhoX, nspec,
-                lower_solid, upper_solid,
-                gamma, U_l, U_r):
+def riemann_cons(idir, ng, coord_type,
+                 idens, ixmom, iymom, iener, irhoX, nspec,
+                 lower_solid, upper_solid,
+                 gamma, U_l, U_r):
     r"""
     Solve riemann shock tube problem for a general equation of
     state using the method of Colella, Glaz, and Ferguson.  See
@@ -269,12 +271,12 @@ def riemann_cgf(idir, ng, coord_type,
     Returns
     -------
     out : ndarray
-        Conserved flux
+        Conserved states.
     """
 
     qx, qy, nvar = U_l.shape
 
-    F = np.zeros((qx, qy, nvar))
+    U_out = np.zeros((qx, qy, nvar))
 
     smallc = 1.e-10
     smallrho = 1.e-10
@@ -499,43 +501,74 @@ def riemann_cgf(idir, ng, coord_type,
                 if j == jhi + 1 and upper_solid == 1:
                     un_state = 0.0
 
-            # compute the fluxes
-            F[i, j, idens] = rho_state * un_state
+            # update conserved state
+            U_out[i, j, idens] = rho_state
 
             if idir == 1:
-                F[i, j, ixmom] = rho_state * un_state**2
-                F[i, j, iymom] = rho_state * ut_state * un_state
-
-                # if Cartesian2d, then add pressure to xmom flux
+                U_out[i, j, ixmom] = rho_state * un_state
+                U_out[i, j, iymom] = rho_state * ut_state
                 if coord_type == 0:
-                    F[i, j, ixmom] += p_state
-
+                    U_out[i, j, ixmom] += p_state
             else:
-                F[i, j, ixmom] = rho_state * ut_state * un_state
-                F[i, j, iymom] = rho_state * un_state**2
-
-                # if Cartesian2d, then add pressure to ymom flux
+                U_out[i, j, ixmom] = rho_state * ut_state
+                U_out[i, j, iymom] = rho_state * un_state
                 if coord_type == 0:
-                    F[i, j, iymom] += p_state
+                    U_out[i, j, iymom] += p_state
 
-            F[i, j, iener] = rhoe_state * un_state + \
-                0.5 * rho_state * (un_state**2 + ut_state**2) * un_state + \
-                p_state * un_state
-
-            if nspec > 0:
-                F[i, j, irhoX:irhoX + nspec] = xn * rho_state * un_state
-
-            # update conserved state
-            U_out[i, j, idens] = rho_state
-            U_out[i, j, ixmom] = rho_state * un_state
-            U_out[i, j, iymom] = rho_state * vn_state
             U_out[i, j, iener] = rhoe_state + \
                 0.5 * rho_state * (un_state**2 + ut_state**2)
 
             if nspec > 0:
                 U_out[i, j, irhoX:irhoX + nspec] = xn * rho_state
 
-    return F, U_out
+    return U_out
+
+
+@njit(cache=True)
+def riemann_cgf(idir, ng, coord_type,
+                idens, ixmom, iymom, iener, irhoX, nspec,
+                lower_solid, upper_solid,
+                gamma, U_l, U_r):
+    r"""
+    This uses riemann_cons to directly output fluxes instead of conserved states.
+    This is mainly used to be consistent with riemann_hllc.
+
+    Parameters
+    ----------
+    idir : int
+        Are we predicting to the edges in the x-direction (1) or y-direction (2)?
+    ng : int
+        The number of ghost cells
+    nspec : int
+        The number of species
+    idens, ixmom, iymom, iener, irhoX : int
+        The indices of the density, x-momentum, y-momentum, internal energy density
+        and species partial densities in the conserved state vector.
+    lower_solid, upper_solid : int
+        Are we at lower or upper solid boundaries?
+    gamma : float
+        Adiabatic index
+    U_l, U_r : ndarray
+        Conserved state on the left and right cell edges.
+
+    Returns
+    -------
+    out : ndarray
+        Fluxes
+    """
+
+    # get conserved states from U_l and U_r
+    U_state = riemann_cons(idir, ng, coord_type,
+                           idens, ixmom, iymom, iener, irhoX, nspec,
+                           lower_solid, upper_solid,
+                           gamma, U_l, U_r)
+
+    # Construct the corresponding flux
+    F = consFlux(idir, coord_type, gamma,
+                 idens, ixmom, iymom, iener, irhoX, nspec,
+                 U_state)
+
+    return F
 
 
 @njit(cache=True)
@@ -855,6 +888,10 @@ def riemann_hllc(idir, ng, coord_type,
         Conserved flux
     """
 
+    if coord_type == 1:
+        msg.fail("ERROR: HLLC Riemann Solver is not supported " +
+                 "for SphericalPolar Geometry")
+
     qx, qy, nvar = U_l.shape
 
     F = np.zeros((qx, qy, nvar))
@@ -862,7 +899,6 @@ def riemann_hllc(idir, ng, coord_type,
     smallc = 1.e-10
     smallp = 1.e-10
 
-    U_out = np.zeros((qx, qy, nvar))
     U_state = np.zeros(nvar)
 
     nx = qx - 2 * ng
@@ -1084,12 +1120,9 @@ def riemann_hllc(idir, ng, coord_type,
                                       idens, ixmom, iymom, iener, irhoX, nspec,
                                       U_state)
 
-            # update the output conserved state
-            U_out[i, j, :] = U_state[:]
-
             # we should deal with solid boundaries somehow here
 
-    return F, U_out
+    return F
 
 
 @njit(cache=True)
@@ -1121,36 +1154,36 @@ def consFlux(idir, coord_type, gamma,
 
     F = np.zeros_like(U_state)
 
-    u = U_state[ixmom] / U_state[idens]
-    v = U_state[iymom] / U_state[idens]
+    u = U_state[..., ixmom] / U_state[..., idens]
+    v = U_state[..., iymom] / U_state[..., idens]
 
-    p = (U_state[iener] - 0.5 * U_state[idens] * (u * u + v * v)) * (gamma - 1.0)
+    p = (U_state[..., iener] - 0.5 * U_state[..., idens] * (u * u + v * v)) * (gamma - 1.0)
 
     if idir == 1:
-        F[idens] = U_state[idens] * u
-        F[ixmom] = U_state[ixmom] * u
+        F[..., idens] = U_state[..., idens] * u
+        F[..., ixmom] = U_state[..., ixmom] * u
         # if Cartesian2d, then add pressure to xmom flux
         if coord_type == 0:
-            F[ixmom] += p
+            F[..., ixmom] += p
 
-        F[iymom] = U_state[iymom] * u
-        F[iener] = (U_state[iener] + p) * u
+        F[..., iymom] = U_state[..., iymom] * u
+        F[..., iener] = (U_state[..., iener] + p) * u
 
         if nspec > 0:
-            F[irhoX:irhoX + nspec] = U_state[irhoX:irhoX + nspec] * u
+            F[..., irhoX:irhoX + nspec] = U_state[..., irhoX:irhoX + nspec] * u
 
     else:
-        F[idens] = U_state[idens] * v
-        F[ixmom] = U_state[ixmom] * v
-        F[iymom] = U_state[iymom] * v
+        F[..., idens] = U_state[..., idens] * v
+        F[..., ixmom] = U_state[..., ixmom] * v
+        F[..., iymom] = U_state[..., iymom] * v
         # if Cartesian2d, then add pressure to ymom flux
         if coord_type == 0:
-            F[iymom] += p
+            F[..., iymom] += p
 
-        F[iener] = (U_state[iener] + p) * v
+        F[..., iener] = (U_state[..., iener] + p) * v
 
         if nspec > 0:
-            F[irhoX:irhoX + nspec] = U_state[irhoX:irhoX + nspec] * v
+            F[..., irhoX:irhoX + nspec] = U_state[..., irhoX:irhoX + nspec] * v
 
     return F
 
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 14ea50f6d..13f41354f 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -4,7 +4,9 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
+import pyro.compressible.interface as ifc
 import pyro.compressible.unsplit_fluxes as flx
+import pyro.mesh.array_indexer as ai
 import pyro.mesh.boundary as bnd
 from pyro.compressible import BC, derives, eos
 from pyro.mesh.patch import SphericalPolar
@@ -201,16 +203,86 @@ def evolve(self):
         ener = self.cc_data.get_var("energy")
 
         grav = self.rp.get_param("compressible.grav")
+        gamma = self.rp.get_param("eos.gamma")
 
         myg = self.cc_data.grid
 
-        Flux_x, Flux_y = flx.unsplit_fluxes(self.cc_data, self.aux_data, self.rp,
-                                            self.ivars, self.solid, self.tc, self.dt)
+        # First get conserved states normal to the x and y interface
+        U_xl, U_xr, U_yl, U_yr = flx.interface_states(self.cc_data, self.rp,
+                                                      self.ivars, self.tc, self.dt)
+
+        # Apply source terms to them.
+        # This includes external (gravity), geometric and pressure terms.
+        U_xl, U_xr, U_yl, U_yr = flx.apply_source_terms(U_xl, U_xr, U_yl, U_yr,
+                                                        self.cc_data, self.aux_data, self.rp,
+                                                        self.ivars, self.tc, self.dt)
+
+        # Apply transverse corrections.
+        U_xl, U_xr, U_yl, U_yr = flx.apply_transverse_flux(U_xl, U_xr, U_yl, U_yr,
+                                                           self.cc_data, self.rp, self.ivars,
+                                                           self.solid, self.tc, self.dt)
+
+        # Get the actual interface conserved state after using Riemann Solver
+        # Then construct the corresponding fluxes using the conserved states
+
+        if myg.coord_type == 1:
+            # We need pressure from interface state for conservative update for
+            # SphericalPolar geometry. So we need interface conserved states.
+
+            # Get the conserved interface state from Riemann Solver
+            _ux = ifc.riemann_cons(1, myg.ng, myg.coord_type,
+                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                   self.solid.xl, self.solid.xr,
+                                   gamma, U_xl, U_xr)
+
+            _uy = ifc.riemann_cons(2, myg.ng, myg.coord_type,
+                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                   self.solid.yl, self.solid.yr,
+                                   gamma, U_yl, U_yr)
+
+            U_x = ai.ArrayIndexer(d=_ux, grid=myg)
+            U_y = ai.ArrayIndexer(d=_uy, grid=myg)
+
+            # Find primitive variable since we need pressure in conservative update.
+
+            qx = cons_to_prim(U_x, gamma, self.ivars, myg)
+            qy = cons_to_prim(U_y, gamma, self.ivars, myg)
+
+            # Find the corresponding flux from the conserved states.
+            _fx = ifc.consFlux(1, myg.coord_type, gamma,
+                               self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                               self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                               _ux)
+
+            _fy = ifc.consFlux(2, myg.coord_type, gamma,
+                               self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                               self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                               _uy)
+
+            F_x = ai.ArrayIndexer(d=_fx, grid=myg)
+            F_y = ai.ArrayIndexer(d=_fy, grid=myg)
+
+        else:
+            # Directly calculate the interface flux using Riemann Solver
+            F_x, F_y = flx.riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                                        self.cc_data, self.rp, self.ivars,
+                                        self.solid, self.tc)
+
+        # Apply artificial viscosity to fluxes
+        q = cons_to_prim(self.cc_data.data, gamma, self.ivars, myg)
+
+        F_x, F_y = flx.apply_artificial_viscosity(F_x, F_y, q,
+                                                  self.cc_data, self.rp,
+                                                  self.ivars)
+
+        # Flux_x, Flux_y = flx.unsplit_fluxes(self.cc_data, self.aux_data, self.rp,
+        #                                     self.ivars, self.solid, self.tc, self.dt)
 
         old_dens = dens.copy()
         old_xmom = xmom.copy()
         old_ymom = ymom.copy()
-        old_pres = derives.derive_primitives(self.cc_data, "pressure")
 
         # conservative update
         dtdV = self.dt / myg.V.v()
@@ -219,26 +291,22 @@ def evolve(self):
             var = self.cc_data.get_var_by_index(n)
 
             var.v()[:, :] += dtdV * \
-                (Flux_x.v(n=n)*myg.Ax_l.v() - Flux_x.ip(1, n=n)*myg.Ax_r.v() +
-                 Flux_y.v(n=n)*myg.Ay_l.v() - Flux_y.jp(1, n=n)*myg.Ay_r.v())
-
-        # Get pressure using the interface flux
-
-        pres = derives.derive_primitives(self.cc_data, "pressure")
+                (F_x.v(n=n)*myg.Ax_l.v() - F_x.ip(1, n=n)*myg.Ax_r.v() +
+                 F_y.v(n=n)*myg.Ay_l.v() - F_y.jp(1, n=n)*myg.Ay_r.v())
 
         # Apply external source (gravity) and geometric terms
 
-        if isinstance(myg, SphericalPolar):
+        if myg.coord_type == 1:
             xmom.v()[:, :] += 0.5*self.dt * \
                 ((dens.v() + old_dens.v())*grav +
                  (ymom.v()**2 / dens.v() +
                   old_ymom.v()**2 / old_dens.v()) / myg.x2d.v()) - \
-                self.dt * (pres.ip(1) - pres.v()) / myg.Lx.v()
+                self.dt * (qx.ip(1, n=self.ivars.ip) - qx.v(n=self.ivars.ip)) / myg.Lx.v()
 
             ymom.v()[:, :] += 0.5*self.dt * \
                 (-xmom.v()*ymom.v() / dens.v() -
                  old_xmom.v()*old_ymom.v() / old_dens.v()) / myg.x2d.v() - \
-                self.dt * (pres.jp(1) - pres.v()) / myg.Ly.v()
+                self.dt * (qy.jp(1, n=self.ivars.ip) - qy.v(n=self.ivars.ip)) / myg.Ly.v()
 
             ener.v()[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
 
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 7073518d8..5be0d882e 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -122,8 +122,6 @@
 
 """
 
-import numpy as np
-
 import pyro.compressible as comp
 import pyro.compressible.interface as ifc
 import pyro.mesh.array_indexer as ai
@@ -132,6 +130,451 @@
 from pyro.util import msg
 
 
+def interface_states(my_data, rp, ivars, tc, dt):
+    """
+    interface_states returns the normal conserved states in the x and y
+    interfaces. We get the normal fluxes by finding the normal primitive states,
+    Then construct the corresponding conserved states.
+
+    Parameters
+    ----------
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    tc : TimerCollection object
+        The timers we are using to profile
+    dt : float
+        The timestep we are advancing through.
+
+    Returns
+    -------
+    out : ndarray, ndarray, ndarray, ndarray
+        Left and right normal conserved states in x and y interfaces
+    """
+
+    myg = my_data.grid
+    gamma = rp.get_param("eos.gamma")
+
+    # =========================================================================
+    # compute the primitive variables
+    # =========================================================================
+    # Q = (rho, u, v, p, {X})
+
+    q = comp.cons_to_prim(my_data.data, gamma, ivars, myg)
+
+    # =========================================================================
+    # compute the flattening coefficients
+    # =========================================================================
+
+    # there is a single flattening coefficient (xi) for all directions
+    use_flattening = rp.get_param("compressible.use_flattening")
+
+    if use_flattening:
+        xi_x = reconstruction.flatten(myg, q, 1, ivars, rp)
+        xi_y = reconstruction.flatten(myg, q, 2, ivars, rp)
+
+        xi = reconstruction.flatten_multid(myg, q, xi_x, xi_y, ivars)
+    else:
+        xi = 1.0
+
+    # monotonized central differences
+    tm_limit = tc.timer("limiting")
+    tm_limit.begin()
+
+    limiter = rp.get_param("compressible.limiter")
+
+    ldx = myg.scratch_array(nvar=ivars.nvar)
+    ldy = myg.scratch_array(nvar=ivars.nvar)
+
+    for n in range(ivars.nvar):
+        ldx[:, :, n] = xi*reconstruction.limit(q[:, :, n], myg, 1, limiter)
+        ldy[:, :, n] = xi*reconstruction.limit(q[:, :, n], myg, 2, limiter)
+
+    tm_limit.end()
+
+    # =========================================================================
+    # x-direction
+    # =========================================================================
+
+    # left and right primitive variable states
+    tm_states = tc.timer("interfaceStates")
+    tm_states.begin()
+
+    V_l, V_r = ifc.states(1, myg.ng, myg.Lx, dt,
+                          ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
+                          ivars.naux,
+                          gamma,
+                          q, ldx)
+
+    tm_states.end()
+
+    # transform primitive interface states back into conserved variables
+    U_xl = comp.prim_to_cons(V_l, gamma, ivars, myg)
+    U_xr = comp.prim_to_cons(V_r, gamma, ivars, myg)
+
+    # =========================================================================
+    # y-direction
+    # =========================================================================
+
+    # left and right primitive variable states
+    tm_states.begin()
+
+    _V_l, _V_r = ifc.states(2, myg.ng, myg.Ly, dt,
+                            ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
+                            ivars.naux,
+                            gamma,
+                            q, ldy)
+    V_l = ai.ArrayIndexer(d=_V_l, grid=myg)
+    V_r = ai.ArrayIndexer(d=_V_r, grid=myg)
+
+    tm_states.end()
+
+    # transform primitive interface states back into conserved variables
+    U_yl = comp.prim_to_cons(V_l, gamma, ivars, myg)
+    U_yr = comp.prim_to_cons(V_r, gamma, ivars, myg)
+
+    return U_xl, U_xr, U_yl, U_yr
+
+
+def apply_source_terms(U_xl, U_xr, U_yl, U_yr,
+                       my_data, my_aux, rp, ivars, tc, dt):
+    """
+    This function applies source terms including external (gravity),
+    geometric terms, and pressure terms to the left and right
+    interface states (normal conserved states).
+    Both geometric and pressure terms arise purely from geometry.
+
+    Parameters
+    ----------
+    U_xl, U_xr, U_yl, U_yr: ndarray, ndarray, ndarray, ndarray
+        Conserved states in the left and right x-interface
+        and left and right y-interface.
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    my_aux : CellCenterData2d object
+        The data object that carries auxillary quantities which we need
+        to fill in the ghost cells.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    tc : TimerCollection object
+        The timers we are using to profile
+    dt : float
+        The timestep we are advancing through.
+
+    Returns
+    -------
+    out : ndarray, ndarray, ndarray, ndarray
+        Left and right normal conserved states in x and y interfaces
+        with source terms added.
+    """
+
+    tm_source = tc.timer("sourceTerms")
+    tm_source.begin()
+
+    myg = my_data.grid
+
+    dens = my_data.get_var("density")
+    xmom = my_data.get_var("x-momentum")
+    ymom = my_data.get_var("y-momentum")
+    pres = my_data.get_var("pressure")
+
+    dens_src = my_aux.get_var("dens_src")
+    xmom_src = my_aux.get_var("xmom_src")
+    ymom_src = my_aux.get_var("ymom_src")
+    E_src = my_aux.get_var("E_src")
+
+    grav = rp.get_param("compressible.grav")
+
+    # Calculate external source (gravity), geometric, and pressure terms
+    if myg.coord == 1:
+        # assume gravity points in r-direction in spherical.
+        dens_src.v()[:, :] = 0.0
+        xmom_src.v()[:, :] = dens.v()*grav + \
+            ymom.v()**2 / (dens.v()*myg.x2d.v()) - \
+            (pres.ip(1) - pres.v()) / myg.Lx.v()
+        ymom_src.v()[:, :] = -(pres.jp(1) - pres.v()) / myg.Ly.v() - \
+            dens.v()*xmom.v()*ymom.v() / (dens.v()*myg.x2d.v())
+        E_src.v()[:, :] = xmom.v()*grav
+
+    else:
+        # assume gravity points in y-direction in cartesian
+        dens_src.v()[:, :] = 0.0
+        xmom_src.v()[:, :] = 0.0
+        ymom_src.v()[:, :] = dens.v()*grav
+        E_src.v()[:, :] = ymom.v()*grav
+
+    my_aux.fill_BC("dens_src")
+    my_aux.fill_BC("xmom_src")
+    my_aux.fill_BC("ymom_src")
+    my_aux.fill_BC("E_src")
+
+    # U_xl[i,j] += 0.5*dt*source[i-1, j]
+    U_xl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.ip(-1, buf=1)
+    U_xl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.ip(-1, buf=1)
+    U_xl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.ip(-1, buf=1)
+
+    # U_xr[i,j] += 0.5*dt*source[i, j]
+    U_xr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
+    U_xr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
+    U_xr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
+
+    # U_yl[i,j] += 0.5*dt*source[i, j-1]
+    U_yl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.jp(-1, buf=1)
+    U_yl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.jp(-1, buf=1)
+    U_yl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.jp(-1, buf=1)
+
+    # U_yr[i,j] += 0.5*dt*source[i, j]
+    U_yr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
+    U_yr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
+    U_yr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
+
+    tm_source.end()
+
+    return U_xl, U_xr, U_yl, U_yr
+
+
+def riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                 my_data, rp, ivars, solid, tc):
+    """
+    This constructs the unsplit fluxes through the x and y interfaces
+    using the left and right conserved states by using the riemann solver.
+
+    Parameters
+    ----------
+    U_xl, U_xr, U_yl, U_yr: ndarray, ndarray, ndarray, ndarray
+        Conserved states in the left and right x-interface
+        and left and right y-interface.
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    solid: A container class
+        This is used in Riemann solver to indicate which side has solid boundary
+    tc : TimerCollection object
+        The timers we are using to profile
+
+    Returns
+    -------
+    out : ndarray, ndarray
+        Fluxes in x and y direction
+    """
+
+    tm_riem = tc.timer("riemann")
+    tm_riem.begin()
+
+    myg = my_data.grid
+
+    riemann = rp.get_param("compressible.riemann")
+    gamma = rp.get_param("eos.gamma")
+
+    riemannFunc = None
+    if riemann == "HLLC":
+        riemannFunc = ifc.riemann_hllc
+    elif riemann == "CGF":
+        riemannFunc = ifc.riemann_cgf
+    else:
+        msg.fail("ERROR: Riemann solver undefined")
+
+    _fx = riemannFunc(1, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.xl, solid.xr,
+                      gamma, U_xl, U_xr)
+
+    _fy = riemannFunc(2, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.yl, solid.yr,
+                      gamma, U_yl, U_yr)
+
+    F_x = ai.ArrayIndexer(d=_fx, grid=myg)
+    F_y = ai.ArrayIndexer(d=_fy, grid=myg)
+
+    tm_riem.end()
+
+    return F_x, F_y
+
+
+def apply_transverse_flux(U_xl, U_xr, U_yl, U_yr,
+                          my_data, rp, ivars, solid, tc, dt):
+    """
+    This function applies transverse correction terms to the
+    normal conserved states after applying other source terms.
+
+    We construct the state perpendicular to the interface
+    by adding the central difference part to the transverse flux
+    difference.
+
+    The states that we represent by indices i,j are shown below
+    (1,2,3,4):
+
+
+      j+3/2--+----------+----------+----------+
+             |          |          |          |
+             |          |          |          |
+        j+1 -+          |          |          |
+             |          |          |          |
+             |          |          |          |    1: U_xl[i,j,:] = U
+      j+1/2--+----------XXXXXXXXXXXX----------+                      i-1/2,j,L
+             |          X          X          |
+             |          X          X          |
+          j -+        1 X 2        X          |    2: U_xr[i,j,:] = U
+             |          X          X          |                      i-1/2,j,R
+             |          X    4     X          |
+      j-1/2--+----------XXXXXXXXXXXX----------+
+             |          |    3     |          |    3: U_yl[i,j,:] = U
+             |          |          |          |                      i,j-1/2,L
+        j-1 -+          |          |          |
+             |          |          |          |
+             |          |          |          |    4: U_yr[i,j,:] = U
+      j-3/2--+----------+----------+----------+                      i,j-1/2,R
+             |    |     |    |     |    |     |
+                 i-1         i         i+1
+           i-3/2      i-1/2      i+1/2      i+3/2
+
+
+    remember that the fluxes are stored on the left edge, so
+
+    F_x[i,j,:] = F_x
+                    i-1/2, j
+
+    F_y[i,j,:] = F_y
+                    i, j-1/2
+
+    Parameters
+    ----------
+    U_xl, U_xr, U_yl, U_yr: ndarray, ndarray, ndarray, ndarray
+        Conserved states in the left and right x-interface
+        and left and right y-interface.
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    solid: A container class
+        This is used in Riemann solver to indicate which side has solid boundary
+    tc : TimerCollection object
+        The timers we are using to profile
+    dt : float
+        The timestep we are advancing through.
+
+    Returns
+    -------
+    out : ndarray, ndarray, ndarray, ndarray
+        Left and right normal conserved states in x and y interfaces
+        with source terms added.
+    """
+
+    # Use Riemann Solver to get interface flux using the left and right states
+
+    F_x, F_y = riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                            my_data, rp, ivars, solid, tc)
+
+    # Now we update the conserved states using the transverse fluxes.
+
+    myg = my_data.grid
+
+    tm_transverse = tc.timer("transverse flux addition")
+    tm_transverse.begin()
+
+    b = (2, 1)
+    hdtV = 0.5*dt / myg.V
+
+    for n in range(ivars.nvar):
+
+        # U_xl[i,j,:] = U_xl[i,j,:] - 0.5*dt/dy * (F_y[i-1,j+1,:] - F_y[i-1,j,:])
+        U_xl.v(buf=b, n=n)[:, :] += \
+            - hdtV.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n)*myg.Ay_r.ip(-1, buf=b) -
+                             F_y.ip(-1, buf=b, n=n)*myg.Ay_l.ip(-1, buf=b))
+
+        # U_xr[i,j,:] = U_xr[i,j,:] - 0.5*dt/dy * (F_y[i,j+1,:] - F_y[i,j,:]
+        U_xr.v(buf=b, n=n)[:, :] += \
+            - hdtV.v(buf=b)*(F_y.jp(1, buf=b, n=n)*myg.Ay_r.v(buf=b) -
+                             F_y.v(buf=b, n=n)*myg.Ay_l.v(buf=b))
+
+        # U_yl[i,j,:] = U_yl[i,j,:] - 0.5*dt/dx * (F_x[i+1,j-1,:] - F_x[i,j-1,:])
+        U_yl.v(buf=b, n=n)[:, :] += \
+            - hdtV.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n)*myg.Ax_r.jp(-1, buf=b) -
+                             F_x.jp(-1, buf=b, n=n)*myg.Ax_l.jp(-1, buf=b))
+
+        # U_yr[i,j,:] = U_yr[i,j,:] - 0.5*dt/dx * (F_x[i+1,j,:] - F_x[i,j,:])
+        U_yr.v(buf=b, n=n)[:, :] += \
+            - hdtV.v(buf=b)*(F_x.ip(1, buf=b, n=n)*myg.Ax_r.v(buf=b) -
+                             F_x.v(buf=b, n=n)*myg.Ax_l.v(buf=b))
+
+    tm_transverse.end()
+
+    return U_xl, U_xr, U_yl, U_yr
+
+
+def apply_artificial_viscosity(F_x, F_y, q,
+                               my_data, rp, ivars):
+    """
+    This applies artificial viscosity correction terms to the fluxes.
+
+    Parameters
+    ----------
+    F_x, F_y : ndarray, ndarray
+        Fluxes in x and y interface.
+    q : ndarray
+        Primitive variables
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    dt : float
+        The timestep we are advancing through.
+
+    Returns
+    -------
+    out : ndarray, ndarray
+        Fluxes in x and y interface.
+    """
+
+    cvisc = rp.get_param("compressible.cvisc")
+
+    myg = my_data.grid
+
+    _ax, _ay = ifc.artificial_viscosity(myg.ng, myg.dx, myg.dy,
+        cvisc, q.v(n=ivars.iu, buf=myg.ng), q.v(n=ivars.iv, buf=myg.ng))
+
+    avisco_x = ai.ArrayIndexer(d=_ax, grid=myg)
+    avisco_y = ai.ArrayIndexer(d=_ay, grid=myg)
+
+    b = (2, 1)
+
+    for n in range(ivars.nvar):
+        # F_x = F_x + avisco_x * (U(i-1,j) - U(i,j))
+        var = my_data.get_var_by_index(n)
+
+        F_x.v(buf=b, n=n)[:, :] += \
+            avisco_x.v(buf=b)*(var.ip(-1, buf=b) - var.v(buf=b))
+
+        # F_y = F_y + avisco_y * (U(i,j-1) - U(i,j))
+        F_y.v(buf=b, n=n)[:, :] += \
+            avisco_y.v(buf=b)*(var.jp(-1, buf=b) - var.v(buf=b))
+
+    return F_x, F_y
+
+
 def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     """
     unsplitFluxes returns the fluxes through the x and y interfaces by
@@ -162,7 +605,6 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     -------
     out : ndarray, ndarray
         The fluxes on the x- and y-interfaces
-
     """
 
     tm_flux = tc.timer("unsplitFluxes")
@@ -257,7 +699,6 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     dens = my_data.get_var("density")
     xmom = my_data.get_var("x-momentum")
     ymom = my_data.get_var("y-momentum")
-    E = my_data.get_var("energy")
     pres = my_data.get_var("pressure")
 
     dens_src = my_aux.get_var("dens_src")
@@ -326,12 +767,12 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     else:
         msg.fail("ERROR: Riemann solver undefined")
 
-    _fx, _ux = riemannFunc(1, myg.ng, myg.coord_type,
+    _fx = riemannFunc(1, myg.ng, myg.coord_type,
                            ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
                            solid.xl, solid.xr,
                            gamma, U_xl, U_xr)
 
-    _fy, _uy = riemannFunc(2, myg.ng, myg.coord_type,
+    _fy = riemannFunc(2, myg.ng, myg.coord_type,
                            ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
                            solid.yl, solid.yr,
                            gamma, U_yl, U_yr)
@@ -427,31 +868,21 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
 
     tm_riem.begin()
 
-    _fx, _ux = riemannFunc(1, myg.ng, myg.coord_type,
-                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                           solid.xl, solid.xr,
-                           gamma, U_xl, U_xr)
+    _fx = riemannFunc(1, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.xl, solid.xr,
+                      gamma, U_xl, U_xr)
 
-    _fy, _uy = riemannFunc(2, myg.ng, myg.coord_type,
-                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                           solid.yl, solid.yr,
-                           gamma, U_yl, U_yr)
+    _fy = riemannFunc(2, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.yl, solid.yr,
+                      gamma, U_yl, U_yr)
 
     F_x = ai.ArrayIndexer(d=_fx, grid=myg)
     F_y = ai.ArrayIndexer(d=_fy, grid=myg)
 
     tm_riem.end()
 
-    #
-    # Since conservative update of SphericalPolar Geometry need
-    # pressure term specifically, update pressure here.
-    #
-    # Use F_x to get p_{i +/- 1/2, j} and F_y to get p_{i,j +/- 1/2}
-
-    q_x = comp.cons_to_prim
-    p_x =
-    p_y =
-
     # =========================================================================
     # apply artificial viscosity
     # =========================================================================

From 6bb2b66706a60e5fcef988f80eec99ea18834a2c Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 16:43:49 -0400
Subject: [PATCH 37/65] update

---
 pyro/compressible/interface.py      | 4 ++--
 pyro/compressible/simulation.py     | 6 +++---
 pyro/compressible/unsplit_fluxes.py | 2 +-
 pyro/compressible_rk/fluxes.py      | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 9ebcc7e36..3f703c091 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -888,9 +888,9 @@ def riemann_hllc(idir, ng, coord_type,
         Conserved flux
     """
 
+
     if coord_type == 1:
-        msg.fail("ERROR: HLLC Riemann Solver is not supported " +
-                 "for SphericalPolar Geometry")
+        msg.fail("ERROR: HLLC Riemann Solver is not supported for SphericalPolar Geometry")
 
     qx, qy, nvar = U_l.shape
 
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 13f41354f..dde5e5bbf 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -308,12 +308,12 @@ def evolve(self):
                  old_xmom.v()*old_ymom.v() / old_dens.v()) / myg.x2d.v() - \
                 self.dt * (qy.jp(1, n=self.ivars.ip) - qy.v(n=self.ivars.ip)) / myg.Ly.v()
 
-            ener.v()[:, :] += 0.5*self.dt*(xmom[:, :] + old_xmom[:, :])*grav
+            ener.v()[:, :] += 0.5*self.dt*(xmom.v() + old_xmom.v())*grav
 
         else:
             # gravitational source terms
-            ymom.v()[:, :] += 0.5*self.dt*(dens[:, :] + old_dens[:, :])*grav
-            ener.v()[:, :] += 0.5*self.dt*(ymom[:, :] + old_ymom[:, :])*grav
+            ymom.v()[:, :] += 0.5*self.dt*(dens.v() + old_dens.v())*grav
+            ener.v()[:, :] += 0.5*self.dt*(ymom.v() + old_ymom.v())*grav
 
         if self.particles is not None:
             self.particles.update_particles(self.dt)
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 5be0d882e..e3180ad18 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -295,7 +295,7 @@ def apply_source_terms(U_xl, U_xr, U_yl, U_yr,
     grav = rp.get_param("compressible.grav")
 
     # Calculate external source (gravity), geometric, and pressure terms
-    if myg.coord == 1:
+    if myg.coord_type == 1:
         # assume gravity points in r-direction in spherical.
         dens_src.v()[:, :] = 0.0
         xmom_src.v()[:, :] = dens.v()*grav + \
diff --git a/pyro/compressible_rk/fluxes.py b/pyro/compressible_rk/fluxes.py
index 15d2146b1..1f11a0765 100644
--- a/pyro/compressible_rk/fluxes.py
+++ b/pyro/compressible_rk/fluxes.py
@@ -174,12 +174,12 @@ def fluxes(my_data, rp, ivars, solid, tc):
     else:
         msg.fail("ERROR: Riemann solver undefined")
 
-    _fx = riemannFunc(1, myg.ng,
+    _fx = riemannFunc(1, myg.ng, myg.coord_type,
                       ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
                       solid.xl, solid.xr,
                       gamma, U_xl, U_xr)
 
-    _fy = riemannFunc(2, myg.ng,
+    _fy = riemannFunc(2, myg.ng, myg.coord_type,
                       ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
                       solid.yl, solid.yr,
                       gamma, U_yl, U_yr)

From 1a6b0d4d748a1a921e13193ff762612ad88bf13a Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 18:20:00 -0400
Subject: [PATCH 38/65] fix error message when using HLLC with sphericalpolar
 geometry

---
 pyro/compressible/interface.py  | 4 ----
 pyro/compressible/simulation.py | 6 ++++++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 3f703c091..17b740fde 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -888,10 +888,6 @@ def riemann_hllc(idir, ng, coord_type,
         Conserved flux
     """
 
-
-    if coord_type == 1:
-        msg.fail("ERROR: HLLC Riemann Solver is not supported for SphericalPolar Geometry")
-
     qx, qy, nvar = U_l.shape
 
     F = np.zeros((qx, qy, nvar))
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index dde5e5bbf..d58564cb1 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -111,6 +111,12 @@ def initialize(self, extra_vars=None, ng=4):
         my_grid = grid_setup(self.rp, ng=ng)
         my_data = self.data_class(my_grid)
 
+        # Make sure we use CGF for riemann solver when we do SphericalPolar
+        riemann = self.rp.get_param("compressible.riemann")
+        if my_grid.coord_type == 1 and riemann == "HLLC":
+            msg.fail("ERROR: Only CGF Riemann Solver is supported " +
+                     "with SphericalPolar Geometry")
+
         # define solver specific boundary condition routines
         bnd.define_bc("hse", BC.user, is_solid=False)
         bnd.define_bc("ramp", BC.user, is_solid=False)  # for double mach reflection problem

From 172f62c7065691e7645bfa99bba30816ebced597 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 18:21:31 -0400
Subject: [PATCH 39/65] fix flake8

---
 pyro/compressible/interface.py  | 2 --
 pyro/compressible/simulation.py | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index 17b740fde..c801bf8ca 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -1,8 +1,6 @@
 import numpy as np
 from numba import njit
 
-from pyro.util import msg
-
 
 @njit(cache=True)
 def states(idir, ng, dx, dt,
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index d58564cb1..154f21754 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -12,7 +12,7 @@
 from pyro.mesh.patch import SphericalPolar
 from pyro.particles import particles
 from pyro.simulation_null import NullSimulation, bc_setup, grid_setup
-from pyro.util import plot_tools
+from pyro.util import msg, plot_tools
 
 
 class Variables:

From 2bc645b757c3f2834bb76d593581f9ff7abb972d Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 21:03:23 -0400
Subject: [PATCH 40/65] add try except for getting riemann solver

---
 pyro/compressible/simulation.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 154f21754..7df36d008 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -112,7 +112,11 @@ def initialize(self, extra_vars=None, ng=4):
         my_data = self.data_class(my_grid)
 
         # Make sure we use CGF for riemann solver when we do SphericalPolar
-        riemann = self.rp.get_param("compressible.riemann")
+        try:
+            riemann = self.rp.get_param("compressible.riemann")
+        except KeyError:
+            msg.fail("ERROR: Riemann Solver is not set.")
+
         if my_grid.coord_type == 1 and riemann == "HLLC":
             msg.fail("ERROR: Only CGF Riemann Solver is supported " +
                      "with SphericalPolar Geometry")

From 0933ee98b3a6d1af51448b1e0c4508ce88040dcf Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 21:11:33 -0400
Subject: [PATCH 41/65] update unit_test to specify riemann solver

---
 pyro/compressible/tests/test_compressible.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyro/compressible/tests/test_compressible.py b/pyro/compressible/tests/test_compressible.py
index ad862f0b6..dd5e4dd60 100644
--- a/pyro/compressible/tests/test_compressible.py
+++ b/pyro/compressible/tests/test_compressible.py
@@ -26,6 +26,8 @@ def setup_method(self):
         self.rp.params["eos.gamma"] = 1.4
         self.rp.params["compressible.grav"] = 1.0
 
+        self.rp.params["compressible.riemann"] = "HLLC"
+
         self.sim = sn.Simulation("compressible", "test", self.rp)
         self.sim.initialize()
 

From 3dde81c378d949aff65f41adb2f55ebe91603be0 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 21:18:16 -0400
Subject: [PATCH 42/65] specify riemann solver in compressible_rk unit test

---
 pyro/compressible_rk/tests/test_compressible_rk.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyro/compressible_rk/tests/test_compressible_rk.py b/pyro/compressible_rk/tests/test_compressible_rk.py
index 0fba61d68..47ef0b4aa 100644
--- a/pyro/compressible_rk/tests/test_compressible_rk.py
+++ b/pyro/compressible_rk/tests/test_compressible_rk.py
@@ -22,6 +22,8 @@ def setup_method(self):
         self.rp.params["eos.gamma"] = 1.4
         self.rp.params["compressible.grav"] = 1.0
 
+        self.rp.params["compressible.riemann"] = "HLLC"
+
         self.sim = sn.Simulation("compressible", "test", self.rp)
         self.sim.initialize()
 

From 5d6baa1a26b2323faa6bde3798015aebd584b1ee Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 21:43:46 -0400
Subject: [PATCH 43/65] revert unit tests back and only add warning if riemann
 solver is not set

---
 pyro/compressible/simulation.py                    | 2 +-
 pyro/compressible/tests/test_compressible.py       | 2 --
 pyro/compressible_rk/tests/test_compressible_rk.py | 2 --
 3 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 7df36d008..94289f3b0 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -115,7 +115,7 @@ def initialize(self, extra_vars=None, ng=4):
         try:
             riemann = self.rp.get_param("compressible.riemann")
         except KeyError:
-            msg.fail("ERROR: Riemann Solver is not set.")
+            msg.warning("ERROR: Riemann Solver is not set.")
 
         if my_grid.coord_type == 1 and riemann == "HLLC":
             msg.fail("ERROR: Only CGF Riemann Solver is supported " +
diff --git a/pyro/compressible/tests/test_compressible.py b/pyro/compressible/tests/test_compressible.py
index dd5e4dd60..ad862f0b6 100644
--- a/pyro/compressible/tests/test_compressible.py
+++ b/pyro/compressible/tests/test_compressible.py
@@ -26,8 +26,6 @@ def setup_method(self):
         self.rp.params["eos.gamma"] = 1.4
         self.rp.params["compressible.grav"] = 1.0
 
-        self.rp.params["compressible.riemann"] = "HLLC"
-
         self.sim = sn.Simulation("compressible", "test", self.rp)
         self.sim.initialize()
 
diff --git a/pyro/compressible_rk/tests/test_compressible_rk.py b/pyro/compressible_rk/tests/test_compressible_rk.py
index 47ef0b4aa..0fba61d68 100644
--- a/pyro/compressible_rk/tests/test_compressible_rk.py
+++ b/pyro/compressible_rk/tests/test_compressible_rk.py
@@ -22,8 +22,6 @@ def setup_method(self):
         self.rp.params["eos.gamma"] = 1.4
         self.rp.params["compressible.grav"] = 1.0
 
-        self.rp.params["compressible.riemann"] = "HLLC"
-
         self.sim = sn.Simulation("compressible", "test", self.rp)
         self.sim.initialize()
 

From 1c491e082bae12bab8b150d1a359cd050f7886c7 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 22:14:34 -0400
Subject: [PATCH 44/65] change from isinstance to check coord_type

---
 pyro/compressible/unsplit_fluxes.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index e3180ad18..054fc15d5 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -126,7 +126,6 @@
 import pyro.compressible.interface as ifc
 import pyro.mesh.array_indexer as ai
 from pyro.mesh import reconstruction
-from pyro.mesh.patch import SphericalPolar
 from pyro.util import msg
 
 
@@ -709,7 +708,7 @@ def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
     grav = rp.get_param("compressible.grav")
 
     # Calculate external source (gravity), geometric, and pressure terms
-    if isinstance(myg, SphericalPolar):
+    if myg.coord_type == 1:
         # assume gravity points in r-direction in spherical.
         dens_src.v()[:, :] = 0.0
         xmom_src.v()[:, :] = dens.v()*grav + \

From 32cf0306602bfde93aa9167b30713fdd97487034 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 23:07:55 -0400
Subject: [PATCH 45/65] fix unintentional extra pressure

---
 pyro/compressible/interface.py  | 4 ----
 pyro/compressible/simulation.py | 5 ++---
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index c801bf8ca..d6741650a 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -505,13 +505,9 @@ def riemann_cons(idir, ng, coord_type,
             if idir == 1:
                 U_out[i, j, ixmom] = rho_state * un_state
                 U_out[i, j, iymom] = rho_state * ut_state
-                if coord_type == 0:
-                    U_out[i, j, ixmom] += p_state
             else:
                 U_out[i, j, ixmom] = rho_state * ut_state
                 U_out[i, j, iymom] = rho_state * un_state
-                if coord_type == 0:
-                    U_out[i, j, iymom] += p_state
 
             U_out[i, j, iener] = rhoe_state + \
                 0.5 * rho_state * (un_state**2 + ut_state**2)
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 94289f3b0..819560fc4 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -9,7 +9,6 @@
 import pyro.mesh.array_indexer as ai
 import pyro.mesh.boundary as bnd
 from pyro.compressible import BC, derives, eos
-from pyro.mesh.patch import SphericalPolar
 from pyro.particles import particles
 from pyro.simulation_null import NullSimulation, bc_setup, grid_setup
 from pyro.util import msg, plot_tools
@@ -369,7 +368,7 @@ def dovis(self):
         x = myg.scratch_array()
         y = myg.scratch_array()
 
-        if isinstance(myg, SphericalPolar):
+        if myg.coord_type == 1:
             x.v()[:, :] = myg.x2d.v()[:, :]*np.sin(myg.y2d.v()[:, :])
             y.v()[:, :] = myg.x2d.v()[:, :]*np.cos(myg.y2d.v()[:, :])
         else:
@@ -408,7 +407,7 @@ def dovis(self):
             ax.scatter(particle_positions[:, 0],
                 particle_positions[:, 1], s=5, c=colors, alpha=0.8, cmap="Greys")
 
-            if isinstance(myg, SphericalPolar):
+            if myg.coord_type == 1:
                 ax.set_xlim([np.min(x), np.max(x)])
                 ax.set_ylim([np.min(y), np.max(y)])
             else:

From 95538df457e085438bfddcde6d4c042b2e991e23 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 23:09:13 -0400
Subject: [PATCH 46/65] remove old code

---
 pyro/compressible/simulation.py     |   3 -
 pyro/compressible/unsplit_fluxes.py | 337 ----------------------------
 2 files changed, 340 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 819560fc4..b46c2658c 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -286,9 +286,6 @@ def evolve(self):
                                                   self.cc_data, self.rp,
                                                   self.ivars)
 
-        # Flux_x, Flux_y = flx.unsplit_fluxes(self.cc_data, self.aux_data, self.rp,
-        #                                     self.ivars, self.solid, self.tc, self.dt)
-
         old_dens = dens.copy()
         old_xmom = xmom.copy()
         old_ymom = ymom.copy()
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 054fc15d5..e824e578b 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -572,340 +572,3 @@ def apply_artificial_viscosity(F_x, F_y, q,
             avisco_y.v(buf=b)*(var.jp(-1, buf=b) - var.v(buf=b))
 
     return F_x, F_y
-
-
-def unsplit_fluxes(my_data, my_aux, rp, ivars, solid, tc, dt):
-    """
-    unsplitFluxes returns the fluxes through the x and y interfaces by
-    doing an unsplit reconstruction of the interface values and then
-    solving the Riemann problem through all the interfaces at once
-
-    currently we assume a gamma-law EOS
-
-    The runtime parameter grav is assumed to be the gravitational
-    acceleration in the y-direction
-
-    Parameters
-    ----------
-    my_data : CellCenterData2d object
-        The data object containing the grid and advective scalar that
-        we are advecting.
-    rp : RuntimeParameters object
-        The runtime parameters for the simulation
-    vars : Variables object
-        The Variables object that tells us which indices refer to which
-        variables
-    tc : TimerCollection object
-        The timers we are using to profile
-    dt : float
-        The timestep we are advancing through.
-
-    Returns
-    -------
-    out : ndarray, ndarray
-        The fluxes on the x- and y-interfaces
-    """
-
-    tm_flux = tc.timer("unsplitFluxes")
-    tm_flux.begin()
-
-    myg = my_data.grid
-
-    gamma = rp.get_param("eos.gamma")
-
-    # =========================================================================
-    # compute the primitive variables
-    # =========================================================================
-    # Q = (rho, u, v, p, {X})
-
-    q = comp.cons_to_prim(my_data.data, gamma, ivars, myg)
-
-    # =========================================================================
-    # compute the flattening coefficients
-    # =========================================================================
-
-    # there is a single flattening coefficient (xi) for all directions
-    use_flattening = rp.get_param("compressible.use_flattening")
-
-    if use_flattening:
-        xi_x = reconstruction.flatten(myg, q, 1, ivars, rp)
-        xi_y = reconstruction.flatten(myg, q, 2, ivars, rp)
-
-        xi = reconstruction.flatten_multid(myg, q, xi_x, xi_y, ivars)
-    else:
-        xi = 1.0
-
-    # monotonized central differences
-    tm_limit = tc.timer("limiting")
-    tm_limit.begin()
-
-    limiter = rp.get_param("compressible.limiter")
-
-    ldx = myg.scratch_array(nvar=ivars.nvar)
-    ldy = myg.scratch_array(nvar=ivars.nvar)
-
-    for n in range(ivars.nvar):
-        ldx[:, :, n] = xi*reconstruction.limit(q[:, :, n], myg, 1, limiter)
-        ldy[:, :, n] = xi*reconstruction.limit(q[:, :, n], myg, 2, limiter)
-
-    tm_limit.end()
-
-    # =========================================================================
-    # x-direction
-    # =========================================================================
-
-    # left and right primitive variable states
-    tm_states = tc.timer("interfaceStates")
-    tm_states.begin()
-
-    V_l, V_r = ifc.states(1, myg.ng, myg.Lx, dt,
-                          ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
-                          ivars.naux,
-                          gamma,
-                          q, ldx)
-
-    tm_states.end()
-
-    # transform interface states back into conserved variables
-    U_xl = comp.prim_to_cons(V_l, gamma, ivars, myg)
-    U_xr = comp.prim_to_cons(V_r, gamma, ivars, myg)
-
-    # =========================================================================
-    # y-direction
-    # =========================================================================
-
-    # left and right primitive variable states
-    tm_states.begin()
-
-    _V_l, _V_r = ifc.states(2, myg.ng, myg.Ly, dt,
-                            ivars.irho, ivars.iu, ivars.iv, ivars.ip, ivars.ix,
-                            ivars.naux,
-                            gamma,
-                            q, ldy)
-    V_l = ai.ArrayIndexer(d=_V_l, grid=myg)
-    V_r = ai.ArrayIndexer(d=_V_r, grid=myg)
-
-    tm_states.end()
-
-    # transform interface states back into conserved variables
-    U_yl = comp.prim_to_cons(V_l, gamma, ivars, myg)
-    U_yr = comp.prim_to_cons(V_r, gamma, ivars, myg)
-
-    # =========================================================================
-    # apply source terms
-    # =========================================================================
-
-    dens = my_data.get_var("density")
-    xmom = my_data.get_var("x-momentum")
-    ymom = my_data.get_var("y-momentum")
-    pres = my_data.get_var("pressure")
-
-    dens_src = my_aux.get_var("dens_src")
-    xmom_src = my_aux.get_var("xmom_src")
-    ymom_src = my_aux.get_var("ymom_src")
-    E_src = my_aux.get_var("E_src")
-
-    grav = rp.get_param("compressible.grav")
-
-    # Calculate external source (gravity), geometric, and pressure terms
-    if myg.coord_type == 1:
-        # assume gravity points in r-direction in spherical.
-        dens_src.v()[:, :] = 0.0
-        xmom_src.v()[:, :] = dens.v()*grav + \
-            ymom.v()**2 / (dens.v()*myg.x2d.v()) - \
-            (pres.ip(1) - pres.v()) / myg.Lx.v()
-        ymom_src.v()[:, :] = -(pres.jp(1) - pres.v()) / myg.Ly.v() - \
-            dens.v()*xmom.v()*ymom.v() / (dens.v()*myg.x2d.v())
-        E_src.v()[:, :] = xmom.v()*grav
-
-    else:
-        # assume gravity points in y-direction in cartesian
-        dens_src.v()[:, :] = 0.0
-        xmom_src.v()[:, :] = 0.0
-        ymom_src.v()[:, :] = dens.v()*grav
-        E_src.v()[:, :] = ymom.v()*grav
-
-    my_aux.fill_BC("dens_src")
-    my_aux.fill_BC("xmom_src")
-    my_aux.fill_BC("ymom_src")
-    my_aux.fill_BC("E_src")
-
-    # ymom_xl[i,j] += 0.5*dt*dens[i-1,j]*grav
-    U_xl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.ip(-1, buf=1)
-    U_xl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.ip(-1, buf=1)
-    U_xl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.ip(-1, buf=1)
-
-    # ymom_xr[i,j] += 0.5*dt*dens[i,j]*grav
-    U_xr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
-    U_xr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
-    U_xr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
-
-    # ymom_yl[i,j] += 0.5*dt*dens[i,j-1]*grav
-    U_yl.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.jp(-1, buf=1)
-    U_yl.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.jp(-1, buf=1)
-    U_yl.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.jp(-1, buf=1)
-
-    # ymom_yr[i,j] += 0.5*dt*dens[i,j]*grav
-    U_yr.v(buf=1, n=ivars.ixmom)[:, :] += 0.5*dt*xmom_src.v(buf=1)
-    U_yr.v(buf=1, n=ivars.iymom)[:, :] += 0.5*dt*ymom_src.v(buf=1)
-    U_yr.v(buf=1, n=ivars.iener)[:, :] += 0.5*dt*E_src.v(buf=1)
-
-    # =========================================================================
-    # compute transverse fluxes
-    # =========================================================================
-    tm_riem = tc.timer("riemann")
-    tm_riem.begin()
-
-    riemann = rp.get_param("compressible.riemann")
-
-    riemannFunc = None
-    if riemann == "HLLC":
-        riemannFunc = ifc.riemann_hllc
-    elif riemann == "CGF":
-        riemannFunc = ifc.riemann_cgf
-    else:
-        msg.fail("ERROR: Riemann solver undefined")
-
-    _fx = riemannFunc(1, myg.ng, myg.coord_type,
-                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                           solid.xl, solid.xr,
-                           gamma, U_xl, U_xr)
-
-    _fy = riemannFunc(2, myg.ng, myg.coord_type,
-                           ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                           solid.yl, solid.yr,
-                           gamma, U_yl, U_yr)
-
-    F_x = ai.ArrayIndexer(d=_fx, grid=myg)
-    F_y = ai.ArrayIndexer(d=_fy, grid=myg)
-
-    tm_riem.end()
-
-    # =========================================================================
-    # construct the interface values of U now
-    # =========================================================================
-
-    """
-    finally, we can construct the state perpendicular to the interface
-    by adding the central difference part to the transverse flux
-    difference.
-
-    The states that we represent by indices i,j are shown below
-    (1,2,3,4):
-
-
-      j+3/2--+----------+----------+----------+
-             |          |          |          |
-             |          |          |          |
-        j+1 -+          |          |          |
-             |          |          |          |
-             |          |          |          |    1: U_xl[i,j,:] = U
-      j+1/2--+----------XXXXXXXXXXXX----------+                      i-1/2,j,L
-             |          X          X          |
-             |          X          X          |
-          j -+        1 X 2        X          |    2: U_xr[i,j,:] = U
-             |          X          X          |                      i-1/2,j,R
-             |          X    4     X          |
-      j-1/2--+----------XXXXXXXXXXXX----------+
-             |          |    3     |          |    3: U_yl[i,j,:] = U
-             |          |          |          |                      i,j-1/2,L
-        j-1 -+          |          |          |
-             |          |          |          |
-             |          |          |          |    4: U_yr[i,j,:] = U
-      j-3/2--+----------+----------+----------+                      i,j-1/2,R
-             |    |     |    |     |    |     |
-                 i-1         i         i+1
-           i-3/2      i-1/2      i+1/2      i+3/2
-
-
-    remember that the fluxes are stored on the left edge, so
-
-    F_x[i,j,:] = F_x
-                    i-1/2, j
-
-    F_y[i,j,:] = F_y
-                    i, j-1/2
-
-    """
-
-    tm_transverse = tc.timer("transverse flux addition")
-    tm_transverse.begin()
-
-    b = (2, 1)
-    hdtV = 0.5*dt / myg.V
-
-    for n in range(ivars.nvar):
-
-        # U_xl[i,j,:] = U_xl[i,j,:] - 0.5*dt/dy * (F_y[i-1,j+1,:] - F_y[i-1,j,:])
-        U_xl.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n)*myg.Ay_r.ip(-1, buf=b) -
-                             F_y.ip(-1, buf=b, n=n)*myg.Ay_l.ip(-1, buf=b))
-
-        # U_xr[i,j,:] = U_xr[i,j,:] - 0.5*dt/dy * (F_y[i,j+1,:] - F_y[i,j,:])
-        U_xr.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_y.jp(1, buf=b, n=n)*myg.Ay_r.v(buf=b) -
-                             F_y.v(buf=b, n=n)*myg.Ay_l.v(buf=b))
-
-        # U_yl[i,j,:] = U_yl[i,j,:] - 0.5*dt/dx * (F_x[i+1,j-1,:] - F_x[i,j-1,:])
-        U_yl.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n)*myg.Ax_r.jp(-1, buf=b) -
-                             F_x.jp(-1, buf=b, n=n)*myg.Ax_l.jp(-1, buf=b))
-
-        # U_yr[i,j,:] = U_yr[i,j,:] - 0.5*dt/dx * (F_x[i+1,j,:] - F_x[i,j,:])
-        U_yr.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_x.ip(1, buf=b, n=n)*myg.Ax_r.v(buf=b) -
-                             F_x.v(buf=b, n=n)*myg.Ax_l.v(buf=b))
-
-    tm_transverse.end()
-
-    # =========================================================================
-    # construct the fluxes normal to the interfaces
-    # =========================================================================
-
-    # up until now, F_x and F_y stored the transverse fluxes, now we
-    # overwrite with the fluxes normal to the interfaces
-
-    tm_riem.begin()
-
-    _fx = riemannFunc(1, myg.ng, myg.coord_type,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.xl, solid.xr,
-                      gamma, U_xl, U_xr)
-
-    _fy = riemannFunc(2, myg.ng, myg.coord_type,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.yl, solid.yr,
-                      gamma, U_yl, U_yr)
-
-    F_x = ai.ArrayIndexer(d=_fx, grid=myg)
-    F_y = ai.ArrayIndexer(d=_fy, grid=myg)
-
-    tm_riem.end()
-
-    # =========================================================================
-    # apply artificial viscosity
-    # =========================================================================
-    cvisc = rp.get_param("compressible.cvisc")
-
-    _ax, _ay = ifc.artificial_viscosity(myg.ng, myg.dx, myg.dy,
-        cvisc, q.v(n=ivars.iu, buf=myg.ng), q.v(n=ivars.iv, buf=myg.ng))
-
-    avisco_x = ai.ArrayIndexer(d=_ax, grid=myg)
-    avisco_y = ai.ArrayIndexer(d=_ay, grid=myg)
-
-    b = (2, 1)
-
-    for n in range(ivars.nvar):
-        # F_x = F_x + avisco_x * (U(i-1,j) - U(i,j))
-        var = my_data.get_var_by_index(n)
-
-        F_x.v(buf=b, n=n)[:, :] += \
-            avisco_x.v(buf=b)*(var.ip(-1, buf=b) - var.v(buf=b))
-
-        # F_y = F_y + avisco_y * (U(i,j-1) - U(i,j))
-        F_y.v(buf=b, n=n)[:, :] += \
-            avisco_y.v(buf=b)*(var.jp(-1, buf=b) - var.v(buf=b))
-
-    tm_flux.end()
-
-    return F_x, F_y

From 05b58f647a2aa238df71953f1f74af6ba6fc4578 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 31 Jul 2024 23:24:30 -0400
Subject: [PATCH 47/65] fix flake8 and pylint

---
 pyro/compressible/interface.py  | 6 ++++--
 pyro/compressible/simulation.py | 4 ++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index d6741650a..ff0e2d0c2 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -216,7 +216,7 @@ def states(idir, ng, dx, dt,
 
 
 @njit(cache=True)
-def riemann_cons(idir, ng, coord_type,
+def riemann_cons(idir, ng,
                  idens, ixmom, iymom, iener, irhoX, nspec,
                  lower_solid, upper_solid,
                  gamma, U_l, U_r):
@@ -272,6 +272,8 @@ def riemann_cons(idir, ng, coord_type,
         Conserved states.
     """
 
+    # pylint: disable=unused-variable
+
     qx, qy, nvar = U_l.shape
 
     U_out = np.zeros((qx, qy, nvar))
@@ -552,7 +554,7 @@ def riemann_cgf(idir, ng, coord_type,
     """
 
     # get conserved states from U_l and U_r
-    U_state = riemann_cons(idir, ng, coord_type,
+    U_state = riemann_cons(idir, ng,
                            idens, ixmom, iymom, iener, irhoX, nspec,
                            lower_solid, upper_solid,
                            gamma, U_l, U_r)
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index b46c2658c..e484d4674 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -239,13 +239,13 @@ def evolve(self):
             # SphericalPolar geometry. So we need interface conserved states.
 
             # Get the conserved interface state from Riemann Solver
-            _ux = ifc.riemann_cons(1, myg.ng, myg.coord_type,
+            _ux = ifc.riemann_cons(1, myg.ng,
                                    self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
                                    self.ivars.iener, self.ivars.irhox, self.ivars.naux,
                                    self.solid.xl, self.solid.xr,
                                    gamma, U_xl, U_xr)
 
-            _uy = ifc.riemann_cons(2, myg.ng, myg.coord_type,
+            _uy = ifc.riemann_cons(2, myg.ng,
                                    self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
                                    self.ivars.iener, self.ivars.irhox, self.ivars.naux,
                                    self.solid.yl, self.solid.yr,

From 0f1ed3c9da05c020f5382e5a10ced311249e3a8c Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 11:57:21 -0400
Subject: [PATCH 48/65] get rid of redundant A_r, fix A_y calcualtion for
 sphericalpolar and some cleanup

---
 pyro/mesh/patch.py            | 40 ++++++++++-------------------------
 pyro/mesh/tests/test_patch.py | 28 ++++++++++++------------
 2 files changed, 24 insertions(+), 44 deletions(-)

diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 481a0f316..d0e6d2f1f 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -214,13 +214,11 @@ def __init__(self, nx, ny, ng=1,
 
         # This is area of the side that is perpendicular to x.
 
-        self.Ax_l = self.Ly.copy()
-        self.Ax_r = self.Ly.copy()
+        self.Ax = self.Ly
 
         # This is area of the side that is perpendicular to y.
 
-        self.Ay_l = self.Lx.copy()
-        self.Ay_r = self.Lx.copy()
+        self.Ay = self.Lx
 
         # Volume of the cell.
 
@@ -272,41 +270,25 @@ def __init__(self, nx, ny, ng=1,
         # dL_theta x dL_phi = r^2 * sin(theta) * dtheta * dphi
 
         # dAr_l = - r{i-1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        area_x_l = np.abs(-2.0 * np.pi * self.xl2d.v(buf=self.ng)**2 *
-                 (np.cos(self.yr2d.v(buf=self.ng)) -
-                  np.cos(self.yl2d.v(buf=self.ng))))
-        self.Ax_l = ArrayIndexer(area_x_l, grid=self)
-
-        # dAr_r = - r{i+1/2}^2 * 2pi * cos(theta{i+1/2}) - cos(theta{i-1/2})
-        area_x_r = np.abs(-2.0 * np.pi * self.xr2d.v(buf=self.ng)**2 *
-                 (np.cos(self.yr2d.v(buf=self.ng)) -
-                  np.cos(self.yl2d.v(buf=self.ng))))
-        self.Ax_r = ArrayIndexer(area_x_r, grid=self)
+        self.Ax = np.abs(-2.0 * np.pi * self.xl2d**2 *
+                         (np.cos(self.yr2d) - np.cos(self.yl2d)))
 
         # Returns an array of the face area that points in the theta(y) direction.
         # dL_phi x dL_r = dr * r * sin(theta) * dphi
 
-        # dAtheta_l = 0.5 * pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        area_y_l = np.abs(0.5 * np.pi * np.sin(self.yl2d.v(buf=self.ng)) *
-                 (self.xr2d.v(buf=self.ng)**2 -
-                  self.xl2d.v(buf=self.ng)**2))
-        self.Ay_l = ArrayIndexer(area_y_l, grid=self)
-
-        # dAtheta_r = 0.5 * pi * sin(theta{i+1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
-        area_y_r = np.abs(0.5 * np.pi * np.sin(self.yr2d.v(buf=self.ng)) *
-                 (self.xr2d.v(buf=self.ng)**2 -
-                  self.xl2d.v(buf=self.ng)**2))
-        self.Ay_r = ArrayIndexer(area_y_r, grid=self)
+        # dAtheta_l = pi * sin(theta{i-1/2}) * (r{i+1/2}^2 - r{i-1/2}^2)
+        self.Ay = np.abs(np.pi * np.sin(self.yl2d) *
+                         (self.xr2d**2 - self.xl2d**2))
 
         # Returns an array of the volume of each cell.
         # dV = dL_r * dL_theta * dL_phi
         #    = (dr) * (r * dtheta) * (r * sin(theta) * dphi)
         # dV = - 2*np.pi / 3 * (cos(theta{i+1/2}) - cos(theta{i-1/2})) * (r{i+1/2}^3 - r{i-1/2}^3)
 
-        volume = np.abs(-2.0 * np.pi / 3.0 *
-                 (np.cos(self.yr2d.v(buf=self.ng)) - np.cos(self.yl2d.v(buf=self.ng))) *
-                 (self.xr2d.v(buf=self.ng)**3 - self.xl2d.v(buf=self.ng)**3))
-        self.V = ArrayIndexer(volume, grid=self)
+        self.V = np.abs(-2.0 * np.pi / 3.0 *
+                        (np.cos(self.yr2d) - np.cos(self.yl2d)) *
+                        (self.xr2d - self.xl2d) *
+                        (self.xr2d**2 + self.xl2d**2 + self.xr2d*self.xl2d))
 
     def __str__(self):
         """ print out some basic information about the grid object """
diff --git a/pyro/mesh/tests/test_patch.py b/pyro/mesh/tests/test_patch.py
index 7ad296b9c..3385b788d 100644
--- a/pyro/mesh/tests/test_patch.py
+++ b/pyro/mesh/tests/test_patch.py
@@ -87,12 +87,10 @@ def teardown_method(self):
         self.g = None
 
     def test_Ax(self):
-        assert np.all(self.g.Ax_l.v() == 0.1)
-        assert np.all(self.g.Ax_r.v() == 0.1)
+        assert np.all(self.g.Ax.v() == 0.1)
 
     def test_Ay(self):
-        assert np.all(self.g.Ay_l.v() == 0.25)
-        assert np.all(self.g.Ay_r.v() == 0.25)
+        assert np.all(self.g.Ay.v() == 0.25)
 
     def test_V(self):
         assert np.all(self.g.V.v() == 0.1 * 0.25)
@@ -120,22 +118,22 @@ def teardown_method(self):
     def test_Ax(self):
         area_x_l = np.abs(-2.0 * np.pi * self.g.xl2d.v()**2 *
                  (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())))
-        assert_array_equal(self.g.Ax_l.v(), area_x_l)
+        assert_array_equal(self.g.Ax.v(), area_x_l)
 
         area_x_r = np.abs(-2.0 * np.pi * self.g.xr2d.v()**2 *
                  (np.cos(self.g.yr2d.v()) - np.cos(self.g.yl2d.v())))
-        assert_array_equal(self.g.Ax_r.v(), area_x_r)
+        assert_array_equal(self.g.Ax.ip(1), area_x_r)
 
     def test_Ay(self):
-        area_y_l = np.abs(0.5 * np.pi *
-                 np.sin(self.g.yl2d.v()) *
-                 (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
-        assert_array_equal(self.g.Ay_l.v(), area_y_l)
-
-        area_y_r = np.abs(0.5 * np.pi *
-                 np.sin(self.g.yr2d.v()) *
-                 (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
-        assert_array_equal(self.g.Ay_r.v(), area_y_r)
+        area_y_l = np.abs(np.pi *
+                          np.sin(self.g.yl2d.v()) *
+                          (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
+        assert_array_equal(self.g.Ay.v(), area_y_l)
+
+        area_y_r = np.abs(np.pi *
+                          np.sin(self.g.yr2d.v()) *
+                          (self.g.xr2d.v()**2 - self.g.xl2d.v()**2))
+        assert_array_equal(self.g.Ay.jp(1), area_y_r)
 
     def test_V(self):
         volume = np.abs(-2.0 * np.pi / 3.0 *

From 3db2751648f86ebf8282cf4d32b991b68e5e4966 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 12:10:40 -0400
Subject: [PATCH 49/65] update area factors

---
 pyro/compressible/simulation.py     |  4 ++--
 pyro/compressible/unsplit_fluxes.py | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index e484d4674..1799ba42a 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -297,8 +297,8 @@ def evolve(self):
             var = self.cc_data.get_var_by_index(n)
 
             var.v()[:, :] += dtdV * \
-                (F_x.v(n=n)*myg.Ax_l.v() - F_x.ip(1, n=n)*myg.Ax_r.v() +
-                 F_y.v(n=n)*myg.Ay_l.v() - F_y.jp(1, n=n)*myg.Ay_r.v())
+                (F_x.v(n=n)*myg.Ax.v() - F_x.ip(1, n=n)*myg.Ax.ip(1) +
+                 F_y.v(n=n)*myg.Ay.v() - F_y.jp(1, n=n)*myg.Ay.jp(1))
 
         # Apply external source (gravity) and geometric terms
 
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index e824e578b..3ea659594 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -497,23 +497,23 @@ def apply_transverse_flux(U_xl, U_xr, U_yl, U_yr,
 
         # U_xl[i,j,:] = U_xl[i,j,:] - 0.5*dt/dy * (F_y[i-1,j+1,:] - F_y[i-1,j,:])
         U_xl.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n)*myg.Ay_r.ip(-1, buf=b) -
-                             F_y.ip(-1, buf=b, n=n)*myg.Ay_l.ip(-1, buf=b))
+            - hdtV.v(buf=b)*(F_y.ip_jp(-1, 1, buf=b, n=n)*myg.Ay.ip_jp(-1, 1, buf=b) -
+                             F_y.ip(-1, buf=b, n=n)*myg.Ay.ip(-1, buf=b))
 
         # U_xr[i,j,:] = U_xr[i,j,:] - 0.5*dt/dy * (F_y[i,j+1,:] - F_y[i,j,:]
         U_xr.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_y.jp(1, buf=b, n=n)*myg.Ay_r.v(buf=b) -
-                             F_y.v(buf=b, n=n)*myg.Ay_l.v(buf=b))
+            - hdtV.v(buf=b)*(F_y.jp(1, buf=b, n=n)*myg.Ay.jp(1, buf=b) -
+                             F_y.v(buf=b, n=n)*myg.Ay.v(buf=b))
 
         # U_yl[i,j,:] = U_yl[i,j,:] - 0.5*dt/dx * (F_x[i+1,j-1,:] - F_x[i,j-1,:])
         U_yl.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n)*myg.Ax_r.jp(-1, buf=b) -
-                             F_x.jp(-1, buf=b, n=n)*myg.Ax_l.jp(-1, buf=b))
+            - hdtV.v(buf=b)*(F_x.ip_jp(1, -1, buf=b, n=n)*myg.Ax.ip_jp(1, -1, buf=b) -
+                             F_x.jp(-1, buf=b, n=n)*myg.Ax.jp(-1, buf=b))
 
         # U_yr[i,j,:] = U_yr[i,j,:] - 0.5*dt/dx * (F_x[i+1,j,:] - F_x[i,j,:])
         U_yr.v(buf=b, n=n)[:, :] += \
-            - hdtV.v(buf=b)*(F_x.ip(1, buf=b, n=n)*myg.Ax_r.v(buf=b) -
-                             F_x.v(buf=b, n=n)*myg.Ax_l.v(buf=b))
+            - hdtV.v(buf=b)*(F_x.ip(1, buf=b, n=n)*myg.Ax.ip(1, buf=b) -
+                             F_x.v(buf=b, n=n)*myg.Ax.v(buf=b))
 
     tm_transverse.end()
 

From 893c6709edb4b495c592b77a9cfa9781b9a93d5d Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 14:39:47 -0400
Subject: [PATCH 50/65] add a spherical advection problem. temporarily disable
 aritficial viscosity for sphericalpolar

---
 .../problems/inputs.spherical_advect          | 39 ++++++++++
 .../compressible/problems/spherical_advect.py | 75 +++++++++++++++++++
 pyro/compressible/simulation.py               | 10 ++-
 3 files changed, 120 insertions(+), 4 deletions(-)
 create mode 100644 pyro/compressible/problems/inputs.spherical_advect
 create mode 100644 pyro/compressible/problems/spherical_advect.py

diff --git a/pyro/compressible/problems/inputs.spherical_advect b/pyro/compressible/problems/inputs.spherical_advect
new file mode 100644
index 000000000..3d0682a67
--- /dev/null
+++ b/pyro/compressible/problems/inputs.spherical_advect
@@ -0,0 +1,39 @@
+[driver]
+max_steps = 500
+tmax = 1.0
+
+init_tstep_factor = 1.0
+fix_dt = 0.005
+
+
+[compressible]
+limiter = 0
+cvisc = 0.1
+riemann = CGF
+
+[io]
+basename = spherical_advect_
+
+
+[eos]
+gamma = 1.4
+
+
+[mesh]
+grid_type = SphericalPolar
+nx = 64
+ny = 64
+xmin = 1.0
+xmax = 2.0
+ymin = 0.523
+ymax = 2.617
+
+xlboundary = periodic
+xrboundary = periodic
+
+ylboundary = periodic
+yrboundary = periodic
+
+
+[vis]
+dovis = 1
diff --git a/pyro/compressible/problems/spherical_advect.py b/pyro/compressible/problems/spherical_advect.py
new file mode 100644
index 000000000..586bd1be6
--- /dev/null
+++ b/pyro/compressible/problems/spherical_advect.py
@@ -0,0 +1,75 @@
+import sys
+
+import numpy as np
+
+from pyro.mesh import patch
+from pyro.util import msg
+
+
+def init_data(my_data, rp):
+    """ initialize a smooth advection problem for testing convergence """
+
+    msg.bold("initializing the spherical advect problem...")
+
+    # make sure that we are passed a valid patch object
+    if not isinstance(my_data, patch.CellCenterData2d):
+        print("ERROR: patch invalid in advect.py")
+        print(my_data.__class__)
+        sys.exit()
+
+    # get the density, momenta, and energy as separate variables
+    dens = my_data.get_var("density")
+    xmom = my_data.get_var("x-momentum")
+    ymom = my_data.get_var("y-momentum")
+    ener = my_data.get_var("energy")
+
+    # initialize the components, remember, that ener here is rho*eint
+    # + 0.5*rho*v**2, where eint is the specific internal energy
+    # (erg/g)
+    dens[:, :] = 1.0
+    xmom[:, :] = 0.0
+    ymom[:, :] = 0.0
+
+    gamma = rp.get_param("eos.gamma")
+
+    xmin = rp.get_param("mesh.xmin")
+    xmax = rp.get_param("mesh.xmax")
+
+    ymin = rp.get_param("mesh.ymin")
+    ymax = rp.get_param("mesh.ymax")
+
+    # Actual x- and y- coordinate
+    myg = my_data.grid
+
+    x = myg.scratch_array()
+    y = myg.scratch_array()
+
+    xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
+    yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
+
+    x[:, :] = myg.x2d.v(buf=myg.ng) * np.sin(myg.y2d.v(buf=myg.ng))
+    y[:, :] = myg.x2d.v(buf=myg.ng) * np.cos(myg.y2d.v(buf=myg.ng))
+
+    # Initial density on the very top.
+
+    # this is identical to the advection/smooth problem
+    dens[:, :] = 1.0 + np.exp(-60.0*((x-xctr)**2 +
+                                    (y-yctr)**2))
+
+    # velocity in theta direction.
+    u = 0.0
+    v = 3.0
+
+    xmom[:, :] = dens[:, :]*u
+    ymom[:, :] = dens[:, :]*v
+
+    # pressure is constant
+    p = 1.0
+    ener[:, :] = p/(gamma - 1.0) + 0.5*(xmom[:, :]**2 + ymom[:, :]**2)/dens[:, :]
+
+
+def finalize():
+    """ print out any information to the user at the end of the run """
+
+    print("""
+          """)
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 1799ba42a..be1cc1589 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -280,11 +280,13 @@ def evolve(self):
                                         self.solid, self.tc)
 
         # Apply artificial viscosity to fluxes
-        q = cons_to_prim(self.cc_data.data, gamma, self.ivars, myg)
 
-        F_x, F_y = flx.apply_artificial_viscosity(F_x, F_y, q,
-                                                  self.cc_data, self.rp,
-                                                  self.ivars)
+        if myg.coord_type == 0:
+            q = cons_to_prim(self.cc_data.data, gamma, self.ivars, myg)
+
+            F_x, F_y = flx.apply_artificial_viscosity(F_x, F_y, q,
+                                                      self.cc_data, self.rp,
+                                                      self.ivars)
 
         old_dens = dens.copy()
         old_xmom = xmom.copy()

From b1eaaa839685928adbd1cc9a7571a0af3d171ce1 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 14:59:32 -0400
Subject: [PATCH 51/65] correct source term

---
 pyro/compressible/unsplit_fluxes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 3ea659594..066e579d3 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -301,7 +301,7 @@ def apply_source_terms(U_xl, U_xr, U_yl, U_yr,
             ymom.v()**2 / (dens.v()*myg.x2d.v()) - \
             (pres.ip(1) - pres.v()) / myg.Lx.v()
         ymom_src.v()[:, :] = -(pres.jp(1) - pres.v()) / myg.Ly.v() - \
-            dens.v()*xmom.v()*ymom.v() / (dens.v()*myg.x2d.v())
+            xmom.v()*ymom.v() / (dens.v()*myg.x2d.v())
         E_src.v()[:, :] = xmom.v()*grav
 
     else:

From ffafd7286d72e8062f678f7c55f494026f9b7a20 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 17:54:09 -0400
Subject: [PATCH 52/65] merge spherical_advect with just advect

---
 pyro/compressible/problems/advect.py          | 39 ++++++++--
 ...herical_advect => inputs.advect.spherical} |  0
 .../compressible/problems/spherical_advect.py | 75 -------------------
 3 files changed, 31 insertions(+), 83 deletions(-)
 rename pyro/compressible/problems/{inputs.spherical_advect => inputs.advect.spherical} (100%)
 delete mode 100644 pyro/compressible/problems/spherical_advect.py

diff --git a/pyro/compressible/problems/advect.py b/pyro/compressible/problems/advect.py
index 1feba59d1..f680cbaad 100644
--- a/pyro/compressible/problems/advect.py
+++ b/pyro/compressible/problems/advect.py
@@ -38,16 +38,39 @@ def init_data(my_data, rp):
     ymin = rp.get_param("mesh.ymin")
     ymax = rp.get_param("mesh.ymax")
 
-    xctr = 0.5*(xmin + xmax)
-    yctr = 0.5*(ymin + ymax)
+    myg = my_data.grid
+
+    if myg.coord_type == 0:
+        xctr = 0.5*(xmin + xmax)
+        yctr = 0.5*(ymin + ymax)
+
+        # this is identical to the advection/smooth problem
+        dens[:, :] = 1.0 + np.exp(-60.0*((my_data.grid.x2d-xctr)**2 +
+                                         (my_data.grid.y2d-yctr)**2))
+
+        # velocity is diagonal
+        u = 1.0
+        v = 1.0
+
+    else:
+        x = myg.scratch_array()
+        y = myg.scratch_array()
+
+        xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
+        yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
+
+        x[:, :] = myg.x2d.v(buf=myg.ng) * np.sin(myg.y2d.v(buf=myg.ng))
+        y[:, :] = myg.x2d.v(buf=myg.ng) * np.cos(myg.y2d.v(buf=myg.ng))
+
+        # this is identical to the advection/smooth problem
+        dens[:, :] = 1.0 + np.exp(-60.0*((x-xctr)**2 +
+                                         (y-yctr)**2))
+
+        # velocity in theta direction.
+        u = 0.0
+        v = 3.0
 
-    # this is identical to the advection/smooth problem
-    dens[:, :] = 1.0 + np.exp(-60.0*((my_data.grid.x2d-xctr)**2 +
-                                    (my_data.grid.y2d-yctr)**2))
 
-    # velocity is diagonal
-    u = 1.0
-    v = 1.0
     xmom[:, :] = dens[:, :]*u
     ymom[:, :] = dens[:, :]*v
 
diff --git a/pyro/compressible/problems/inputs.spherical_advect b/pyro/compressible/problems/inputs.advect.spherical
similarity index 100%
rename from pyro/compressible/problems/inputs.spherical_advect
rename to pyro/compressible/problems/inputs.advect.spherical
diff --git a/pyro/compressible/problems/spherical_advect.py b/pyro/compressible/problems/spherical_advect.py
deleted file mode 100644
index 586bd1be6..000000000
--- a/pyro/compressible/problems/spherical_advect.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import sys
-
-import numpy as np
-
-from pyro.mesh import patch
-from pyro.util import msg
-
-
-def init_data(my_data, rp):
-    """ initialize a smooth advection problem for testing convergence """
-
-    msg.bold("initializing the spherical advect problem...")
-
-    # make sure that we are passed a valid patch object
-    if not isinstance(my_data, patch.CellCenterData2d):
-        print("ERROR: patch invalid in advect.py")
-        print(my_data.__class__)
-        sys.exit()
-
-    # get the density, momenta, and energy as separate variables
-    dens = my_data.get_var("density")
-    xmom = my_data.get_var("x-momentum")
-    ymom = my_data.get_var("y-momentum")
-    ener = my_data.get_var("energy")
-
-    # initialize the components, remember, that ener here is rho*eint
-    # + 0.5*rho*v**2, where eint is the specific internal energy
-    # (erg/g)
-    dens[:, :] = 1.0
-    xmom[:, :] = 0.0
-    ymom[:, :] = 0.0
-
-    gamma = rp.get_param("eos.gamma")
-
-    xmin = rp.get_param("mesh.xmin")
-    xmax = rp.get_param("mesh.xmax")
-
-    ymin = rp.get_param("mesh.ymin")
-    ymax = rp.get_param("mesh.ymax")
-
-    # Actual x- and y- coordinate
-    myg = my_data.grid
-
-    x = myg.scratch_array()
-    y = myg.scratch_array()
-
-    xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
-    yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
-
-    x[:, :] = myg.x2d.v(buf=myg.ng) * np.sin(myg.y2d.v(buf=myg.ng))
-    y[:, :] = myg.x2d.v(buf=myg.ng) * np.cos(myg.y2d.v(buf=myg.ng))
-
-    # Initial density on the very top.
-
-    # this is identical to the advection/smooth problem
-    dens[:, :] = 1.0 + np.exp(-60.0*((x-xctr)**2 +
-                                    (y-yctr)**2))
-
-    # velocity in theta direction.
-    u = 0.0
-    v = 3.0
-
-    xmom[:, :] = dens[:, :]*u
-    ymom[:, :] = dens[:, :]*v
-
-    # pressure is constant
-    p = 1.0
-    ener[:, :] = p/(gamma - 1.0) + 0.5*(xmom[:, :]**2 + ymom[:, :]**2)/dens[:, :]
-
-
-def finalize():
-    """ print out any information to the user at the end of the run """
-
-    print("""
-          """)

From 8b4d19ed87e36cd94e3b8079fb57fe93c15385bd Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 1 Aug 2024 18:29:36 -0400
Subject: [PATCH 53/65] fix flake8

---
 pyro/compressible/problems/advect.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pyro/compressible/problems/advect.py b/pyro/compressible/problems/advect.py
index f680cbaad..ff015dda8 100644
--- a/pyro/compressible/problems/advect.py
+++ b/pyro/compressible/problems/advect.py
@@ -70,7 +70,6 @@ def init_data(my_data, rp):
         u = 0.0
         v = 3.0
 
-
     xmom[:, :] = dens[:, :]*u
     ymom[:, :] = dens[:, :]*v
 

From ae42ae43969620f85d4b580052ae56a400a3d4b2 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Mon, 26 Aug 2024 10:56:41 -0400
Subject: [PATCH 54/65] add spherical sedov input

---
 pyro/compressible/problems/advect.py          | 13 ++--
 .../problems/inputs.advect.spherical          |  8 +--
 .../problems/inputs.sedov.spherical           | 41 +++++++++++++
 pyro/compressible/problems/sedov.py           | 59 ++++++++++++-------
 pyro/compressible/simulation.py               | 11 +++-
 5 files changed, 99 insertions(+), 33 deletions(-)
 create mode 100644 pyro/compressible/problems/inputs.sedov.spherical

diff --git a/pyro/compressible/problems/advect.py b/pyro/compressible/problems/advect.py
index ff015dda8..e43ca966c 100644
--- a/pyro/compressible/problems/advect.py
+++ b/pyro/compressible/problems/advect.py
@@ -56,19 +56,22 @@ def init_data(my_data, rp):
         x = myg.scratch_array()
         y = myg.scratch_array()
 
-        xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
-        yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
+        # xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
+        # yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
+
+        xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.5)
+        yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.5)
 
         x[:, :] = myg.x2d.v(buf=myg.ng) * np.sin(myg.y2d.v(buf=myg.ng))
         y[:, :] = myg.x2d.v(buf=myg.ng) * np.cos(myg.y2d.v(buf=myg.ng))
 
         # this is identical to the advection/smooth problem
-        dens[:, :] = 1.0 + np.exp(-60.0*((x-xctr)**2 +
+        dens[:, :] = 1.0 + np.exp(-120.0*((x-xctr)**2 +
                                          (y-yctr)**2))
 
         # velocity in theta direction.
-        u = 0.0
-        v = 3.0
+        u = 1.0
+        v = 0.0
 
     xmom[:, :] = dens[:, :]*u
     ymom[:, :] = dens[:, :]*v
diff --git a/pyro/compressible/problems/inputs.advect.spherical b/pyro/compressible/problems/inputs.advect.spherical
index 3d0682a67..043628792 100644
--- a/pyro/compressible/problems/inputs.advect.spherical
+++ b/pyro/compressible/problems/inputs.advect.spherical
@@ -28,11 +28,11 @@ xmax = 2.0
 ymin = 0.523
 ymax = 2.617
 
-xlboundary = periodic
-xrboundary = periodic
+xlboundary = outflow
+xrboundary = outflow
 
-ylboundary = periodic
-yrboundary = periodic
+ylboundary = outflow
+yrboundary = outflow
 
 
 [vis]
diff --git a/pyro/compressible/problems/inputs.sedov.spherical b/pyro/compressible/problems/inputs.sedov.spherical
new file mode 100644
index 000000000..55e826da2
--- /dev/null
+++ b/pyro/compressible/problems/inputs.sedov.spherical
@@ -0,0 +1,41 @@
+[driver]
+max_steps = 5000
+tmax = 0.1
+
+
+[compressible]
+limiter = 2
+cvisc = 0.1
+riemann = CGF
+
+[io]
+basename = sedov_spherical_
+dt_out = 0.0125
+
+
+[eos]
+gamma = 1.4
+
+
+[mesh]
+grid_type = SphericalPolar
+nx = 128
+ny = 128
+xmin = 0.1
+xmax = 1.0
+ymin = 0.785
+ymax = 2.355
+
+xlboundary = reflect-odd
+xrboundary = outflow
+
+ylboundary = outflow
+yrboundary = outflow
+
+
+[sedov]
+r_init = 0.2
+
+
+[vis]
+dovis = 1
diff --git a/pyro/compressible/problems/sedov.py b/pyro/compressible/problems/sedov.py
index 73eee2780..b73c7521a 100644
--- a/pyro/compressible/problems/sedov.py
+++ b/pyro/compressible/problems/sedov.py
@@ -31,8 +31,6 @@ def init_data(my_data, rp):
     xmom[:, :] = 0.0
     ymom[:, :] = 0.0
 
-    E_sedov = 1.0
-
     r_init = rp.get_param("sedov.r_init")
 
     gamma = rp.get_param("eos.gamma")
@@ -44,38 +42,55 @@ def init_data(my_data, rp):
     ymin = rp.get_param("mesh.ymin")
     ymax = rp.get_param("mesh.ymax")
 
-    xctr = 0.5*(xmin + xmax)
-    yctr = 0.5*(ymin + ymax)
+    grid = my_data.grid
+
+    if grid.coord_type == 0:
+        # If we do Cartesian2d geometry
+
+        E_sedov = 1.0
+
+        xctr = 0.5*(xmin + xmax)
+        yctr = 0.5*(ymin + ymax)
+
+        # initialize the pressure by putting the explosion energy into a
+        # volume of constant pressure.  Then compute the energy in a zone
+        # from this.
+        nsub = rp.get_param("sedov.nsub")
+
+        dist = np.sqrt((my_data.grid.x2d - xctr)**2 +
+                       (my_data.grid.y2d - yctr)**2)
 
-    # initialize the pressure by putting the explosion energy into a
-    # volume of constant pressure.  Then compute the energy in a zone
-    # from this.
-    nsub = rp.get_param("sedov.nsub")
+        p = 1.e-5
+        ener[:, :] = p/(gamma - 1.0)
 
-    dist = np.sqrt((my_data.grid.x2d - xctr)**2 +
-                   (my_data.grid.y2d - yctr)**2)
+        for i, j in np.transpose(np.nonzero(dist < 2.0*r_init)):
 
-    p = 1.e-5
-    ener[:, :] = p/(gamma - 1.0)
+            xsub = my_data.grid.xl[i] + (my_data.grid.dx/nsub)*(np.arange(nsub) + 0.5)
+            ysub = my_data.grid.yl[j] + (my_data.grid.dy/nsub)*(np.arange(nsub) + 0.5)
 
-    for i, j in np.transpose(np.nonzero(dist < 2.0*r_init)):
+            xx, yy = np.meshgrid(xsub, ysub, indexing="ij")
 
-        xsub = my_data.grid.xl[i] + (my_data.grid.dx/nsub)*(np.arange(nsub) + 0.5)
-        ysub = my_data.grid.yl[j] + (my_data.grid.dy/nsub)*(np.arange(nsub) + 0.5)
+            dist = np.sqrt((xx - xctr)**2 + (yy - yctr)**2)
 
-        xx, yy = np.meshgrid(xsub, ysub, indexing="ij")
+            n_in_pert = np.count_nonzero(dist <= r_init)
 
-        dist = np.sqrt((xx - xctr)**2 + (yy - yctr)**2)
+            p = n_in_pert*(gamma - 1.0)*E_sedov/(pi*r_init*r_init) + \
+                (nsub*nsub - n_in_pert)*1.e-5
 
-        n_in_pert = np.count_nonzero(dist <= r_init)
+            p = p/(nsub*nsub)
 
-        p = n_in_pert*(gamma - 1.0)*E_sedov/(pi*r_init*r_init) + \
-            (nsub*nsub - n_in_pert)*1.e-5
+            ener[i, j] = p/(gamma - 1.0)
 
-        p = p/(nsub*nsub)
+    else:
+        # If we do SphericalPolar geometry
 
-        ener[i, j] = p/(gamma - 1.0)
+        # Just put a high energy for now.
+        E_sedov = 1.e5
 
+        p = 1.e-5
+        ener[:, :] = p/(gamma - 1.0)
+        myg = my_data.grid
+        ener[myg.x2d < r_init] = E_sedov
 
 def finalize():
     """ print out any information to the user at the end of the run """
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index be1cc1589..4f13d60b4 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -191,9 +191,16 @@ def method_compute_timestep(self):
         # get the variables we need
         u, v, cs = self.cc_data.get_var(["velocity", "soundspeed"])
 
+        grid = self.cc_data.grid
+
         # the timestep is min(dx/(|u| + cs), dy/(|v| + cs))
-        xtmp = self.cc_data.grid.dx/(abs(u) + cs)
-        ytmp = self.cc_data.grid.dy/(abs(v) + cs)
+        if grid.coord_type == 0:
+            xtmp = grid.dx/(abs(u) + cs)
+            ytmp = grid.dy/(abs(v) + cs)
+
+        else:
+            xtmp = grid.dx/(abs(u) + cs)
+            ytmp = grid.xmin * grid.dy/(abs(v) + cs)
 
         self.dt = cfl*float(min(xtmp.min(), ytmp.min()))
 

From 1db79abd5935dfcb96b7a63b2e095edd7b4f3f66 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 27 Aug 2024 15:29:16 -0400
Subject: [PATCH 55/65] update artificial viscosity to be in-sync with castro
 and add sphericalpolar support

---
 pyro/compressible/interface.py      | 76 +++++++++++++++++++++++------
 pyro/compressible/simulation.py     |  9 ++--
 pyro/compressible/unsplit_fluxes.py |  5 +-
 pyro/mesh/patch.py                  |  4 +-
 4 files changed, 71 insertions(+), 23 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index ff0e2d0c2..d0c531d29 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -1182,6 +1182,7 @@ def consFlux(idir, coord_type, gamma,
 
 @njit(cache=True)
 def artificial_viscosity(ng, dx, dy,
+                         xmin, ymin, coord_type,
                          cvisc, u, v):
     r"""
     Compute the artificial viscosity.  Here, we compute edge-centered
@@ -1216,6 +1217,8 @@ def artificial_viscosity(ng, dx, dy,
         The number of ghost cells
     dx, dy : float
         Cell spacings
+    xmin, ymin : float
+        Min physical x, y boundary
     cvisc : float
         viscosity parameter
     u, v : ndarray
@@ -1231,6 +1234,7 @@ def artificial_viscosity(ng, dx, dy,
 
     avisco_x = np.zeros((qx, qy))
     avisco_y = np.zeros((qx, qy))
+    divU = np.zeros((qx, qy))
 
     nx = qx - 2 * ng
     ny = qy - 2 * ng
@@ -1239,25 +1243,69 @@ def artificial_viscosity(ng, dx, dy,
     jlo = ng
     jhi = ng + ny
 
+    # Let's first compute divergence at the vertex
+    # First compute the left and right x-velocities by
+    # averaging over the y-interface.
+    # As well as the top and bottom y-velocities by
+    # averaging over the x-interface.
+    # Then a simple difference is done between the right and left,
+    # and top and bottom to get the divergence at the vertex.
+
     for i in range(ilo - 1, ihi + 1):
         for j in range(jlo - 1, jhi + 1):
 
-            # start by computing the divergence on the x-interface.  The
-            # x-difference is simply the difference of the cell-centered
-            # x-velocities on either side of the x-interface.  For the
-            # y-difference, first average the four cells to the node on
-            # each end of the edge, and: difference these to find the
-            # edge centered y difference.
-            divU_x = (u[i, j] - u[i - 1, j]) / dx + \
-                0.25 * (v[i, j + 1] + v[i - 1, j + 1] -
-                        v[i, j - 1] - v[i - 1, j - 1]) / dy
+            # For Cartesian2d:
+            if coord_type == 0:
+                # Find the average right and left u velocity
+                ur = 0.5 * (u[i, j] + u[i, j - 1])
+                ul = 0.5 * (u[i - 1, j] + u[i - 1, j - 1])
+
+                # Find the average top and bottom v velocity
+                vt = 0.5 * (v[i, j] + v[i - 1, j])
+                vb = 0.5 * (v[i, j - 1] + v[i - 1, j - 1])
+
+                # Finite difference to get ux and vy
+                ux = (ur - ul) / dx
+                vy = (vt - vb) / dy
+
+                # Find div(U)_{i-1/2, j-1/2}
+                divU[i, j] = ux + vy
+
+            # For SphericalPolar:
+            else:
+                # cell-centered r-coord of right, left cell and face-centered r
+                rr = (i + 1 - ng) * dx + xmin
+                rl = (i - ng) * dx + xmin
+                rc = 0.5 * (rr + rl)
+
+                # cell-centered sin(theta) of top, bot cell and face-centered
+                sint = np.sin((j + 1 - ng) * dy + ymin)
+                sinb = np.sin((j - ng) * dy + ymin)
+                sinc = np.sin((j + 0.5 - ng) * dy + ymin)
+
+                # Find the average right and left u velocity
+                ur = 0.5 * (u[i, j] + u[i, j - 1])
+                ul = 0.5 * (u[i - 1, j] + u[i - 1, j - 1])
+
+                # Find the average top and bottom v velocity
+                vt = 0.5 * (v[i, j] + v[i - 1, j])
+                vb = 0.5 * (v[i, j - 1] + v[i - 1, j - 1])
+
+                # Finite difference to get ux and vy
+                ux = (ur*rr - ul*rl) / (rc * dx)
+                vy = (sint*vt - sinb*vb) / (rc * sinc * dy)
+
+                # Find div(U)_{i-1/2, j-1/2}
+                divU[i, j] = ux + vy
 
-            avisco_x[i, j] = cvisc * max(-divU_x * dx, 0.0)
+    # Compute divergence at the face by averaging over divergence at vertex
+    for i in range(ilo, ihi):
+        for j in range(jlo, jhi):
 
-            # now the y-interface value
-            divU_y = 0.25 * (u[i + 1, j] + u[i + 1, j - 1] - u[i - 1, j] - u[i - 1, j - 1]) / dx + \
-                (v[i, j] - v[i, j - 1]) / dy
+            divU_x = 0.5 * (divU[i, j] + divU[i, j + 1])
+            divU_y = 0.5 * (divU[i, j] + divU[i + 1, j])
 
-            avisco_y[i, j] = cvisc * max(-divU_y * dy, 0.0)
+            avisco_x[i, j] = cvisc * max(-divU_x, 0.0)
+            avisco_y[i, j] = cvisc * max(-divU_y, 0.0)
 
     return avisco_x, avisco_y
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 4f13d60b4..196718c95 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -288,12 +288,11 @@ def evolve(self):
 
         # Apply artificial viscosity to fluxes
 
-        if myg.coord_type == 0:
-            q = cons_to_prim(self.cc_data.data, gamma, self.ivars, myg)
+        q = cons_to_prim(self.cc_data.data, gamma, self.ivars, myg)
 
-            F_x, F_y = flx.apply_artificial_viscosity(F_x, F_y, q,
-                                                      self.cc_data, self.rp,
-                                                      self.ivars)
+        F_x, F_y = flx.apply_artificial_viscosity(F_x, F_y, q,
+                                                  self.cc_data, self.rp,
+                                                  self.ivars)
 
         old_dens = dens.copy()
         old_xmom = xmom.copy()
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 066e579d3..1f47900ad 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -553,6 +553,7 @@ def apply_artificial_viscosity(F_x, F_y, q,
     myg = my_data.grid
 
     _ax, _ay = ifc.artificial_viscosity(myg.ng, myg.dx, myg.dy,
+                                        myg.xmin, myg.ymin, myg.coord_type,
         cvisc, q.v(n=ivars.iu, buf=myg.ng), q.v(n=ivars.iv, buf=myg.ng))
 
     avisco_x = ai.ArrayIndexer(d=_ax, grid=myg)
@@ -565,10 +566,10 @@ def apply_artificial_viscosity(F_x, F_y, q,
         var = my_data.get_var_by_index(n)
 
         F_x.v(buf=b, n=n)[:, :] += \
-            avisco_x.v(buf=b)*(var.ip(-1, buf=b) - var.v(buf=b))
+            avisco_x.v(buf=b)*myg.Lx.v(buf=b)*(var.ip(-1, buf=b) - var.v(buf=b))
 
         # F_y = F_y + avisco_y * (U(i,j-1) - U(i,j))
         F_y.v(buf=b, n=n)[:, :] += \
-            avisco_y.v(buf=b)*(var.jp(-1, buf=b) - var.v(buf=b))
+            avisco_y.v(buf=b)*myg.Ly.v(buf=b)*(var.jp(-1, buf=b) - var.v(buf=b))
 
     return F_x, F_y
diff --git a/pyro/mesh/patch.py b/pyro/mesh/patch.py
index 5d272e5f9..f31dc13c2 100644
--- a/pyro/mesh/patch.py
+++ b/pyro/mesh/patch.py
@@ -110,10 +110,10 @@ def __init__(self, nx, ny, ng=1,
 
         # compute the indices of the block interior (excluding guardcells)
         self.ilo = self.ng
-        self.ihi = self.ng + self.nx-1
+        self.ihi = self.ng + self.nx - 1
 
         self.jlo = self.ng
-        self.jhi = self.ng + self.ny-1
+        self.jhi = self.ng + self.ny - 1
 
         # center of the grid (for convenience)
         self.ic = self.ilo + self.nx//2 - 1

From fd01f70548fc8da6cac6fc6b717cabde810a4b93 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 27 Aug 2024 16:47:07 -0400
Subject: [PATCH 56/65] add spherical advect with different resolutions for
 convergence test

---
 pyro/compressible/problems/advect.py          | 11 ++----
 .../problems/inputs.advect.spherical.128      | 39 +++++++++++++++++++
 .../problems/inputs.advect.spherical.256      | 39 +++++++++++++++++++
 ...t.spherical => inputs.advect.spherical.64} |  2 +-
 4 files changed, 83 insertions(+), 8 deletions(-)
 create mode 100644 pyro/compressible/problems/inputs.advect.spherical.128
 create mode 100644 pyro/compressible/problems/inputs.advect.spherical.256
 rename pyro/compressible/problems/{inputs.advect.spherical => inputs.advect.spherical.64} (91%)

diff --git a/pyro/compressible/problems/advect.py b/pyro/compressible/problems/advect.py
index e43ca966c..2d7a1bbda 100644
--- a/pyro/compressible/problems/advect.py
+++ b/pyro/compressible/problems/advect.py
@@ -56,11 +56,8 @@ def init_data(my_data, rp):
         x = myg.scratch_array()
         y = myg.scratch_array()
 
-        # xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
-        # yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
-
-        xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.5)
-        yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.5)
+        xctr = 0.5*(xmin + xmax) * np.sin((ymin + ymax) * 0.25)
+        yctr = 0.5*(xmin + xmax) * np.cos((ymin + ymax) * 0.25)
 
         x[:, :] = myg.x2d.v(buf=myg.ng) * np.sin(myg.y2d.v(buf=myg.ng))
         y[:, :] = myg.x2d.v(buf=myg.ng) * np.cos(myg.y2d.v(buf=myg.ng))
@@ -70,8 +67,8 @@ def init_data(my_data, rp):
                                          (y-yctr)**2))
 
         # velocity in theta direction.
-        u = 1.0
-        v = 0.0
+        u = 0.0
+        v = 1.0
 
     xmom[:, :] = dens[:, :]*u
     ymom[:, :] = dens[:, :]*v
diff --git a/pyro/compressible/problems/inputs.advect.spherical.128 b/pyro/compressible/problems/inputs.advect.spherical.128
new file mode 100644
index 000000000..c4689c15e
--- /dev/null
+++ b/pyro/compressible/problems/inputs.advect.spherical.128
@@ -0,0 +1,39 @@
+[driver]
+max_steps = 500
+tmax = 1.0
+
+init_tstep_factor = 1.0
+fix_dt = 0.0025
+
+
+[compressible]
+limiter = 0
+cvisc = 0.1
+riemann = CGF
+
+[io]
+basename = spherical_advect_128_
+
+
+[eos]
+gamma = 1.4
+
+
+[mesh]
+grid_type = SphericalPolar
+nx = 128
+ny = 128
+xmin = 1.0
+xmax = 2.0
+ymin = 0.523
+ymax = 2.617
+
+xlboundary = outflow
+xrboundary = outflow
+
+ylboundary = outflow
+yrboundary = outflow
+
+
+[vis]
+dovis = 1
diff --git a/pyro/compressible/problems/inputs.advect.spherical.256 b/pyro/compressible/problems/inputs.advect.spherical.256
new file mode 100644
index 000000000..df68fbb08
--- /dev/null
+++ b/pyro/compressible/problems/inputs.advect.spherical.256
@@ -0,0 +1,39 @@
+[driver]
+max_steps = 1000
+tmax = 1.0
+
+init_tstep_factor = 1.0
+fix_dt = 0.00125
+
+
+[compressible]
+limiter = 0
+cvisc = 0.1
+riemann = CGF
+
+[io]
+basename = spherical_advect_256_
+
+
+[eos]
+gamma = 1.4
+
+
+[mesh]
+grid_type = SphericalPolar
+nx = 256
+ny = 256
+xmin = 1.0
+xmax = 2.0
+ymin = 0.523
+ymax = 2.617
+
+xlboundary = outflow
+xrboundary = outflow
+
+ylboundary = outflow
+yrboundary = outflow
+
+
+[vis]
+dovis = 1
diff --git a/pyro/compressible/problems/inputs.advect.spherical b/pyro/compressible/problems/inputs.advect.spherical.64
similarity index 91%
rename from pyro/compressible/problems/inputs.advect.spherical
rename to pyro/compressible/problems/inputs.advect.spherical.64
index 043628792..2f3db135c 100644
--- a/pyro/compressible/problems/inputs.advect.spherical
+++ b/pyro/compressible/problems/inputs.advect.spherical.64
@@ -12,7 +12,7 @@ cvisc = 0.1
 riemann = CGF
 
 [io]
-basename = spherical_advect_
+basename = spherical_advect_64_
 
 
 [eos]

From cc349e6e541caa1744f4dfdca3ed339bb9ef7788 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Tue, 27 Aug 2024 19:03:13 -0400
Subject: [PATCH 57/65] update misc

---
 pyro/compressible/interface.py                    | 2 ++
 pyro/compressible/problems/inputs.advect.128      | 2 +-
 pyro/compressible/problems/inputs.advect.256      | 2 +-
 pyro/compressible/problems/inputs.advect.64       | 2 +-
 pyro/compressible/problems/inputs.sedov.spherical | 2 +-
 pyro/compressible/problems/sedov.py               | 4 ++--
 pyro/compressible/simulation.py                   | 8 ++++----
 7 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/pyro/compressible/interface.py b/pyro/compressible/interface.py
index d0c531d29..2d64facb7 100644
--- a/pyro/compressible/interface.py
+++ b/pyro/compressible/interface.py
@@ -1154,6 +1154,7 @@ def consFlux(idir, coord_type, gamma,
     if idir == 1:
         F[..., idens] = U_state[..., idens] * u
         F[..., ixmom] = U_state[..., ixmom] * u
+
         # if Cartesian2d, then add pressure to xmom flux
         if coord_type == 0:
             F[..., ixmom] += p
@@ -1168,6 +1169,7 @@ def consFlux(idir, coord_type, gamma,
         F[..., idens] = U_state[..., idens] * v
         F[..., ixmom] = U_state[..., ixmom] * v
         F[..., iymom] = U_state[..., iymom] * v
+
         # if Cartesian2d, then add pressure to ymom flux
         if coord_type == 0:
             F[..., iymom] += p
diff --git a/pyro/compressible/problems/inputs.advect.128 b/pyro/compressible/problems/inputs.advect.128
index c657a646a..b699c7182 100644
--- a/pyro/compressible/problems/inputs.advect.128
+++ b/pyro/compressible/problems/inputs.advect.128
@@ -12,7 +12,7 @@ cvisc = 0.1
 
 
 [io]
-basename = advect_
+basename = advect_128_
 
 
 [eos]
diff --git a/pyro/compressible/problems/inputs.advect.256 b/pyro/compressible/problems/inputs.advect.256
index 77cec1857..487135ef0 100644
--- a/pyro/compressible/problems/inputs.advect.256
+++ b/pyro/compressible/problems/inputs.advect.256
@@ -12,7 +12,7 @@ cvisc = 0.1
 
 
 [io]
-basename = advect_
+basename = advect_256_
 
 
 [eos]
diff --git a/pyro/compressible/problems/inputs.advect.64 b/pyro/compressible/problems/inputs.advect.64
index 8e99c8ff1..d24745688 100644
--- a/pyro/compressible/problems/inputs.advect.64
+++ b/pyro/compressible/problems/inputs.advect.64
@@ -12,7 +12,7 @@ cvisc = 0.1
 
 
 [io]
-basename = advect_
+basename = advect_64_
 
 
 [eos]
diff --git a/pyro/compressible/problems/inputs.sedov.spherical b/pyro/compressible/problems/inputs.sedov.spherical
index 55e826da2..1930c911a 100644
--- a/pyro/compressible/problems/inputs.sedov.spherical
+++ b/pyro/compressible/problems/inputs.sedov.spherical
@@ -34,7 +34,7 @@ yrboundary = outflow
 
 
 [sedov]
-r_init = 0.2
+r_init = 0.13
 
 
 [vis]
diff --git a/pyro/compressible/problems/sedov.py b/pyro/compressible/problems/sedov.py
index b73c7521a..af143a1f0 100644
--- a/pyro/compressible/problems/sedov.py
+++ b/pyro/compressible/problems/sedov.py
@@ -85,9 +85,9 @@ def init_data(my_data, rp):
         # If we do SphericalPolar geometry
 
         # Just put a high energy for now.
-        E_sedov = 1.e5
+        E_sedov = 1.e6
 
-        p = 1.e-5
+        p = 1.e-6
         ener[:, :] = p/(gamma - 1.0)
         myg = my_data.grid
         ener[myg.x2d < r_init] = E_sedov
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 196718c95..e3d20299e 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -195,12 +195,12 @@ def method_compute_timestep(self):
 
         # the timestep is min(dx/(|u| + cs), dy/(|v| + cs))
         if grid.coord_type == 0:
-            xtmp = grid.dx/(abs(u) + cs)
-            ytmp = grid.dy/(abs(v) + cs)
+            xtmp = grid.dx / (abs(u) + cs)
+            ytmp = grid.dy / (abs(v) + cs)
 
         else:
-            xtmp = grid.dx/(abs(u) + cs)
-            ytmp = grid.xmin * grid.dy/(abs(v) + cs)
+            xtmp = grid.dx / (abs(u) + cs)
+            ytmp = grid.x[grid.ilo] * grid.dy / (abs(v) + cs)
 
         self.dt = cfl*float(min(xtmp.min(), ytmp.min()))
 

From f706483e8c651901996929ba365b44d1f033bdbc Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 11:41:40 -0400
Subject: [PATCH 58/65] update how to compute timestep

---
 pyro/compressible/simulation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index e3d20299e..842d8103a 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -200,7 +200,7 @@ def method_compute_timestep(self):
 
         else:
             xtmp = grid.dx / (abs(u) + cs)
-            ytmp = grid.x[grid.ilo] * grid.dy / (abs(v) + cs)
+            ytmp = grid.x2d * grid.dy / (abs(v) + cs)
 
         self.dt = cfl*float(min(xtmp.min(), ytmp.min()))
 

From 6ea0272cc47654f2d5fa1370a4ece75f492d68f7 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 11:43:38 -0400
Subject: [PATCH 59/65] simplify timestep again

---
 pyro/compressible/simulation.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 842d8103a..faa154135 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -194,13 +194,8 @@ def method_compute_timestep(self):
         grid = self.cc_data.grid
 
         # the timestep is min(dx/(|u| + cs), dy/(|v| + cs))
-        if grid.coord_type == 0:
-            xtmp = grid.dx / (abs(u) + cs)
-            ytmp = grid.dy / (abs(v) + cs)
-
-        else:
-            xtmp = grid.dx / (abs(u) + cs)
-            ytmp = grid.x2d * grid.dy / (abs(v) + cs)
+        xtmp = grid.Lx / (abs(u) + cs)
+        ytmp = grid.Ly / (abs(v) + cs)
 
         self.dt = cfl*float(min(xtmp.min(), ytmp.min()))
 

From 719bbfb928d63a2195a90c6be4842d3846beb802 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 15:27:14 -0400
Subject: [PATCH 60/65] update module

---
 pyro/compressible/simulation.py | 45 +++++++++++++++++----------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index faa154135..a9a64f0a4 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -5,6 +5,7 @@
 import numpy as np
 
 import pyro.compressible.interface as ifc
+import pyro.compressible.riemann as riemann
 import pyro.compressible.unsplit_fluxes as flx
 import pyro.mesh.array_indexer as ai
 import pyro.mesh.boundary as bnd
@@ -241,17 +242,17 @@ def evolve(self):
             # SphericalPolar geometry. So we need interface conserved states.
 
             # Get the conserved interface state from Riemann Solver
-            _ux = ifc.riemann_cons(1, myg.ng,
-                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
-                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
-                                   self.solid.xl, self.solid.xr,
-                                   gamma, U_xl, U_xr)
-
-            _uy = ifc.riemann_cons(2, myg.ng,
-                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
-                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
-                                   self.solid.yl, self.solid.yr,
-                                   gamma, U_yl, U_yr)
+            _ux = riemann.riemann_cons(1, myg.ng,
+                                       self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                       self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                       self.solid.xl, self.solid.xr,
+                                       gamma, U_xl, U_xr)
+
+            _uy = riemann.riemann_cons(2, myg.ng,
+                                       self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                       self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                       self.solid.yl, self.solid.yr,
+                                       gamma, U_yl, U_yr)
 
             U_x = ai.ArrayIndexer(d=_ux, grid=myg)
             U_y = ai.ArrayIndexer(d=_uy, grid=myg)
@@ -262,24 +263,24 @@ def evolve(self):
             qy = cons_to_prim(U_y, gamma, self.ivars, myg)
 
             # Find the corresponding flux from the conserved states.
-            _fx = ifc.consFlux(1, myg.coord_type, gamma,
-                               self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
-                               self.ivars.iener, self.ivars.irhox, self.ivars.naux,
-                               _ux)
+            _fx = riemann.consFlux(1, myg.coord_type, gamma,
+                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                   _ux)
 
-            _fy = ifc.consFlux(2, myg.coord_type, gamma,
-                               self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
-                               self.ivars.iener, self.ivars.irhox, self.ivars.naux,
-                               _uy)
+            _fy = riemann.consFlux(2, myg.coord_type, gamma,
+                                   self.ivars.idens, self.ivars.ixmom, self.ivars.iymom,
+                                   self.ivars.iener, self.ivars.irhox, self.ivars.naux,
+                                   _uy)
 
             F_x = ai.ArrayIndexer(d=_fx, grid=myg)
             F_y = ai.ArrayIndexer(d=_fy, grid=myg)
 
         else:
             # Directly calculate the interface flux using Riemann Solver
-            F_x, F_y = flx.riemann_flux(U_xl, U_xr, U_yl, U_yr,
-                                        self.cc_data, self.rp, self.ivars,
-                                        self.solid, self.tc)
+            F_x, F_y = riemann.riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                                            self.cc_data, self.rp, self.ivars,
+                                            self.solid, self.tc)
 
         # Apply artificial viscosity to fluxes
 

From d4b73dc2ad935ed628f3abe7bd0dea63decd11ce Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 15:42:25 -0400
Subject: [PATCH 61/65] update modules

---
 pyro/compressible/problems/sedov.py |  1 +
 pyro/compressible/riemann.py        | 65 +++++++++++++++++++++++++++
 pyro/compressible/simulation.py     |  1 -
 pyro/compressible/unsplit_fluxes.py | 68 +----------------------------
 4 files changed, 68 insertions(+), 67 deletions(-)

diff --git a/pyro/compressible/problems/sedov.py b/pyro/compressible/problems/sedov.py
index af143a1f0..6cc7b7488 100644
--- a/pyro/compressible/problems/sedov.py
+++ b/pyro/compressible/problems/sedov.py
@@ -92,6 +92,7 @@ def init_data(my_data, rp):
         myg = my_data.grid
         ener[myg.x2d < r_init] = E_sedov
 
+
 def finalize():
     """ print out any information to the user at the end of the run """
 
diff --git a/pyro/compressible/riemann.py b/pyro/compressible/riemann.py
index fe1feab08..00792f0e2 100644
--- a/pyro/compressible/riemann.py
+++ b/pyro/compressible/riemann.py
@@ -1,5 +1,6 @@
 import numpy as np
 from numba import njit
+import pyro.mesh.array_indexer as ai
 
 
 @njit(cache=True)
@@ -904,6 +905,70 @@ def riemann_hllc(idir, ng, coord_type,
     return F
 
 
+def riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                 my_data, rp, ivars, solid, tc):
+    """
+    This constructs the unsplit fluxes through the x and y interfaces
+    using the left and right conserved states by using the riemann solver.
+
+    Parameters
+    ----------
+    U_xl, U_xr, U_yl, U_yr: ndarray, ndarray, ndarray, ndarray
+        Conserved states in the left and right x-interface
+        and left and right y-interface.
+    my_data : CellCenterData2d object
+        The data object containing the grid and advective scalar that
+        we are advecting.
+    rp : RuntimeParameters object
+        The runtime parameters for the simulation
+    ivars : Variables object
+        The Variables object that tells us which indices refer to which
+        variables
+    solid: A container class
+        This is used in Riemann solver to indicate which side has solid boundary
+    tc : TimerCollection object
+        The timers we are using to profile
+
+    Returns
+    -------
+    out : ndarray, ndarray
+        Fluxes in x and y direction
+    """
+
+    tm_riem = tc.timer("riemann")
+    tm_riem.begin()
+
+    myg = my_data.grid
+
+    riemann_method = rp.get_param("compressible.riemann")
+    gamma = rp.get_param("eos.gamma")
+
+    riemannFunc = None
+    if riemann_method == "HLLC":
+        riemannFunc = riemann_hllc
+    elif riemann_method == "CGF":
+        riemannFunc = riemann_cgf
+    else:
+        msg.fail("ERROR: Riemann solver undefined")
+
+    _fx = riemannFunc(1, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.xl, solid.xr,
+                      gamma, U_xl, U_xr)
+
+    _fy = riemannFunc(2, myg.ng, myg.coord_type,
+                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
+                      solid.yl, solid.yr,
+                      gamma, U_yl, U_yr)
+
+    F_x = ai.ArrayIndexer(d=_fx, grid=myg)
+    F_y = ai.ArrayIndexer(d=_fy, grid=myg)
+
+    tm_riem.end()
+
+    return F_x, F_y
+
+
 @njit(cache=True)
 def consFlux(idir, coord_type, gamma,
              idens, ixmom, iymom, iener, irhoX, nspec,
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index a9a64f0a4..65791cfea 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -4,7 +4,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
-import pyro.compressible.interface as ifc
 import pyro.compressible.riemann as riemann
 import pyro.compressible.unsplit_fluxes as flx
 import pyro.mesh.array_indexer as ai
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 48959ae2a..5ddf7679e 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -342,70 +342,6 @@ def apply_source_terms(U_xl, U_xr, U_yl, U_yr,
     return U_xl, U_xr, U_yl, U_yr
 
 
-def riemann_flux(U_xl, U_xr, U_yl, U_yr,
-                 my_data, rp, ivars, solid, tc):
-    """
-    This constructs the unsplit fluxes through the x and y interfaces
-    using the left and right conserved states by using the riemann solver.
-
-    Parameters
-    ----------
-    U_xl, U_xr, U_yl, U_yr: ndarray, ndarray, ndarray, ndarray
-        Conserved states in the left and right x-interface
-        and left and right y-interface.
-    my_data : CellCenterData2d object
-        The data object containing the grid and advective scalar that
-        we are advecting.
-    rp : RuntimeParameters object
-        The runtime parameters for the simulation
-    ivars : Variables object
-        The Variables object that tells us which indices refer to which
-        variables
-    solid: A container class
-        This is used in Riemann solver to indicate which side has solid boundary
-    tc : TimerCollection object
-        The timers we are using to profile
-
-    Returns
-    -------
-    out : ndarray, ndarray
-        Fluxes in x and y direction
-    """
-
-    tm_riem = tc.timer("riemann")
-    tm_riem.begin()
-
-    myg = my_data.grid
-
-    riemann_method = rp.get_param("compressible.riemann")
-    gamma = rp.get_param("eos.gamma")
-
-    riemannFunc = None
-    if riemann_method == "HLLC":
-        riemannFunc = riemann.riemann_hllc
-    elif riemann_method == "CGF":
-        riemannFunc = riemann.riemann_cgf
-    else:
-        msg.fail("ERROR: Riemann solver undefined")
-
-    _fx = riemannFunc(1, myg.ng, myg.coord_type,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.xl, solid.xr,
-                      gamma, U_xl, U_xr)
-
-    _fy = riemannFunc(2, myg.ng, myg.coord_type,
-                      ivars.idens, ivars.ixmom, ivars.iymom, ivars.iener, ivars.irhox, ivars.naux,
-                      solid.yl, solid.yr,
-                      gamma, U_yl, U_yr)
-
-    F_x = ai.ArrayIndexer(d=_fx, grid=myg)
-    F_y = ai.ArrayIndexer(d=_fy, grid=myg)
-
-    tm_riem.end()
-
-    return F_x, F_y
-
-
 def apply_transverse_flux(U_xl, U_xr, U_yl, U_yr,
                           my_data, rp, ivars, solid, tc, dt):
     """
@@ -481,8 +417,8 @@ def apply_transverse_flux(U_xl, U_xr, U_yl, U_yr,
 
     # Use Riemann Solver to get interface flux using the left and right states
 
-    F_x, F_y = riemann_flux(U_xl, U_xr, U_yl, U_yr,
-                            my_data, rp, ivars, solid, tc)
+    F_x, F_y = riemann.riemann_flux(U_xl, U_xr, U_yl, U_yr,
+                                    my_data, rp, ivars, solid, tc)
 
     # Now we update the conserved states using the transverse fluxes.
 

From 9f53d160c299c42a948c7baddc10ef60de107c26 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 15:47:15 -0400
Subject: [PATCH 62/65] fix pylint

---
 pyro/compressible/riemann.py        | 2 ++
 pyro/compressible/simulation.py     | 7 +++----
 pyro/compressible/unsplit_fluxes.py | 1 -
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pyro/compressible/riemann.py b/pyro/compressible/riemann.py
index 00792f0e2..9b4de9b3a 100644
--- a/pyro/compressible/riemann.py
+++ b/pyro/compressible/riemann.py
@@ -1,6 +1,8 @@
 import numpy as np
 from numba import njit
+
 import pyro.mesh.array_indexer as ai
+from pyro.util import msg
 
 
 @njit(cache=True)
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 65791cfea..c8caaa355 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -4,11 +4,10 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
-import pyro.compressible.riemann as riemann
 import pyro.compressible.unsplit_fluxes as flx
 import pyro.mesh.array_indexer as ai
 import pyro.mesh.boundary as bnd
-from pyro.compressible import BC, derives, eos
+from pyro.compressible import BC, derives, eos, riemann
 from pyro.particles import particles
 from pyro.simulation_null import NullSimulation, bc_setup, grid_setup
 from pyro.util import msg, plot_tools
@@ -112,11 +111,11 @@ def initialize(self, extra_vars=None, ng=4):
 
         # Make sure we use CGF for riemann solver when we do SphericalPolar
         try:
-            riemann = self.rp.get_param("compressible.riemann")
+            riemann_method = self.rp.get_param("compressible.riemann")
         except KeyError:
             msg.warning("ERROR: Riemann Solver is not set.")
 
-        if my_grid.coord_type == 1 and riemann == "HLLC":
+        if my_grid.coord_type == 1 and riemann_method == "HLLC":
             msg.fail("ERROR: Only CGF Riemann Solver is supported " +
                      "with SphericalPolar Geometry")
 
diff --git a/pyro/compressible/unsplit_fluxes.py b/pyro/compressible/unsplit_fluxes.py
index 5ddf7679e..6edcd919b 100644
--- a/pyro/compressible/unsplit_fluxes.py
+++ b/pyro/compressible/unsplit_fluxes.py
@@ -127,7 +127,6 @@
 import pyro.mesh.array_indexer as ai
 from pyro.compressible import riemann
 from pyro.mesh import reconstruction
-from pyro.util import msg
 
 
 def interface_states(my_data, rp, ivars, tc, dt):

From ae846c6ec4195f68bf1b0051778ddab09fa133e3 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Wed, 28 Aug 2024 16:07:07 -0400
Subject: [PATCH 63/65] update artificial viscosity in compressible_rk

---
 pyro/compressible_rk/fluxes.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyro/compressible_rk/fluxes.py b/pyro/compressible_rk/fluxes.py
index 7d410ad1d..bd6b65ead 100644
--- a/pyro/compressible_rk/fluxes.py
+++ b/pyro/compressible_rk/fluxes.py
@@ -195,7 +195,8 @@ def fluxes(my_data, rp, ivars, solid, tc):
     cvisc = rp.get_param("compressible.cvisc")
 
     _ax, _ay = interface.artificial_viscosity(myg.ng, myg.dx, myg.dy,
-        cvisc, q.v(n=ivars.iu, buf=myg.ng), q.v(n=ivars.iv, buf=myg.ng))
+                                              myg.xmin, myg.ymin, myg.coord_type,
+                                              cvisc, q.v(n=ivars.iu, buf=myg.ng), q.v(n=ivars.iv, buf=myg.ng))
 
     avisco_x = ai.ArrayIndexer(d=_ax, grid=myg)
     avisco_y = ai.ArrayIndexer(d=_ay, grid=myg)

From c903938f5f56c38cfa07b16e6e60ee52ac1fb17f Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Thu, 29 Aug 2024 22:17:45 -0400
Subject: [PATCH 64/65] fix flake8

---
 pyro/compressible/riemann.py    | 1 -
 pyro/compressible/simulation.py | 1 -
 2 files changed, 2 deletions(-)

diff --git a/pyro/compressible/riemann.py b/pyro/compressible/riemann.py
index 8df02f49e..834166ffe 100644
--- a/pyro/compressible/riemann.py
+++ b/pyro/compressible/riemann.py
@@ -922,7 +922,6 @@ def riemann_flux(idir, U_l, U_r, my_data, rp, ivars,
                      lower_solid, upper_solid,
                      gamma, U_l, U_r)
 
-
     # If riemann_method is not HLLC, then construct flux using conserved states
     if riemann_method != "HLLC":
         _f = consFlux(idir, myg.coord_type, gamma,
diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index 260b19cc6..a15de4f4f 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -5,7 +5,6 @@
 import numpy as np
 
 import pyro.compressible.unsplit_fluxes as flx
-import pyro.mesh.array_indexer as ai
 import pyro.mesh.boundary as bnd
 from pyro.compressible import BC, derives, eos, riemann
 from pyro.particles import particles

From c8a24f1d96c4b1b2bd9f5ecbec45ff6baa5d8c60 Mon Sep 17 00:00:00 2001
From: Zhi <zhichen0428@gmail.com>
Date: Fri, 30 Aug 2024 12:52:08 -0400
Subject: [PATCH 65/65] add more comments

---
 pyro/compressible/simulation.py | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/pyro/compressible/simulation.py b/pyro/compressible/simulation.py
index a15de4f4f..de8fd4ddb 100644
--- a/pyro/compressible/simulation.py
+++ b/pyro/compressible/simulation.py
@@ -221,7 +221,8 @@ def evolve(self):
                                                       self.ivars, self.tc, self.dt)
 
         # Apply source terms to them.
-        # This includes external (gravity), geometric and pressure terms.
+        # This includes external (gravity), geometric and pressure terms for SphericalPolar
+        # Only gravitional source for Cartesian2d
         U_xl, U_xr, U_yl, U_yr = flx.apply_source_terms(U_xl, U_xr, U_yl, U_yr,
                                                         self.cc_data, self.aux_data, self.rp,
                                                         self.ivars, self.tc, self.dt)
@@ -237,7 +238,6 @@ def evolve(self):
         if myg.coord_type == 1:
             # We need pressure from interface state for conservative update for
             # SphericalPolar geometry. So we need interface conserved states.
-
             F_x, U_x = riemann.riemann_flux(1, U_xl, U_xr,
                                             self.cc_data, self.rp, self.ivars,
                                             self.solid.xl, self.solid.xr, self.tc,
@@ -276,7 +276,9 @@ def evolve(self):
         old_xmom = xmom.copy()
         old_ymom = ymom.copy()
 
-        # conservative update
+        # Conservative update
+
+        # Apply contribution due to fluxes
         dtdV = self.dt / myg.V.v()
 
         for n in range(self.ivars.nvar):
@@ -286,7 +288,16 @@ def evolve(self):
                 (F_x.v(n=n)*myg.Ax.v() - F_x.ip(1, n=n)*myg.Ax.ip(1) +
                  F_y.v(n=n)*myg.Ay.v() - F_y.jp(1, n=n)*myg.Ay.jp(1))
 
-        # Apply external source (gravity) and geometric terms
+        # Now apply external sources
+
+        # For SphericalPolar (coord_type == 1):
+        # There are gravity (external) sources,
+        # geometric terms due to local unit vectors, and pressure gradient
+        # since we don't include pressure in xmom and ymom fluxes
+        # due to incompatible divergence and gradient in non-Cartesian geometry
+
+        # For Cartesian2d (coord_type == 0):
+        # There is only gravity sources.
 
         if myg.coord_type == 1:
             xmom.v()[:, :] += 0.5*self.dt * \
@@ -303,7 +314,6 @@ def evolve(self):
             ener.v()[:, :] += 0.5*self.dt*(xmom.v() + old_xmom.v())*grav
 
         else:
-            # gravitational source terms
             ymom.v()[:, :] += 0.5*self.dt*(dens.v() + old_dens.v())*grav
             ener.v()[:, :] += 0.5*self.dt*(ymom.v() + old_ymom.v())*grav