nrl-tracker 1.7.0__py3-none-any.whl → 1.7.3__py3-none-any.whl

pytcl/assignment_algorithms/jpda.py

@@ -9,7 +9,7 @@ This is more sophisticated than GNN which makes hard assignment decisions,
 as JPDA can handle measurement origin uncertainty in cluttered environments.
 """
 
-from typing import List, NamedTuple, Optional, Tuple
+from typing import Any, List, NamedTuple, Optional
 
 import numpy as np
 from numba import njit
@@ -24,7 +24,7 @@ class JPDAResult(NamedTuple):
 
     Attributes
     ----------
-    association_probs : ndarray
+    association_probs : ndarray[Any]
         Association probability matrix of shape (n_tracks, n_measurements + 1).
         association_probs[i, j] is the probability that track i is associated
         with measurement j. The last column (j = n_measurements) represents
@@ -32,9 +32,9 @@ class JPDAResult(NamedTuple):
     marginal_probs : list of ndarray
         List of marginal association probabilities for each track.
         marginal_probs[i][j] = P(measurement j originated from track i).
-    likelihood_matrix : ndarray
+    likelihood_matrix : ndarray[Any]
         Measurement likelihood matrix of shape (n_tracks, n_measurements).
-    gated : ndarray
+    gated : ndarray[Any]
         Boolean matrix indicating which track-measurement pairs passed gating.
     """
 
@@ -53,7 +53,7 @@ class JPDAUpdate(NamedTuple):
         Updated state estimates for each track.
     covariances : list of ndarray
         Updated covariances for each track (includes spread of means).
-    association_probs : ndarray
+    association_probs : ndarray[Any]
         Association probability matrix.
     innovations : list of ndarray
         Combined weighted innovations for each track.
@@ -66,8 +66,8 @@ class JPDAUpdate(NamedTuple):
 
 
 def compute_measurement_likelihood(
-    innovation: NDArray,
-    innovation_cov: NDArray,
+    innovation: NDArray[Any],
+    innovation_cov: NDArray[Any],
     detection_prob: float = 1.0,
 ) -> float:
     """
@@ -75,9 +75,9 @@ def compute_measurement_likelihood(
 
     Parameters
     ----------
-    innovation : ndarray
+    innovation : ndarray[Any]
         Measurement innovation (residual), shape (m,).
-    innovation_cov : ndarray
+    innovation_cov : ndarray[Any]
         Innovation covariance, shape (m, m).
     detection_prob : float
         Probability of detection (Pd).
@@ -102,14 +102,14 @@ def compute_measurement_likelihood(
 
 
 def compute_likelihood_matrix(
-    track_states: List[NDArray],
-    track_covariances: List[NDArray],
-    measurements: NDArray,
-    H: NDArray,
-    R: NDArray,
+    track_states: list[NDArray[Any]],
+    track_covariances: list[NDArray[Any]],
+    measurements: NDArray[Any],
+    H: NDArray[Any],
+    R: NDArray[Any],
     detection_prob: float = 1.0,
     gate_threshold: Optional[float] = None,
-) -> Tuple[NDArray, NDArray]:
+) -> tuple[NDArray[Any], NDArray[Any]]:
     """
     Compute likelihood matrix for all track-measurement pairs.
 
@@ -119,11 +119,11 @@ def compute_likelihood_matrix(
         State estimates for each track.
     track_covariances : list of ndarray
         Covariances for each track.
-    measurements : ndarray
+    measurements : ndarray[Any]
         Measurements, shape (n_meas, m).
-    H : ndarray
+    H : ndarray[Any]
         Measurement matrix, shape (m, n).
-    R : ndarray
+    R : ndarray[Any]
         Measurement noise covariance, shape (m, m).
     detection_prob : float
         Probability of detection.
@@ -132,9 +132,9 @@ def compute_likelihood_matrix(
 
     Returns
     -------
-    likelihood_matrix : ndarray
+    likelihood_matrix : ndarray[Any]
         Likelihood values, shape (n_tracks, n_meas).
-    gated : ndarray
+    gated : ndarray[Any]
         Boolean gating matrix, shape (n_tracks, n_meas).
     """
     n_tracks = len(track_states)
@@ -163,11 +163,11 @@ def compute_likelihood_matrix(
 
 
 def jpda_probabilities(
-    likelihood_matrix: NDArray,
-    gated: NDArray,
+    likelihood_matrix: NDArray[Any],
+    gated: NDArray[Any],
     detection_prob: float = 1.0,
     clutter_density: float = 1e-6,
-) -> NDArray:
+) -> NDArray[Any]:
     """
     Compute JPDA association probabilities.
 
@@ -176,9 +176,9 @@ def jpda_probabilities(
 
     Parameters
     ----------
-    likelihood_matrix : ndarray
+    likelihood_matrix : ndarray[Any]
         Likelihood values, shape (n_tracks, n_meas).
-    gated : ndarray
+    gated : ndarray[Any]
         Boolean gating matrix, shape (n_tracks, n_meas).
     detection_prob : float
         Probability of detection (Pd).
@@ -187,7 +187,7 @@ def jpda_probabilities(
 
     Returns
     -------
-    beta : ndarray
+    beta : ndarray[Any]
         Association probability matrix, shape (n_tracks, n_meas + 1).
         beta[i, j] = P(measurement j is from track i) for j < n_meas.
         beta[i, n_meas] = P(track i has no measurement).
@@ -218,11 +218,11 @@ def jpda_probabilities(
 
 
 def _jpda_exact(
-    likelihood_matrix: NDArray,
-    gated: NDArray,
+    likelihood_matrix: NDArray[Any],
+    gated: NDArray[Any],
     detection_prob: float,
     clutter_density: float,
-) -> NDArray:
+) -> NDArray[Any]:
     """
     Exact JPDA computation via hypothesis enumeration.
 
@@ -241,8 +241,8 @@ def _jpda_exact(
     def generate_hypotheses(
         meas_idx: int,
         current_assignment: List[int],
-        used_tracks: set,
-    ):
+        used_tracks: set[Any],
+    ) -> Any:
         """Recursively generate valid hypotheses."""
         if meas_idx == n_meas:
             yield current_assignment.copy()
@@ -268,11 +268,11 @@ def _jpda_exact(
     hypothesis_probs = []
     hypothesis_assignments = []
 
-    for assignment in generate_hypotheses(0, [], set()):
+    for assignment in generate_hypotheses(0, [], set[Any]()):
         # Compute probability of this hypothesis
         prob = 1.0
 
-        detected_tracks = set()
+        detected_tracks = set[Any]()
         for j, track_idx in enumerate(assignment):
             if track_idx == -1:
                 # Measurement j is clutter
@@ -301,7 +301,7 @@ def _jpda_exact(
     for h_idx, (assignment, prob) in enumerate(
         zip(hypothesis_assignments, hypothesis_probs)
     ):
-        detected_tracks = set()
+        detected_tracks = set[Any]()
         for j, track_idx in enumerate(assignment):
             if track_idx >= 0:
                 beta[track_idx, j] += prob
@@ -317,11 +317,11 @@ def _jpda_exact(
 
 @njit(cache=True)
 def _jpda_approximate_core(
-    likelihood_matrix: np.ndarray,
-    gated: np.ndarray,
+    likelihood_matrix: np.ndarray[Any, Any],
+    gated: np.ndarray[Any, Any],
     detection_prob: float,
     clutter_density: float,
-) -> np.ndarray:
+) -> np.ndarray[Any, Any]:
     """JIT-compiled core of approximate JPDA computation."""
     n_tracks = likelihood_matrix.shape[0]
     n_meas = likelihood_matrix.shape[1]
@@ -369,11 +369,11 @@ def _jpda_approximate_core(
 
 
 def _jpda_approximate(
-    likelihood_matrix: NDArray,
-    gated: NDArray,
+    likelihood_matrix: NDArray[Any],
+    gated: NDArray[Any],
     detection_prob: float,
     clutter_density: float,
-) -> NDArray:
+) -> NDArray[Any]:
     """
     Approximate JPDA using parametric approach.
 

pytcl/assignment_algorithms/nd_assignment.py

@@ -212,14 +212,15 @@ def relaxation_assignment_nd(
         result_relaxed = greedy_assignment_nd(relaxed_cost)
 
         # Compute lower bound from relaxed solution
-        lower_bound = (
-            result_relaxed.cost
-            + sum(np.sum(lambdas[d]) for d in range(n_dims))
+        lower_bound = result_relaxed.cost + sum(
+            np.sum(lambdas[d]) for d in range(n_dims)
         )
 
         # Extract solution from relaxed problem
         if len(result_relaxed.assignments) > 0:
-            actual_cost = float(np.sum(cost_tensor[tuple(result_relaxed.assignments.T)]))
+            actual_cost = float(
+                np.sum(cost_tensor[tuple(result_relaxed.assignments.T)])
+            )
 
             if actual_cost < best_cost:
                 best_cost = actual_cost

pytcl/assignment_algorithms/network_flow.py

@@ -20,7 +20,7 @@ References
 """
 
 from enum import Enum
-from typing import NamedTuple, Tuple
+from typing import Any, NamedTuple, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -79,7 +79,7 @@ class FlowEdge(NamedTuple):
 
 def assignment_to_flow_network(
     cost_matrix: NDArray[np.float64],
-) -> Tuple[list, NDArray, NDArray]:
+) -> Tuple[list[FlowEdge], NDArray[np.floating], NDArray[Any]]:
     """
     Convert 2D assignment problem to min-cost flow network.
 
@@ -140,7 +140,9 @@ def assignment_to_flow_network(
     # Tasks to sink: capacity 1, cost 0
     for j in range(1, n + 1):
         task_node = m + j
-        edges.append(FlowEdge(from_node=task_node, to_node=sink, capacity=1.0, cost=0.0))
+        edges.append(
+            FlowEdge(from_node=task_node, to_node=sink, capacity=1.0, cost=0.0)
+        )
 
     # Supply/demand: source supplies m units, sink demands m units
     supplies = np.zeros(n_nodes)
@@ -158,7 +160,7 @@ def assignment_to_flow_network(
 
 
 def min_cost_flow_successive_shortest_paths(
-    edges: list,
+    edges: list[FlowEdge],
     supplies: NDArray[np.float64],
     max_iterations: int = 1000,
 ) -> MinCostFlowResult:
@@ -260,7 +262,9 @@ def min_cost_flow_successive_shortest_paths(
 
         # Find minimum capacity along path
         min_flow = min(residual_capacity[e] for e in path_edges)
-        min_flow = min(min_flow, current_supplies[excess_node], -current_supplies[deficit_node])
+        min_flow = min(
+            min_flow, current_supplies[excess_node], -current_supplies[deficit_node]
+        )
 
         # Push flow along path
         total_cost = 0.0
@@ -295,7 +299,7 @@ def min_cost_flow_successive_shortest_paths(
 
 def assignment_from_flow_solution(
     flow: NDArray[np.float64],
-    edges: list,
+    edges: list[FlowEdge],
     cost_matrix_shape: Tuple[int, int],
 ) -> Tuple[NDArray[np.intp], float]:
     """
@@ -331,7 +335,11 @@ def assignment_from_flow_solution(
     assignment = np.array(assignment, dtype=np.intp)
     cost = 0.0
     if len(assignment) > 0:
-        cost = float(np.sum(flow[edge_idx] * edges[edge_idx].cost for edge_idx in range(len(edges))))
+        cost = float(
+            np.sum(
+                flow[edge_idx] * edges[edge_idx].cost for edge_idx in range(len(edges))
+            )
+        )
 
     return assignment, cost
 
@@ -356,6 +364,8 @@ def min_cost_assignment_via_flow(
     """
     edges, supplies, _ = assignment_to_flow_network(cost_matrix)
     result = min_cost_flow_successive_shortest_paths(edges, supplies)
-    assignment, cost = assignment_from_flow_solution(result.flow, edges, cost_matrix.shape)
+    assignment, cost = assignment_from_flow_solution(
+        result.flow, edges, cost_matrix.shape
+    )
 
     return assignment, cost

pytcl/assignment_algorithms/three_dimensional/assignment.py

@@ -11,7 +11,7 @@ cost subject to the constraint that each index appears in at most one
 selected tuple.
 """
 
-from typing import List, NamedTuple, Optional, Tuple
+from typing import Any, List, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -511,7 +511,7 @@ def assign3d_auction(
     assign_i: List[Optional[Tuple[int, int]]] = [None] * n1
 
     # Reverse: which i is assigned to (j, k)
-    reverse: dict = {}
+    reverse: dict[tuple[int, int], int] = {}
 
     converged = False
 
@@ -585,7 +585,7 @@ def assign3d(
     cost_tensor: ArrayLike,
     method: str = "lagrangian",
     maximize: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> Assignment3DResult:
     """
     Solve 3D assignment problem.

pytcl/astronomical/__init__.py

@@ -77,10 +77,10 @@ from pytcl.astronomical.orbital_mechanics import (
     vis_viva,
 )
 from pytcl.astronomical.reference_frames import (
-    earth_rotation_angle,  # Time utilities; Precession; Nutation; Earth rotation; Polar motion; Full transformations; Ecliptic/equatorial
+    earth_rotation_angle,  # Time utilities; Precession; Nutation
 )
+from pytcl.astronomical.reference_frames import ecef_to_eci  # Time utilities
 from pytcl.astronomical.reference_frames import (
-    ecef_to_eci,
     eci_to_ecef,
     ecliptic_to_equatorial,
     equation_of_equinoxes,
@@ -116,7 +116,7 @@ from pytcl.astronomical.reference_frames import (
     true_obliquity,
 )
 from pytcl.astronomical.relativity import (
-    C_LIGHT,  # Physical constants; Schwarzschild metric; Time dilation; Shapiro delay; Precession; PN effects; Range corrections
+    C_LIGHT,  # Physical constants; Schwarzschild metric; Time dilation
 )
 from pytcl.astronomical.relativity import (
     G_GRAV,
@@ -130,6 +130,12 @@ from pytcl.astronomical.relativity import (
     schwarzschild_radius,
     shapiro_delay,
 )
+from pytcl.astronomical.sgp4 import (
+    SGP4Satellite,
+    SGP4State,
+    sgp4_propagate,
+    sgp4_propagate_batch,
+)
 from pytcl.astronomical.special_orbits import (
     OrbitType,
     classify_orbit,
@@ -148,12 +154,6 @@ from pytcl.astronomical.special_orbits import (
     true_anomaly_to_parabolic_anomaly,
     velocity_parabolic,
 )
-from pytcl.astronomical.sgp4 import (
-    SGP4Satellite,
-    SGP4State,
-    sgp4_propagate,
-    sgp4_propagate_batch,
-)
 from pytcl.astronomical.time_systems import (
     JD_GPS_EPOCH,  # Julian dates; Time scales; Unix time; GPS week; Sidereal time; Leap seconds; Constants
 )

pytcl/astronomical/ephemerides.py

@@ -49,9 +49,10 @@ References
 
 """
 
-from typing import Literal, Optional, Tuple
+from typing import Any, Literal, Optional, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 
 # Constants for unit conversion
 AU_PER_KM = 1.0 / 149597870.7  # 1 AU in km
@@ -152,10 +153,10 @@ class DEEphemeris:
         self.version = version
         self._jplephem = jplephem
         self._kernel: Optional[object] = None
-        self._cache: dict = {}
+        self._cache: dict[str, Any] = {}
 
     @property
-    def kernel(self):
+    def kernel(self) -> Optional[object]:
         """Lazy-load ephemeris kernel on first access.
 
         Note: This requires jplephem to be installed and the kernel file
@@ -204,7 +205,7 @@ class DEEphemeris:
 
     def sun_position(
         self, jd: float, frame: Literal["icrf", "ecliptic"] = "icrf"
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
         """Compute Sun position and velocity.
 
         Parameters
@@ -253,7 +254,7 @@ class DEEphemeris:
 
     def moon_position(
         self, jd: float, frame: Literal["icrf", "ecliptic", "earth_centered"] = "icrf"
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
         """Compute Moon position and velocity.
 
         Parameters
@@ -323,7 +324,7 @@ class DEEphemeris:
         ],
         jd: float,
         frame: Literal["icrf", "ecliptic"] = "icrf",
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> Tuple[np.ndarray[Any, Any], np.ndarray[Any, Any]]:
         """Compute planet position and velocity.
 
         Parameters
@@ -379,7 +380,7 @@ class DEEphemeris:
 
     def barycenter_position(
         self, body: str, jd: float
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
         """Compute position of any body relative to Solar System Barycenter.
 
         Parameters
@@ -424,7 +425,7 @@ def _get_default_ephemeris() -> DEEphemeris:
 
 def sun_position(
     jd: float, frame: Literal["icrf", "ecliptic"] = "icrf"
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
     """Convenience function: Compute Sun position and velocity.
 
     Parameters
@@ -451,7 +452,7 @@ def sun_position(
 
 def moon_position(
     jd: float, frame: Literal["icrf", "ecliptic", "earth_centered"] = "icrf"
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
     """Convenience function: Compute Moon position and velocity.
 
     Parameters
@@ -482,7 +483,7 @@ def planet_position(
     ],
     jd: float,
     frame: Literal["icrf", "ecliptic"] = "icrf",
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[np.ndarray[Any, Any], np.ndarray[Any, Any]]:
     """Convenience function: Compute planet position and velocity.
 
     Parameters
@@ -509,7 +510,9 @@ def planet_position(
     return _get_default_ephemeris().planet_position(planet, jd, frame=frame)
 
 
-def barycenter_position(body: str, jd: float) -> Tuple[np.ndarray, np.ndarray]:
+def barycenter_position(
+    body: str, jd: float
+) -> Tuple[NDArray[np.floating], NDArray[np.floating]]:
     """Convenience function: Position relative to Solar System Barycenter.
 
     Parameters

pytcl/astronomical/reference_frames.py

@@ -23,7 +23,7 @@ References
 
 import logging
 from functools import lru_cache
-from typing import Optional, Tuple
+from typing import Any, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -97,7 +97,9 @@ def precession_angles_iau76(T: float) -> Tuple[float, float, float]:
 
 
 @lru_cache(maxsize=_CACHE_MAXSIZE)
-def _precession_matrix_cached(jd_quantized: float) -> tuple:
+def _precession_matrix_cached(
+    jd_quantized: float,
+) -> tuple[tuple[np.ndarray[Any, Any], ...], ...]:
     """Cached precession matrix computation (internal).
 
     Returns tuple of tuples for hashability.
@@ -234,7 +236,9 @@ def mean_obliquity_iau80(jd: float) -> float:
 
 
 @lru_cache(maxsize=_CACHE_MAXSIZE)
-def _nutation_matrix_cached(jd_quantized: float) -> tuple:
+def _nutation_matrix_cached(
+    jd_quantized: float,
+) -> tuple[tuple[np.ndarray[Any, Any], ...], ...]:
     """Cached nutation matrix computation (internal).
 
     Returns tuple of tuples for hashability.
@@ -1414,7 +1418,7 @@ def clear_transformation_cache() -> None:
     _logger.debug("Transformation matrix cache cleared")
 
 
-def get_cache_info() -> dict:
+def get_cache_info() -> dict[str, Any]:
     """Get cache statistics for transformation matrices.
 
     Returns

pytcl/astronomical/relativity.py

@@ -20,6 +20,7 @@ References:
 """
 
 import numpy as np
+from numpy.typing import NDArray
 
 # Physical constants (CODATA 2018 values)
 C_LIGHT = 299792458.0  # Speed of light (m/s)
@@ -154,9 +155,9 @@ def proper_time_rate(v: float, r: float, gm: float = GM_EARTH) -> float:
 
 
 def shapiro_delay(
-    observer_pos: np.ndarray,
-    light_source_pos: np.ndarray,
-    gravitating_body_pos: np.ndarray,
+    observer_pos: NDArray[np.floating],
+    light_source_pos: NDArray[np.floating],
+    gravitating_body_pos: NDArray[np.floating],
     gm: float = GM_SUN,
 ) -> float:
     """Compute Shapiro time delay for light propagation through gravitational field.
@@ -263,8 +264,8 @@ def schwarzschild_precession_per_orbit(a: float, e: float, gm: float = GM_SUN) -
 
 
 def post_newtonian_acceleration(
-    r_vec: np.ndarray, v_vec: np.ndarray, gm: float = GM_EARTH
-) -> np.ndarray:
+    r_vec: NDArray[np.floating], v_vec: NDArray[np.floating], gm: float = GM_EARTH
+) -> NDArray[np.floating]:
     """Compute post-Newtonian acceleration corrections (1PN order).
 
     Extends Newtonian gravity with first-order post-Newtonian corrections.

pytcl/astronomical/special_orbits.py

@@ -26,10 +26,10 @@ from numpy.typing import NDArray
 class OrbitType(Enum):
     """Classification of orbit types based on eccentricity."""
 
-    CIRCULAR = 0      # e = 0
-    ELLIPTICAL = 1    # 0 < e < 1
-    PARABOLIC = 2     # e = 1 (boundary case)
-    HYPERBOLIC = 3    # e > 1
+    CIRCULAR = 0  # e = 0
+    ELLIPTICAL = 1  # 0 < e < 1
+    PARABOLIC = 2  # e = 1 (boundary case)
+    HYPERBOLIC = 3  # e > 1
 
 
 class ParabolicElements(NamedTuple):
@@ -303,9 +303,7 @@ def hyperbolic_anomaly_to_true_anomaly(H: float, e: float) -> float:
     if e <= 1:
         raise ValueError(f"Eccentricity must be > 1 for hyperbolic orbits, got {e}")
 
-    nu = 2.0 * np.arctan(
-        np.sqrt((e + 1.0) / (e - 1.0)) * np.tanh(H / 2.0)
-    )
+    nu = 2.0 * np.arctan(np.sqrt((e + 1.0) / (e - 1.0)) * np.tanh(H / 2.0))
 
     return nu
 
@@ -334,9 +332,7 @@ def true_anomaly_to_hyperbolic_anomaly(nu: float, e: float) -> float:
     if e <= 1:
         raise ValueError(f"Eccentricity must be > 1 for hyperbolic orbits, got {e}")
 
-    H = 2.0 * np.arctanh(
-        np.sqrt((e - 1.0) / (e + 1.0)) * np.tan(nu / 2.0)
-    )
+    H = 2.0 * np.arctanh(np.sqrt((e - 1.0) / (e + 1.0)) * np.tan(nu / 2.0))
 
     return H
 
@@ -501,10 +497,10 @@ def semi_major_axis_from_energy(mu: float, specific_energy: float) -> float:
 
 
 def eccentricity_vector(
-    r: NDArray,
-    v: NDArray,
+    r: NDArray[np.floating],
+    v: NDArray[np.floating],
     mu: float,
-) -> NDArray:
+) -> NDArray[np.floating]:
     """
     Compute eccentricity vector from position and velocity.
 

pytcl/atmosphere/__init__.py

@@ -24,12 +24,6 @@ from pytcl.atmosphere.ionosphere import (
     simple_iri,
 )
 from pytcl.atmosphere.models import G0  # Constants
-from pytcl.atmosphere.nrlmsise00 import (
-    F107Index,
-    NRLMSISE00,
-    NRLMSISE00Output,
-    nrlmsise00,
-)
 from pytcl.atmosphere.models import (
     GAMMA,
     P0,
@@ -43,6 +37,12 @@ from pytcl.atmosphere.models import (
     true_airspeed_from_mach,
     us_standard_atmosphere_1976,
 )
+from pytcl.atmosphere.nrlmsise00 import (
+    NRLMSISE00,
+    F107Index,
+    NRLMSISE00Output,
+    nrlmsise00,
+)
 
 __all__ = [
     # Atmosphere state and models