metrust 0.2.8__tar.gz → 0.2.9__tar.gz

{metrust-0.2.8 → metrust-0.2.9}/Cargo.lock

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

{metrust-0.2.8 → metrust-0.2.9}/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metrust
-Version: 0.2.8
+Version: 0.2.9
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{metrust-0.2.8 → metrust-0.2.9}/crates/metrust/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/crates/rustmet-core/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/crates/wx-field/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/crates/wx-math/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/crates/wx-radar/Cargo.toml

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

{metrust-0.2.8 → metrust-0.2.9}/docs/index.md

@@ -233,4 +233,4 @@ cape, cin = cape_cin(p, T, Td, prof)
 
 ---
 
-*metrust v0.2.8 -- MIT License -- [GitHub](https://github.com/FahrenheitResearch/metrust-py)*
+*metrust v0.2.9 -- MIT License -- [GitHub](https://github.com/FahrenheitResearch/metrust-py)*

{metrust-0.2.8 → metrust-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "metrust"
-version = "0.2.8"
+version = "0.2.9"
 description = "Rust-powered drop-in replacement for MetPy -- 150/150 calc functions plus 36 extras, 10-93000x faster"
 requires-python = ">=3.9"
 license = {text = "MIT"}

{metrust-0.2.8 → metrust-0.2.9}/python/metrust/calc/__init__.py

@@ -2573,11 +2573,228 @@ def _mean_spacing(val, target_unit="m"):
     return float(arr.mean()) if arr.ndim > 0 and arr.size > 1 else float(arr)
 
 
+def _is_variable_spacing(val):
+    """Check if dx/dy is a 2D array (variable spacing, e.g., lat/lon grid)."""
+    if hasattr(val, "magnitude"):
+        arr = np.asarray(val.magnitude)
+    else:
+        arr = np.asarray(val)
+    if arr.ndim < 2:
+        return False
+    # Check if values vary significantly (>5% relative range)
+    finite = arr[np.isfinite(arr)]
+    if finite.size < 2:
+        return False
+    rng = finite.max() - finite.min()
+    return rng > 0.05 * abs(finite.mean()) if abs(finite.mean()) > 1e-10 else rng > 1e-10
+
+
+def _gradient_2d_variable(field, dx_2d, dy_2d):
+    """Compute ∂f/∂x and ∂f/∂y with variable 2D grid spacing.
+
+    Uses centered differences in the interior, one-sided at boundaries,
+    matching MetPy's first_derivative behavior on variable-spaced grids.
+    """
+    arr = np.asarray(field, dtype=np.float64)
+    ny, nx = arr.shape
+    dx = np.asarray(dx_2d, dtype=np.float64)
+    dy = np.asarray(dy_2d, dtype=np.float64)
+
+    # Pad dx/dy to match field shape if needed (MetPy grid_deltas returns (ny, nx-1) and (ny-1, nx))
+    if dx.shape != (ny, nx):
+        if dx.shape == (ny, nx - 1):
+            # Average adjacent to get (ny, nx)
+            dx_full = np.empty((ny, nx))
+            dx_full[:, 0] = dx[:, 0]
+            dx_full[:, -1] = dx[:, -1]
+            dx_full[:, 1:-1] = (dx[:, :-1] + dx[:, 1:]) / 2.0
+            dx = dx_full
+        else:
+            dx = np.broadcast_to(dx, (ny, nx)).copy()
+    if dy.shape != (ny, nx):
+        if dy.shape == (ny - 1, nx):
+            dy_full = np.empty((ny, nx))
+            dy_full[0, :] = dy[0, :]
+            dy_full[-1, :] = dy[-1, :]
+            dy_full[1:-1, :] = (dy[:-1, :] + dy[1:, :]) / 2.0
+            dy = dy_full
+        else:
+            dy = np.broadcast_to(dy, (ny, nx)).copy()
+
+    # Replace zeros/near-zeros with NaN to avoid division by zero (poles)
+    dx[np.abs(dx) < 1.0] = np.nan
+    dy[np.abs(dy) < 1.0] = np.nan
+
+    # ∂f/∂x — centered differences along axis=1
+    dfdx = np.full_like(arr, np.nan)
+    dfdx[:, 1:-1] = (arr[:, 2:] - arr[:, :-2]) / (2.0 * dx[:, 1:-1])
+    dfdx[:, 0] = (arr[:, 1] - arr[:, 0]) / dx[:, 0]
+    dfdx[:, -1] = (arr[:, -1] - arr[:, -2]) / dx[:, -1]
+
+    # ∂f/∂y — centered differences along axis=0
+    dfdy = np.full_like(arr, np.nan)
+    dfdy[1:-1, :] = (arr[2:, :] - arr[:-2, :]) / (2.0 * dy[1:-1, :])
+    dfdy[0, :] = (arr[1, :] - arr[0, :]) / dy[0, :]
+    dfdy[-1, :] = (arr[-1, :] - arr[-2, :]) / dy[-1, :]
+
+    return dfdx, dfdy
+
+
 def _safe_unit_str(unit_obj):
     """Return a unit string usable with *our* registry, avoiding cross-registry ops."""
     return str(unit_obj)
 
 
+def _first_derivative_variable(field, delta, axis):
+    """Compute first derivative with variable spacing along an axis.
+
+    Matches MetPy's first_derivative: centered differences in interior,
+    one-sided at boundaries. *delta* is a 1-D or 2-D array of grid spacings
+    (one fewer element than field along *axis*).
+    """
+    arr = np.asarray(field, dtype=np.float64)
+    d = np.asarray(delta, dtype=np.float64).copy()
+    # Replace near-zero spacings with NaN to avoid division by zero (e.g., at poles)
+    d[np.abs(d) < 1.0] = np.nan
+    n = arr.shape[axis]
+
+    # Expand delta to match field dimensions if needed
+    if d.ndim == 1 and d.size == n - 1:
+        # Standard case: spacing between adjacent levels
+        pass
+    elif d.ndim == 2 and d.shape[axis] == n - 1:
+        pass
+    elif d.ndim == 2 and d.shape[axis] == n:
+        # Average adjacent to get n-1 spacings
+        d = (np.take(d, range(d.shape[axis] - 1), axis=axis)
+             + np.take(d, range(1, d.shape[axis]), axis=axis)) / 2.0
+    elif d.size == 1:
+        return np.gradient(arr, float(d.ravel()[0]), axis=axis)
+    else:
+        return np.gradient(arr, float(np.mean(d)), axis=axis)
+
+    result = np.empty_like(arr)
+    # Interior: centered differences
+    slc_c = [slice(None)] * arr.ndim
+    slc_p = [slice(None)] * arr.ndim
+    slc_m = [slice(None)] * arr.ndim
+    slc_c[axis] = slice(1, -1)
+    slc_p[axis] = slice(2, None)
+    slc_m[axis] = slice(None, -2)
+
+    # d_fwd[i] = spacing from i to i+1, d_bwd[i] = spacing from i-1 to i
+    slc_df = [slice(None)] * d.ndim
+    slc_db = [slice(None)] * d.ndim
+    slc_df[axis] = slice(1, None)    # d[1:]
+    slc_db[axis] = slice(None, -1)   # d[:-1]
+
+    d_fwd = d[tuple(slc_df)]
+    d_bwd = d[tuple(slc_db)]
+
+    # Broadcast delta to match field shape
+    if d_fwd.ndim < arr.ndim:
+        shape = [1] * arr.ndim
+        shape[axis] = d_fwd.shape[0] if d_fwd.ndim > 0 else 1
+        d_fwd = d_fwd.reshape(shape)
+        d_bwd = d_bwd.reshape(shape)
+
+    result[tuple(slc_c)] = (arr[tuple(slc_p)] - arr[tuple(slc_m)]) / (d_fwd + d_bwd)
+
+    # Boundaries: forward/backward differences
+    slc_0 = [slice(None)] * arr.ndim
+    slc_1 = [slice(None)] * arr.ndim
+    slc_0[axis] = 0
+    slc_1[axis] = 1
+    d0 = np.take(d, 0, axis=axis)
+    if d0.ndim < arr[tuple(slc_0)].ndim:
+        d0 = np.expand_dims(d0, axis=axis) if d0.ndim > 0 else d0
+    result[tuple(slc_0)] = (arr[tuple(slc_1)] - arr[tuple(slc_0)]) / d0
+
+    slc_n1 = [slice(None)] * arr.ndim
+    slc_n2 = [slice(None)] * arr.ndim
+    slc_n1[axis] = -1
+    slc_n2[axis] = -2
+    dn = np.take(d, -1, axis=axis)
+    if dn.ndim < arr[tuple(slc_n1)].ndim:
+        dn = np.expand_dims(dn, axis=axis) if dn.ndim > 0 else dn
+    result[tuple(slc_n1)] = (arr[tuple(slc_n1)] - arr[tuple(slc_n2)]) / dn
+
+    return result
+
+
+def _get_scale_factors(data):
+    """Extract map projection scale factors from xarray CRS metadata.
+
+    Returns (parallel_scale, meridional_scale) as 2D arrays matching data shape,
+    or (None, None) if no CRS is available.
+    """
+    if not hasattr(data, "metpy"):
+        return None, None
+    try:
+        crs = data.metpy.cartopy_crs
+    except Exception:
+        return None, None
+
+    lat_arr, lon_arr = _infer_lat_lon(data)
+    if lat_arr is None:
+        return None, None
+
+    lat_2d = np.asarray(lat_arr.magnitude if hasattr(lat_arr, "magnitude") else lat_arr, dtype=np.float64)
+    lon_2d = np.asarray(lon_arr.magnitude if hasattr(lon_arr, "magnitude") else lon_arr, dtype=np.float64)
+
+    ny, nx = data.shape[-2:]
+    if lat_2d.ndim == 1:
+        lat_2d = np.broadcast_to(lat_2d[:, None], (ny, nx))
+        lon_2d = np.broadcast_to(lon_2d[None, :], (ny, nx))
+
+    try:
+        from pyproj import Proj
+        proj = Proj(crs)
+        factors = proj.get_factors(lon_2d.ravel(), lat_2d.ravel())
+        ps = np.asarray(factors.parallel_scale).reshape(ny, nx)
+        ms = np.asarray(factors.meridional_scale).reshape(ny, nx)
+        return ps, ms
+    except Exception:
+        # Fallback for lat/lon: parallel_scale = 1/cos(lat), meridional_scale = 1
+        ps = 1.0 / np.cos(np.deg2rad(lat_2d))
+        ms = np.ones_like(ps)
+        return ps, ms
+
+
+def _vector_derivative_corrected(u_arr, v_arr, dx, dy, parallel_scale, meridional_scale):
+    """Compute map-projection-corrected vector derivative components.
+
+    Returns (du_dy_corrected, dv_dx_corrected) for vorticity,
+    or (du_dx_corrected, dv_dy_corrected) for divergence.
+    """
+    dx_m = np.asarray(dx.to("m").magnitude if hasattr(dx, "to") else dx, dtype=np.float64)
+    dy_m = np.asarray(dy.to("m").magnitude if hasattr(dy, "to") else dy, dtype=np.float64)
+
+    # Cartesian derivatives with variable spacing
+    du_dx = _first_derivative_variable(u_arr, dx_m, axis=-1)
+    du_dy = _first_derivative_variable(u_arr, dy_m, axis=-2)
+    dv_dx = _first_derivative_variable(v_arr, dx_m, axis=-1)
+    dv_dy = _first_derivative_variable(v_arr, dy_m, axis=-2)
+
+    ps = np.asarray(parallel_scale, dtype=np.float64)
+    ms = np.asarray(meridional_scale, dtype=np.float64)
+
+    # Scale factor derivatives
+    dp_dy = _first_derivative_variable(ps, dy_m, axis=-2)
+    dm_dx = _first_derivative_variable(ms, dx_m, axis=-1)
+
+    # Map factor corrections (MetPy vector_derivative formula)
+    dx_correction = ms / ps * dp_dy
+    dy_correction = ps / ms * dm_dx
+
+    du_dx_corr = ps * du_dx - v_arr * dx_correction
+    du_dy_corr = ms * du_dy + v_arr * dy_correction
+    dv_dx_corr = ps * dv_dx + u_arr * dx_correction
+    dv_dy_corr = ms * dv_dy - u_arr * dy_correction
+
+    return du_dx_corr, du_dy_corr, dv_dx_corr, dv_dy_corr
+
+
 def divergence(u, v, dx=None, dy=None, x_dim=-1, y_dim=-2, parallel_scale=None,
                meridional_scale=None, latitude=None, longitude=None, crs=None):
     """Horizontal divergence on a 2-D grid.
@@ -2598,8 +2815,34 @@ def divergence(u, v, dx=None, dy=None, x_dim=-1, y_dim=-2, parallel_scale=None,
         raise TypeError("divergence requires dx/dy or inferable latitude/longitude coordinates")
     u_arr = np.asarray(_strip(u, "m/s"), dtype=np.float64)
     v_arr = np.asarray(_strip(v, "m/s"), dtype=np.float64)
-    dx_val = _mean_spacing(dx, "m")
-    dy_val = _mean_spacing(dy, "m")
+
+    # Check for map projection scale factors (spherical corrections)
+    if parallel_scale is None and meridional_scale is None:
+        ps, ms = _get_scale_factors(u)
+    else:
+        ps = np.asarray(parallel_scale, dtype=np.float64) if parallel_scale is not None else None
+        ms = np.asarray(meridional_scale, dtype=np.float64) if meridional_scale is not None else None
+
+    dx_m = np.asarray(dx.to("m").magnitude if hasattr(dx, "to") else dx, dtype=np.float64)
+    dy_m = np.asarray(dy.to("m").magnitude if hasattr(dy, "to") else dy, dtype=np.float64)
+
+    # If we have scale factors, use full vector derivative with metric corrections
+    if ps is not None and ms is not None:
+        du_dx_corr, _, _, dv_dy_corr = _vector_derivative_corrected(
+            u_arr, v_arr, dx, dy, ps, ms)
+        result = du_dx_corr + dv_dy_corr
+        return _wrap_result_like(u, result, "1/s")
+
+    # Variable spacing without scale factors
+    if _is_variable_spacing(dx) or _is_variable_spacing(dy) or dx_m.ndim >= 2:
+        dudx = _first_derivative_variable(u_arr, dx_m, axis=-1)
+        dvdy = _first_derivative_variable(v_arr, dy_m, axis=-2)
+        result = dudx + dvdy
+        return _wrap_result_like(u, result, "1/s")
+
+    # Uniform grid: fast Rust path
+    dx_val = float(dx_m.mean()) if dx_m.ndim > 0 else float(dx_m)
+    dy_val = float(dy_m.mean()) if dy_m.ndim > 0 else float(dy_m)
     if u_arr.ndim == 2:
         result = np.asarray(_calc.divergence(np.ascontiguousarray(u_arr), np.ascontiguousarray(v_arr), dx_val, dy_val))
         return _wrap_result_like(u, result, "1/s")
@@ -2632,11 +2875,37 @@ def vorticity(u, v, dx=None, dy=None, x_dim=-1, y_dim=-2,
     dx, dy = _resolve_dx_dy(u, dx=dx, dy=dy, latitude=latitude, longitude=longitude)
     if dx is None or dy is None:
         raise TypeError("vorticity requires dx/dy or inferable latitude/longitude coordinates")
-    u_f = _flat(u, "m/s")
-    v_f = _flat(v, "m/s")
-    dx_val = _mean_spacing(dx, "m")
-    dy_val = _mean_spacing(dy, "m")
-    result = np.asarray(_calc.vorticity(u_f, v_f, dx_val, dy_val))
+    u_arr = np.asarray(_strip(u, "m/s"), dtype=np.float64)
+    v_arr = np.asarray(_strip(v, "m/s"), dtype=np.float64)
+
+    # Check for map projection scale factors (spherical corrections)
+    if parallel_scale is None and meridional_scale is None:
+        ps, ms = _get_scale_factors(u)
+    else:
+        ps = np.asarray(parallel_scale, dtype=np.float64) if parallel_scale is not None else None
+        ms = np.asarray(meridional_scale, dtype=np.float64) if meridional_scale is not None else None
+
+    dx_m = np.asarray(dx.to("m").magnitude if hasattr(dx, "to") else dx, dtype=np.float64)
+    dy_m = np.asarray(dy.to("m").magnitude if hasattr(dy, "to") else dy, dtype=np.float64)
+
+    # If we have scale factors, use full vector derivative with metric corrections
+    if ps is not None and ms is not None:
+        _, du_dy_corr, dv_dx_corr, _ = _vector_derivative_corrected(
+            u_arr, v_arr, dx, dy, ps, ms)
+        result = dv_dx_corr - du_dy_corr
+        return _wrap_result_like(u, result, "1/s")
+
+    # Variable spacing without scale factors (flat-Earth, variable grid)
+    if _is_variable_spacing(dx) or _is_variable_spacing(dy) or dx_m.ndim >= 2:
+        dvdx = _first_derivative_variable(v_arr, dx_m, axis=-1)
+        dudy = _first_derivative_variable(u_arr, dy_m, axis=-2)
+        result = dvdx - dudy
+        return _wrap_result_like(u, result, "1/s")
+
+    # Uniform grid: fast Rust path
+    dx_val = float(dx_m.mean()) if dx_m.ndim > 0 else float(dx_m)
+    dy_val = float(dy_m.mean()) if dy_m.ndim > 0 else float(dy_m)
+    result = np.asarray(_calc.vorticity(np.ascontiguousarray(u_arr), np.ascontiguousarray(v_arr), dx_val, dy_val))
     return _wrap_result_like(u, result, "1/s")
 
 
@@ -4056,8 +4325,37 @@ def lat_lon_grid_deltas(longitude, latitude, x_dim=-1, y_dim=-2, geod=None):
         lon_arr, lat_arr = lat_arr, lon_arr
     if lon_arr.ndim == 1 and lat_arr.ndim == 1:
         lon_arr, lat_arr = np.meshgrid(lon_arr, lat_arr)
-    dx, dy = _calc.lat_lon_grid_deltas(lat_arr, lon_arr)
-    return np.asarray(dx) * units.m, np.asarray(dy) * units.m
+    dx_abs, dy_abs = _calc.lat_lon_grid_deltas(lat_arr, lon_arr)
+    dx_out = np.asarray(dx_abs, dtype=np.float64)
+    dy_out = np.asarray(dy_abs, dtype=np.float64)
+
+    # Apply sign based on coordinate direction (MetPy convention):
+    # dx > 0 when longitude increases, dy > 0 when latitude increases
+    ny, nx = lat_arr.shape
+    # dx sign: based on longitude difference (column-wise)
+    if nx > 1:
+        lon_sign = np.sign(lon_arr[:, 1:] - lon_arr[:, :-1])
+        # Pad to match dx shape (which may be ny x nx or ny x nx-1)
+        if dx_out.shape[-1] == nx - 1:
+            dx_out = dx_out * lon_sign
+        elif dx_out.shape[-1] == nx:
+            lon_sign_full = np.ones((ny, nx))
+            lon_sign_full[:, 1:] = lon_sign
+            lon_sign_full[:, 0] = lon_sign[:, 0]
+            dx_out = dx_out * lon_sign_full
+
+    # dy sign: based on latitude difference (row-wise)
+    if ny > 1:
+        lat_sign = np.sign(lat_arr[1:, :] - lat_arr[:-1, :])
+        if dy_out.shape[0] == ny - 1:
+            dy_out = dy_out * lat_sign
+        elif dy_out.shape[0] == ny:
+            lat_sign_full = np.ones((ny, nx))
+            lat_sign_full[1:, :] = lat_sign
+            lat_sign_full[0, :] = lat_sign[0, :]
+            dy_out = dy_out * lat_sign_full
+
+    return dx_out * units.m, dy_out * units.m
 
 
 # ============================================================================

metrust-0.2.8/tmp_bunkers.txt

@@ -1,106 +0,0 @@
-@exporter.export
-@preprocess_and_wrap()
-@check_units('[pressure]', '[speed]', '[speed]', '[length]')
-def bunkers_storm_motion(pressure, u, v, height):
-    r"""Calculate right-mover and left-mover supercell storm motions using the Bunkers method.
-
-    This is a physically based, shear-relative, and Galilean invariant method for predicting
-    supercell motion. Full atmospheric profiles of wind components, as well as pressure and
-    heights, need to be provided so that calculation can properly calculate the required
-    surface to 6 km mean flow.
-
-    The calculation in summary is (from [Bunkers2000]_):
-
-    * surface to 6 km non-pressure-weighted mean wind
-    * a deviation from the sfc to 6 km mean wind of 7.5 m s−1
-    * a 5.5 to 6 km mean wind for the head of the vertical wind shear vector
-    * a surface to 0.5 km mean wind for the tail of the vertical wind shear vector
-
-    Parameters
-    ----------
-    pressure : `pint.Quantity`
-        Pressure from full profile
-
-    u : `pint.Quantity`
-        Full profile of the U-component of the wind
-
-    v : `pint.Quantity`
-        Full profile of the V-component of the wind
-
-    height : `pint.Quantity`
-        Full profile of height
-
-    Returns
-    -------
-    right_mover: (`pint.Quantity`, `pint.Quantity`)
-        Scalar U- and V- components of Bunkers right-mover storm motion
-
-    left_mover: (`pint.Quantity`, `pint.Quantity`)
-        Scalar U- and V- components of Bunkers left-mover storm motion
-
-    wind_mean: (`pint.Quantity`, `pint.Quantity`)
-        Scalar U- and V- components of surface to 6 km mean flow
-
-    Examples
-    --------
-    >>> from metpy.calc import bunkers_storm_motion, wind_components
-    >>> from metpy.units import units
-    >>> p = [1000, 925, 850, 700, 500, 400] * units.hPa
-    >>> h = [250, 700, 1500, 3100, 5720, 7120] * units.meters
-    >>> wdir = [165, 180, 190, 210, 220, 250] * units.degree
-    >>> sped = [5, 15, 20, 30, 50, 60] * units.knots
-    >>> u, v = wind_components(sped, wdir)
-    >>> bunkers_storm_motion(p, u, v, h)
-    (<Quantity([22.09618172 12.43406736], 'knot')>,
-    <Quantity([ 6.02861839 36.76517865], 'knot')>,
-    <Quantity([14.06240005 24.599623  ], 'knot')>)
-
-    Notes
-    -----
-    Only functions on 1D profiles (not higher-dimension vertical cross sections or grids).
-    Since this function returns scalar values when given a profile, this will return Pint
-    Quantities even when given xarray DataArray profiles.
-
-    .. versionchanged:: 1.0
-       Renamed ``heights`` parameter to ``height``
-
-    """
-    # remove nans from input data
-    pressure, u, v, height = _remove_nans(pressure, u, v, height)
-
-    # mean wind from sfc-6km
-    wind_mean = weighted_continuous_average(pressure, u, v, height=height,
-                                            depth=units.Quantity(6000, 'meter'))
-
-    wind_mean = units.Quantity.from_list(wind_mean)
-
-    # mean wind from sfc-500m
-    wind_500m = weighted_continuous_average(pressure, u, v, height=height,
-                                            depth=units.Quantity(500, 'meter'))
-
-    wind_500m = units.Quantity.from_list(wind_500m)
-
-    # mean wind from 5.5-6km
-    wind_5500m = weighted_continuous_average(
-        pressure, u, v, height=height,
-        depth=units.Quantity(500, 'meter'),
-        bottom=height[0] + units.Quantity(5500, 'meter'))
-
-    wind_5500m = units.Quantity.from_list(wind_5500m)
-
-    # Calculate the shear vector from sfc-500m to 5.5-6km
-    shear = wind_5500m - wind_500m
-
-    # Take the cross product of the wind shear and k, and divide by the vector magnitude and
-    # multiply by the deviation empirically calculated in Bunkers (2000) (7.5 m/s)
-    shear_cross = concatenate([shear[1], -shear[0]])
-    shear_mag = np.hypot(*shear)
-    rdev = shear_cross * (units.Quantity(7.5, 'm/s').to(u.units) / shear_mag)
-
-    # Add the deviations to the layer average wind to get the RM motion
-    right_mover = wind_mean + rdev
-
-    # Subtract the deviations to get the LM motion
-    left_mover = wind_mean - rdev
-
-    return right_mover, left_mover, wind_mean

metrust-0.2.8/tmp_wca.txt

@@ -1,59 +0,0 @@
-@exporter.export
-@preprocess_and_wrap()
-@check_units('[pressure]')
-def weighted_continuous_average(pressure, *args, height=None, bottom=None, depth=None):
-    r"""Calculate weighted-continuous mean of an arbitrary variable through a layer.
-
-    Layer top and bottom specified in height or pressure.
-
-    Formula based on that from [Holton2004]_ pg. 76 and the NCL function ``wgt_vertical_n``
-
-    .. math::  WCA = \frac{\int_{p_s}^{p_b} A dp}{\int_{p_s}^{p_b} dp}
-
-    where:
-
-    * :math:`WCA` is the weighted continuous average of a variable.
-    * :math:`p_b` is the bottom pressure level.
-    * :math:`p_s` is the top pressure level.
-    * :math:`A` is the variable whose weighted continuous average is being calculated.
-
-    Parameters
-    ----------
-    pressure : `pint.Quantity`
-        Atmospheric pressure profile.
-
-    args : `pint.Quantity`
-        Parameters for which the weighted-continuous mean is to be calculated.
-
-    height : `pint.Quantity`, optional
-        Heights from sounding. Standard atmosphere heights assumed (if needed)
-        if no heights are given.
-
-    bottom: `pint.Quantity`, optional
-        The bottom of the layer in either the provided height coordinate
-        or in pressure. Don't provide in meters AGL unless the provided
-        height coordinate is meters AGL. Default is the first observation,
-        assumed to be the surface.
-
-    depth: `pint.Quantity`, optional
-        Depth of the layer in meters or hPa.
-
-    Returns
-    -------
-    list of `pint.Quantity`
-        list of layer mean value for each profile in args.
-
-    Notes
-    -----
-    Only functions on 1D profiles (not higher-dimension vertical cross sections or grids).
-    Since this function returns scalar values when given a profile, this will return Pint
-    Quantities even when given xarray DataArray profiles.
-
-    """
-    # Split pressure profile from other variables to average
-    pres_prof, *others = get_layer(
-        pressure, *args, height=height, bottom=bottom, depth=depth
-    )
-
-    return [trapezoid(var_prof, x=pres_prof) / (pres_prof[-1] - pres_prof[0])
-            for var_prof in others]