metrust 0.3.3__tar.gz → 0.3.4__tar.gz

{metrust-0.3.3 → metrust-0.3.4}/Cargo.lock

@@ -788,7 +788,7 @@ dependencies = [
 
 [[package]]
 name = "metrust"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "chrono",
  "criterion",
@@ -802,7 +802,7 @@ dependencies = [
 
 [[package]]
 name = "metrust-py"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "metrust",
  "numpy",
@@ -1419,7 +1419,7 @@ dependencies = [
 
 [[package]]
 name = "rustmet-core"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "chrono",
  "flate2",
@@ -1934,14 +1934,14 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "wx-field"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "chrono",
 ]
 
 [[package]]
 name = "wx-math"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "rayon",
  "wx-field",
@@ -1949,7 +1949,7 @@ dependencies = [
 
 [[package]]
 name = "wx-radar"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "byteorder",
  "bzip2",

{metrust-0.3.3 → metrust-0.3.4}/Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT"
 
 [package]
 name = "metrust-py"
-version = "0.3.3"
+version = "0.3.4"
 edition.workspace = true
 description = "Python bindings for metrust — a drop-in replacement for MetPy"
 readme = "README.md"

metrust-0.3.4/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: metrust
+Version: 0.3.4
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Requires-Dist: numpy>=1.20
+Requires-Dist: pint>=0.20
+Summary: Rust-powered drop-in replacement for MetPy -- 150/150 calc functions plus 36 extras, 10-93000x faster
+Keywords: meteorology,weather,rust,metpy,atmospheric-science,nwp,cape,sounding
+Author: Fahrenheit Research
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://fahrenheitresearch.github.io/metrust-py/
+Project-URL: Homepage, https://github.com/FahrenheitResearch/metrust-py
+Project-URL: Issues, https://github.com/FahrenheitResearch/metrust-py/issues
+Project-URL: Repository, https://github.com/FahrenheitResearch/metrust-py
+
+# metrust
+
+**Drop-in replacement for MetPy's calculation layer, powered by Rust.**
+
+150/150 `metpy.calc` functions implemented natively, plus 36 extras. 6-30x faster on real-world workflows. Verified against MetPy on SounderPy, MetPy Cookbook examples, and synthetic global grids.
+
+```python
+# The only change: swap the import
+from metrust.calc import cape_cin, potential_temperature, vorticity
+from metrust.units import units
+```
+
+## Installation
+
+```bash
+pip install metrust
+```
+
+For plotting, xarray accessor, or Level2File (forwarded to MetPy):
+
+```bash
+pip install metrust metpy
+```
+
+## What It Does
+
+metrust implements every function in `metpy.calc` with a Rust backend compiled via PyO3. The Python API matches MetPy's signatures, units, and return types:
+
+```python
+import numpy as np
+from metrust.calc import (
+    cape_cin, parcel_profile, bunkers_storm_motion,
+    storm_relative_helicity, significant_tornado_parameter,
+    vorticity, divergence, advection,
+)
+from metrust.units import units
+
+# Sounding analysis (same API as MetPy)
+p = np.array([1000, 925, 850, 700, 500, 300]) * units.hPa
+T = np.array([25, 20, 15, 5, -15, -40]) * units.degC
+Td = np.array([20, 15, 10, -5, -25, -50]) * units.degC
+
+prof = parcel_profile(p, T[0], Td[0])
+cape, cin = cape_cin(p, T, Td, prof)  # MetPy parcel_profile form works
+
+# Grid kinematics with xarray (dx/dy inferred from lat/lon coords)
+vort = vorticity(u_xarray, v_xarray)  # spherical metric corrections included
+div = divergence(u_xarray, v_xarray)
+```
+
+## Speed
+
+Benchmarked on real-world workflows (v0.3.3, validated by Codex against MetPy):
+
+| Workflow | Speedup | Notes |
+|---|---|---|
+| MetPy Cookbook sounding analysis | **6.0x** | Full severe weather stack |
+| MetPy Cookbook 500 hPa grid | **6.1x** | Vorticity, smoothing, advection |
+| MetPy Cookbook Q-vectors | **6.1x** | Q-vector divergence |
+| SounderPy compute-heavy subset | **29.7x** | Thermo + wind + severe params |
+| MetPy isentropic example | **2.3x** | Isentropic interpolation + Montgomery |
+| Vorticity/divergence (global grid) | **2.3x** | Spherical corrections on 721x1440 |
+
+Array operations on 1M elements (32-core Ryzen, rayon parallel):
+
+| Function | Time | Throughput |
+|---|---|---|
+| `potential_temperature` | 1.8 ms | 550 M/s |
+| `wet_bulb_temperature` | 7.3 ms | 137 M/s |
+| `wind_speed` | 1.5 ms | 660 M/s |
+
+## Numerical Parity
+
+Verified on the MetPy OUN 2011-05-22 12Z test sounding:
+
+| Metric | Difference from MetPy |
+|---|---|
+| CAPE | +4.0 J/kg |
+| MUCAPE | +7.6 J/kg |
+| SRH (0-1 km) | +0.3 m^2/s^2 |
+| Critical angle | +0.2 deg |
+| Bunkers RM | +0.02 m/s |
+| STP | +0.01 |
+| Montgomery streamfunction | corr 1.0000 |
+| Isentropic pressure | 7e-13 hPa diff |
+| Vorticity (global lat/lon) | corr 1.0000 |
+
+Uses MetPy-exact physical constants (Rd, Cp, Lv, epsilon), MetPy's CAPE integration formula (`g * dTv/Tv * dz`), pressure-weighted Bunkers algorithm, Newton solver for isentropic interpolation, and spherical metric tensor corrections for lat/lon grid kinematics.
+
+## Coverage
+
+- **150/150** `metpy.calc` functions (100% coverage)
+- **36 extras** not in MetPy (grid composites, fire weather indices, etc.)
+- **28 Rust array bindings** with rayon parallelism and GIL release
+- **Pint application registry** shared with MetPy (no cross-registry errors)
+- **xarray support** with coordinate inference and shape preservation
+
+## What's Not Native
+
+These forward to MetPy when installed:
+
+- `metrust.plots` (matplotlib-based plotting)
+- `metrust.xarray` (xarray accessor)
+- `metrust.io.Level2File` (NEXRAD Level II)
+
+Core `metrust.calc` is 100% native Rust with no MetPy dependency.
+
+## Examples
+
+See `examples/` for complete drop-in demos:
+
+- `cookbook_sounding.py` — MetPy Cookbook sounding analysis
+- `cookbook_500hpa_grid.py` — MetPy Cookbook 500 hPa vorticity advection
+- `sounderpy_dropin.py` — SounderPy-style full sounding pipeline
+
+## Testing
+
+```bash
+cargo test --workspace          # 1,186 Rust tests
+python -m pytest tests/ -q      # 20 Python tests (including MetPy drop-in regression)
+```
+
+## Documentation
+
+Full docs at [fahrenheitresearch.github.io/metrust-py](https://fahrenheitresearch.github.io/metrust-py/), including:
+
+- API reference for all 186 functions
+- Beginner tutorials (Weather 101, soundings, grids, recipes)
+- Migration guide from MetPy
+- Performance benchmarks
+
+## License
+
+MIT
+

metrust-0.3.4/README.md

@@ -0,0 +1,134 @@
+# metrust
+
+**Drop-in replacement for MetPy's calculation layer, powered by Rust.**
+
+150/150 `metpy.calc` functions implemented natively, plus 36 extras. 6-30x faster on real-world workflows. Verified against MetPy on SounderPy, MetPy Cookbook examples, and synthetic global grids.
+
+```python
+# The only change: swap the import
+from metrust.calc import cape_cin, potential_temperature, vorticity
+from metrust.units import units
+```
+
+## Installation
+
+```bash
+pip install metrust
+```
+
+For plotting, xarray accessor, or Level2File (forwarded to MetPy):
+
+```bash
+pip install metrust metpy
+```
+
+## What It Does
+
+metrust implements every function in `metpy.calc` with a Rust backend compiled via PyO3. The Python API matches MetPy's signatures, units, and return types:
+
+```python
+import numpy as np
+from metrust.calc import (
+    cape_cin, parcel_profile, bunkers_storm_motion,
+    storm_relative_helicity, significant_tornado_parameter,
+    vorticity, divergence, advection,
+)
+from metrust.units import units
+
+# Sounding analysis (same API as MetPy)
+p = np.array([1000, 925, 850, 700, 500, 300]) * units.hPa
+T = np.array([25, 20, 15, 5, -15, -40]) * units.degC
+Td = np.array([20, 15, 10, -5, -25, -50]) * units.degC
+
+prof = parcel_profile(p, T[0], Td[0])
+cape, cin = cape_cin(p, T, Td, prof)  # MetPy parcel_profile form works
+
+# Grid kinematics with xarray (dx/dy inferred from lat/lon coords)
+vort = vorticity(u_xarray, v_xarray)  # spherical metric corrections included
+div = divergence(u_xarray, v_xarray)
+```
+
+## Speed
+
+Benchmarked on real-world workflows (v0.3.3, validated by Codex against MetPy):
+
+| Workflow | Speedup | Notes |
+|---|---|---|
+| MetPy Cookbook sounding analysis | **6.0x** | Full severe weather stack |
+| MetPy Cookbook 500 hPa grid | **6.1x** | Vorticity, smoothing, advection |
+| MetPy Cookbook Q-vectors | **6.1x** | Q-vector divergence |
+| SounderPy compute-heavy subset | **29.7x** | Thermo + wind + severe params |
+| MetPy isentropic example | **2.3x** | Isentropic interpolation + Montgomery |
+| Vorticity/divergence (global grid) | **2.3x** | Spherical corrections on 721x1440 |
+
+Array operations on 1M elements (32-core Ryzen, rayon parallel):
+
+| Function | Time | Throughput |
+|---|---|---|
+| `potential_temperature` | 1.8 ms | 550 M/s |
+| `wet_bulb_temperature` | 7.3 ms | 137 M/s |
+| `wind_speed` | 1.5 ms | 660 M/s |
+
+## Numerical Parity
+
+Verified on the MetPy OUN 2011-05-22 12Z test sounding:
+
+| Metric | Difference from MetPy |
+|---|---|
+| CAPE | +4.0 J/kg |
+| MUCAPE | +7.6 J/kg |
+| SRH (0-1 km) | +0.3 m^2/s^2 |
+| Critical angle | +0.2 deg |
+| Bunkers RM | +0.02 m/s |
+| STP | +0.01 |
+| Montgomery streamfunction | corr 1.0000 |
+| Isentropic pressure | 7e-13 hPa diff |
+| Vorticity (global lat/lon) | corr 1.0000 |
+
+Uses MetPy-exact physical constants (Rd, Cp, Lv, epsilon), MetPy's CAPE integration formula (`g * dTv/Tv * dz`), pressure-weighted Bunkers algorithm, Newton solver for isentropic interpolation, and spherical metric tensor corrections for lat/lon grid kinematics.
+
+## Coverage
+
+- **150/150** `metpy.calc` functions (100% coverage)
+- **36 extras** not in MetPy (grid composites, fire weather indices, etc.)
+- **28 Rust array bindings** with rayon parallelism and GIL release
+- **Pint application registry** shared with MetPy (no cross-registry errors)
+- **xarray support** with coordinate inference and shape preservation
+
+## What's Not Native
+
+These forward to MetPy when installed:
+
+- `metrust.plots` (matplotlib-based plotting)
+- `metrust.xarray` (xarray accessor)
+- `metrust.io.Level2File` (NEXRAD Level II)
+
+Core `metrust.calc` is 100% native Rust with no MetPy dependency.
+
+## Examples
+
+See `examples/` for complete drop-in demos:
+
+- `cookbook_sounding.py` — MetPy Cookbook sounding analysis
+- `cookbook_500hpa_grid.py` — MetPy Cookbook 500 hPa vorticity advection
+- `sounderpy_dropin.py` — SounderPy-style full sounding pipeline
+
+## Testing
+
+```bash
+cargo test --workspace          # 1,186 Rust tests
+python -m pytest tests/ -q      # 20 Python tests (including MetPy drop-in regression)
+```
+
+## Documentation
+
+Full docs at [fahrenheitresearch.github.io/metrust-py](https://fahrenheitresearch.github.io/metrust-py/), including:
+
+- API reference for all 186 functions
+- Beginner tutorials (Weather 101, soundings, grids, recipes)
+- Migration guide from MetPy
+- Performance benchmarks
+
+## License
+
+MIT

{metrust-0.3.3 → metrust-0.3.4}/crates/metrust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "metrust"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 description = "A pure-Rust drop-in replacement for MetPy — meteorological calculations, data I/O, and visualization"
 license = "MIT"

{metrust-0.3.3 → metrust-0.3.4}/crates/metrust/src/interpolate/mod.rs

@@ -10,6 +10,9 @@ pub use wx_math::regrid::{
     cross_section_data, interpolate_vertical,
 };
 
+// ── Re-exports from wx-math interpolate ─────────────────────────────
+pub use wx_math::interpolate::inverse_distance_to_points;
+
 // ── Convenience wrapper ─────────────────────────────────────────────
 
 /// Interpolate scattered values onto a regular lat/lon grid.
@@ -270,12 +273,15 @@ pub fn inverse_distance_to_grid(
     out
 }
 
-/// Inverse distance weighted (IDW) interpolation to arbitrary points.
+/// Inverse distance weighted (IDW) interpolation to arbitrary points (legacy API).
 ///
 /// Same algorithm as [`inverse_distance_to_grid`] but evaluates at
 /// the supplied `(target_lats, target_lons)` positions instead of a
 /// regular grid.
-pub fn inverse_distance_to_points(
+///
+/// For the newer Barnes/Cressman-capable variant, see the re-exported
+/// [`inverse_distance_to_points`] from `wx_math::interpolate`.
+pub fn inverse_distance_to_points_legacy(
     src_lats: &[f64],
     src_lons: &[f64],
     src_values: &[f64],
@@ -627,7 +633,7 @@ pub fn interpolate_to_points(
         }
         _ => {
             // Default to inverse distance (idw / linear)
-            inverse_distance_to_points(
+            inverse_distance_to_points_legacy(
                 src_lats, src_lons, src_values,
                 target_lats, target_lons,
                 2.0,    // power
@@ -1000,7 +1006,7 @@ mod tests {
         // Target at midpoint.
         let tgt_lats = vec![31.0];
         let tgt_lons = vec![-90.0];
-        let out = inverse_distance_to_points(
+        let out = inverse_distance_to_points_legacy(
             &src_lats, &src_lons, &src_vals,
             &tgt_lats, &tgt_lons,
             2.0, 1, 5.0,
@@ -1017,7 +1023,7 @@ mod tests {
         // Target exactly at first source point.
         let tgt_lats = vec![40.0];
         let tgt_lons = vec![-80.0];
-        let out = inverse_distance_to_points(
+        let out = inverse_distance_to_points_legacy(
             &src_lats, &src_lons, &src_vals,
             &tgt_lats, &tgt_lons,
             2.0, 1, 10.0,

{metrust-0.3.3 → metrust-0.3.4}/crates/rustmet-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustmet-core"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 description = "Pure Rust GRIB2 processor and weather model data library — HRRR, GFS, NAM, RAP"
 license = "MIT"

{metrust-0.3.3 → metrust-0.3.4}/crates/wx-field/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wx-field"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 description = "Shared type foundation for the unified atmospheric engine — fields, projections, metadata"
 license = "MIT"

{metrust-0.3.3 → metrust-0.3.4}/crates/wx-math/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wx-math"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 description = "Meteorological computations and grid math"
 license = "MIT"

metrust-0.3.4/crates/wx-math/src/interpolate.rs

@@ -0,0 +1,174 @@
+//! Interpolation routines (Barnes, Cressman, IDW families).
+//!
+//! This module provides scattered-data interpolation functions that support
+//! multiple weighting schemes via the `kind` parameter:
+//!
+//! * `kind = 0` -- standard inverse-distance weighting (1/d^2)
+//! * `kind = 1` -- Barnes scheme (Gaussian weight controlled by `kappa` and `gamma`)
+//! * `kind = 2` -- Cressman scheme (parabolic weight within `radius`)
+
+/// Inverse distance weighted interpolation to arbitrary target points.
+///
+/// # Arguments
+///
+/// * `obs_x`  -- observation x-coordinates (e.g. longitude or projected easting)
+/// * `obs_y`  -- observation y-coordinates (e.g. latitude or projected northing)
+/// * `obs_values` -- observed values at each station
+/// * `grid_x` -- target x-coordinates to interpolate onto
+/// * `grid_y` -- target y-coordinates to interpolate onto
+/// * `radius` -- search radius (same units as coordinates)
+/// * `min_neighbors` -- minimum number of neighbors required; returns `NaN` if fewer
+/// * `kind`   -- weighting scheme: 0 = IDW, 1 = Barnes, 2 = Cressman
+/// * `kappa`  -- smoothing parameter for Barnes scheme
+/// * `gamma`  -- convergence parameter for Barnes scheme
+///
+/// # Returns
+///
+/// A `Vec<f64>` of length `grid_x.len()` with the interpolated values.
+pub fn inverse_distance_to_points(
+    obs_x: &[f64],
+    obs_y: &[f64],
+    obs_values: &[f64],
+    grid_x: &[f64],
+    grid_y: &[f64],
+    radius: f64,
+    min_neighbors: usize,
+    kind: u8,
+    kappa: f64,
+    gamma: f64,
+) -> Vec<f64> {
+    let n = obs_values.len();
+    assert_eq!(obs_x.len(), n, "obs_x length must match obs_values");
+    assert_eq!(obs_y.len(), n, "obs_y length must match obs_values");
+    assert_eq!(grid_x.len(), grid_y.len(), "grid_x and grid_y must have the same length");
+
+    let r2 = radius * radius;
+
+    grid_x
+        .iter()
+        .zip(grid_y.iter())
+        .map(|(&gx, &gy)| {
+            let mut w_sum = 0.0_f64;
+            let mut wv_sum = 0.0_f64;
+            let mut count = 0usize;
+
+            for i in 0..n {
+                let dx = gx - obs_x[i];
+                let dy = gy - obs_y[i];
+                let d2 = dx * dx + dy * dy;
+
+                if d2 > r2 {
+                    continue;
+                }
+
+                // Coincident point -- return exact value.
+                if d2 < 1e-30 {
+                    return obs_values[i];
+                }
+
+                let w = match kind {
+                    1 => {
+                        // Barnes: w = exp(-d^2 / (kappa * gamma))
+                        (-d2 / (kappa * gamma)).exp()
+                    }
+                    2 => {
+                        // Cressman: w = (R^2 - d^2) / (R^2 + d^2)
+                        (r2 - d2) / (r2 + d2)
+                    }
+                    _ => {
+                        // Standard IDW: w = 1 / d^2
+                        1.0 / d2
+                    }
+                };
+
+                w_sum += w;
+                wv_sum += w * obs_values[i];
+                count += 1;
+            }
+
+            if count < min_neighbors {
+                f64::NAN
+            } else {
+                wv_sum / w_sum
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_idw_basic() {
+        // Two equidistant points, target at midpoint => average.
+        let obs_x = vec![0.0, 2.0];
+        let obs_y = vec![0.0, 0.0];
+        let obs_v = vec![10.0, 20.0];
+        let gx = vec![1.0];
+        let gy = vec![0.0];
+        let out = inverse_distance_to_points(
+            &obs_x, &obs_y, &obs_v, &gx, &gy,
+            10.0, 1, 0, 100000.0, 0.2,
+        );
+        assert!((out[0] - 15.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_idw_coincident() {
+        let obs_x = vec![5.0];
+        let obs_y = vec![5.0];
+        let obs_v = vec![42.0];
+        let gx = vec![5.0];
+        let gy = vec![5.0];
+        let out = inverse_distance_to_points(
+            &obs_x, &obs_y, &obs_v, &gx, &gy,
+            10.0, 1, 0, 100000.0, 0.2,
+        );
+        assert!((out[0] - 42.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_idw_too_few_neighbors() {
+        let obs_x = vec![0.0];
+        let obs_y = vec![0.0];
+        let obs_v = vec![10.0];
+        let gx = vec![100.0]; // outside radius
+        let gy = vec![0.0];
+        let out = inverse_distance_to_points(
+            &obs_x, &obs_y, &obs_v, &gx, &gy,
+            5.0, 1, 0, 100000.0, 0.2,
+        );
+        assert!(out[0].is_nan());
+    }
+
+    #[test]
+    fn test_barnes_returns_value() {
+        let obs_x = vec![0.0, 2.0];
+        let obs_y = vec![0.0, 0.0];
+        let obs_v = vec![10.0, 20.0];
+        let gx = vec![1.0];
+        let gy = vec![0.0];
+        let out = inverse_distance_to_points(
+            &obs_x, &obs_y, &obs_v, &gx, &gy,
+            10.0, 1, 1, 100000.0, 0.2,
+        );
+        // With equal distances, Barnes should also give the average.
+        assert!((out[0] - 15.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_cressman_returns_value() {
+        let obs_x = vec![0.0, 2.0];
+        let obs_y = vec![0.0, 0.0];
+        let obs_v = vec![10.0, 20.0];
+        let gx = vec![1.0];
+        let gy = vec![0.0];
+        let out = inverse_distance_to_points(
+            &obs_x, &obs_y, &obs_v, &gx, &gy,
+            10.0, 1, 2, 100000.0, 0.2,
+        );
+        // With equal distances, Cressman should also give the average.
+        assert!((out[0] - 15.0).abs() < 1e-10);
+    }
+}

{metrust-0.3.3 → metrust-0.3.4}/crates/wx-math/src/lib.rs

@@ -8,3 +8,4 @@ pub mod dynamics;
 pub mod gridmath;
 pub mod composite;
 pub mod regrid;
+pub mod interpolate;

{metrust-0.3.3 → metrust-0.3.4}/crates/wx-radar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wx-radar"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 description = "Radar data processing — NEXRAD Level-II parser, PPI renderer, color tables"
 license = "MIT"