paddle 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

paddle/__init__.py

@@ -4,4 +4,4 @@ from .find_init_params import find_init_params
 from .evolve_kinetics import evolve_kinetics
 
 __all__ = ["setup_profile", "write_profile", "find_init_params", "evolve_kinetics"]
-__version__ = "1.2.0"
+__version__ = "1.2.2"

paddle/cubed_sphere_ui.py

@@ -0,0 +1,63 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.widgets import Slider, CheckButtons, Button
+from cubed_sphere_utils import draw_panel_corner
+
+plt.close("all")
+fig = plt.figure(figsize=(9, 7))
+ax = fig.add_axes([0.08, 0.18, 0.82, 0.75])
+ax.set_aspect("equal")
+ax.set_xlim(-1.05, 1.05)
+ax.set_ylim(-1.05, 1.05)
+ax.set_title(
+    "Interactive orthographic view — drag sliders to rotate view_dir\n(+X solid, +Y dotted, +Z dash-dot; ghosts dashed)"
+)
+
+ax_az = fig.add_axes([0.08, 0.10, 0.6, 0.03])
+ax_el = fig.add_axes([0.08, 0.06, 0.6, 0.03])
+s_az = Slider(ax_az, "Azimuth (°)", 0, 360, valinit=45, valstep=1)
+s_el = Slider(ax_el, "Elevation (°)", -85, 85, valinit=10, valstep=1)
+
+ax_chk = fig.add_axes([0.72, 0.05, 0.18, 0.10])
+checks = CheckButtons(ax_chk, labels=["Show +Z"], actives=[True])
+
+ax_reset = fig.add_axes([0.65, 0.12, 0.1, 0.04])
+btn_reset = Button(ax_reset, "Reset")
+
+
+def viewdir_from_angles(az_deg, el_deg):
+    az = np.deg2rad(az_deg)
+    el = np.deg2rad(el_deg)
+    c = np.cos(el)
+    return np.array([c * np.cos(az), c * np.sin(az), np.sin(el)])
+
+
+def redraw(_=None):
+    ax.cla()
+    ax.set_aspect("equal")
+    ax.set_xlim(-1.1, 1.1)
+    ax.set_ylim(-1.1, 1.1)
+    ax.set_title(
+        "Interactive orthographic view — drag sliders to rotate view_dir\n(+X solid, +Y dotted, +Z dash-dot; ghosts dashed)"
+    )
+    V = viewdir_from_angles(s_az.val, s_el.val)
+
+    draw_panel_corner(ax, N=8, nghost=3, view_dir=V)
+
+    fig.canvas.draw_idle()
+
+
+def on_reset(event):
+    s_az.reset()
+    s_el.reset()
+    if not checks.get_status()[0]:
+        checks.set_active(0)
+
+
+s_az.on_changed(redraw)
+s_el.on_changed(redraw)
+checks.on_clicked(redraw)
+btn_reset.on_clicked(on_reset)
+
+redraw()
+plt.show()

paddle/cubed_sphere_utils.py

@@ -0,0 +1,356 @@
+import numpy as np
+from matplotlib.patches import Polygon
+from typing import Tuple
+
+
+def normalize(v: np.ndarray) -> np.ndarray:
+    return v / np.linalg.norm(v)
+
+
+def gnomonic_equiangular_to_xyz(alpha, beta, face="+X"):
+    """
+    Map equiangular gnomonic coordinates (alpha, beta) in radians to
+    Cartesian coordinates (x, y, z) on the unit sphere for a given cube face.
+
+    (alpha, beta) are the equiangular angles from the face center:
+        t = tan(alpha), u = tan(beta)
+    Faces: "+X", "-X", "+Y", "-Y", "+Z", "-Z"
+    """
+    t = np.tan(alpha)
+    u = np.tan(beta)
+
+    if face == "+X":
+        X, Y, Z = np.ones_like(t), t, u
+    elif face == "-X":
+        X, Y, Z = -np.ones_like(t), -t, u
+    elif face == "+Y":
+        X, Y, Z = -t, np.ones_like(t), u
+    elif face == "-Y":
+        X, Y, Z = t, -np.ones_like(t), u
+    elif face == "+Z":
+        X, Y, Z = -u, t, np.ones_like(t)
+    elif face == "-Z":
+        X, Y, Z = u, t, -np.ones_like(t)
+    else:
+        raise ValueError("Invalid face specifier")
+
+    inv_norm = 1.0 / np.sqrt(X * X + Y * Y + Z * Z)
+    return X * inv_norm, Y * inv_norm, Z * inv_norm
+
+
+def orthographic_project(face_xyz, view_dir=np.array([1, 0, 0])):
+    """Orthographic projection onto the plane normal to view_dir."""
+    x, y, z = face_xyz
+    V = normalize(np.array(view_dir))
+    # Construct orthonormal basis (e1,e2) spanning plane perpendicular to V
+    # Choose arbitrary "up" vector not parallel to V
+    up_guess = np.array([0, 0, 1]) if abs(V[2]) < 0.9 else np.array([0, 1, 0])
+    e1 = normalize(np.cross(up_guess, V))
+    e2 = np.cross(V, e1)
+    # Project coordinates
+    U = x * e1[0] + y * e1[1] + z * e1[2]
+    W = x * e2[0] + y * e2[1] + z * e2[2]
+    return U, W
+
+
+def visible_segments(u, v, depth, vis_mask):
+    segs = []
+    start = None
+    for i in range(len(u)):
+        if vis_mask[i] and start is None:
+            start = i
+        elif (not vis_mask[i]) and (start is not None):
+            segs.append((u[start:i], v[start:i], depth[start:i]))
+            start = None
+    if start is not None:
+        segs.append((u[start:], v[start:], depth[start:]))
+    return segs
+
+
+def plot_on_face(ax, alpha, beta, face="+X", view_dir=np.array([1, 0, 0]), **kwargs):
+    x, y, z = gnomonic_equiangular_to_xyz(alpha, beta, face=face)
+    # r·V (nearness for ortho)
+    depth = x * view_dir[0] + y * view_dir[1] + z * view_dir[2]
+
+    vis = depth > 0  # front hemisphere
+    u, v = orthographic_project((x, y, z), view_dir=view_dir)
+    segs = visible_segments(u, v, depth, vis)
+    segs.sort(key=lambda seg: np.max(seg[2]) if seg[2].size else -1)
+    for uu, vv, dd in segs:
+        ax.plot(uu, vv, zorder=np.max(dd) if dd.size else 0, **kwargs)
+
+
+def scatter_on_face(ax, alpha, beta, face="+X", view_dir=np.array([1, 0, 0]), **kwargs):
+    x, y, z = gnomonic_equiangular_to_xyz(alpha, beta, face=face)
+    # r·V (nearness for ortho)
+    depth = x * view_dir[0] + y * view_dir[1] + z * view_dir[2]
+
+    vis = depth > 0  # front hemisphere
+    u, v = orthographic_project((x, y, z), view_dir=view_dir)
+    ax.scatter(u[vis], v[vis], zorder=np.max(depth[vis]), **kwargs)
+
+
+def panel_ab_limits(
+    dxy, N, nghost, exterior=True
+) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+    """
+    Return ((a_min, b_min), (a_max, b_max)) in equiangular gnomonic coords (radians)
+    for a single cubed-sphere panel.
+
+    Panel interior spans α,β ∈ [-π/4, +π/4]. Each cell has angular size
+    dθ = (π/2) / N. Ghost zones extend outward by 'nghost' cells.
+
+    Offsets (dx, dy) ∈ {-1, 0, 1} select a slab/corner in each dimension:
+      - dx = -1: left
+      - dx =  0: center
+      - dx = +1: right
+      (analogous for dy: bottom/center/top)
+
+    exterior=True:
+      - (0, 0) returns FULL exterior limits including ghost zones
+      - (-1, 0) returns the LEFT ghost region only (width = nghost * dθ), etc.
+
+    exterior=False:
+      - (0, 0) returns interior limits ONLY
+      - (-1, 0) returns the interior boundary slab adjacent to the left edge,
+        with the SAME thickness as the ghost zone (nghost * dθ) but inside.
+        (Analogous for other offsets and for dy.)
+
+    Returns:
+      ((a_min, b_min), (a_max, b_max))
+    """
+    dx, dy = dxy
+    if dx not in (-1, 0, 1) or dy not in (-1, 0, 1):
+        raise ValueError("dx, dy must be in {-1, 0, 1}")
+    if N <= 0 or nghost < 0:
+        raise ValueError("N must be > 0 and nghost >= 0")
+
+    dtheta = (np.pi / 2.0) / N
+    aL_int, aR_int = -np.pi / 4, +np.pi / 4
+    bB_int, bT_int = -np.pi / 4, +np.pi / 4
+
+    # External (interior + ghosts) bounds along each dimension
+    aL_ext = aL_int - nghost * dtheta
+    aR_ext = aR_int + nghost * dtheta
+    bB_ext = bB_int - nghost * dtheta
+    bT_ext = bT_int + nghost * dtheta
+
+    def one_dim_limits(
+        offset: int, L_int: float, R_int: float, L_ext: float, R_ext: float
+    ):
+        if offset == 0:  # full span incl. ghosts
+            return (L_int, R_int)
+        if exterior:
+            if offset == -1:  # left ghost slab
+                return (L_ext, L_int)
+            else:  # +1: right ghost slab
+                return (R_int, R_ext)
+        else:
+            if offset == -1:  # interior boundary slab (left), same thickness as ghosts
+                return (L_int, L_int + nghost * dtheta)
+            else:  # +1: interior boundary slab (right)
+                return (R_int - nghost * dtheta, R_int)
+
+    a_min, a_max = one_dim_limits(dx, aL_int, aR_int, aL_ext, aR_ext)
+    b_min, b_max = one_dim_limits(dy, bB_int, bT_int, bB_ext, bT_ext)
+
+    # set to whole domain
+    if dx == 0 and dy == 0 and exterior:
+        a_min, a_max = aL_ext, aR_ext
+        b_min, b_max = bB_ext, bT_ext
+
+    # Ensure (lower-left, upper-right) ordering
+    a0, a1 = (min(a_min, a_max), max(a_min, a_max))
+    b0, b1 = (min(b_min, b_max), max(b_min, b_max))
+    return (a0, b0), (a1, b1)
+
+
+def sample_edge(a0, b0, a1, b1, n_pts=64):
+    t = np.linspace(0.0, 1.0, n_pts)
+    return (a0 + (a1 - a0) * t), (b0 + (b1 - b0) * t)
+
+
+def make_poly_patch(verts_ab, face="+X", view_dir=(1, 0, 0), n_pts=64, **kwargs):
+    # Sample each edge, map to sphere, cull back hemisphere
+    boundary_u, boundary_v, boundary_d = [], [], []
+    for (a0, b0), (a1, b1) in zip(verts_ab, verts_ab[1:] + verts_ab[:1]):
+        aa, bb = sample_edge(a0, b0, a1, b1, n_pts=n_pts)
+        xyz = gnomonic_equiangular_to_xyz(aa, bb, face=face)
+        u, v = orthographic_project(xyz, view_dir=view_dir)
+        d = xyz[0] * view_dir[0] + xyz[1] * view_dir[1] + xyz[2] * view_dir[2]
+        mask = d > 0
+        boundary_u.append(u[mask])
+        boundary_v.append(v[mask])
+        boundary_d.append(d[mask])
+
+    if not any(len(u) for u in boundary_u):
+        return None  # fully occluded
+
+    U = np.concatenate(boundary_u)
+    V = np.concatenate(boundary_v)
+    D = (
+        np.concatenate(boundary_d)
+        if any(len(d) for d in boundary_d)
+        else np.array([0.0])
+    )
+
+    poly = Polygon(np.c_[U, V], closed=True, zorder=1 + float(np.max(D)), **kwargs)
+    return poly
+
+
+def draw_panel_grid(
+    ax,
+    face="+X",
+    N=8,
+    nghost=3,
+    n_pts=800,
+    view_dir=np.array([1, 0, 0]),
+    color="C0",
+    linestyle="--",
+    linewidth=0.8,
+    facecolor="none",
+):
+    """
+    Plot an equiangular gnomonic grid for a single cubed-sphere panel with ghost zones.
+      - N: number of interior cells per direction (there are N+1 interior grid lines).
+      - nghost: number of extra ghost cells beyond each edge (drawn dashed).
+    """
+    # Uniform grid in equiangular coordinates; panel spans [-pi/4, +pi/4].
+    dtheta = (np.pi / 2) / N  # cell size in angle
+
+    # Grid-line indices: i = -N/2 ... N/2 for interior; extend by nghost
+    halfN = N // 2
+    idx = np.arange(-halfN - nghost, halfN + nghost + 1)
+    alphas = idx * dtheta  # positions of grid lines
+    centers = 0.5 * (alphas[1:] + alphas[:-1])  # cell centers
+
+    # Limit plotting domain to a slightly larger band so dashed ghost lines are visible
+    s = np.linspace(-np.pi / 4 - nghost * dtheta, np.pi / 4 + nghost * dtheta, n_pts)
+
+    # alpha = const lines
+    for i, alpha in zip(idx, alphas):
+        # skip the first and the last lines
+        if i == idx[0] or i == idx[-1]:
+            continue
+        plot_on_face(
+            ax,
+            np.full_like(s, alpha),
+            s,
+            face=face,
+            view_dir=view_dir,
+            linewidth=linewidth,
+            linestyle=linestyle,
+            color=color,
+        )
+
+    # beta = const lines
+    for j, beta in zip(idx, alphas):
+        # skip the first and the last lines
+        if j == idx[0] or j == idx[-1]:
+            continue
+        plot_on_face(
+            ax,
+            s,
+            np.full_like(s, beta),
+            face=face,
+            view_dir=view_dir,
+            linewidth=linewidth,
+            linestyle=linestyle,
+            color=color,
+        )
+
+    # cell centers (solid dots)
+    center_a, center_b = np.meshgrid(centers, centers)
+    scatter_on_face(
+        ax,
+        center_a.flatten(),
+        center_b.flatten(),
+        face=face,
+        view_dir=view_dir,
+        s=10,
+        facecolors=facecolor,
+        edgecolors=color,
+    )
+
+    # Interior panel boundary (bold): |alpha|=pi/4 and |beta|=pi/4
+    for alpha in [-np.pi / 4, np.pi / 4]:
+        plot_on_face(
+            ax,
+            np.full_like(s, alpha),
+            s,
+            face=face,
+            view_dir=view_dir,
+            linestyle="-.",
+            linewidth=1.6,
+            color=color,
+        )
+    for beta in [-np.pi / 4, np.pi / 4]:
+        plot_on_face(
+            ax,
+            s,
+            np.full_like(s, beta),
+            face=face,
+            view_dir=view_dir,
+            linestyle="-.",
+            linewidth=1.6,
+            color=color,
+        )
+
+
+def draw_single_panel(
+    ax, face="+X", N=8, nghost=3, color="C0", view_dir=np.array([1, 0, 0])
+):
+    # all grid lines including ghosts
+    draw_panel_grid(ax, face=face, N=N, nghost=nghost, color=color, view_dir=view_dir)
+
+    # interior grid lines only
+    draw_panel_grid(
+        ax,
+        face=face,
+        N=N,
+        nghost=0,
+        view_dir=view_dir,
+        linestyle="-",
+        linewidth=1.2,
+        facecolor=color,
+        color=color,
+    )
+
+
+def draw_panel_seam(ax, N=8, nghost=3, view_dir=np.array([1.0, 1.0, 0.0])):
+    draw_single_panel(ax, "+X", N=N, nghost=nghost, view_dir=view_dir, color="C0")
+    draw_single_panel(ax, "+Y", N=N, nghost=nghost, view_dir=view_dir, color="C1")
+
+    # ghost zone patches
+    (a0, b0), (a1, b1) = panel_ab_limits((1, 0), N=N, nghost=nghost, exterior=True)
+    verts_box = [(a0, b0), (a1, b0), (a1, b1), (a0, b1)]
+    poly = make_poly_patch(
+        verts_box,
+        face="+X",
+        view_dir=view_dir,
+        edgecolor="k",
+        # grey with some transparency
+        facecolor=(0.5, 0.5, 0.5, 0.3),
+        linewidth=1.2,
+    )
+    ax.add_patch(poly)
+
+
+def draw_panel_corner(ax, N=8, nghost=3, view_dir=np.array([1.0, 1.0, 1.0])):
+    draw_single_panel(ax, "+X", N=N, nghost=nghost, view_dir=view_dir, color="C0")
+    draw_single_panel(ax, "+Y", N=N, nghost=nghost, view_dir=view_dir, color="C1")
+    draw_single_panel(ax, "+Z", N=N, nghost=nghost, view_dir=view_dir, color="C2")
+
+    # ghost zone patches
+    (a0, b0), (a1, b1) = panel_ab_limits((1, 1), N=N, nghost=nghost, exterior=True)
+    verts_box = [(a0, b0), (a1, b0), (a1, b1), (a0, b1)]
+    poly = make_poly_patch(
+        verts_box,
+        face="+X",
+        view_dir=view_dir,
+        edgecolor="k",
+        # grey with some transparency
+        facecolor=(0.5, 0.5, 0.5, 0.3),
+        linewidth=1.2,
+    )
+    ax.add_patch(poly)

paddle/evolve_kinetics.py

@@ -6,9 +6,10 @@ from snapy import kIDN, kIPR, kICY
 
 def evolve_kinetics(
     hydro_w: torch.Tensor,
-    block: snapy.MeshBlock,
-    kinet: kintera.Kinetics,
+    eos: snapy.EquationOfState,
     thermo_x: kintera.ThermoX,
+    thermo_y: kintera.ThermoY,
+    kinet: kintera.Kinetics,
     dt,
 ) -> torch.Tensor:
     """
@@ -16,30 +17,45 @@ def evolve_kinetics(
 
     Args:
         hydro_w (torch.Tensor): The primitive variables tensor.
-        block (snapy.MeshBlock): The mesh block containing the simulation data.
-        kinet (kintera.Kinetics): The kinetics module for chemical reactions.
+        eos (snapy.EquationOfState): The equation-of-state.
         thermo_x (kintera.ThermoX): The thermodynamics module for computing properties.
+        thermo_y (kintera.ThermoY): The thermodynamics module for computing properties.
+        kinet (kintera.Kinetics): The kinetics module for chemical reactions.
         dt (float): The time step for evolution.
 
     Returns:
         torch.Tensor: The change in mass density due to chemical reactions.
     """
-    eos = block.hydro.get_eos()
-    thermo_y = block.module("hydro.eos.thermo")
-
+    # compute temperature and pressure
     temp = eos.compute("W->T", (hydro_w,))
     pres = hydro_w[kIPR]
+
+    # compute mole fractions from mass fractions
     xfrac = thermo_y.compute("Y->X", (hydro_w[kICY:],))
+
+    # compute molar concentrations
     conc = thermo_x.compute("TPX->V", (temp, pres, xfrac))
+
+    # compute volumetric heat capacity
     cp_vol = thermo_x.compute("TV->cp", (temp, conc))
 
-    conc_kinet = kinet.options.narrow_copy(conc, thermo_y.options)
+    # narrow species for kinetics
+    # conc_kinet = kinet.options.narrow_copy(conc, thermo_y.options)
+    conc_kinet = conc[:, :, :, 1:]  # exclude dry species
+
+    # compute rate and rate jacobians
     rate, rc_ddC, rc_ddT = kinet.forward_nogil(temp, pres, conc_kinet)
+
+    # compute reaction jacobian
     jac = kinet.jacobian(temp, conc_kinet, cp_vol, rate, rc_ddC, rc_ddT)
 
+    # compute concentration change
     stoich = kinet.buffer("stoich")
     del_conc = kintera.evolve_implicit(rate, stoich, jac, dt)
 
+    # compute density change
     inv_mu = thermo_y.buffer("inv_mu")
     del_rho = del_conc / inv_mu[1:].view(1, 1, 1, -1)
+
+    # return permutated density change for hydro
     return del_rho.permute(3, 0, 1, 2)

paddle/find_init_params.py

@@ -34,7 +34,7 @@ def find_init_params(
         dict: Dictionary containing the found parameters: Ts, Ps, xH2O, xNH3, xH2S.
     """
     count = 0
-    eos = block.hydro.get_eos()
+    eos = block.module("hydro.eos")
 
     while count < max_iter:
         if verbose:

paddle/plot_cubed_sphere_panel.py

@@ -0,0 +1,21 @@
+import matplotlib.pyplot as plt
+from cubed_sphere_utils import (
+    make_poly_patch,
+    draw_single_panel,
+    draw_panel_seam,
+    draw_panel_corner,
+)
+
+if __name__ == "__main__":
+    fig, ax = plt.subplots(figsize=(8, 8))
+
+    # draw_single_panel(ax, N=6, nghost=3)
+    draw_panel_seam(ax, N=6, nghost=2)
+    # draw_panel_corner(ax, N=8, nghost=3)
+
+    ax.set_aspect("equal")
+    ax.set_xlabel("X (orthographic)")
+    ax.set_ylabel("Y (orthographic)")
+    ax.set_xlim(-1.1, 1.1)
+    ax.set_ylim(-1.1, 1.1)
+    plt.show()

paddle/setup_profile.py

@@ -34,7 +34,7 @@ def integrate_neutral(
     pres_ad = pres.clone()
     xfrac_ad = xfrac.clone()
 
-    thermo_x.extrapolate_ad(temp_ad, pres_ad, xfrac_ad, grav, dz)
+    thermo_x.extrapolate_dz(temp_ad, pres_ad, xfrac_ad, dz, grav=grav)
     conc_ad = thermo_x.compute("TPX->V", [temp_ad, pres_ad, xfrac_ad])
     rho_ad = thermo_x.compute("V->D", [conc_ad])
     rho_bar = 0.5 * (rho + rho_ad)
@@ -192,7 +192,7 @@ def setup_profile(
     Tmin = param.get("Tmin", 0.0)
 
     # get handles to modules
-    coord = block.module("hydro.coord")
+    coord = block.module("coord")
     thermo_y = block.module("hydro.eos.thermo")
 
     # get coordinates
@@ -224,23 +224,26 @@ def setup_profile(
 
     # start and end indices for the vertical direction
     # excluding ghost cells
-    ifirst = coord.ifirst()
-    ilast = coord.ilast()
+    il = coord.il()
+    iu = coord.iu()
 
     # vertical grid distance of the first cell
-    dz = coord.buffer("dx1f")[ifirst]
+    dz = coord.buffer("dx1f")[il]
 
     # half a grid to cell center
-    thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz / 2.0, verbose=verbose)
+    rainout = method.split("-")[0] != "moist"
+    thermo_x.extrapolate_dz(
+        temp, pres, xfrac, dz / 2.0, grav=grav, verbose=verbose, rainout=rainout
+    )
 
     # adiabatic extrapolation
     if method == "isothermal":
-        i_isothermal = ifirst
-        ifirst = ilast
+        i_isothermal = il
+        il = iu
     else:
-        i_isothermal = ilast
+        i_isothermal = iu
 
-    for i in range(ifirst, ilast):
+    for i in range(il, iu + 1):
         # drop clouds fractions
         if method.split("-")[0] != "moist":
             for cid in thermo_x.options.cloud_ids():
@@ -261,14 +264,16 @@ def setup_profile(
         elif method.split("-")[0] == "neutral":
             temp, pres, xfrac = integrate_neutral(thermo_x, temp, pres, xfrac, grav, dz)
         else:
-            thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz, verbose=verbose)
+            thermo_x.extrapolate_dz(
+                temp, pres, xfrac, dz, grav=grav, verbose=verbose, rainout=rainout
+            )
 
         if torch.any(temp < Tmin):
             i_isothermal = i + 1
             break
 
     # isothermal extrapolation
-    for i in range(i_isothermal, ilast):
+    for i in range(i_isothermal, iu + 1):
         # drop clouds fractions
         if method.split("-")[0] != "moist":
             for cid in thermo_x.options.cloud_ids():

paddle/write_profile.py

@@ -11,8 +11,8 @@ from snapy import kIPR, kICY
 
 def write_profile(
     filename: str,
-    hydro_w: torch.Tensor,
     block: snapy.MeshBlock,
+    hydro_w: torch.Tensor,
     ref_pressure: float = 1.0e5,
     comment: Optional[str] = None,
 ) -> None:
@@ -30,9 +30,9 @@ def write_profile(
         None
     """
     # useful modules
+    coord = block.module("coord")
     thermo_y = block.module("hydro.eos.thermo")
-    coord = block.module("hydro.coord")
-    eos = block.hydro.get_eos()
+    eos = block.module("hydro.eos")
 
     # handling mole fraction quantities
     thermo_x = kintera.ThermoX(thermo_y.options)

{paddle-1.2.0.dist-info → paddle-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paddle
-Version: 1.2.0
+Version: 1.2.2
 Summary: Python Atmospheric Dynamics: Discovery and Learning about Exoplanets. An open-source, user-friendly python frontend of canoe
 Project-URL: Homepage, https://github.com/elijah-mullens/paddle
 Project-URL: Repository, https://github.com/elijah-mullens/paddle
@@ -23,7 +23,7 @@ Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.9
 Requires-Dist: scipy
-Requires-Dist: snapy>=1.0.3
+Requires-Dist: snapy>=1.1.5
 Requires-Dist: torch<=2.7.1,>=2.7.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == 'dev'

paddle-1.2.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+paddle/__init__.py,sha256=LnVUdwA5HacoapuAHkSJhROl2UxvK_0HtR_CAB3tBbU,281
+paddle/crm.py,sha256=pME4nF5gjlJm-36yMl0N8bzT6UBr2CsOD6nopby7e9M,1993
+paddle/cubed_sphere_ui.py,sha256=2oYfAje6ALuT21fRMFKLYigr59yWDdP3_y6dZ8B4j44,1732
+paddle/cubed_sphere_utils.py,sha256=c7vr0S7JEiMy5UjmEK51gmGZY0j144UjVRsp2wO-iig,11686
+paddle/evolve_kinetics.py,sha256=dMphJqggu18yVqfdcKHbaxkXZhifBfvNjMiDLbdxaOg,2020
+paddle/example_save.py,sha256=MYVOr9J5oTU2NILPnr3qhHdbU7u81Rtca8RjVv8xE6s,610
+paddle/find_init_params.py,sha256=h7ka8fREXjD2RmhflWpByWHFhKoHNCYGN4TATQY0FYg,2532
+paddle/nc2pt.py,sha256=LXR0fnUTaOA_uaDsLU4YqdAVFyycB6SvRq12xWhHhLA,1136
+paddle/plot_cubed_sphere_panel.py,sha256=jK813orIrRHjvZ5WwX3gzAZ1cub8eQFRTqU8cXtU5VM,525
+paddle/pt2nc.py,sha256=lLviBm6a2O05RvuPQc8DxV5pGr_VEhlSkrKPV1lQ3yU,3913
+paddle/setup_profile.py,sha256=A4ityv7RKeOyAEcsGKewxI_VHFeJ3mMGgqrxKnBCkMk,8869
+paddle/write_profile.py,sha256=TFpRvh0OKDIuDfiUqvxrI53AokAkkiVjTtXWXNtXTzU,3912
+paddle-1.2.2.dist-info/METADATA,sha256=7wiw18jCawqiO1ZhgkL1ekQI23w0fWZUyhmXu0f1s98,6005
+paddle-1.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+paddle-1.2.2.dist-info/entry_points.txt,sha256=pDR96GW6ylBZrbFd-tRGthW8qTuYaSLjrEt1LFIEYto,48
+paddle-1.2.2.dist-info/licenses/LICENSE,sha256=e6NthgKABUnLRqjuETcBGgsOuA-aJANpNoeXMe9RBso,1071
+paddle-1.2.2.dist-info/RECORD,,

paddle-1.2.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-paddle/__init__.py,sha256=RAXFapvqRTn4YjzlDkCj3POZcN3LP43d14YabPEdjzE,281
-paddle/crm.py,sha256=pME4nF5gjlJm-36yMl0N8bzT6UBr2CsOD6nopby7e9M,1993
-paddle/evolve_kinetics.py,sha256=3fkFnYqJRNimOaxuf2FAnMUrMGaaP1vJwSWfRU3R1XM,1553
-paddle/example_save.py,sha256=MYVOr9J5oTU2NILPnr3qhHdbU7u81Rtca8RjVv8xE6s,610
-paddle/find_init_params.py,sha256=EwedId1KljMxOD0lD7RZmWJGJuaItiPPlW_EtW8O6L8,2528
-paddle/nc2pt.py,sha256=LXR0fnUTaOA_uaDsLU4YqdAVFyycB6SvRq12xWhHhLA,1136
-paddle/pt2nc.py,sha256=lLviBm6a2O05RvuPQc8DxV5pGr_VEhlSkrKPV1lQ3yU,3913
-paddle/setup_profile.py,sha256=GkeucqDZvi3ZW5uTf4Y8fMaPe1XGQu1Mhg2NJkO6uD0,8770
-paddle/write_profile.py,sha256=g2e7RIViwiEok0fbfgDgait2dVVYSdzUcu8WGd5sD9g,3914
-paddle-1.2.0.dist-info/METADATA,sha256=9Ae-55Z2CMkb6ymoTVzVXms2_Gq0n1yetcwppi-b2qA,6005
-paddle-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-paddle-1.2.0.dist-info/entry_points.txt,sha256=pDR96GW6ylBZrbFd-tRGthW8qTuYaSLjrEt1LFIEYto,48
-paddle-1.2.0.dist-info/licenses/LICENSE,sha256=e6NthgKABUnLRqjuETcBGgsOuA-aJANpNoeXMe9RBso,1071
-paddle-1.2.0.dist-info/RECORD,,