geopack-vectorize 2.0.1__tar.gz → 2.0.3__tar.gz

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [2.0.3] - 2026-11-07
+
+### Fixed
+- Return NaN fields for NaN coordinates in vectorized T01/T96 instead of
+  leaving zero outputs when no magnetopause region matches. Valid points
+  in the same batch retain their scalar-reference values.
+- Normalize Cartesian-to-spherical longitude in vectorized `sphcar` to
+  match the scalar convention of [0, 2*pi), retaining phi=0 at the poles.
+
+## [2.0.2] - 2026-11-04
+
+### Fixed
+- Preserve the T01 IMF clock angle for negative By instead of replacing it
+  with 2*pi, correcting both scalar and vectorized magnetic fields.
+- Accept integer coordinates without truncation in vectorized T01/T96,
+  and preserve NumPy broadcasting and multidimensional inputs in T01.
+- Broadcast all coordinate/vector components before transforms and determine
+  scalar outputs from every input, including spherical transforms and the
+  IGRF GSM/GSW wrappers.
+
 ## [2.0.1] - 2026-10-28
 
 ### Fixed

{geopack_vectorize-2.0.1/geopack_vectorize.egg-info → geopack_vectorize-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geopack-vectorize
-Version: 2.0.1
+Version: 2.0.3
 Summary: Python implementation of geopack and Tsyganenko models with optimized vectorization
 Home-page: https://github.com/Butadiene/geopack-vectorize
 Author: geopack-vectorize contributors
@@ -64,6 +64,12 @@ geopack-vectorize extends the original geopack by adding vectorized implementati
 - **Full Backward Compatibility**: All original geopack functions remain unchanged and available
 - **Comprehensive Validation**: Extensive test suite ensuring < 10⁻¹¹ relative error vs original implementations
 
+## Publication and Citation
+
+geopack-vectorize, including its Mageometry component for local-frame analysis of magnetic field geometry, is described in the following paper published in *Earth, Planets and Space*. If you use this work in your research, please cite:
+
+> Isono, K., Yoshikawa, A. & Katoh, Y. (2026). A local-frame approach to three-dimensional analysis of magnetospheric magnetic fields. *Earth, Planets and Space*, **78**, Article 201. [doi:10.1186/s40623-026-02528-2](https://doi.org/10.1186/s40623-026-02528-2).
+
 ## Upgrading to v2.0.0
 
 As of v2.0.0, the PyPI package name has changed from `geopack-vectorized` to `geopack-vectorize`. The old `geopack-vectorized` package will remain available for a transitional period but will eventually be removed. Please update your installation:

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/README.md

@@ -16,6 +16,12 @@ geopack-vectorize extends the original geopack by adding vectorized implementati
 - **Full Backward Compatibility**: All original geopack functions remain unchanged and available
 - **Comprehensive Validation**: Extensive test suite ensuring < 10⁻¹¹ relative error vs original implementations
 
+## Publication and Citation
+
+geopack-vectorize, including its Mageometry component for local-frame analysis of magnetic field geometry, is described in the following paper published in *Earth, Planets and Space*. If you use this work in your research, please cite:
+
+> Isono, K., Yoshikawa, A. & Katoh, Y. (2026). A local-frame approach to three-dimensional analysis of magnetospheric magnetic fields. *Earth, Planets and Space*, **78**, Article 201. [doi:10.1186/s40623-026-02528-2](https://doi.org/10.1186/s40623-026-02528-2).
+
 ## Upgrading to v2.0.0
 
 As of v2.0.0, the PyPI package name has changed from `geopack-vectorized` to `geopack-vectorize`. The old `geopack-vectorized` package will remain available for a transitional period but will eventually be removed. Please update your installation:

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/examples/notebooks/directional_derivatives_maps/t96_field_directional_derivatives.ipynb

@@ -339,7 +339,7 @@
     "    unit:\n",
     "      - None -> uses UNIT_STR (for Gamma, etc.)\n",
     "      - \"\"   -> no unit display (for ratio, etc.)\n",
-    "      - \"A\"  -> [A] (for FAC, etc.)\n",
+    "      - \"A/m$^2$\" -> [A/m$^2$] (for FAC current density, etc.)\n",
     "    \"\"\"\n",
     "    if unit is None:\n",
     "        unit = UNIT_STR\n",
@@ -850,7 +850,7 @@
     "\n",
     "def compute_fac_proxy_and_ratio(Bmag_nT, dn_db_T, db_dn_T):\n",
     "    mu0 = 1.25663706127e-6\n",
-    "    FAC = Bmag_nT * (dn_db_T - db_dn_T) / mu0 * (1e-9) / (6371 * 1e6)  # A\n",
+    "    FAC = Bmag_nT * (dn_db_T - db_dn_T) / mu0 * (1e-9) / (6371 * 1e3)  # A/m^2 (1 Re = 6371 km = 6.371e6 m)\n",
     "    den = np.abs(dn_db_T) + np.abs(db_dn_T)\n",
     "    ratio = np.abs(dn_db_T) / np.where(den == 0, np.nan, den)\n",
     "    return FAC, ratio\n",
@@ -918,7 +918,7 @@
     "                r\"Field-Aligned Current  $\\frac{B}{\\mu_0}$((∂n/∂b)·T − (∂b/∂n)·T)\"\n",
     "            ),\n",
     "            cbar_label=\"FAC\",\n",
-    "            unit=\"A\",\n",
+    "            unit=\"A/m$^2$\",\n",
     "            force_levels=None,\n",
     "        ),\n",
     "        dict(\n",
@@ -1166,7 +1166,7 @@
     "                r\"Field-Aligned Current  $\\frac{B}{\\mu_0}$((∂n/∂b)·T − (∂b/∂n)·T)\"\n",
     "            ),\n",
     "            cbar_label=\"FAC\",\n",
-    "            unit=\"A\",\n",
+    "            unit=\"A/m$^2$\",\n",
     "            force_levels=None,\n",
     "        ),\n",
     "        dict(\n",
@@ -1464,7 +1464,7 @@
     "                    r\"Field-Aligned Current  $\\frac{B}{\\mu_0}$((∂n/∂b)·T − (∂b/∂n)·T)\"\n",
     "                ),\n",
     "                cbar_label=\"FAC\",\n",
-    "                unit=\"A\",\n",
+    "                unit=\"A/m$^2$\",\n",
     "                force_levels=None,\n",
     "            ),\n",
     "            dict(\n",
@@ -1581,7 +1581,7 @@
     "                    r\"Field-Aligned Current  $\\frac{B}{\\mu_0}$((∂n/∂b)·T − (∂b/∂n)·T)\"\n",
     "                ),\n",
     "                cbar_label=\"FAC\",\n",
-    "                unit=\"A\",\n",
+    "                unit=\"A/m$^2$\",\n",
     "                force_levels=None,\n",
     "            ),\n",
     "            dict(\n",

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/__init__.py

@@ -6,7 +6,7 @@ This module re-exports all public functions defined in geopack/geopack.py,
 so that they can be imported directly from `geopack`.
 """
 
-__version__ = '2.0.1'
+__version__ = '2.0.3'
 
 from .geopack import (
     update_igrf,

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/models/t01.py

@@ -147,7 +147,7 @@ def extall(iopgen,iopt,iopb,iopr,a,ntot,pdyn,dst,byimf,bzimf,vbimf1,vbimf2,ps,x,
         theta = 0.
     else:
         theta=np.arctan2(byimf,bzimf)
-        if theta <= 0: theta = 2*np.pi
+        if theta <= 0: theta += 2*np.pi
 
     ct=np.cos(theta)
     st=np.sin(theta)

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/vectorized/coordinates.py

@@ -34,12 +34,13 @@ def gsmgse(xgsm, ygsm, zgsm, j):
         Transformed coordinates (GSE if j>0, GSM if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xgsm)
+    scalar_input = all(np.isscalar(c) for c in (xgsm, ygsm, zgsm))
     
     # Ensure arrays
     xgsm = np.atleast_1d(xgsm)
     ygsm = np.atleast_1d(ygsm)
     zgsm = np.atleast_1d(zgsm)
+    xgsm, ygsm, zgsm = np.broadcast_arrays(xgsm, ygsm, zgsm)
     
     # Get transformation angles from geopack globals
     chi = gp.chi
@@ -83,12 +84,13 @@ def geigeo(xgei, ygei, zgei, j):
         Transformed coordinates (GEO if j>0, GEI if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xgei)
+    scalar_input = all(np.isscalar(c) for c in (xgei, ygei, zgei))
     
     # Ensure arrays
     xgei = np.atleast_1d(xgei)
     ygei = np.atleast_1d(ygei)
     zgei = np.atleast_1d(zgei)
+    xgei, ygei, zgei = np.broadcast_arrays(xgei, ygei, zgei)
     
     # Get transformation angles from geopack globals
     cgst = gp.cgst
@@ -132,12 +134,13 @@ def magsm(xmag, ymag, zmag, j):
         Transformed coordinates (SM if j>0, MAG if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xmag)
+    scalar_input = all(np.isscalar(c) for c in (xmag, ymag, zmag))
     
     # Ensure arrays
     xmag = np.atleast_1d(xmag)
     ymag = np.atleast_1d(ymag)
     zmag = np.atleast_1d(zmag)
+    xmag, ymag, zmag = np.broadcast_arrays(xmag, ymag, zmag)
     
     # Get transformation angles from geopack globals
     sfi = gp.sfi
@@ -181,12 +184,13 @@ def smgsm(xsm, ysm, zsm, j):
         Transformed coordinates (GSM if j>0, SM if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xsm)
+    scalar_input = all(np.isscalar(c) for c in (xsm, ysm, zsm))
     
     # Ensure arrays
     xsm = np.atleast_1d(xsm)
     ysm = np.atleast_1d(ysm)
     zsm = np.atleast_1d(zsm)
+    xsm, ysm, zsm = np.broadcast_arrays(xsm, ysm, zsm)
     
     # Get transformation angles from geopack globals
     sps = gp.sps
@@ -230,12 +234,13 @@ def geomag(xgeo, ygeo, zgeo, j):
         Transformed coordinates (MAG if j>0, GEO if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xgeo)
+    scalar_input = all(np.isscalar(c) for c in (xgeo, ygeo, zgeo))
     
     # Ensure arrays
     xgeo = np.atleast_1d(xgeo)
     ygeo = np.atleast_1d(ygeo)
     zgeo = np.atleast_1d(zgeo)
+    xgeo, ygeo, zgeo = np.broadcast_arrays(xgeo, ygeo, zgeo)
     
     # Get transformation matrix elements from geopack globals
     # These are set by recalc() based on IGRF coefficients
@@ -286,12 +291,13 @@ def geogsm(xgeo, ygeo, zgeo, j):
         Transformed coordinates (GSM if j>0, GEO if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xgeo)
+    scalar_input = all(np.isscalar(c) for c in (xgeo, ygeo, zgeo))
     
     # Ensure arrays
     xgeo = np.atleast_1d(xgeo)
     ygeo = np.atleast_1d(ygeo)
     zgeo = np.atleast_1d(zgeo)
+    xgeo, ygeo, zgeo = np.broadcast_arrays(xgeo, ygeo, zgeo)
     
     # Get transformation matrix elements from geopack globals
     a11 = gp.a11
@@ -342,12 +348,13 @@ def gswgsm(xgsw, ygsw, zgsw, j):
         Transformed coordinates (GSM if j>0, GSW if j<0)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(xgsw)
+    scalar_input = all(np.isscalar(c) for c in (xgsw, ygsw, zgsw))
     
     # Ensure arrays
     xgsw = np.atleast_1d(xgsw)
     ygsw = np.atleast_1d(ygsw)
     zgsw = np.atleast_1d(zgsw)
+    xgsw, ygsw, zgsw = np.broadcast_arrays(xgsw, ygsw, zgsw)
     
     # Get transformation matrix elements from geopack globals
     e11 = gp.e11
@@ -378,4 +385,4 @@ def gswgsm(xgsw, ygsw, zgsw, j):
     if scalar_input:
         return x_out.item(), y_out.item(), z_out.item()
     else:
-        return x_out, y_out, z_out
+        return x_out, y_out, z_out

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/vectorized/coordinates_complex.py

@@ -23,14 +23,16 @@ def sphcar(r, theta, phi, j):
     -------
     tuple of (float or ndarray)
         Transformed coordinates (x,y,z if j>0, r,theta,phi if j<0)
+        For j<0, phi is in [0, 2*pi), with phi=0 at the poles.
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(r)
+    scalar_input = all(np.isscalar(c) for c in (r, theta, phi))
     
     # Ensure arrays
     r = np.atleast_1d(r)
     theta = np.atleast_1d(theta)
     phi = np.atleast_1d(phi)
+    r, theta, phi = np.broadcast_arrays(r, theta, phi)
     
     if j > 0:  # Spherical to Cartesian
         sq = r * np.sin(theta)
@@ -49,6 +51,7 @@ def sphcar(r, theta, phi, j):
         
         # Handle conditional logic for phi
         phi_out = np.where(sq != 0, np.arctan2(y, x), 0.0)
+        phi_out = np.where(phi_out < 0, phi_out + 2 * np.pi, phi_out)
         
         # Handle conditional logic for theta
         theta_out = np.where(sq != 0, 
@@ -81,7 +84,7 @@ def bspcar(theta, phi, br, btheta, bphi):
         Magnetic field components in Cartesian coordinates (bx, by, bz)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(theta)
+    scalar_input = all(np.isscalar(c) for c in (theta, phi, br, btheta, bphi))
     
     # Ensure arrays
     theta = np.atleast_1d(theta)
@@ -89,6 +92,7 @@ def bspcar(theta, phi, br, btheta, bphi):
     br = np.atleast_1d(br)
     btheta = np.atleast_1d(btheta)
     bphi = np.atleast_1d(bphi)
+    theta, phi, br, btheta, bphi = np.broadcast_arrays(theta, phi, br, btheta, bphi)
     
     # Calculate trigonometric values
     s = np.sin(theta)
@@ -126,7 +130,7 @@ def bcarsp(x, y, z, bx, by, bz):
         Magnetic field components in spherical coordinates (br, btheta, bphi)
     """
     # Check if input is scalar
-    scalar_input = np.isscalar(x)
+    scalar_input = all(np.isscalar(c) for c in (x, y, z, bx, by, bz))
     
     # Ensure arrays
     x = np.atleast_1d(x)
@@ -135,6 +139,7 @@ def bcarsp(x, y, z, bx, by, bz):
     bx = np.atleast_1d(bx)
     by = np.atleast_1d(by)
     bz = np.atleast_1d(bz)
+    x, y, z, bx, by, bz = np.broadcast_arrays(x, y, z, bx, by, bz)
     
     # Calculate distances
     rho2 = x*x + y*y
@@ -167,4 +172,4 @@ def bcarsp(x, y, z, bx, by, bz):
     if scalar_input:
         return br.item(), btheta.item(), bphi.item()
     else:
-        return br, btheta, bphi
+        return br, btheta, bphi

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/vectorized/igrf.py

@@ -225,7 +225,7 @@ def igrf_gsm(xgsm, ygsm, zgsm):
         Magnetic field components in GSM coordinates (nT)
     """
     # Handle scalar inputs
-    scalar_input = np.isscalar(xgsm)
+    scalar_input = all(np.isscalar(c) for c in (xgsm, ygsm, zgsm))
     xgsm = np.atleast_1d(xgsm)
     ygsm = np.atleast_1d(ygsm)
     zgsm = np.atleast_1d(zgsm)
@@ -270,7 +270,7 @@ def igrf_gsw(xgsw, ygsw, zgsw):
         Magnetic field components in GSW coordinates (nT)
     """
     # Handle scalar inputs
-    scalar_input = np.isscalar(xgsw)
+    scalar_input = all(np.isscalar(c) for c in (xgsw, ygsw, zgsw))
     xgsw = np.atleast_1d(xgsw)
     ygsw = np.atleast_1d(ygsw)
     zgsw = np.atleast_1d(zgsw)
@@ -289,4 +289,4 @@ def igrf_gsw(xgsw, ygsw, zgsw):
     if scalar_input:
         return bxgsw.item(), bygsw.item(), bzgsw.item()
     else:
-        return bxgsw, bygsw, bzgsw
+        return bxgsw, bygsw, bzgsw

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/vectorized/models/t01.py

@@ -60,10 +60,11 @@ def t01(parmod, ps, x, y, z):
     # Track if all inputs were scalar
     scalar_input = np.isscalar(x) and np.isscalar(y) and np.isscalar(z)
     
-    # Convert inputs to numpy arrays
-    x = np.atleast_1d(x)
-    y = np.atleast_1d(y)
-    z = np.atleast_1d(z)
+    # Normalize dtype and shape before masked coordinate iterations.
+    x, y, z = np.broadcast_arrays(
+        np.atleast_1d(np.asarray(x, dtype=float)),
+        np.atleast_1d(np.asarray(y, dtype=float)),
+        np.atleast_1d(np.asarray(z, dtype=float)))
 
     a = np.array([
         1.00000, 2.47341, 0.40791, 0.30429, -0.10637, -0.89108, 3.29350,
@@ -133,7 +134,7 @@ def extall(iopgen,iopt,iopb,iopr,a,ntot,pdyn,dst,byimf,bzimf,vbimf1,vbimf2,ps,x,
         theta = 0.
     else:
         theta=np.arctan2(byimf,bzimf)
-        if theta <= 0: theta = 2*np.pi
+        if theta <= 0: theta += 2*np.pi
 
     ct=np.cos(theta)
     st=np.sin(theta)
@@ -172,8 +173,7 @@ def extall(iopgen,iopt,iopb,iopr,a,ntot,pdyn,dst,byimf,bzimf,vbimf1,vbimf2,ps,x,
         zss[active] = znew
 
         # Skip already-converged points in subsequent iterations
-        active_idx = np.where(active)[0]
-        active[active_idx] = dd > 1e-6
+        active[active] = dd > 1e-6
 
     rho2=y**2+zss**2
     asq=am**2
@@ -249,7 +249,8 @@ def extall(iopgen,iopt,iopb,iopr,a,ntot,pdyn,dst,byimf,bzimf,vbimf1,vbimf2,ps,x,
     mask_interp = (sigma >= (s0 - dsig)) & (sigma < (s0 + dsig))
     mask_out = sigma >= (s0 + dsig)
 
-    bx, by, bz = np.zeros_like(x), np.zeros_like(y), np.zeros_like(z)
+    # NaN sigma matches no region, so invalid coordinates must stay undefined.
+    bx, by, bz = np.full_like(x, np.nan), np.full_like(y, np.nan), np.full_like(z, np.nan)
 
     # Case 1: Inside the magnetosphere
     bx = np.where(mask_in, bbx, bx)
@@ -1966,4 +1967,4 @@ def dipole(ps, x, y, z):
     by = -3 * y * q * (x * sps + z * cps)
     bz = q * ((x2 + y2 - 2 * z2) * cps - xz3 * sps)
 
-    return bx, by, bz
+    return bx, by, bz

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack/vectorized/models/t96.py

@@ -46,9 +46,9 @@ def t96(parmod, ps, x, y, z):
     scalar_input = np.isscalar(x) and np.isscalar(y) and np.isscalar(z)
     
     # Convert inputs to numpy arrays
-    x = np.atleast_1d(x)
-    y = np.atleast_1d(y)
-    z = np.atleast_1d(z)
+    x = np.atleast_1d(np.asarray(x, dtype=float))
+    y = np.atleast_1d(np.asarray(y, dtype=float))
+    z = np.atleast_1d(np.asarray(z, dtype=float))
     
     # Broadcast arrays to same shape
     x, y, z = np.broadcast_arrays(x, y, z)
@@ -125,10 +125,10 @@ def t96(parmod, ps, x, y, z):
     sqrt_arg = np.maximum(sqrt_arg, 0)  # Ensure non-negative
     sigma = np.sqrt((aro + axx0 + np.sqrt(sqrt_arg)) / (2.0 * asq))
     
-    # Initialize output arrays
-    bx = np.zeros_like(x)
-    by = np.zeros_like(y)
-    bz = np.zeros_like(z)
+    # NaN sigma matches no region, so invalid coordinates must stay undefined.
+    bx = np.full_like(x, np.nan)
+    by = np.full_like(y, np.nan)
+    bz = np.full_like(z, np.nan)
     
     # Define masks for three regions
     mask_inside = sigma < (s0 - dsig)
@@ -2443,4 +2443,4 @@ if __name__ == '__main__':
     print("\nArray input:")
     for i in range(len(x_arr)):
         print(f"  Point ({x_arr[i]}, {y_arr[i]}, {z_arr[i]}): "
-              f"B = ({bx_arr[i]:.3f}, {by_arr[i]:.3f}, {bz_arr[i]:.3f}) nT")
+              f"B = ({bx_arr[i]:.3f}, {by_arr[i]:.3f}, {bz_arr[i]:.3f}) nT")

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3/geopack_vectorize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geopack-vectorize
-Version: 2.0.1
+Version: 2.0.3
 Summary: Python implementation of geopack and Tsyganenko models with optimized vectorization
 Home-page: https://github.com/Butadiene/geopack-vectorize
 Author: geopack-vectorize contributors
@@ -64,6 +64,12 @@ geopack-vectorize extends the original geopack by adding vectorized implementati
 - **Full Backward Compatibility**: All original geopack functions remain unchanged and available
 - **Comprehensive Validation**: Extensive test suite ensuring < 10⁻¹¹ relative error vs original implementations
 
+## Publication and Citation
+
+geopack-vectorize, including its Mageometry component for local-frame analysis of magnetic field geometry, is described in the following paper published in *Earth, Planets and Space*. If you use this work in your research, please cite:
+
+> Isono, K., Yoshikawa, A. & Katoh, Y. (2026). A local-frame approach to three-dimensional analysis of magnetospheric magnetic fields. *Earth, Planets and Space*, **78**, Article 201. [doi:10.1186/s40623-026-02528-2](https://doi.org/10.1186/s40623-026-02528-2).
+
 ## Upgrading to v2.0.0
 
 As of v2.0.0, the PyPI package name has changed from `geopack-vectorized` to `geopack-vectorize`. The old `geopack-vectorized` package will remain available for a transitional period but will eventually be removed. Please update your installation:

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/geopack_vectorize.egg-info/SOURCES.txt

@@ -60,7 +60,9 @@ geopack_vectorize.egg-info/dependency_links.txt
 geopack_vectorize.egg-info/requires.txt
 geopack_vectorize.egg-info/top_level.txt
 tests/installed_smoke.py
+tests/test_coordinate_broadcasting.py
 tests/test_distribution.py
+tests/test_model_input_regressions.py
 tests/test_trace_vectorized.py
 tests/test_trace_vectorized_with_vectorized_models.py
 tests/test_vectorized_models.py

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geopack-vectorize"
-version = "2.0.1"
+version = "2.0.3"
 description = "Python implementation of geopack and Tsyganenko models with optimized vectorization"
 authors = [
     {name = "Sheng Tian", email = "ts0110@atmos.ucla.edu"}

{geopack_vectorize-2.0.1 → geopack_vectorize-2.0.3}/setup.py

@@ -6,7 +6,7 @@ with open('README.md', 'r', encoding='utf-8') as fh:
 
 setuptools.setup(
     name='geopack-vectorize',
-    version='2.0.1',
+    version='2.0.3',
     author='geopack-vectorize contributors',
     author_email='',
     description='Vectorized Python implementation of geopack and Tsyganenko models (fork of tsssss/geopack)',

geopack_vectorize-2.0.3/tests/test_coordinate_broadcasting.py

@@ -0,0 +1,95 @@
+"""Scalar and NumPy broadcasting contracts for transforms and IGRF wrappers."""
+
+import unittest
+
+import numpy as np
+
+from geopack import geopack as scalar
+from geopack.vectorized import coordinates, coordinates_complex, igrf
+
+
+class TestCoordinateBroadcasting(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        scalar.recalc(100., vxgse=-400., vygse=15., vzgse=20.)
+
+    def assert_pointwise(self, vector_function, scalar_function, arguments, extra=()):
+        broadcast = np.broadcast_arrays(*arguments)
+        expected = np.array([scalar_function(*point, *extra)
+                             for point in zip(*(c.ravel() for c in broadcast))])
+        expected = expected.T.reshape((3,) + broadcast[0].shape)
+        actual = vector_function(*arguments, *extra)
+        for component in actual:
+            self.assertEqual(component.shape, broadcast[0].shape)
+        np.testing.assert_allclose(actual, expected, rtol=1e-11, atol=1e-8)
+
+    def test_cartesian_transforms_broadcast_each_component_in_both_directions(self):
+        names = ('gsmgse', 'geigeo', 'magsm', 'smgsm', 'geomag', 'geogsm', 'gswgsm')
+        cases = [(np.array([1., 2.]), 3., 4.),
+                 (1., np.array([2., 3.]), 4.),
+                 (1., 2., np.array([3., 4.])),
+                 (np.array([1., 2.])[:, None], np.array([2., 3., 4.]), 4.)]
+        for name in names:
+            for direction in (-1, 1):
+                for coords in cases:
+                    with self.subTest(transform=name, direction=direction,
+                                      shapes=tuple(np.shape(c) for c in coords)):
+                        self.assert_pointwise(getattr(coordinates, name), getattr(scalar, name),
+                                              coords, (direction,))
+                with self.subTest(transform=name, direction=direction, scalar=True):
+                    result = getattr(coordinates, name)(1., 2., 3., direction)
+                    self.assertTrue(all(isinstance(c, float) for c in result))
+                    np.testing.assert_allclose(result, getattr(scalar, name)(1., 2., 3., direction))
+
+    def test_spherical_coordinate_transforms_broadcast(self):
+        cases = (
+            ((5., np.array([.5, 1.]), .3), 1),
+            ((np.array([4., 5.]), .5, .3), 1),
+            ((5., .5, np.array([.3, .6])), 1),
+            ((1., np.array([2., 3.]), 4.), -1),
+            ((np.array([1., 2.])[:, None], 2., np.array([3., 4., 5.])), -1),
+        )
+        for coords, direction in cases:
+            with self.subTest(direction=direction, shapes=tuple(np.shape(c) for c in coords)):
+                self.assert_pointwise(coordinates_complex.sphcar, scalar.sphcar, coords, (direction,))
+
+    def test_magnetic_component_transforms_broadcast_every_input(self):
+        for name, base in (('bspcar', [.7, .3, 4., 2., 1.]),
+                           ('bcarsp', [4., 2., 1., 3., 2., 1.])):
+            for index in range(len(base)):
+                arguments = list(base)
+                arguments[index] = base[index] + np.array([0., .1])
+                with self.subTest(transform=name, vector_input=index):
+                    self.assert_pointwise(getattr(coordinates_complex, name), getattr(scalar, name),
+                                          arguments)
+            result = getattr(coordinates_complex, name)(*base)
+            self.assertTrue(all(isinstance(c, float) for c in result))
+
+    def test_cartesian_to_spherical_longitude_matches_scalar_in_all_quadrants(self):
+        # Include the negative x axis, signed zero, both poles, and the origin.
+        points = np.array([[1., 1., 0.], [-1., 1., 0.], [-1., -1., 0.], [1., -1., 0.],
+                           [-1., 0., 0.], [-1., -0., 0.], [1., -0., 0.],
+                           [0., 0., 1.], [0., 0., -1.], [0., 0., 0.]])
+        for point in points:
+            with self.subTest(point=point):
+                actual = coordinates_complex.sphcar(*point, -1)
+                self.assertTrue(all(isinstance(c, float) for c in actual))
+                np.testing.assert_allclose(actual, scalar.sphcar(*point, -1), atol=1e-14)
+                self.assertGreaterEqual(actual[2], 0.)
+                self.assertLess(actual[2], 2 * np.pi)
+        self.assert_pointwise(coordinates_complex.sphcar, scalar.sphcar, points.T, (-1,))
+        self.assert_pointwise(coordinates_complex.sphcar, scalar.sphcar,
+                              (np.array([-1., 1.])[:, None], np.array([-1., 1.]), 0.), (-1,))
+
+    def test_igrf_cartesian_wrappers_broadcast(self):
+        for name in ('igrf_gsm', 'igrf_gsw'):
+            for coords in ((5., np.array([1., 2.]), 1.),
+                           (np.array([4., 5.])[:, None], np.array([1., 2., 3.]), 1.)):
+                with self.subTest(wrapper=name, shapes=tuple(np.shape(c) for c in coords)):
+                    self.assert_pointwise(getattr(igrf, name), getattr(scalar, name), coords)
+            result = getattr(igrf, name)(5., 1., 1.)
+            self.assertTrue(all(isinstance(c, float) for c in result))
+
+
+if __name__ == '__main__':
+    unittest.main()

geopack_vectorize-2.0.3/tests/test_model_input_regressions.py

@@ -0,0 +1,96 @@
+"""Regressions independent of scalar/vectorized implementation agreement."""
+
+import unittest
+
+import numpy as np
+
+from geopack import models
+from geopack.vectorized import models as vectorized
+
+
+PARMOD = [2., -20., 2., -5., 1., 1., 1., 1., 1., 1.]
+
+
+class TestModelInputRegressions(unittest.TestCase):
+    def test_nan_coordinates_return_nan_for_scalar_inputs(self):
+        for name in ('t01', 't96'):
+            for axis in range(3):
+                point = [-6., 1., 2.]
+                point[axis] = np.nan
+                with self.subTest(model=name, nan_axis=axis), np.errstate(invalid='ignore'):
+                    expected = getattr(models, name)(PARMOD, .2, *point)
+                    actual = getattr(vectorized, name)(PARMOD, .2, *point)
+                    self.assertTrue(np.all(np.isnan(expected)))
+                    self.assertTrue(np.all(np.isnan(actual)))
+                    self.assertTrue(all(isinstance(c, float) for c in actual))
+
+    def test_nan_coordinates_preserve_valid_points_in_multidimensional_batches(self):
+        valid_points = np.array([[-6., 1., 2.], [10.0655881232758, 2., 1.], [15., 3., 1.]])
+        for name in ('t01', 't96'):
+            expected = np.full((3, len(valid_points), 2), np.nan)
+            expected[:, :, 0] = np.array([
+                getattr(models, name)(PARMOD, .2, *point) for point in valid_points
+            ]).T
+            self.assertTrue(np.all(np.isfinite(expected[:, :, 0])))
+            for axis in range(3):
+                points = np.repeat(valid_points[:, None, :], 2, axis=1)
+                points[:, 1, axis] = np.nan
+                with self.subTest(model=name, nan_axis=axis), np.errstate(invalid='ignore'):
+                    actual = getattr(vectorized, name)(PARMOD, .2, *np.moveaxis(points, -1, 0))
+                    self.assertEqual(np.shape(actual), expected.shape)
+                    np.testing.assert_allclose(actual, expected, rtol=1e-10, atol=1e-6,
+                                               equal_nan=True)
+
+    def test_t01_imf_interconnection_preserves_clock_angle(self):
+        # With G1/G2 held fixed, the IMF dependence is exactly the prescribed
+        # T01 interconnection field, including outside the magnetopause.
+        for function in (models.t01, vectorized.t01):
+            for point in ((-6., 2., 1.), (15., 3., 1.)):
+                base = list(PARMOD)
+                base[2:4] = [0., 0.]
+                baseline = np.array(function(base, .2, *point))
+                for by in (-5., -1e-8, -0., 0., 1e-8, 5.):
+                    for bz in (-5., 5.):
+                        with self.subTest(api=function.__module__, point=point, by=by, bz=bz):
+                            parameters = list(PARMOD)
+                            parameters[2:4] = [by, bz]
+                            theta = np.arctan2(by, bz)
+                            factor = .05887 + .57691 * np.sin(theta / 2.)**2
+                            expected = baseline + factor * np.array([0., by, bz])
+                            actual = function(parameters, .2, *point)
+                            np.testing.assert_allclose(actual, expected, rtol=1e-12, atol=1e-9)
+
+    def test_integer_coordinates_match_scalar_fields_in_all_regions(self):
+        points = np.array([[5, 1, 1], [10, 0, -5], [15, 1, 1]])
+        for name in ('t01', 't96'):
+            scalar, batched = getattr(models, name), getattr(vectorized, name)
+            expected = np.array([scalar(PARMOD, .4, *point.astype(float)) for point in points]).T
+            with self.subTest(model=name, mode='batch'):
+                np.testing.assert_allclose(batched(PARMOD, .4, *points.T), expected,
+                                           rtol=1e-10, atol=1e-6)
+            for point, field in zip(points, expected.T):
+                with self.subTest(model=name, point=point):
+                    actual = batched(PARMOD, .4, *(int(c) for c in point))
+                    np.testing.assert_allclose(actual, field, rtol=1e-10, atol=1e-6)
+                    self.assertTrue(all(isinstance(c, float) for c in actual))
+
+    def test_t01_broadcast_and_mesh_inputs_match_pointwise_fields(self):
+        points = (
+            (5., np.array([1., 2.]), 1.),
+            (np.array([5., 10.])[:, None], np.array([1., 2., 3.]), -5.),
+            np.meshgrid([5., 10.], [1., 2.], [-5., 1.], indexing='ij'),
+        )
+        for coords in points:
+            broadcast = np.broadcast_arrays(*coords)
+            expected = np.array([models.t01(PARMOD, .4, *point)
+                                 for point in zip(*(c.ravel() for c in broadcast))])
+            expected = expected.T.reshape((3,) + broadcast[0].shape)
+            with self.subTest(shape=broadcast[0].shape):
+                actual = vectorized.t01(PARMOD, .4, *coords)
+                for component in actual:
+                    self.assertEqual(component.shape, broadcast[0].shape)
+                np.testing.assert_allclose(actual, expected, rtol=1e-10, atol=1e-6)
+
+
+if __name__ == '__main__':
+    unittest.main()