modverif 0.2.2__tar.gz → 0.2.4__tar.gz

{modverif-0.2.2 → modverif-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modverif
-Version: 0.2.2
+Version: 0.2.4
 Project-URL: Documentation, https://mullenkamp.github.io/modverif/
 Project-URL: Source, https://github.com/mullenkamp/modverif
 Author-email: mullenkamp <mullenkamp1@gmail.com>

{modverif-0.2.2 → modverif-0.2.4}/modverif/__init__.py

@@ -1,4 +1,4 @@
 from modverif.evaluator import Evaluator
 from modverif.station import StationEvaluator
 
-__version__ = '0.2.2'
+__version__ = '0.2.4'

{modverif-0.2.2 → modverif-0.2.4}/modverif/composite.py

@@ -68,7 +68,9 @@ def _read_grid_from_ds(ds):
     Read 2D grid coordinate arrays and CRS info from a cfdb dataset.
 
     For datasets with ``latitude``/``longitude``: returns lat/lon arrays,
-    data_crs=PlateCarree, is_projected=False.
+    data_crs=PlateCarree, is_projected=False. Longitudes > 180 are wrapped
+    to the -180..180 range and the longitude axis is reordered so values
+    are ascending (handles data that crosses the antimeridian).
 
     For projected datasets with ``y``/``x`` and a CRS: returns native
     projected coordinate arrays, the CRS, is_projected=True.
@@ -76,21 +78,35 @@ def _read_grid_from_ds(ds):
     Returns
     -------
     tuple
-        (x2d, y2d, data_crs, is_projected) where x2d/y2d are 2D arrays
-        in native coordinates and data_crs is a pyproj.CRS.
+        (x2d, y2d, data_crs, is_projected, lon_sort_idx) where x2d/y2d
+        are 2D arrays in native coordinates, data_crs is a pyproj.CRS,
+        and lon_sort_idx is an index array to reorder data along the
+        longitude axis (None if no reordering needed).
     """
     coord_names = set(ds.coord_names)
     var_names = set(ds.data_var_names)
 
     if 'latitude' in coord_names or 'latitude' in var_names:
         xlat, xlong = _read_latlon_2d(ds)
-        return xlong, xlat, None, False
+
+        # Handle antimeridian: wrap > 180 and reorder so lons are ascending
+        lon_sort_idx = None
+        if np.any(xlong > 180):
+            xlong = np.where(xlong > 180, xlong - 360, xlong)
+            if xlong.ndim == 2:
+                # 1D coordinates meshed into 2D — reorder along lon axis
+                lon_1d = xlong[0, :]
+                lon_sort_idx = np.argsort(lon_1d)
+                xlong = xlong[:, lon_sort_idx]
+                xlat = xlat[:, lon_sort_idx]
+
+        return xlong, xlat, None, False, lon_sort_idx
 
     if 'y' in coord_names and 'x' in coord_names and ds.crs is not None:
         y_1d = ds['y'].data
         x_1d = ds['x'].data
         x2d, y2d = np.meshgrid(x_1d, y_1d)
-        return x2d, y2d, ds.crs, True
+        return x2d, y2d, ds.crs, True, None
 
     raise ValueError(
         "Dataset must contain either 'latitude'/'longitude' coordinates "
@@ -99,6 +115,13 @@ def _read_grid_from_ds(ds):
     )
 
 
+def _apply_lon_sort(data_2d, lon_sort_idx):
+    """Reorder a 2D array along the longitude axis if needed."""
+    if lon_sort_idx is not None:
+        return data_2d[:, lon_sort_idx]
+    return data_2d
+
+
 def _draw_composite_layers(
     ax,
     x2d: np.ndarray,
@@ -432,7 +455,7 @@ def plot_storm_composite_timestep(
         raise FileNotFoundError(f"Dataset not found: {cfdb_path}")
 
     with cfdb.open_dataset(cfdb_path) as ds:
-        x2d, y2d, data_crs, is_projected = _read_grid_from_ds(ds)
+        x2d, y2d, data_crs, is_projected, lon_sort = _read_grid_from_ds(ds)
         time_values = ds['time'].data
 
         # Validate time index
@@ -440,15 +463,15 @@ def plot_storm_composite_timestep(
             raise IndexError(f"time_index {time_index} out of range [0, {len(time_values) - 1}]")
 
         # Read fields
-        vimf_u = _read_var_2d(ds, vimf_u_var, time_index)
-        vimf_v = _read_var_2d(ds, vimf_v_var, time_index)
-        pwat = _read_var_2d(ds, pwat_var, time_index)
+        vimf_u = _apply_lon_sort(_read_var_2d(ds, vimf_u_var, time_index), lon_sort)
+        vimf_v = _apply_lon_sort(_read_var_2d(ds, vimf_v_var, time_index), lon_sort)
+        pwat = _apply_lon_sort(_read_var_2d(ds, pwat_var, time_index), lon_sort)
 
         # MSLP with compute fallback
         if mslp_var == 'mslp':
-            mslp = _read_slp_from_cfdb(ds, time_index)
+            mslp = _apply_lon_sort(_read_slp_from_cfdb(ds, time_index), lon_sort)
         else:
-            mslp = _read_var_2d(ds, mslp_var, time_index)
+            mslp = _apply_lon_sort(_read_var_2d(ds, mslp_var, time_index), lon_sort)
 
         time_str = str(time_values[time_index])
 
@@ -532,7 +555,7 @@ def plot_storm_composite(
     png_files = []
 
     with cfdb.open_dataset(cfdb_path) as ds:
-        x2d, y2d, data_crs, is_projected = _read_grid_from_ds(ds)
+        x2d, y2d, data_crs, is_projected, lon_sort = _read_grid_from_ds(ds)
         time_values = ds['time'].data
         n_times = len(time_values)
 
@@ -571,14 +594,14 @@ def plot_storm_composite(
                 continue
 
             # Read fields
-            vimf_u = _read_var_2d(ds, vimf_u_var, t)
-            vimf_v = _read_var_2d(ds, vimf_v_var, t)
-            pwat = _read_var_2d(ds, pwat_var, t)
+            vimf_u = _apply_lon_sort(_read_var_2d(ds, vimf_u_var, t), lon_sort)
+            vimf_v = _apply_lon_sort(_read_var_2d(ds, vimf_v_var, t), lon_sort)
+            pwat = _apply_lon_sort(_read_var_2d(ds, pwat_var, t), lon_sort)
 
             if mslp_var == 'mslp':
-                mslp = _read_slp_from_cfdb(ds, t)
+                mslp = _apply_lon_sort(_read_slp_from_cfdb(ds, t), lon_sort)
             else:
-                mslp = _read_var_2d(ds, mslp_var, t)
+                mslp = _apply_lon_sort(_read_var_2d(ds, mslp_var, t), lon_sort)
 
             time_str = str(t_val)
             frame_path = output_dir / f'{filename_prefix}_t{t:03d}.png'
@@ -827,8 +850,8 @@ def plot_storm_composite_comparison_timestep(
         raise FileNotFoundError(f"Dataset not found: {cfdb_path_b}")
 
     with cfdb.open_dataset(cfdb_path_a) as ds_a, cfdb.open_dataset(cfdb_path_b) as ds_b:
-        x2d_a, y2d_a, data_crs_a, is_projected_a = _read_grid_from_ds(ds_a)
-        x2d_b, y2d_b, data_crs_b, is_projected_b = _read_grid_from_ds(ds_b)
+        x2d_a, y2d_a, data_crs_a, is_projected_a, lon_sort_a = _read_grid_from_ds(ds_a)
+        x2d_b, y2d_b, data_crs_b, is_projected_b, lon_sort_b = _read_grid_from_ds(ds_b)
 
         times_a = ds_a['time'].data
         times_b = ds_b['time'].data
@@ -842,22 +865,22 @@ def plot_storm_composite_comparison_timestep(
         t_val, idx_a, idx_b = matched[time_index]
 
         # Read fields from dataset A
-        vimf_u_a = _read_var_2d(ds_a, vimf_u_var_a, idx_a)
-        vimf_v_a = _read_var_2d(ds_a, vimf_v_var_a, idx_a)
-        pwat_a = _read_var_2d(ds_a, pwat_var_a, idx_a)
+        vimf_u_a = _apply_lon_sort(_read_var_2d(ds_a, vimf_u_var_a, idx_a), lon_sort_a)
+        vimf_v_a = _apply_lon_sort(_read_var_2d(ds_a, vimf_v_var_a, idx_a), lon_sort_a)
+        pwat_a = _apply_lon_sort(_read_var_2d(ds_a, pwat_var_a, idx_a), lon_sort_a)
         if mslp_var_a == 'mslp':
-            mslp_a = _read_slp_from_cfdb(ds_a, idx_a)
+            mslp_a = _apply_lon_sort(_read_slp_from_cfdb(ds_a, idx_a), lon_sort_a)
         else:
-            mslp_a = _read_var_2d(ds_a, mslp_var_a, idx_a)
+            mslp_a = _apply_lon_sort(_read_var_2d(ds_a, mslp_var_a, idx_a), lon_sort_a)
 
         # Read fields from dataset B
-        vimf_u_b = _read_var_2d(ds_b, vimf_u_var_b, idx_b)
-        vimf_v_b = _read_var_2d(ds_b, vimf_v_var_b, idx_b)
-        pwat_b = _read_var_2d(ds_b, pwat_var_b, idx_b)
+        vimf_u_b = _apply_lon_sort(_read_var_2d(ds_b, vimf_u_var_b, idx_b), lon_sort_b)
+        vimf_v_b = _apply_lon_sort(_read_var_2d(ds_b, vimf_v_var_b, idx_b), lon_sort_b)
+        pwat_b = _apply_lon_sort(_read_var_2d(ds_b, pwat_var_b, idx_b), lon_sort_b)
         if mslp_var_b == 'mslp':
-            mslp_b = _read_slp_from_cfdb(ds_b, idx_b)
+            mslp_b = _apply_lon_sort(_read_slp_from_cfdb(ds_b, idx_b), lon_sort_b)
         else:
-            mslp_b = _read_var_2d(ds_b, mslp_var_b, idx_b)
+            mslp_b = _apply_lon_sort(_read_var_2d(ds_b, mslp_var_b, idx_b), lon_sort_b)
 
         time_str = str(t_val)
 
@@ -960,8 +983,8 @@ def plot_storm_composite_comparison(
     png_files = []
 
     with cfdb.open_dataset(cfdb_path_a) as ds_a, cfdb.open_dataset(cfdb_path_b) as ds_b:
-        x2d_a, y2d_a, data_crs_a, is_projected_a = _read_grid_from_ds(ds_a)
-        x2d_b, y2d_b, data_crs_b, is_projected_b = _read_grid_from_ds(ds_b)
+        x2d_a, y2d_a, data_crs_a, is_projected_a, lon_sort_a = _read_grid_from_ds(ds_a)
+        x2d_b, y2d_b, data_crs_b, is_projected_b, lon_sort_b = _read_grid_from_ds(ds_b)
 
         times_a = ds_a['time'].data
         times_b = ds_b['time'].data
@@ -992,22 +1015,22 @@ def plot_storm_composite_comparison(
 
         for i, (t_val, idx_a, idx_b) in enumerate(matched):
             # Read fields from dataset A
-            vimf_u_a = _read_var_2d(ds_a, vimf_u_var_a, idx_a)
-            vimf_v_a = _read_var_2d(ds_a, vimf_v_var_a, idx_a)
-            pwat_a = _read_var_2d(ds_a, pwat_var_a, idx_a)
+            vimf_u_a = _apply_lon_sort(_read_var_2d(ds_a, vimf_u_var_a, idx_a), lon_sort_a)
+            vimf_v_a = _apply_lon_sort(_read_var_2d(ds_a, vimf_v_var_a, idx_a), lon_sort_a)
+            pwat_a = _apply_lon_sort(_read_var_2d(ds_a, pwat_var_a, idx_a), lon_sort_a)
             if mslp_var_a == 'mslp':
-                mslp_a = _read_slp_from_cfdb(ds_a, idx_a)
+                mslp_a = _apply_lon_sort(_read_slp_from_cfdb(ds_a, idx_a), lon_sort_a)
             else:
-                mslp_a = _read_var_2d(ds_a, mslp_var_a, idx_a)
+                mslp_a = _apply_lon_sort(_read_var_2d(ds_a, mslp_var_a, idx_a), lon_sort_a)
 
             # Read fields from dataset B
-            vimf_u_b = _read_var_2d(ds_b, vimf_u_var_b, idx_b)
-            vimf_v_b = _read_var_2d(ds_b, vimf_v_var_b, idx_b)
-            pwat_b = _read_var_2d(ds_b, pwat_var_b, idx_b)
+            vimf_u_b = _apply_lon_sort(_read_var_2d(ds_b, vimf_u_var_b, idx_b), lon_sort_b)
+            vimf_v_b = _apply_lon_sort(_read_var_2d(ds_b, vimf_v_var_b, idx_b), lon_sort_b)
+            pwat_b = _apply_lon_sort(_read_var_2d(ds_b, pwat_var_b, idx_b), lon_sort_b)
             if mslp_var_b == 'mslp':
-                mslp_b = _read_slp_from_cfdb(ds_b, idx_b)
+                mslp_b = _apply_lon_sort(_read_slp_from_cfdb(ds_b, idx_b), lon_sort_b)
             else:
-                mslp_b = _read_var_2d(ds_b, mslp_var_b, idx_b)
+                mslp_b = _apply_lon_sort(_read_var_2d(ds_b, mslp_var_b, idx_b), lon_sort_b)
 
             time_str = str(t_val)
             frame_path = output_dir / f'{filename_prefix}_t{i:03d}.png'