ubc-solar-physics 1.5.0__cp312-cp312-win_amd64.whl → 1.7.0__cp312-cp312-win_amd64.whl

physics/models/battery/kalman_filter.py

@@ -1,132 +1,188 @@
 import numpy as np
-from scipy import optimize
-from filterpy.kalman import ExtendedKalmanFilter as EKF
-from physics.models.battery.battery_config import BatteryModelConfig
+from filterpy.kalman import ExtendedKalmanFilter
+from typing import Protocol, runtime_checkable, cast, Callable
+from physics.models.battery import EquivalentCircuitModelConfig
+from numpy.typing import NDArray
 
 
-class EKF_SOC:
-    def __init__(self, battery_config: BatteryModelConfig, initial_SOC=1, initial_Uc=0):
+@runtime_checkable
+class FilteredBatteryModelConfig(Protocol):
+    """
+    A specification for a configuration object which contains the requisite data to specify
+    a `FilteredBatteryModel`.
+    """
+    @property
+    def battery_model_config(self) -> EquivalentCircuitModelConfig:
         """
-        EKF_SOC represents the Kalman filter used for predicting state of charge.
+        Configuration of the underlying `EquivalentCircuitModel`.
+        """
+        ...
+
+    @property
+    def process_noise_matrix(self) -> NDArray[float]:
+        """
+        A 2x2 matrix containing the process noise covariance matrix where [0, 0] is the SOC evolution
+        noise and [1, 1] is the polarization potential evolution noise.
+        """
+        ...
+
+    @property
+    def state_covariance_matrix(self) -> NDArray[float]:
+        """
+        A 2x2 matrix containing the state covariance matrix where [0, 0] is the SOC covariance
+        noise and [1, 1] is the polarization potential covariance.
+        """
+        ...
+
+    @property
+    def measurement_noise_vector(self) -> NDArray[float]:
+        """
+        A 1x1 vector containing the noise expected in the terminal voltage measurement.
+        """
+        ...
+
 
-        :param BatteryModelConfig battery_config: Contains the HPPC parameters of the battery model.
-        :param float initial_SOC: Initial state of charge of the battery (ranges from 0 to 1 inclusive, default is 1).
-        :param float initial_Uc: Initial polarization voltage of the battery in volts (default is 0).
+class FilteredBatteryModel:
+    """
+    `FilteredBatteryModel` is a first-order Thevenin equivalent model of a lithium-ion battery packed, wrapped
+    in a Kalman filter which uses voltage measurements with model predictions.
+    """
+    def __init__(
+            self,
+            battery_config: FilteredBatteryModelConfig,
+            initial_SOC: float = 1.0,
+            initial_Uc: float = 0.0,
+            alpha: float = 0.9
+    ):
+        """
+        :param FilteredBatteryModelConfig battery_config: Contains Kalman filter state estimation configuration and
+            underlying equivalent circuit model configuration.
+        :param float initial_SOC: Initial SOC of the battery, in the range (0, 1].
+        :param float initial_Uc: Initial polarization voltage of the battery in Volts.
         """
         # Initial state
-        self.SOC = initial_SOC
-        self.Uc = initial_Uc  # Polarization Voltage
+        assert 0.0 <= initial_SOC <= 1.1, "`initial_SOC` must be in (0, 1.1]!"
 
-        # Covariance Matrices
-        self.Q_covariance = np.eye(2) * 0.0001
-        self.R_covariance = np.eye(1) * 0.5  # currently not really trusting the predicted state
+        self._SOC = initial_SOC     # State of Charge
+        self._Uc = initial_Uc       # Polarization Voltage
 
         # Load Config data
-        self.R_P = battery_config.R_P
-        self.C_P = battery_config.C_P
-        self.Q_total = battery_config.Q_total
-        SOC_data = battery_config.SOC_data
-        Uoc_data = battery_config.Uoc_data
-        R_0_data = battery_config.R_0_data
-
-        def quintic_polynomial(x, x0, x1, x2, x3, x4):
-            return np.polyval([x0, x1, x2, x3, x4], x)
-
-        U_oc_coefficients, _ = optimize.curve_fit(quintic_polynomial, SOC_data, Uoc_data)
-        R_0_coefficients, _ = optimize.curve_fit(quintic_polynomial, SOC_data, R_0_data)
-        self.U_oc = lambda soc: np.polyval(U_oc_coefficients, soc)  # Open-circuit voltage as a function of SOC
-        self.R_0 = lambda soc: np.polyval(R_0_coefficients, soc)  # Resistance as a function of SOC
-        self.Uoc_derivative = lambda soc: np.polyval(np.polyder(U_oc_coefficients), soc)  # Derivative of Uoc wrt SOC
-
-        self.tau = self.R_P / self.C_P
-
-        # initializing the ekf object
-        self.ekf = EKF(dim_x=2, dim_z=1)
-        self.ekf.x = np.array([self.SOC, self.Uc])
-        self.ekf.P = np.diag([1e-6, 1e-6])  # I'm keeping low uncertainty in initial SOC and Uc
-        self.ekf.Q = self.Q_covariance
-        self.ekf.R = self.R_covariance
-
-        # For logs
-        self.predicted_measurement = 0
-    
-    def get_SOC(self): 
+        self._Q_total = battery_config.battery_model_config.Q_total
+
+        # These `cast` calls just promise to the type-checker that these will map floats to floats
+        self._U_oc = cast(Callable[[float], float], battery_config.battery_model_config.get_Uoc)
+        self._R_0 = cast(Callable[[float], float], battery_config.battery_model_config.get_R_0)
+        self._R_P = cast(Callable[[float], float], battery_config.battery_model_config.get_R_P)
+        self._C_P = cast(Callable[[float], float], battery_config.battery_model_config.get_C_P)
+
+        self._tau: Callable[[float], float] = lambda soc: self._R_P(soc) * self._C_P(soc)  # Characteristic Time in s
+
+        def central_difference_derivative(func, value, h=1e-6):
+            """
+            Compute the derivative of an arbitrary function `func` at `SOC` using central difference.
+
+            :param func: The function to differentiate.
+            :param value: The point at which to compute the derivative.
+            :param h: Step size for the finite difference.
+            :return: The derivative of the function at `SOC`.
+            """
+            return (func(value + h) - func(value - h)) / (2 * h)
+
+        self._dUoc_dSOC = lambda soc: central_difference_derivative(self._U_oc, np.minimum(1.0, soc))  # dUOC wrt to SOC
+        self._dR0_dSOC = lambda soc: central_difference_derivative(self._R_0, np.minimum(1.0, soc))    # dR0 wrt to SOC
+
+        # Initializing the EKF object
+        self._ekf = ExtendedKalmanFilter(dim_x=2, dim_z=1)
+
+        # State Vector
+        self._ekf.x = np.array([
+            self._SOC,
+            self._Uc]
+        )
+
+        self._ekf.P = battery_config.state_covariance_matrix
+        self._ekf.Q = battery_config.process_noise_matrix
+        self._ekf.R = battery_config.measurement_noise_vector
+
+        assert 0 <= alpha <= 1, "`alpha` should be between 0 and 1!"
+        self._alpha = alpha
+
+        self._filtered_I = 0
+        self._predicted_measurement = 0
+
+    @property
+    def SOC(self) -> float:
         """
-        Return the current state of charge of the battery.
+        Return the current SOC of the battery.
 
         :return: The current state of charge.
-        :rtype: float
         """
-        return self.SOC
+        return self._SOC
 
-    def get_Uc(self):
+    @property
+    def Uc(self) -> float:
         """
         Return the polarization voltage of the battery.
 
         :return: The current polarization voltage.
-        :rtype: float
         """
-        return self.Uc
+        return self._Uc
 
-    def get_predicted_Ut(self):
+    @property
+    def Ut(self) -> float:
         """
         Return the predicted terminal voltage for the last prediction step.
 
         :return: The predicted terminal voltage.
-        :rtype: float
         """
-        return self.predicted_measurement
-        
-    def update_filter(self, measured_Ut, I):
+        return self._predicted_measurement
+
+    def update_filter(self, measured_Ut, current):
         """
         Update the filter based on a new measurement and the predicted state.
         This function should be called after `predict_state` in a typical predict-update workflow.
 
         :param float measured_Ut: The actual voltage across the terminals of the battery.
-        :param float I: The current being sourced by the battery.
+        :param float current: The current being sourced by the battery.
         """
-        check_Terminal_V(measured_Ut)
-
-        h_jacobian = self._measurement_jacobian
-        Hx = self._measurement_function
+        # Simple low-pass filter to current
+        self._filtered_I = self._alpha * self._filtered_I + (1 - self._alpha) * current
 
-        self.ekf.update(z=measured_Ut, HJacobian=h_jacobian, Hx=Hx, hx_args=I)
+        self._ekf.update(z=measured_Ut, HJacobian=self._measurement_jacobian, Hx=self._measurement_function)
 
-        self.SOC, self.Uc = self.ekf.x
+        self._SOC, self._Uc = self._ekf.x
+        self._SOC = np.clip(self._SOC, 0.0, 1.1)
 
-    def predict_state(self, I, time_step):
+    def predict_state(self, current, time_step):
         """
         Predict the next evolution of the state vector (SOC, Uc).
         This function should be called before updating the filter in a typical predict-update workflow.
 
-        :param float I: The current being sourced by the battery. Positive indicates current being drawn.
+        :param float current: The current being sourced by the battery.
+            Sign convention is that positive indicates current being drawn.
         :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
-        """       
-        check_current(I)
+        """
         # Control matrix B (for input current I_k)
-        self.ekf.B = np.array([-time_step / self.Q_total, self.R_P * (1 - np.exp(-time_step / self.tau))])
-        self.ekf.F = self._state_jacobian(time_step)
+        self._ekf.B = np.array([
+            -time_step / self._Q_total,
+            self._R_P(self._SOC) * (1 - np.exp(-time_step / (self._tau(self._SOC)))),
+        ])
+        self._ekf.F = self._state_jacobian(time_step)
 
-        self.ekf.predict(u=I)
-        print(f'ekf prediction: {self.ekf.x_prior}')
+        self._ekf.predict(u=current)
+        self._SOC, self._Uc = self._ekf.x
 
-    def predict_then_update(self, measured_Ut, I, time_step):
+    def predict_then_update(self, measured_Ut: float, current: float, time_step: float):
         """
         Predict the next evolution of the state vector (SOC, Uc), then update the filter
         based on this prediction and a measurement. Abstracts the full predict-update workflow of the EKF.
 
         :param float measured_Ut: The actual voltage across the terminals of the battery.
-        :param float I: The current being sourced by the battery. Positive indicates current being drawn.
+        :param float current: The current being sourced by the battery. Positive indicates current being drawn.
         :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
         """
-        check_current(I)
-        check_Terminal_V(measured_Ut)
-
-        self.predict_state(I, time_step)
-        print(f'predicted: {self.ekf.x_prior}')
-
-        self.update_filter(measured_Ut, I)
-        print(f'SOC: {self.ekf.x[0]}, Uc: {self.ekf.x[1]}')
+        self.predict_state(current, time_step)
+        self.update_filter(measured_Ut, current)
 
     def _state_jacobian(self, time_step):
         """
@@ -136,7 +192,7 @@ class EKF_SOC:
         :return: The state Jacobian matrix.
         :rtype: np.ndarray
         """
-        return np.array([[1, 0], [0, np.exp(-time_step / self.tau)]])
+        return np.array([[1, 0], [0, np.exp(-time_step / self._tau(self._SOC))]])
 
     def _measurement_jacobian(self, x):
         """
@@ -147,195 +203,21 @@ class EKF_SOC:
         :rtype: np.ndarray
         """
         SOC = x[0]
-        derivative = self.Uoc_derivative(SOC)
-        return np.array([[derivative, -1]])
+        dUoc_dSOC = self._dUoc_dSOC(SOC)
+        dR0_dSOC = self._dR0_dSOC(SOC)
+
+        return np.array([[dUoc_dSOC - dR0_dSOC * self._filtered_I, -1]])
 
-    def _measurement_function(self, x, I):
+    def _measurement_function(self, x) -> float:
         """
         Return the measurement function relating terminal voltage to SOC and polarization voltage.
 
         :param list[float, float] x: The state vector [SOC, Uc].
-        :param float I: The current being sourced by the battery.
         :return: The predicted terminal voltage.
-        :rtype: float
         """
         SOC, Uc = x
-        R_0 = self.R_0(SOC)
-        Uoc = self.U_oc(SOC)
-        self.predicted_measurement = Uoc - Uc - R_0 * I
-        return self.predicted_measurement
-
-
-def check_current(I):
-    if not isinstance(I, (float, int)):
-        raise TypeError(f"Invalid type for current I: {type(I)}. Expected float or int.")
-    if not (-45.0 <= I <= 45.0):
-        raise ValueError(f"Invalid value for current (I): {I}. Must be between -45.0A and 45.0A.")
-
-
-def check_Terminal_V(Ut):
-    if not isinstance(Ut, (float, int)):
-        raise TypeError(f"Invalid type for measured_Ut: {type(Ut)}. Expected float or int.")
-    if not (0.0 <= Ut <= 5.0):
-        raise ValueError(f"Invalid value for terminal voltage (measured_Ut): {Ut}. Must be between 0.0 and 5.0 volts.")
-
-import numpy as np
-from filterpy.kalman import ExtendedKalmanFilter as EKF
-from physics.models.battery.battery_config import BatteryModelConfig
-import numpy as np
-
-class EKF_SOC():
-    def __init__(self, battery_config: BatteryModelConfig,  initial_SOC = 1, initial_Uc = 0):
-        """
-        EKF_SOC represents the kalman filter used for predicting state of charge.
-
-        Attributes:
-            battery_model_config (BatteryModelConfig): This contains the HPPC parameters of the battery model
-            initial_SOC (float/int): Ranges from 0 to 1 inclusive. The initial state of charge of the battery.
-            initial_Uc (float/int):  The initial polarization volatge of the battery. (V)
-        """
-        # Inital state
-        self.SOC = initial_SOC
-        self.Uc = initial_Uc  # Polarization Volatge
-
-        # Covariance Matrices
-        self.Q_covariance = np.eye(2) * 0.0001
-        self.R_covariance = np.eye(1) * 0.5     # currently not really trusting the predicted state
-
-        # Load Config data
-        self.R_P = battery_config.R_P
-        self.C_P = battery_config.C_P
-        self.Q_total = battery_config.Q_total
-        SOC_data = np.array(battery_config.SOC_data)
-        Uoc_data = np.array(battery_config.Uoc_data)
-        R_0_data = np.array(battery_config.R_0_data)
-
-        # polynomial interpolation
-        self.Uoc_coefficients = np.polyfit(SOC_data, Uoc_data, 7)
-        self.R_0_coefficients = np.polyfit(SOC_data, R_0_data, 7)
-        self.Uoc_derivative_coefficients = np.polyder(self.Uoc_coefficients)
-
-        self.tau = self.R_P / self.C_P
-
-        # initializing the ekf object
-        self.ekf = EKF(dim_x=2, dim_z=1)
-        self.ekf.x = np.array([self.SOC, self.Uc])
-        self.ekf.P = np.diag([1e-6, 1e-6])  # I'm keeping low uncertainty in initial SOC and Uc
-        self.ekf.Q = self.Q_covariance
-        self.ekf.R = self.R_covariance
-
-        # For logs
-        self.predicted_measurment = 0
-    
-    def get_SOC(self): 
-        """ Return the state of charge of the battery """
-        return self.SOC
-    
-    def get_Uc(self):
-        """ Return the polarization voltage of the battery """
-        return self.Uc
-    
-    def get_predicted_Ut(self):
-        """ Return the predicted terminal voltage for the last prediction step """
-        return self.predicted_measurment
-        
-    def update_filter(self, measured_Ut, I):
-        """
-        Update the filter based on a new measurment, and the predicted state.
-        This function should be called after predict_state in a typical predict update workflow.
+        Uoc = self._U_oc(SOC)
+        R0 = self._R_0(SOC)
+        self._predicted_measurement = Uoc - Uc - R0 * self._filtered_I
 
-        Attributes:
-            measured_Ut (float/integer): The actual voltage across the terminals of the battery.
-            I (float/integer): The current being sourced by the battery
-        """
-        check_Terminal_V(measured_Ut)
-
-        h_jacobian = self._measurement_jacobian
-        Hx = self._measurement_function
-
-        self.ekf.update(z=measured_Ut, HJacobian=h_jacobian, Hx=Hx, hx_args=I)
-
-        self.SOC, self.Uc = self.ekf.x
-
-    def predict_state(self, I, time_step):
-        """
-        Predicts the next evolution of the state vector (SOC, Uc).
-        This function should be called before updating the filter in a typical predict update workflow.
-
-        Attributes:
-            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
-            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
-        """        
-        check_current(I)
-        # Control matrix B (for input current I_k)
-        self.ekf.B = np.array([-time_step / self.Q_total, self.R_P * (1 - np.exp(-time_step / self.tau))])
-        self.ekf.F = self._state_jacobian(time_step)
-        
-        self.ekf.predict(u=I)
-        print(f'ekf prediction: {self.ekf.x_prior}')
-
-    def predict_then_update(self, measured_Ut, I, time_step):
-        """
-        Predicts the next evolution of the state vector (SOC, Uc), then updates the filter
-        based on this prediction and a measurement.
-        This function abstracts the full predict update workflow of the EKF. 
-
-        Attributes:
-            measured_Ut (float/integer): The actual voltage across the terminals of the battery.
-            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
-            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
-        """  
-        check_current(I)
-        check_Terminal_V(measured_Ut)
-
-        self.predict_state(I, time_step)
-        print(f'predicted: {self.ekf.x_prior}')
-
-        self.update_filter(measured_Ut, I)
-        print(f'SOC: {self.ekf.x[0]}, Uc: {self.ekf.x[1]}')
-
-    def _state_jacobian(self, time_step):
-        """ 
-        Returns the state jacobian for the current time 
-
-        Attributes:
-            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
-        """
-        return np.array([[1, 0], [0, np.exp(-time_step / self.tau)]])
-
-    def _measurement_jacobian(self, x):
-        """ 
-        Returns the measurement jacobian for the current time 
-
-        Attributes:
-            x [float, float]: The state vector [SOC, Uc], where both values are floats or integers.
-        """
-        SOC = x[0]
-        derivative = np.polyval(self.Uoc_derivative_coefficients, SOC)
-        return np.array([[derivative, -1]])
-
-    def _measurement_function(self, x, I):
-        """
-        The customized measurement equation relating Ut to SOC and Uc
-
-        Attributes:
-            x [float, float]: The state vector [SOC, Uc], where both values are floats or integers.
-            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
-        """
-        SOC, Uc = x
-        R_0 = np.polyval(self.R_0_coefficients, SOC)
-        Uoc = np.polyval(self.Uoc_coefficients, SOC)
-        self.predicted_measurment = Uoc - Uc - R_0*I
-        return self.predicted_measurment
-
-def check_current(I):
-    if not isinstance(I, (float, int)):
-        raise TypeError(f"Invalid type for current I: {type(I)}. Expected float or int.")
-    if not (-45.0 <= I <= 45.0):
-        raise ValueError(f"Invalid value for current (I): {I}. Must be between -45.0A and 45.0A.")
-
-def check_Terminal_V(Ut):
-    if not isinstance(Ut, (float, int)):
-        raise TypeError(f"Invalid type for measured_Ut: {type(Ut)}. Expected float or int.")
-    if not (0.0 <= Ut <= 5.0):
-        raise ValueError(f"Invalid value for terminal voltage (measured_Ut): {Ut}. Must be between 0.0 and 5.0 volts.")
+        return self._predicted_measurement

physics_rs/__init__.pyi

@@ -0,0 +1,111 @@
+import numpy as np
+
+
+def constrain_speeds(speed_limits: np.ndarray, speeds: np.ndarray, tick: int) -> np.ndarray:
+    """
+    Constrains the vehicle speeds based on the speed limits and computes new speeds.
+
+    :param speed_limits: Array of speed limits (km/h) for each point.
+    :param speeds: Array of vehicle speeds (km/h).
+    :param tick: The time step (in some unit, e.g., seconds or ticks).
+
+    :return: A NumPy array of constrained vehicle speeds (km/h).
+    """
+    ...
+
+
+def calculate_array_ghi_times(python_local_times: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Calculates the array of GHI times based on local times.
+
+    :param python_local_times: Array of local times (UNIX timestamps or other format).
+
+    :return: A tuple of two NumPy arrays:
+        - Day of year (f64)
+        - Local time (f64)
+    """
+    ...
+
+
+def closest_gis_indices_loop(python_cumulative_distances: np.ndarray,
+                             python_average_distances: np.ndarray) -> np.ndarray:
+    """
+    Finds the closest GIS indices based on cumulative and average distances.
+
+    :param python_cumulative_distances: Array of cumulative distances.
+    :param python_average_distances: Array of average distances.
+
+    :return: A NumPy array of indices (i64) corresponding to the closest GIS indices.
+    """
+    ...
+
+
+def closest_weather_indices_loop(
+        python_cumulative_distances: np.ndarray,
+        python_average_distances: np.ndarray
+) -> np.ndarray:
+    """
+    Finds the closest weather indices based on cumulative and average distances.
+
+    :param python_cumulative_distances: Array of cumulative distances.
+    :param python_average_distances: Array of average distances.
+
+    :return: A NumPy array of indices (i64) corresponding to the closest weather indices.
+    """
+    ...
+
+
+def weather_in_time(
+        python_unix_timestamps: np.ndarray,
+        python_indices: np.ndarray,
+        python_weather_forecast: np.ndarray,
+        index: int
+) -> np.ndarray:
+    """
+    Retrieves the weather forecast at specific times for given indices.
+
+    :param python_unix_timestamps: Array of UNIX timestamps.
+    :param python_indices: Array of indices to look up.
+    :param python_weather_forecast: Array of weather forecasts.
+    :param index: A specific index to look up in the weather forecast.
+
+    :return: A NumPy array of weather values (f64) at the specified times and indices.
+    """
+    ...
+
+
+def update_battery_state(
+        python_energy_or_current_array: np.ndarray,
+        time_step: float,
+        initial_state_of_charge: float,
+        initial_polarization_potential: float,
+        python_internal_resistance_lookup: np.ndarray,
+        python_open_circuit_voltage_lookup: np.ndarray,
+        python_polarization_resistance_lookup: np.ndarray,
+        python_polarization_capacitance_lookup: np.ndarray,
+        nominal_charge_capacity: float,
+        is_power: bool,
+        quantization_step: float,
+        min_soc: float
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Updates the battery state (SOC and terminal voltage) based on energy/current input.
+
+    :param python_energy_or_current_array: Array of energy or current input values (f64).
+    :param time_step: Time step (f64).
+    :param initial_state_of_charge: Initial state of charge (f64).
+    :param initial_polarization_potential: Initial polarization potential (f64).
+    :param python_internal_resistance_lookup: Array of internal resistance values (f64).
+    :param python_open_circuit_voltage_lookup: Array of open-circuit voltage values (f64).
+    :param python_polarization_resistance_lookup: Array of polarization resistance values (f64).
+    :param python_polarization_capacitance_lookup: Array of polarization capacitance values (f64).
+    :param nominal_charge_capacity: Nominal charge capacity (f64).
+    :param is_power: Boolean flag to indicate if the input is power (`True`) or current (`False`).
+    :param quantization_step: The step size used to quantize the SOC (f64).
+    :param min_soc: The minimum SOC used when computing the lookup tables
+
+    :return: A tuple containing:
+        - An array of updated SOC values (f64).
+        - An array of updated terminal voltage values (f64).
+    """
+    ...

{ubc_solar_physics-1.5.0.dist-info → ubc_solar_physics-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.5.0
+Version: 1.7.0
 Summary: UBC Solar's Simulation Environment
 Author: Fisher Xue, Mihir Nimgade, Chris Chang, David Widjaja, Justin Hua, Ilya Veksler, Renu Rajamagesh, Ritchie Xia, Erik Langille, Chris Aung, Nicolas Ric, Ishaan Trivedi, Jason Liang, Felix Toft, Mack Wilson, Jonah Lee, Tamzeed Quazi, Joshua Riefman
 Author-email: UBC Solar <strategy@ubcsolar.com>
@@ -73,6 +73,7 @@ Requires-Dist: pandas
 Requires-Dist: pydantic ==2.9.2
 Requires-Dist: scipy
 Requires-Dist: tomli
+Requires-Dist: scipy-stubs
 
 # UBC Solar Physics