nrl-tracker 0.22.3__py3-none-any.whl → 0.22.4__py3-none-any.whl

pytcl/containers/rtree.py

@@ -281,7 +281,9 @@ class RTree:
 
         # Simple split: sort by center x-coordinate and split in half
         if node.is_leaf:
-            sorted_entries = sorted(entries, key=lambda e: e[0].center[0] if e[0] else 0)
+            sorted_entries = sorted(
+                entries, key=lambda e: e[0].center[0] if e[0] else 0
+            )
         else:
             sorted_entries = sorted(
                 entries,
@@ -479,7 +481,8 @@ class RTree:
             else:
                 # Sort children by distance and search closest first
                 child_dists = [
-                    (min_dist_to_box(query, c.bbox) if c.bbox else np.inf, c) for c in node.children
+                    (min_dist_to_box(query, c.bbox) if c.bbox else np.inf, c)
+                    for c in node.children
                 ]
                 child_dists.sort(key=lambda x: x[0])
                 for _, child in child_dists:

pytcl/coordinate_systems/conversions/geodetic.py

@@ -147,7 +147,9 @@ def ecef2geodetic(
         # Bowring's iterative method
         # Initial estimate
         theta = np.arctan2(z * a, p * b)
-        lat = np.arctan2(z + ep2 * b * np.sin(theta) ** 3, p - e2 * a * np.cos(theta) ** 3)
+        lat = np.arctan2(
+            z + ep2 * b * np.sin(theta) ** 3, p - e2 * a * np.cos(theta) ** 3
+        )
 
         # Iterate for improved accuracy
         for _ in range(5):
@@ -376,8 +378,18 @@ def enu2ecef(
     cos_lon = np.cos(lon_ref)
 
     # ECEF = R^T @ ENU + ECEF_ref
-    x = -sin_lon * east - sin_lat * cos_lon * north + cos_lat * cos_lon * up + ecef_ref[0]
-    y = cos_lon * east - sin_lat * sin_lon * north + cos_lat * sin_lon * up + ecef_ref[1]
+    x = (
+        -sin_lon * east
+        - sin_lat * cos_lon * north
+        + cos_lat * cos_lon * up
+        + ecef_ref[0]
+    )
+    y = (
+        cos_lon * east
+        - sin_lat * sin_lon * north
+        + cos_lat * sin_lon * up
+        + ecef_ref[1]
+    )
     z = cos_lat * north + sin_lat * up + ecef_ref[2]
 
     if x.size == 1:

pytcl/coordinate_systems/projections/projections.py

@@ -140,7 +140,9 @@ def mercator(
 
     # Northing using isometric latitude
     sin_lat = np.sin(lat)
-    y = a * np.log(np.tan(np.pi / 4 + lat / 2) * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
+    y = a * np.log(
+        np.tan(np.pi / 4 + lat / 2) * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
+    )
 
     # Scale factor
     cos_lat = np.cos(lat)
@@ -201,7 +203,9 @@ def mercator_inverse(
 
     for _ in range(max_iter):
         sin_lat = np.sin(lat)
-        lat_new = np.pi / 2 - 2 * np.arctan(t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
+        lat_new = np.pi / 2 - 2 * np.arctan(
+            t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
+        )
         if abs(lat_new - lat) < tol:
             break
         lat = lat_new
@@ -579,7 +583,9 @@ def geodetic2utm(lat: float, lon: float, zone: Optional[int] = None) -> UTMResul
         northing = result.y + 10000000.0
         hemisphere = "S"
 
-    return UTMResult(easting, northing, zone, hemisphere, result.scale, result.convergence)
+    return UTMResult(
+        easting, northing, zone, hemisphere, result.scale, result.convergence
+    )
 
 
 def utm2geodetic(
@@ -690,7 +696,8 @@ def stereographic(
         return (
             2
             * np.arctan(
-                np.tan(np.pi / 4 + phi / 2) * ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
+                np.tan(np.pi / 4 + phi / 2)
+                * ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
             )
             - np.pi / 2
         )
@@ -778,7 +785,8 @@ def stereographic_inverse(
     chi0 = (
         2
         * np.arctan(
-            np.tan(np.pi / 4 + lat0 / 2) * ((1 - e * sin_lat0) / (1 + e * sin_lat0)) ** (e / 2)
+            np.tan(np.pi / 4 + lat0 / 2)
+            * ((1 - e * sin_lat0) / (1 + e * sin_lat0)) ** (e / 2)
         )
         - np.pi / 2
     )
@@ -813,7 +821,8 @@ def stereographic_inverse(
         lat_new = (
             2
             * np.arctan(
-                np.tan(np.pi / 4 + chi / 2) * ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2)
+                np.tan(np.pi / 4 + chi / 2)
+                * ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2)
             )
             - np.pi / 2
         )
@@ -945,7 +954,9 @@ def lambert_conformal_conic(
 
     def compute_t(phi: float) -> float:
         sin_phi = np.sin(phi)
-        return np.tan(np.pi / 4 - phi / 2) / (((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2))
+        return np.tan(np.pi / 4 - phi / 2) / (
+            ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
+        )
 
     m1 = compute_m(lat1)
     m2 = compute_m(lat2)
@@ -1034,7 +1045,9 @@ def lambert_conformal_conic_inverse(
 
     def compute_t(phi: float) -> float:
         sin_phi = np.sin(phi)
-        return np.tan(np.pi / 4 - phi / 2) / (((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2))
+        return np.tan(np.pi / 4 - phi / 2) / (
+            ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
+        )
 
     m1 = compute_m(lat1)
     m2 = compute_m(lat2)
@@ -1062,7 +1075,9 @@ def lambert_conformal_conic_inverse(
     lat = np.pi / 2 - 2 * np.arctan(t)
     for _ in range(max_iter):
         sin_lat = np.sin(lat)
-        lat_new = np.pi / 2 - 2 * np.arctan(t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
+        lat_new = np.pi / 2 - 2 * np.arctan(
+            t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
+        )
         if abs(lat_new - lat) < tol:
             break
         lat = lat_new
@@ -1126,7 +1141,13 @@ def azimuthal_equidistant(
     """
     # Use spherical approximation with authalic radius
     R = a * np.sqrt(
-        (1 + (1 - e2) / (2 * np.sqrt(1 - e2)) * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))) / 2
+        (
+            1
+            + (1 - e2)
+            / (2 * np.sqrt(1 - e2))
+            * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))
+        )
+        / 2
     )
 
     sin_lat = np.sin(lat)
@@ -1196,7 +1217,13 @@ def azimuthal_equidistant_inverse(
         (latitude, longitude) in radians.
     """
     R = a * np.sqrt(
-        (1 + (1 - e2) / (2 * np.sqrt(1 - e2)) * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))) / 2
+        (
+            1
+            + (1 - e2)
+            / (2 * np.sqrt(1 - e2))
+            * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))
+        )
+        / 2
     )
 
     rho = np.sqrt(x**2 + y**2)

pytcl/coordinate_systems/rotations/rotations.py

@@ -353,7 +353,9 @@ def rotmat2axisangle(
         return axis / np.linalg.norm(axis), float(angle)
 
     # General case
-    axis = np.array([R[2, 1] - R[1, 2], R[0, 2] - R[2, 0], R[1, 0] - R[0, 1]]) / (2 * np.sin(angle))
+    axis = np.array([R[2, 1] - R[1, 2], R[0, 2] - R[2, 0], R[1, 0] - R[0, 1]]) / (
+        2 * np.sin(angle)
+    )
 
     return axis, float(angle)
 

pytcl/core/array_utils.py

@@ -374,7 +374,10 @@ def normalize_vector(
     v: ArrayLike,
     axis: int | None = None,
     return_norm: bool = False,
-) -> NDArray[np.floating[Any]] | tuple[NDArray[np.floating[Any]], NDArray[np.floating[Any]]]:
+) -> (
+    NDArray[np.floating[Any]]
+    | tuple[NDArray[np.floating[Any]], NDArray[np.floating[Any]]]
+):
     """
     Normalize vector(s) to unit length.
 

pytcl/core/constants.py

@@ -71,7 +71,9 @@ EARTH_ECCENTRICITY_SQ: Final[float] = 2 * EARTH_FLATTENING - EARTH_FLATTENING**2
 EARTH_ECCENTRICITY: Final[float] = math.sqrt(EARTH_ECCENTRICITY_SQ)
 
 #: Second eccentricity squared
-EARTH_ECCENTRICITY_PRIME_SQ: Final[float] = EARTH_ECCENTRICITY_SQ / (1 - EARTH_ECCENTRICITY_SQ)
+EARTH_ECCENTRICITY_PRIME_SQ: Final[float] = EARTH_ECCENTRICITY_SQ / (
+    1 - EARTH_ECCENTRICITY_SQ
+)
 
 #: Earth rotation rate [rad/s] (IERS Conventions 2010)
 EARTH_ROTATION_RATE: Final[float] = 7.292115e-5

pytcl/core/validation.py

@@ -108,7 +108,9 @@ def validate_array(
     if ndim is not None:
         valid_ndims = (ndim,) if isinstance(ndim, int) else ndim
         if result.ndim not in valid_ndims:
-            raise ValidationError(f"{name} must have {ndim} dimension(s), got {result.ndim}")
+            raise ValidationError(
+                f"{name} must have {ndim} dimension(s), got {result.ndim}"
+            )
 
     if min_ndim is not None and result.ndim < min_ndim:
         raise ValidationError(
@@ -123,10 +125,14 @@ def validate_array(
     # Check shape
     if shape is not None:
         if len(shape) != result.ndim:
-            raise ValidationError(f"{name} must have {len(shape)} dimensions, got {result.ndim}")
+            raise ValidationError(
+                f"{name} must have {len(shape)} dimensions, got {result.ndim}"
+            )
         for i, (expected, actual) in enumerate(zip(shape, result.shape)):
             if expected is not None and expected != actual:
-                raise ValidationError(f"{name} dimension {i} must be {expected}, got {actual}")
+                raise ValidationError(
+                    f"{name} dimension {i} must be {expected}, got {actual}"
+                )
 
     # Check finite
     if finite and not np.all(np.isfinite(result)):
@@ -253,7 +259,9 @@ def ensure_row_vector(arr: ArrayLike, name: str = "vector") -> NDArray[Any]:
         return result.reshape(1, -1)
     elif result.ndim == 2:
         if result.shape[0] != 1:
-            raise ValidationError(f"{name} must be a row vector (1, n), got shape {result.shape}")
+            raise ValidationError(
+                f"{name} must be a row vector (1, n), got shape {result.shape}"
+            )
         return result
     else:
         raise ValidationError(f"{name} must be 1D or 2D, got {result.ndim}D")
@@ -366,7 +374,8 @@ def ensure_positive_definite(
 
     if min_eigenvalue < threshold:
         raise ValidationError(
-            f"{name} must be positive definite, " f"minimum eigenvalue is {min_eigenvalue:.2e}"
+            f"{name} must be positive definite, "
+            f"minimum eigenvalue is {min_eigenvalue:.2e}"
         )
 
     return result
@@ -398,7 +407,9 @@ def validate_same_shape(*arrays: ArrayLike, names: Sequence[str] | None = None)
 
     if not all(s == shapes[0] for s in shapes):
         shape_strs = [f"{name}: {shape}" for name, shape in zip(names, shapes)]
-        raise ValidationError(f"Arrays must have the same shape. Got: {', '.join(shape_strs)}")
+        raise ValidationError(
+            f"Arrays must have the same shape. Got: {', '.join(shape_strs)}"
+        )
 
 
 def validated_array_input(

pytcl/dynamic_estimation/imm.py

@@ -469,8 +469,12 @@ def imm_predict_update(
     result : IMMUpdate
         Updated states, covariances, and mode probabilities.
     """
-    pred = imm_predict(mode_states, mode_covs, mode_probs, transition_matrix, F_list, Q_list)
-    return imm_update(pred.mode_states, pred.mode_covs, pred.mode_probs, z, H_list, R_list)
+    pred = imm_predict(
+        mode_states, mode_covs, mode_probs, transition_matrix, F_list, Q_list
+    )
+    return imm_update(
+        pred.mode_states, pred.mode_covs, pred.mode_probs, z, H_list, R_list
+    )
 
 
 class IMMEstimator:
@@ -672,7 +676,9 @@ class IMMEstimator:
             Update result.
         """
         if not self.H_list:
-            raise ValueError("Measurement model not set. Call set_measurement_model first.")
+            raise ValueError(
+                "Measurement model not set. Call set_measurement_model first."
+            )
 
         result = imm_update(
             self.mode_states,

pytcl/dynamic_estimation/kalman/square_root.py

@@ -705,7 +705,9 @@ def ud_update(
         D_upd = D.copy()
 
         for i in range(m):
-            x_upd, U_upd, D_upd = ud_update_scalar(x_upd, U_upd, D_upd, z[i], H[i, :], R[i, i])
+            x_upd, U_upd, D_upd = ud_update_scalar(
+                x_upd, U_upd, D_upd, z[i], H[i, :], R[i, i]
+            )
     else:
         # Decorrelate measurements
         S_R = np.linalg.cholesky(R)
@@ -718,7 +720,9 @@ def ud_update(
         D_upd = D.copy()
 
         for i in range(m):
-            x_upd, U_upd, D_upd = ud_update_scalar(x_upd, U_upd, D_upd, z_dec[i], H_dec[i, :], 1.0)
+            x_upd, U_upd, D_upd = ud_update_scalar(
+                x_upd, U_upd, D_upd, z_dec[i], H_dec[i, :], 1.0
+            )
 
     # Compute likelihood
     P = ud_reconstruct(U, D)

pytcl/dynamic_estimation/particle_filters/bootstrap.py

@@ -157,7 +157,9 @@ def resample_residual(
     residual = Nw - floor_Nw
 
     # Deterministic copies (JIT-compiled)
-    resampled, idx = _resample_residual_deterministic(particles.astype(np.float64), floor_Nw)
+    resampled, idx = _resample_residual_deterministic(
+        particles.astype(np.float64), floor_Nw
+    )
 
     # Multinomial resampling of residuals
     if idx < N:
@@ -269,7 +271,9 @@ def bootstrap_pf_update(
     N = len(particles)
 
     # Compute likelihoods
-    likelihoods = np.array([likelihood_func(z, particles[i]) for i in range(N)], dtype=np.float64)
+    likelihoods = np.array(
+        [likelihood_func(z, particles[i]) for i in range(N)], dtype=np.float64
+    )
 
     # Update weights
     weights_unnorm = weights * likelihoods

pytcl/dynamic_estimation/smoothers.py

@@ -646,7 +646,9 @@ def rts_smoother_single_step(
     result : SmoothedState
         Smoothed state and covariance at current time.
     """
-    x_s, P_s = kf_smooth(x_filt, P_filt, x_pred_next, P_pred_next, x_smooth_next, P_smooth_next, F)
+    x_s, P_s = kf_smooth(
+        x_filt, P_filt, x_pred_next, P_pred_next, x_smooth_next, P_smooth_next, F
+    )
     return SmoothedState(x=x_s, P=P_s)
 
 

pytcl/dynamic_models/process_noise/polynomial.py

@@ -71,7 +71,9 @@ def q_poly_kal(
 
             # Q[i,j] = q * T^(pi+pj+1) / ((pi+pj+1) * pi! * pj!)
             power = pi + pj + 1
-            Q_1d[i, j] = q * T**power / (power * math.factorial(pi) * math.factorial(pj))
+            Q_1d[i, j] = (
+                q * T**power / (power * math.factorial(pi) * math.factorial(pj))
+            )
 
     if num_dims == 1:
         return Q_1d
@@ -274,7 +276,9 @@ def q_continuous_white_noise(
     """
     # This is the same as q_discrete_white_noise but with spectral density
     # instead of variance (multiply by T for conversion in simple cases)
-    return q_discrete_white_noise(dim=dim, T=T, var=spectral_density, block_size=block_size)
+    return q_discrete_white_noise(
+        dim=dim, T=T, var=spectral_density, block_size=block_size
+    )
 
 
 __all__ = [

pytcl/gravity/clenshaw.py

@@ -407,7 +407,9 @@ def clenshaw_potential(
     V = 0.0
 
     for m in range(n_max + 1):
-        sum_C, sum_S = clenshaw_sum_order(m, cos_theta, sin_theta, C_scaled, S_scaled, n_max)
+        sum_C, sum_S = clenshaw_sum_order(
+            m, cos_theta, sin_theta, C_scaled, S_scaled, n_max
+        )
 
         cos_m_lon = np.cos(m * lon)
         sin_m_lon = np.sin(m * lon)
@@ -496,7 +498,9 @@ def clenshaw_gravity(
 
     for m in range(n_max + 1):
         # Value sum
-        sum_C, sum_S = clenshaw_sum_order(m, cos_theta, sin_theta, C_scaled, S_scaled, n_max)
+        sum_C, sum_S = clenshaw_sum_order(
+            m, cos_theta, sin_theta, C_scaled, S_scaled, n_max
+        )
 
         # Radial derivative sum
         sum_C_r, sum_S_r = clenshaw_sum_order(

pytcl/gravity/egm.py

@@ -491,7 +491,9 @@ def geoid_heights(
     # Compute for each point
     heights = np.zeros(len(lats))
     for i in range(len(lats)):
-        heights[i] = geoid_height(lats[i], lons[i], model, n_max, coefficients=coefficients)
+        heights[i] = geoid_height(
+            lats[i], lons[i], model, n_max, coefficients=coefficients
+        )
 
     return heights
 

pytcl/gravity/models.py

@@ -190,7 +190,9 @@ def normal_gravity(
     sin2_lat = np.sin(lat) ** 2
 
     # Height correction
-    gamma = gamma_0 * (1 - 2 / a * (1 + f + m - 2 * f * sin2_lat) * h + 3 / (a * a) * h * h)
+    gamma = gamma_0 * (
+        1 - 2 / a * (1 + f + m - 2 * f * sin2_lat) * h + 3 / (a * a) * h * h
+    )
 
     return gamma
 

pytcl/gravity/spherical_harmonics.py

@@ -94,7 +94,9 @@ def associated_legendre(
                 b_nm = np.sqrt(((n - 1) ** 2 - m * m) / (4 * (n - 1) ** 2 - 1))
                 P[n, m] = a_nm * (x * P[n - 1, m] - b_nm * P[n - 2, m])
             else:
-                P[n, m] = ((2 * n - 1) * x * P[n - 1, m] - (n + m - 1) * P[n - 2, m]) / (n - m)
+                P[n, m] = (
+                    (2 * n - 1) * x * P[n - 1, m] - (n + m - 1) * P[n - 2, m]
+                ) / (n - m)
 
     return P
 
@@ -155,7 +157,8 @@ def associated_legendre_derivative(
                         factor = np.sqrt((n - m) * (n + m + 1))
                         if m + 1 <= m_max and n >= m + 1:
                             dP[n, m] = (
-                                n * x / u2 * P[n, m] - factor / np.sqrt(u2) * P[n, m + 1]
+                                n * x / u2 * P[n, m]
+                                - factor / np.sqrt(u2) * P[n, m + 1]
                                 if m + 1 <= n
                                 else n * x / u2 * P[n, m]
                             )
@@ -163,7 +166,9 @@ def associated_legendre_derivative(
                             dP[n, m] = n * x / u2 * P[n, m]
                 else:
                     # Unnormalized form
-                    dP[n, m] = (n * x * P[n, m] - (n + m) * P[n - 1, m]) / u2 if n > 0 else 0
+                    dP[n, m] = (
+                        (n * x * P[n, m] - (n + m) * P[n - 1, m]) / u2 if n > 0 else 0
+                    )
 
     return dP
 
@@ -483,7 +488,8 @@ def associated_legendre_scaled(
             s_ratio_2 = scale[n] / scale[n - 2]
 
             P_scaled[n, m] = a_nm * (
-                x * P_scaled[n - 1, m] * s_ratio_1 - b_nm * P_scaled[n - 2, m] * s_ratio_2
+                x * P_scaled[n - 1, m] * s_ratio_1
+                - b_nm * P_scaled[n - 2, m] * s_ratio_2
             )
 
     return P_scaled, scale_exp

pytcl/gravity/tides.py

@@ -179,31 +179,36 @@ def fundamental_arguments(T: float) -> Tuple[float, float, float, float, float]:
     # Mean anomaly of the Moon (l)
     l_moon = (
         134.96340251
-        + (1717915923.2178 * T + 31.8792 * T**2 + 0.051635 * T**3 - 0.00024470 * T**4) / 3600.0
+        + (1717915923.2178 * T + 31.8792 * T**2 + 0.051635 * T**3 - 0.00024470 * T**4)
+        / 3600.0
     ) * deg2rad
 
     # Mean anomaly of the Sun (l')
     l_sun = (
         357.52910918
-        + (129596581.0481 * T - 0.5532 * T**2 + 0.000136 * T**3 - 0.00001149 * T**4) / 3600.0
+        + (129596581.0481 * T - 0.5532 * T**2 + 0.000136 * T**3 - 0.00001149 * T**4)
+        / 3600.0
     ) * deg2rad
 
     # Mean argument of latitude of the Moon (F)
     F = (
         93.27209062
-        + (1739527262.8478 * T - 12.7512 * T**2 - 0.001037 * T**3 + 0.00000417 * T**4) / 3600.0
+        + (1739527262.8478 * T - 12.7512 * T**2 - 0.001037 * T**3 + 0.00000417 * T**4)
+        / 3600.0
     ) * deg2rad
 
     # Mean elongation of the Moon from the Sun (D)
     D = (
         297.85019547
-        + (1602961601.2090 * T - 6.3706 * T**2 + 0.006593 * T**3 - 0.00003169 * T**4) / 3600.0
+        + (1602961601.2090 * T - 6.3706 * T**2 + 0.006593 * T**3 - 0.00003169 * T**4)
+        / 3600.0
     ) * deg2rad
 
     # Mean longitude of the ascending node of the Moon (Omega)
     Omega = (
         125.04455501
-        + (-6962890.5431 * T + 7.4722 * T**2 + 0.007702 * T**3 - 0.00005939 * T**4) / 3600.0
+        + (-6962890.5431 * T + 7.4722 * T**2 + 0.007702 * T**3 - 0.00005939 * T**4)
+        / 3600.0
     ) * deg2rad
 
     return (
@@ -274,7 +279,9 @@ def moon_position_approximate(mjd: float) -> Tuple[float, float, float]:
 
     # Distance perturbations (km)
     r_pert = (
-        -20.905355 * np.cos(M_prime) - 3.699111 * np.cos(2 * D - M_prime) - 2.955968 * np.cos(2 * D)
+        -20.905355 * np.cos(M_prime)
+        - 3.699111 * np.cos(2 * D - M_prime)
+        - 2.955968 * np.cos(2 * D)
     ) * 1000  # Convert to km
 
     # Final position
@@ -579,7 +586,9 @@ def solid_earth_tide_gravity(
     delta_g_north = 0.0
     delta_g_east = 0.0
 
-    return TidalGravity(delta_g=delta_g, delta_g_north=delta_g_north, delta_g_east=delta_g_east)
+    return TidalGravity(
+        delta_g=delta_g, delta_g_north=delta_g_north, delta_g_east=delta_g_east
+    )
 
 
 def ocean_tide_loading_displacement(

pytcl/magnetism/emm.py

@@ -531,7 +531,8 @@ def _high_res_field_spherical(
                     factor = np.sqrt((n - m) * (n + m + 1))
                     if m + 1 <= n:
                         dP[n, m] = (
-                            n * cos_theta / sin_theta * P[n, m] - factor * P[n, m + 1] / sin_theta
+                            n * cos_theta / sin_theta * P[n, m]
+                            - factor * P[n, m + 1] / sin_theta
                             if m + 1 <= n_max_eval
                             else n * cos_theta / sin_theta * P[n, m]
                         )
@@ -558,7 +559,13 @@ def _high_res_field_spherical(
             B_theta += -r_power * dP[n, m] * (gnm * cos_m_lon + hnm * sin_m_lon)
 
             if abs(sin_theta) > 1e-10:
-                B_phi += r_power * m * P[n, m] / sin_theta * (gnm * sin_m_lon - hnm * cos_m_lon)
+                B_phi += (
+                    r_power
+                    * m
+                    * P[n, m]
+                    / sin_theta
+                    * (gnm * sin_m_lon - hnm * cos_m_lon)
+                )
 
     return B_r, B_theta, B_phi
 
@@ -617,7 +624,9 @@ def emm(
     r = a + h
 
     # Compute field in spherical coordinates
-    B_r, B_theta, B_phi = _high_res_field_spherical(lat_gc, lon, r, year, coefficients, n_max)
+    B_r, B_theta, B_phi = _high_res_field_spherical(
+        lat_gc, lon, r, year, coefficients, n_max
+    )
 
     # Convert to geodetic coordinates
     X = -B_theta  # North

pytcl/magnetism/wmm.py

@@ -468,7 +468,8 @@ def magnetic_field_spherical(
                     factor = np.sqrt((n - m) * (n + m + 1))
                     if m + 1 <= n:
                         dP[n, m] = (
-                            n * cos_theta / sin_theta * P[n, m] - factor * P[n, m + 1] / sin_theta
+                            n * cos_theta / sin_theta * P[n, m]
+                            - factor * P[n, m + 1] / sin_theta
                             if m + 1 <= n_max
                             else n * cos_theta / sin_theta * P[n, m]
                         )
@@ -498,7 +499,13 @@ def magnetic_field_spherical(
             B_theta += -r_power * dP[n, m] * (gnm * cos_m_lon + hnm * sin_m_lon)
 
             if abs(sin_theta) > 1e-10:
-                B_phi += r_power * m * P[n, m] / sin_theta * (gnm * sin_m_lon - hnm * cos_m_lon)
+                B_phi += (
+                    r_power
+                    * m
+                    * P[n, m]
+                    / sin_theta
+                    * (gnm * sin_m_lon - hnm * cos_m_lon)
+                )
 
     return B_r, B_theta, B_phi
 

pytcl/mathematical_functions/basic_matrix/decompositions.py

@@ -160,7 +160,9 @@ def tria_sqrt(
     if B is not None:
         B = np.asarray(B, dtype=np.float64)
         if A.shape[0] != B.shape[0]:
-            raise ValueError(f"A and B must have same number of rows: {A.shape[0]} vs {B.shape[0]}")
+            raise ValueError(
+                f"A and B must have same number of rows: {A.shape[0]} vs {B.shape[0]}"
+            )
         combined = np.hstack([A, B])
     else:
         combined = A

pytcl/mathematical_functions/combinatorics/combinatorics.py

@@ -378,7 +378,9 @@ def partitions(n: int, k: Optional[int] = None) -> Iterator[Tuple[int, ...]]:
     [(4,), (3, 1), (2, 2), (2, 1, 1), (1, 1, 1, 1)]
     """
 
-    def gen_partitions(n: int, max_val: int, prefix: Tuple[int, ...]) -> Iterator[Tuple[int, ...]]:
+    def gen_partitions(
+        n: int, max_val: int, prefix: Tuple[int, ...]
+    ) -> Iterator[Tuple[int, ...]]:
         if n == 0:
             yield prefix
             return

pytcl/mathematical_functions/geometry/geometry.py

@@ -191,8 +191,12 @@ def polygon_centroid(vertices: ArrayLike) -> NDArray[np.floating]:
 
     # Centroid
     factor = 1.0 / (3.0 * a)
-    cx = factor * np.sum((x + np.roll(x, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y))
-    cy = factor * np.sum((y + np.roll(y, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y))
+    cx = factor * np.sum(
+        (x + np.roll(x, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y)
+    )
+    cy = factor * np.sum(
+        (y + np.roll(y, -1)) * (x * np.roll(y, -1) - np.roll(x, -1) * y)
+    )
 
     return np.array([cx, cy], dtype=np.float64)
 
@@ -547,10 +551,14 @@ def minimum_bounding_circle(
                 return circle_from_two_points(p1, p3)
 
         ux = (
-            (ax**2 + ay**2) * (by - cy) + (bx**2 + by**2) * (cy - ay) + (cx**2 + cy**2) * (ay - by)
+            (ax**2 + ay**2) * (by - cy)
+            + (bx**2 + by**2) * (cy - ay)
+            + (cx**2 + cy**2) * (ay - by)
         ) / d
         uy = (
-            (ax**2 + ay**2) * (cx - bx) + (bx**2 + by**2) * (ax - cx) + (cx**2 + cy**2) * (bx - ax)
+            (ax**2 + ay**2) * (cx - bx)
+            + (bx**2 + by**2) * (ax - cx)
+            + (cx**2 + cy**2) * (bx - ax)
         ) / d
 
         center = np.array([ux, uy])

pytcl/mathematical_functions/interpolation/interpolation.py

@@ -371,7 +371,9 @@ def rbf_interpolate(
     points = np.asarray(points, dtype=np.float64)
     values = np.asarray(values, dtype=np.float64)
 
-    return interpolate.RBFInterpolator(points, values, kernel=kernel, smoothing=smoothing)
+    return interpolate.RBFInterpolator(
+        points, values, kernel=kernel, smoothing=smoothing
+    )
 
 
 def barycentric(