metrust 0.4.0__tar.gz → 0.4.2__tar.gz

metrust-0.4.2/BENCHMARKS.md

@@ -0,0 +1,236 @@
+# Benchmarks
+
+All results on **NVIDIA GeForce RTX 5090** (34.2 GB VRAM, Blackwell, 21,760 CUDA cores) with CuPy 14.0.1, met-cu 0.2.1, metrust 0.4.0. CPU is a 32-core AMD Ryzen with rayon parallelism.
+
+## Three-Way Comparison: MetPy vs Rust vs CUDA
+
+Real HRRR model output (40 isobaric levels, 1059 × 1799 grid, ~1.9M points per level). `python tests/benchmark_gpu.py`
+
+### Scalar Thermodynamics (2D: 1059×1799)
+
+| Function | MetPy | Rust | CUDA | Rust/MetPy | CUDA/Rust |
+|---|---:|---:|---:|---:|---:|
+| potential_temperature ★ | 11.2 ms | 13.0 ms | 7.9 ms | 0.9x | 1.6x |
+| equiv_potential_temperature ★ | 303.1 ms | 16.5 ms | 9.1 ms | **18x** | 1.8x |
+| dewpoint ★ | 33.6 ms | 10.8 ms | 8.8 ms | 3.1x | 1.2x |
+| saturation_vapor_pressure | 66.7 ms | 8.2 ms | — | 8.1x | — |
+| saturation_mixing_ratio | 78.6 ms | 13.7 ms | — | 5.7x | — |
+| dewpoint_from_rh | 110.3 ms | 7.6 ms | — | **14x** | — |
+| rh_from_dewpoint | 138.7 ms | 10.9 ms | — | **13x** | — |
+| virtual_temperature | 31.1 ms | 19.7 ms | — | 1.6x | — |
+| mixing_ratio | 11.6 ms | 8.5 ms | — | 1.4x | — |
+| wet_bulb_temperature | >10 min | 26.9 ms | — | **>22,000x** | — |
+
+### Grid Kinematics (2D: 1059×1799)
+
+| Function | MetPy | Rust | CUDA | Rust/MetPy | CUDA/Rust |
+|---|---:|---:|---:|---:|---:|
+| vorticity ★ | 98.3 ms | 92.8 ms | 9.3 ms | 1.1x | **10x** |
+| divergence | 96.1 ms | 91.2 ms | — | 1.1x | — |
+| frontogenesis ★ | 733.0 ms | 339.4 ms | 12.2 ms | 2.2x | **28x** |
+| q_vector ★ | 390.3 ms | 310.1 ms | 10.8 ms | 1.3x | **29x** |
+| advection | 161.8 ms | 87.7 ms | — | 1.8x | — |
+
+### 1D Sounding (40 levels, single column)
+
+| Function | MetPy | Rust | Rust/MetPy |
+|---|---:|---:|---:|
+| parcel_profile | 5.5 ms | 0.074 ms | **74x** |
+| cape_cin | 1.4 ms | 0.254 ms | 5.4x |
+| lcl | 0.118 ms | 0.065 ms | 1.8x |
+| lfc | 6.7 ms | 0.107 ms | **62x** |
+| el | 6.6 ms | 0.112 ms | **59x** |
+| precipitable_water | 2.1 ms | 0.057 ms | **36x** |
+
+### Grid Composites (3D: 40×1059×1799 → 2D)
+
+MetPy has no grid-level equivalents for these functions.
+
+| Function | Rust | CUDA | CUDA/Rust |
+|---|---:|---:|---:|
+| compute_cape_cin ★ | 2.96 s | 674.5 ms | **4.4x** |
+| compute_srh ★ | 223.5 ms | 135.8 ms | 1.6x |
+| compute_shear ★ | 190.4 ms | 166.5 ms | 1.1x |
+| compute_pw ★ | 191.6 ms | 107.9 ms | 1.8x |
+| composite_refl_hydrometeors ★ | 154.2 ms | 232.2 ms | 0.7x |
+
+### Summary
+
+| Category | MetPy | Rust | CUDA |
+|---|---:|---:|---:|
+| Scalar thermo (×10) | 785 ms | 136 ms | 26 ms |
+| Grid kinematics (×5) | 1.48 s | 921 ms | 32 ms |
+| 1D sounding (×6) | 22 ms | 0.67 ms | — |
+| Grid composites (×5) | — | 3.72 s | 1.32 s |
+| **★ GPU-eligible total** | — | **4.50 s** | **1.37 s (3.3x)** |
+
+★ = dispatches to CUDA when `set_backend("gpu")`.
+
+---
+
+## Real-Data Verification Benchmarks
+
+12 independent scenarios using actual HRRR and GFS GRIB2 data, verifying correctness across all 4 backends (MetPy, metrust CPU, met-cu GPU, metrust GPU) with ~230 deep statistical checks.
+
+### Timing Highlights on Real Atmospheric Data
+
+| Function | Grid | MetPy | Rust | met-cu GPU | vs MetPy | vs Rust |
+|---|---|---:|---:|---:|---:|---:|
+| frontogenesis | 721×1440 | 388 ms | 154 ms | 3.8 ms | **101x** | **40x** |
+| equiv_potential_temp | 1059×1799 | 13.7 s | 464 ms | 163 ms | **84x** | **2.8x** |
+| compute_srh | 200×200 | — | 124 ms | 2.7 ms | — | **46x** |
+| q_vector | 1059×1799 | — | 115 ms | 4.6 ms | — | **25x** |
+| compute_cape_cin | 200×200 | — | 317 ms | 13 ms | — | **24x** |
+| vorticity | 721×1440 | 41.6 ms | 41.1 ms | 1.7 ms | **24x** | **24x** |
+| potential_temp | 721×1440 | 28.4 ms | 5.5 ms | 1.7 ms | **17x** | **3.2x** |
+
+### Full Pipeline (bench 10: HRRR squall line, 1059×1799×40)
+
+| | Rust CPU | met-cu GPU | Speedup |
+|---|---:|---:|---:|
+| Total (6 functions) | 3.58 s | 762 ms | **4.7x** |
+| CAPE alone | 2.84 s | 622 ms | **4.6x** |
+| Kinematics alone | 230 ms | 10 ms | **23x** |
+
+### 100 Real Soundings (bench 09: HRRR columns across CONUS)
+
+| | MetPy | metrust | Speedup |
+|---|---:|---:|---:|
+| 100 soundings total | 676 ms | 72 ms | **9.4x** |
+| Per sounding | 6.8 ms | 0.72 ms | 9.4x |
+
+### Correctness Summary
+
+All 12 benchmarks pass deep verification against MetPy as ground truth:
+
+| Benchmark | Data | Checks | RMSE | Pearson r |
+|---|---|---:|---|---|
+| 01 HRRR Severe | 1059×1799×40 | 20/20 | ~1e-13 | 1.0000 |
+| 02 GFS Upper Air | 721×1440 | 19/21 | ~1e-14 | 1.0000 |
+| 03 HRRR Warm Front | 1059×1799 | All | ~1e-18 | 1.0000 |
+| 04 HRRR Precip Water | 1059×1799×40 | 14/14 | ~1e-13 | 1.0000 |
+| 05 HRRR Supercell | 1059×1799×40 | 16/20 | ~1e-13 | 0.99999 |
+| 06 GFS Jet Stream | 721×1440 | 16/16 | ~1e-15 | 1.0000 |
+| 07 HRRR Fire Weather | 1059×1799 | 16/16 | ~1e-14 | 1.0000 |
+| 08 GFS Tropical | 121×201×33 | 15/15 | ~1e-15 | 1.0000 |
+| 09 HRRR Soundings | 100×40 | 25/25 | ~12 J/kg (CAPE) | 0.9999 |
+| 10 HRRR Squall Line | 1059×1799×40 | All | ~1e-13 | 1.0000 |
+| 11 GFS Cold Air | 161×1440 | 19/19 | ~1e-14 | 1.0000 |
+| 12 HRRR Boundary Layer | 1059×1799×40 | 35/35 | ~1e-13 | 1.0000 |
+
+Non-passing checks are documented edge cases: frontogenesis boundary NaN (0.05% of points), CIN/LFC sentinel values on marginal soundings.
+
+---
+
+## met-cu Comprehensive Benchmark (202 Functions)
+
+All 202 met-cu functions benchmarked against metrust CPU on 1,905,141 points (HRRR grid).
+
+### Category Averages
+
+| Category | Functions | Avg Speedup | Min | Max |
+|---|---:|---:|---:|---:|
+| Per-element thermo | 52 | **238x** | 1.0x | 971x |
+| Wind per-element | 3 | **7.5x** | 6.3x | 9.3x |
+| Grid stencil | 28 | **39x** | 3.7x | 108x |
+| Column/sounding | 72 | **3.7x** | 0.0x | 85x |
+
+### Top GPU Speedups
+
+| Function | GPU | CPU | Speedup |
+|---|---:|---:|---:|
+| height_to_geopotential | 0.94 ms | 912 ms | **971x** |
+| moist_air_specific_heat_pressure | 0.91 ms | 819 ms | **902x** |
+| coriolis_parameter | 0.94 ms | 830 ms | **883x** |
+| water_latent_heat_melting | 0.98 ms | 828 ms | **849x** |
+| scale_height | 1.08 ms | 916 ms | **847x** |
+| geopotential_to_height | 1.13 ms | 921 ms | **815x** |
+| water_latent_heat_vaporization | 1.02 ms | 808 ms | **794x** |
+| water_latent_heat_sublimation | 1.09 ms | 816 ms | **746x** |
+| moist_air_gas_constant | 1.13 ms | 820 ms | **723x** |
+| heat_index | 2.00 ms | 1035 ms | **517x** |
+
+Note: The extreme speedups (>100x) are for functions where the metrust CPU path falls back to a Python scalar loop (`_vec_call`). The GPU kernel runs natively on the full array. These represent real user-facing speedups.
+
+### Grid Stencil Functions (1059×1799)
+
+| Function | GPU | CPU | Speedup |
+|---|---:|---:|---:|
+| shear_vorticity | 2.05 ms | 221 ms | **108x** |
+| curvature_vorticity | 1.90 ms | 160 ms | **84x** |
+| smooth_rectangular | 0.98 ms | 78 ms | **80x** |
+| total_deformation | 2.26 ms | 144 ms | **64x** |
+| vector_derivative | 2.41 ms | 153 ms | **63x** |
+| geostrophic_wind | 2.24 ms | 117 ms | **52x** |
+| q_vector | 5.37 ms | 240 ms | **45x** |
+| frontogenesis | 5.86 ms | 257 ms | **44x** |
+| vorticity | 2.02 ms | 75 ms | **37x** |
+| smooth_n_point (5) | 0.95 ms | 32 ms | **33x** |
+
+### Where GPU Is Slower
+
+Single-column sounding functions are faster on CPU due to kernel launch overhead:
+
+| Function | GPU | CPU | Ratio |
+|---|---:|---:|---:|
+| parcel_profile | 3.25 ms | 0.16 ms | 0.05x |
+| moist_lapse | 3.15 ms | 0.13 ms | 0.04x |
+| cape_cin (1 sounding) | 3.42 ms | 0.34 ms | 0.1x |
+
+For single soundings, use CPU. For grid-level computation (1000+ columns), GPU wins.
+
+---
+
+## Workflow-Level Speedups
+
+metrust vs MetPy on real-world analysis workflows:
+
+| Workflow | Speedup | Notes |
+|---|---:|---|
+| SounderPy compute-heavy subset | **29.7x** | Thermo + wind + severe params |
+| 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 |
+| MetPy isentropic example | **2.3x** | Isentropic interpolation + Montgomery |
+| Vorticity/divergence (global grid) | **2.3x** | Spherical corrections on 721×1440 |
+
+---
+
+## Rust Array Throughput
+
+1M elements, 32-core Ryzen, rayon parallel:
+
+| Function | Time | Throughput |
+|---|---:|---:|
+| potential_temperature | 1.8 ms | 550 M elem/s |
+| wet_bulb_temperature | 7.3 ms | 137 M elem/s |
+| wind_speed | 1.5 ms | 660 M elem/s |
+
+---
+
+## Running the Benchmarks
+
+```bash
+# Three-way comparison (requires real HRRR data in data/)
+python tests/benchmark_gpu.py              # MetPy + Rust + CUDA
+python tests/benchmark_gpu.py --no-metpy   # Rust + CUDA only (faster)
+
+# Real-data verification suite (requires HRRR + GFS GRIB files in data/)
+python tests/benchmarks/bench_01_hrrr_severe.py
+python tests/benchmarks/bench_02_gfs_upper_air.py
+# ... through bench_12
+
+# Run all verification benchmarks
+for f in tests/benchmarks/bench_*.py; do python "$f"; done
+```
+
+Data files needed in `data/`:
+- `hrrr_prs.grib2` — HRRR pressure levels (~405 MB)
+- `hrrr_sfc.grib2` — HRRR surface fields (~148 MB)
+- `gfs_0p25.grib2` — GFS 0.25° analysis (~490 MB)
+
+Download from NOAA AWS:
+```bash
+curl -Lo data/hrrr_prs.grib2 "https://noaa-hrrr-bdp-pds.s3.amazonaws.com/hrrr.20260328/conus/hrrr.t00z.wrfprsf00.grib2"
+curl -Lo data/gfs_0p25.grib2 "https://noaa-gfs-bdp-pds.s3.amazonaws.com/gfs.20260328/00/atmos/gfs.t00z.pgrb2.0p25.f000"
+```

{metrust-0.4.0 → metrust-0.4.2}/Cargo.lock

@@ -802,7 +802,7 @@ dependencies = [
 
 [[package]]
 name = "metrust-py"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "metrust",
  "numpy",

{metrust-0.4.0 → metrust-0.4.2}/Cargo.toml

@@ -8,9 +8,9 @@ license = "MIT"
 
 [package]
 name = "metrust-py"
-version = "0.4.0"
+version = "0.4.2"
 edition.workspace = true
-description = "Python bindings for metrust — a drop-in replacement for MetPy"
+description = "Python bindings for metrust, a Rust-powered MetPy-compatible calculation layer"
 readme = "README.md"
 
 [lib]

{metrust-0.4.0 → metrust-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metrust
-Version: 0.4.0
+Version: 0.4.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -11,7 +11,7 @@ Requires-Dist: numpy>=1.20
 Requires-Dist: pint>=0.20
 Requires-Dist: met-cu>=0.2.1 ; extra == 'gpu'
 Provides-Extra: gpu
-Summary: Rust-powered drop-in replacement for MetPy -- 150/150 calc functions plus 36 extras, 10-93000x faster
+Summary: Rust-powered MetPy-compatible calculation layer with optional GPU acceleration
 Keywords: meteorology,weather,rust,metpy,atmospheric-science,nwp,cape,sounding
 Author: Fahrenheit Research
 License: MIT
@@ -24,9 +24,9 @@ Project-URL: Repository, https://github.com/FahrenheitResearch/metrust-py
 
 # metrust
 
-**Drop-in replacement for MetPy's calculation layer, powered by Rust.**
+**MetPy-compatible 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.
+150/150 `metpy.calc` functions implemented natively, plus 36 extras. Often faster on real-world workflows. Verified against MetPy on SounderPy, MetPy Cookbook examples, and synthetic global grids.
 
 ```python
 # The only change: swap the import
@@ -54,7 +54,7 @@ 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:
+metrust implements every function in `metpy.calc` with a Rust backend compiled via PyO3. The Python API now matches MetPy's public `metpy.calc` signatures and is designed for MetPy-compatible units, return types, and runtime behavior on the shared calculation surface:
 
 ```python
 import numpy as np
@@ -108,6 +108,8 @@ The GPU backend currently targets the overlap where `met-cu` is already strong a
 - `compute_pw`
 - `composite_reflectivity_from_hydrometeors`
 
+Eligible dispatch currently focuses on scalar thermo plus uniform 2-D Cartesian grid workloads. Latitude/longitude-derived spacing, map-scale corrections, and other projection-aware cases fall back to the Rust CPU backend.
+
 `metrust` still returns the same Pint/NumPy-facing API surface. Unsupported cases automatically stay on the Rust CPU path.
 
 ## Speed
@@ -229,7 +231,7 @@ These forward to MetPy when installed:
 - `metrust.xarray` (xarray accessor)
 - `metrust.io.Level2File` (NEXRAD Level II)
 
-Core `metrust.calc` is native Rust by default with no MetPy dependency. The optional `met-cu` backend is an explicit accelerator, not a requirement.
+Core `metrust.calc` stays native Rust by default with no required MetPy dependency. A small parity-sensitive subset may delegate to MetPy when it is installed; otherwise those paths still fall back to local metrust implementations. The optional `met-cu` backend is an explicit accelerator, not a requirement.
 
 ## Examples
 
@@ -243,7 +245,7 @@ See `examples/` for complete drop-in demos:
 
 ```bash
 cargo test --workspace          # 1,186 Rust tests
-python -m pytest tests/ -q      # 20 Python tests (including MetPy drop-in regression)
+python -m pytest tests/ -q      # 30 Python tests (including MetPy compatibility regression)
 ```
 
 ## Documentation

{metrust-0.4.0 → metrust-0.4.2}/README.md

@@ -1,8 +1,8 @@
 # metrust
 
-**Drop-in replacement for MetPy's calculation layer, powered by Rust.**
+**MetPy-compatible 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.
+150/150 `metpy.calc` functions implemented natively, plus 36 extras. Often faster on real-world workflows. Verified against MetPy on SounderPy, MetPy Cookbook examples, and synthetic global grids.
 
 ```python
 # The only change: swap the import
@@ -30,7 +30,7 @@ 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:
+metrust implements every function in `metpy.calc` with a Rust backend compiled via PyO3. The Python API now matches MetPy's public `metpy.calc` signatures and is designed for MetPy-compatible units, return types, and runtime behavior on the shared calculation surface:
 
 ```python
 import numpy as np
@@ -84,6 +84,8 @@ The GPU backend currently targets the overlap where `met-cu` is already strong a
 - `compute_pw`
 - `composite_reflectivity_from_hydrometeors`
 
+Eligible dispatch currently focuses on scalar thermo plus uniform 2-D Cartesian grid workloads. Latitude/longitude-derived spacing, map-scale corrections, and other projection-aware cases fall back to the Rust CPU backend.
+
 `metrust` still returns the same Pint/NumPy-facing API surface. Unsupported cases automatically stay on the Rust CPU path.
 
 ## Speed
@@ -205,7 +207,7 @@ These forward to MetPy when installed:
 - `metrust.xarray` (xarray accessor)
 - `metrust.io.Level2File` (NEXRAD Level II)
 
-Core `metrust.calc` is native Rust by default with no MetPy dependency. The optional `met-cu` backend is an explicit accelerator, not a requirement.
+Core `metrust.calc` stays native Rust by default with no required MetPy dependency. A small parity-sensitive subset may delegate to MetPy when it is installed; otherwise those paths still fall back to local metrust implementations. The optional `met-cu` backend is an explicit accelerator, not a requirement.
 
 ## Examples
 
@@ -219,7 +221,7 @@ See `examples/` for complete drop-in demos:
 
 ```bash
 cargo test --workspace          # 1,186 Rust tests
-python -m pytest tests/ -q      # 20 Python tests (including MetPy drop-in regression)
+python -m pytest tests/ -q      # 30 Python tests (including MetPy compatibility regression)
 ```
 
 ## Documentation

{metrust-0.4.0 → metrust-0.4.2}/crates/metrust/Cargo.toml

@@ -2,7 +2,7 @@
 name = "metrust"
 version = "0.3.9"
 edition = "2021"
-description = "A pure-Rust drop-in replacement for MetPy — meteorological calculations, data I/O, and visualization"
+description = "A pure-Rust meteorology toolkit with a MetPy-compatible calculation layer"
 license = "MIT"
 
 [dependencies]

{metrust-0.4.0 → metrust-0.4.2}/crates/metrust/src/calc/atmo.rs

@@ -225,10 +225,13 @@ pub fn heat_index(temperature_c: f64, relative_humidity_pct: f64) -> f64 {
     let t_f = temperature_c * 9.0 / 5.0 + 32.0;
     let rh = relative_humidity_pct;
 
-    // Below 80 F, use the simpler Steadman formula
-    if t_f < 80.0 {
-        let hi_f = 0.5 * (t_f + 61.0 + (t_f - 68.0) * 1.2 + rh * 0.094);
-        return (hi_f - 32.0) * 5.0 / 9.0;
+    // NWS two-step: compute Steadman, average with T, then decide
+    let steadman = 0.5 * (t_f + 61.0 + (t_f - 68.0) * 1.2 + rh * 0.094);
+    let hi_avg = (steadman + t_f) / 2.0;
+
+    if hi_avg < 80.0 {
+        // Below threshold, return the averaged Steadman result
+        return (hi_avg - 32.0) * 5.0 / 9.0;
     }
 
     // Rothfusz regression

{metrust-0.4.0 → metrust-0.4.2}/crates/wx-math/src/thermo.rs

@@ -456,7 +456,12 @@ pub fn cape_cin_core(
                     let tv_parc_prev = virtual_temp(t_parc_prev, p_prev, t_parc_prev);
                     let buoy_prev = tv_parc_prev - tv_env_prev;
 
-                    if buoyancy != buoy_prev {
+                    if buoy_prev >= 0.0 {
+                        // Previous level is also buoyant — no real crossing.
+                        // The parcel is buoyant from the LCL (or surface)
+                        // upward, so the LFC is at the LCL pressure.
+                        p_lcl
+                    } else if buoyancy != buoy_prev {
                         let frac = (0.0 - buoy_prev) / (buoyancy - buoy_prev);
                         p_prev + frac * (p_curr - p_prev)
                     } else {
@@ -1423,9 +1428,12 @@ pub fn sigma_to_pressure(sigma: f64, p_sfc: f64, p_top: f64) -> f64 {
 /// t_f: temperature (Fahrenheit), rh: relative humidity (%).
 /// Returns heat index in Fahrenheit.
 pub fn heat_index(t_f: f64, rh: f64) -> f64 {
-    // Below 80F, use simple formula
-    if t_f < 80.0 {
-        return 0.5 * (t_f + 61.0 + (t_f - 68.0) * 1.2 + rh * 0.094);
+    // NWS two-step: compute Steadman, average with T, then decide
+    let steadman = 0.5 * (t_f + 61.0 + (t_f - 68.0) * 1.2 + rh * 0.094);
+    let hi_avg = (steadman + t_f) / 2.0;
+
+    if hi_avg < 80.0 {
+        return hi_avg;
     }
 
     // Rothfusz regression
@@ -3176,9 +3184,10 @@ mod tests {
 
     #[test]
     fn test_heat_index_below_80f() {
-        // Below 80F, uses simple formula: 0.5*(T + 61 + (T-68)*1.2 + RH*0.094)
+        // NWS two-step: Steadman averaged with T when avg < 80F
         let hi = heat_index(70.0, 50.0);
-        let expected = 0.5 * (70.0 + 61.0 + (70.0 - 68.0) * 1.2 + 50.0 * 0.094);
+        let steadman = 0.5 * (70.0 + 61.0 + (70.0 - 68.0) * 1.2 + 50.0 * 0.094);
+        let expected = (steadman + 70.0) / 2.0;
         assert!(
             (hi - expected).abs() < 1e-10,
             "Heat index at 70F/50%: got={hi}, expected={expected}"

{metrust-0.4.0 → metrust-0.4.2}/docs/compatibility.md

@@ -7,9 +7,13 @@ in Rust versus what it delegates to MetPy.
 
 ## 1. Compatibility Model
 
-metrust is a drop-in replacement for `metpy.calc` backed by a compiled Rust
+metrust is a MetPy-compatible calculation layer for `metpy.calc`, backed by a compiled Rust
 engine (`_metrust`).  The compatibility model has three tiers:
 
+Function coverage in the tables below is a functionality matrix. Public `metpy.calc` signatures now
+match MetPy, and the compatibility tests cover explicit runtime regression cases on the shared
+calculation surface.
+
 | Tier | Description |
 |------|-------------|
 | **Native Rust** | Function is implemented entirely in Rust. The Python wrapper strips Pint units, calls the Rust function, and re-attaches units. No MetPy dependency. |

{metrust-0.4.0 → metrust-0.4.2}/docs/guides/migration.md

@@ -19,7 +19,7 @@ from metrust.units import units
 
 That is the entire change for most code. Every function in `metrust.calc`
 accepts the same Pint Quantity inputs and returns Pint Quantity outputs, using
-the same function names and the same positional/keyword signatures as MetPy.
+the same function names and the same public positional/keyword signatures as MetPy.
 
 A project-wide find-and-replace from `metpy.` to `metrust.` is usually
 sufficient. The table below shows the namespace mapping:

{metrust-0.4.0 → metrust-0.4.2}/docs/index.md

@@ -2,8 +2,8 @@
 
 ## Meteorological Computation at the Speed of Rust
 
-**metrust** is a Rust-powered, drop-in replacement for [MetPy](https://unidata.github.io/MetPy/)'s calculation layer.
-Change one import line. Keep your existing code. Get 10--90x faster results.
+**metrust** is a Rust-powered, MetPy-compatible calculation layer for [MetPy](https://unidata.github.io/MetPy/)'s calculation workflows.
+For many `metpy.calc` workflows, changing one import line is enough. Many thermo and grid workloads run substantially faster.
 
 ---
 
@@ -53,7 +53,7 @@ The surface is identical. Under the hood, every calculation runs through compile
 
 ### 150/150 MetPy Calc Functions (Plus 36 Extras)
 
-Every function in `metpy.calc` has a metrust equivalent -- 100% API coverage. Plus 36 additional functions MetPy doesn't have (grid composites, fire weather indices, and more). The entire `metrust.calc` module is backed by Rust -- no MetPy dependency, no Python fallback.
+Every function in `metpy.calc` has a metrust equivalent -- 100% API coverage. Plus 36 additional functions MetPy doesn't have (grid composites, fire weather indices, and more). The calculation layer is Rust-backed by default, with a small parity-sensitive subset optionally delegating to MetPy when it is installed.
 Coverage spans the core of operational meteorology:
 
 - **Thermodynamics** -- potential temperature, equivalent potential temperature, virtual temperature, wet-bulb temperature, LCL, LFC, EL, CAPE/CIN, parcel profiles, precipitable water, thickness hydrostatic, stability indices
@@ -149,8 +149,8 @@ All `metrust.calc` functions compile to native machine code through the Rust too
 
 ### No MetPy Dependency for Calculations
 
-`pip install metrust` pulls in **only** NumPy and Pint. The entire calculation layer is self-contained.
-MetPy is never imported, loaded, or called for any `metrust.calc` function.
+`pip install metrust` pulls in **only** NumPy and Pint. The calculation layer stays self-contained by default.
+A small parity-sensitive subset of `metrust.calc` can delegate to MetPy when MetPy is installed, but the default path remains the Rust backend.
 
 ### Optional MetPy for Plots, xarray, and Level 2
 
@@ -158,7 +158,7 @@ A handful of surfaces intentionally delegate to MetPy when it is installed:
 
 | Surface | Behavior |
 |---|---|
-| `metrust.calc` | 100% native Rust. No MetPy fallback. |
+| `metrust.calc` | Native Rust by default, with limited optional MetPy delegation on a few parity-sensitive paths. |
 | `metrust.io.Level2File` | Forwards to MetPy's Level 2 reader when available. |
 | `metrust.plots` | Forwards to `metpy.plots`. |
 | `metrust.xarray` | Forwards to `metpy.xarray`. |

{metrust-0.4.0 → metrust-0.4.2}/docs/methodology/index.md

@@ -17,7 +17,7 @@ metrust started with SHARPpy-heritage algorithms — Wobus polynomial approximat
 
 Over a series of systematic replacements, metrust moved to MetPy-exact algorithms:
 
-- **Moist lapse rate** replaced with a fourth-order Runge-Kutta (RK4) integration of the full moist-adiabatic ODE, matching MetPy's `moist_lapse` to machine precision.
+- **Moist lapse rate** replaced with a fourth-order Runge-Kutta (RK4) integration of the full moist-adiabatic ODE, matching MetPy closely on the supported reference-pressure paths.
 - **CAPE integration** switched from a simplified buoyancy sum to MetPy's exact formulation: `g * dTv / Tv * dz`, integrated over each layer.
 - **Bunkers storm motion** moved to a pressure-weighted mean wind, matching the Bunkers et al. (2000) method that MetPy implements.
 - **Isentropic interpolation** adopted a Newton solver on the exact theta equation rather than a lookup-table approach.

{metrust-0.4.0 → metrust-0.4.2}/mkdocs.yml

@@ -1,5 +1,5 @@
 site_name: metrust
-site_description: Rust-powered meteorology toolkit — drop-in replacement for MetPy
+site_description: Rust-powered meteorology toolkit with a MetPy-compatible calculation layer
 site_url: https://fahrenheitresearch.github.io/metrust-py/
 repo_url: https://github.com/FahrenheitResearch/metrust-py
 repo_name: FahrenheitResearch/metrust-py

{metrust-0.4.0 → metrust-0.4.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "maturin"
 
 [project]
 name = "metrust"
-version = "0.4.0"
-description = "Rust-powered drop-in replacement for MetPy -- 150/150 calc functions plus 36 extras, 10-93000x faster"
+version = "0.4.2"
+description = "Rust-powered MetPy-compatible calculation layer with optional GPU acceleration"
 requires-python = ">=3.9"
 license = {text = "MIT"}
 authors = [{name = "Fahrenheit Research"}]