ubc-solar-physics 1.0.5__cp39-cp39-win_amd64.whl → 1.2.0__cp39-cp39-win_amd64.whl

physics/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.5'
-__version_tuple__ = version_tuple = (1, 0, 5)
+__version__ = version = '1.2.0'
+__version_tuple__ = version_tuple = (1, 2, 0)

physics/environment/__init__.py

@@ -1,8 +1,3 @@
-from .race import (
-    Race,
-    compile_races
-)
-
 from .gis import (
     GIS,
 )
@@ -17,6 +12,4 @@ __all__ = [
     "IrradiantMeteorology",
     "CloudedMeteorology",
     "GIS",
-    "Race",
-    "compile_races"
 ]

physics/environment/meteorology/clouded_meteorology.py

@@ -1,7 +1,6 @@
 from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
-from physics.environment.race import Race
 from numba import jit
 import core
 from typing import Optional
@@ -28,7 +27,7 @@ class CloudedMeteorology(BaseMeteorology):
 
         self.last_updated_time = self._weather_forecast[0, 0, 2]
 
-    def spatially_localize(self, cumulative_distances: np.ndarray) -> None:
+    def spatially_localize(self, cumulative_distances: np.ndarray, simplify_weather: bool = False) -> None:
         """
 
         IMPORTANT: we only have weather coordinates for a discrete set of coordinates. However, the car could be at any
@@ -46,14 +45,14 @@ class CloudedMeteorology(BaseMeteorology):
         `get_weather_forecast_in_time()` method.
 
         :param np.ndarray cumulative_distances: NumPy Array representing cumulative distances theoretically achievable for a given input speed array
-
+        :param bool simplify_weather: enable to only use a single weather coordinate (for track races without varying weather)
         """
 
-        # if racing FSGP, there is no need for distance calculations. We will return only the origin coordinate
+        # If racing a track race, there is no need for distance calculations. We will return only the origin coordinate
         # This characterizes the weather at every point along the FSGP tracks
         # with the weather at a single coordinate on the track, which is great for reducing the API calls and is a
         # reasonable assumption to make for FSGP only.
-        if self._race.race_type == Race.FSGP:
+        if simplify_weather:
             self._weather_indices = np.zeros_like(cumulative_distances, dtype=int)
             return
 

physics/environment/meteorology/irradiant_meteorology.py

@@ -1,7 +1,6 @@
 from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
-from physics.environment.race import Race
 import core
 from typing import Optional
 
@@ -25,16 +24,18 @@ class IrradiantMeteorology(BaseMeteorology):
 
         super().__init__()
 
-    def spatially_localize(self, cumulative_distances: np.ndarray) -> None:
+    def spatially_localize(self, cumulative_distances: np.ndarray, simplify_weather: bool = False) -> None:
         """
 
         :param np.ndarray cumulative_distances: NumPy Array representing cumulative distances theoretically achievable for a given input speed array
+        :param bool simplify_weather: enable to only use a single weather coordinate (for track races without varying weather)
+
         """
-        # if racing FSGP, there is no need for distance calculations. We will return only the origin coordinate
+        # If racing a track race, there is no need for distance calculations. We will return only the origin coordinate
         # This characterizes the weather at every point along the FSGP tracks
         # with the weather at a single coordinate on the track, which is great for reducing the API calls and is a
         # reasonable assumption to make for FSGP only.
-        if self._race.race_type == Race.FSGP:
+        if simplify_weather:
             self._weather_indices = np.zeros_like(cumulative_distances, dtype=int)
             return
 

physics/lib.rs

@@ -8,6 +8,7 @@ pub mod environment;
 pub mod models;
 use crate::environment::gis::gis::rust_closest_gis_indices_loop;
 use crate::environment::meteorology::meteorology::{rust_calculate_array_ghi_times, rust_closest_weather_indices_loop, rust_weather_in_time, rust_closest_timestamp_indices};
+use crate::models::battery::battery::update_battery_array;
 
 fn constrain_speeds(speed_limits: ArrayViewD<f64>,  speeds: ArrayViewD<f64>, tick: i32) -> Vec<f64> {
     let mut distance: f64 = 0.0;
@@ -94,5 +95,38 @@ fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
         py_result
     }
 
+    #[pyfn(m)]
+    #[pyo3(name = "update_battery_array")]
+    fn update_battery_array_py<'py>(
+        py: Python<'py>,
+        python_delta_energy_array: PyReadwriteArrayDyn<'py, f64>,
+        time_step: f64,
+        initial_state_of_charge: f64,
+        initial_polarization_potential: f64,
+        polarization_resistance: f64,
+        python_internal_resistance_coeffs: PyReadwriteArrayDyn<'py, f64>,
+        python_open_circuit_voltage_coeffs: PyReadwriteArrayDyn<'py, f64>,
+        time_constant: f64,
+        nominal_charge_capacity: f64,
+    ) -> (&'py PyArrayDyn<f64>, &'py PyArrayDyn<f64>) {
+        let delta_energy_array = python_delta_energy_array.as_array();
+        let internal_resistance_coeffs = python_internal_resistance_coeffs.as_array();
+        let open_circuit_voltage_coeffs = python_open_circuit_voltage_coeffs.as_array();
+        let (soc_array, voltage_array): (Vec<f64>, Vec<f64>) = update_battery_array(
+            delta_energy_array,
+            time_step,
+            initial_state_of_charge,
+            initial_polarization_potential,
+            polarization_resistance,
+            internal_resistance_coeffs,
+            open_circuit_voltage_coeffs,
+            time_constant,
+            nominal_charge_capacity,
+        );
+        let py_soc_array = PyArray::from_vec(py, soc_array).to_dyn();
+        let py_voltage_array = PyArray::from_vec(py, voltage_array).to_dyn();
+        (py_soc_array, py_voltage_array)
+    }
+
     Ok(())
 }

physics/models/battery/__init__.py

@@ -1,7 +1,14 @@
 from .base_battery import BaseBattery
 from .basic_battery import BasicBattery
+from .battery_model import BatteryModel
+from .kalman_filter import EKF_SOC
+from .battery_config import BatteryModelConfig, load_battery_config
 
 __all__ = [
     "BaseBattery",
-    "BasicBattery"
+    "BasicBattery",
+    "BatteryModel",
+    "EKF_SOC",
+    "BatteryModelConfig",
+    "load_battery_config"
 ]

physics/models/battery/basic_battery.py

@@ -1,6 +1,5 @@
 import numpy as np
 from numpy.polynomial import Polynomial
-
 from physics.models.battery.base_battery import BaseBattery
 
 

physics/models/battery/battery.rs

@@ -0,0 +1,78 @@
+use std::f64;
+use numpy::ndarray::ArrayViewD;
+
+/// Evaluate a polynomial given coefficients and an input value (x)
+fn evaluate_polynomial(coefficients: &[f64], x: f64) -> f64 {
+    coefficients.iter().fold(0.0, |acc, &coeff| acc * x + coeff)
+}
+
+/// Evolve the battery state for a single step
+fn battery_evolve(
+    power: f64,                    // Watts
+    tick: f64,                     // Seconds
+    state_of_charge: f64,          // Dimensionless, 0 < SOC < 1
+    polarization_potential: f64,   // Volts
+    polarization_resistance: f64,  // Ohms
+    internal_resistance: f64,      // Ohms
+    open_circuit_voltage: f64,     // Volts
+    time_constant: f64,            // Seconds
+    nominal_charge_capacity: f64,  // Nominal charge capacity (Coulombs)
+) -> (f64, f64, f64) {
+    // Compute current (I) based on power input/output
+    let current: f64 = power / (open_circuit_voltage + polarization_potential + internal_resistance);
+
+    // Update state of charge and polarization potential
+    let new_state_of_charge: f64 = state_of_charge + (current * tick / nominal_charge_capacity);
+    let new_polarization_potential: f64 = f64::exp(-tick / time_constant) * polarization_potential
+        + current * polarization_resistance * (1.0 - f64::exp(-tick / time_constant));
+    let terminal_voltage: f64 = open_circuit_voltage + new_polarization_potential
+        + (current * internal_resistance); // Terminal voltage
+
+    (new_state_of_charge, new_polarization_potential, terminal_voltage)
+}
+
+pub fn update_battery_array(
+    delta_energy_array: ArrayViewD<'_, f64>,            // W*s
+    tick: f64,                                          // Seconds
+    initial_state_of_charge: f64,                       // dimensionless, 0 < SOC < 1
+    initial_polarization_potential: f64,                // Volts
+    polarization_resistance: f64,                       // Ohms
+    internal_resistance_coeffs: ArrayViewD<'_, f64>,    // Coefficients for internal resistance
+    open_circuit_voltage_coeffs: ArrayViewD<'_, f64>,   // Coefficients for open-circuit voltage
+    time_constant: f64,                                 // Seconds 
+    nominal_charge_capacity: f64,                       // Coulombs
+) -> (Vec<f64>, Vec<f64>) {
+    let mut state_of_charge: f64 = initial_state_of_charge; 
+    let mut polarization_potential: f64 = initial_polarization_potential;
+    let mut soc_array: Vec<f64> = Vec::with_capacity(delta_energy_array.len());
+    let mut voltage_array: Vec<f64> = Vec::with_capacity(delta_energy_array.len());
+
+    for &power in delta_energy_array.iter() {
+        // Interpolate values from coefficient
+        let open_circuit_voltage: f64 = evaluate_polynomial(open_circuit_voltage_coeffs.as_slice().unwrap(), state_of_charge);
+        let internal_resistance: f64 = evaluate_polynomial(internal_resistance_coeffs.as_slice().unwrap(), state_of_charge);
+
+        let (new_state_of_charge, new_polarization_potential, terminal_voltage) = battery_evolve(
+            power,
+            tick,
+            state_of_charge,
+            polarization_potential,
+            polarization_resistance,
+            internal_resistance,
+            open_circuit_voltage,
+            time_constant,
+            nominal_charge_capacity,
+        );
+
+        // Update state for the next iteration
+        state_of_charge = new_state_of_charge;
+        polarization_potential = new_polarization_potential;
+
+        // Store results
+        soc_array.push(new_state_of_charge);
+        voltage_array.push(terminal_voltage);
+    }
+
+    (soc_array, voltage_array)
+}
+

physics/models/battery/battery_config.py

@@ -0,0 +1,22 @@
+import tomli
+from pydantic import BaseModel
+from typing import List
+import os
+import pathlib
+
+class BatteryModelConfig(BaseModel):
+    R_0_data: List[float]
+    R_P: float
+    C_P: float
+    Q_total: float
+    SOC_data: List[float]
+    Uoc_data: List[float]
+    max_current_capacity: float
+    max_energy_capacity: float
+
+def load_battery_config(absolute_path: str) -> BatteryModelConfig:
+    # Build the full path to the config file
+    full_path = pathlib.Path(absolute_path)
+    with open(full_path, 'rb') as f:
+        data = tomli.load(f)
+    return BatteryModelConfig.model_validate(data)

physics/models/battery/battery_model.py

@@ -0,0 +1,135 @@
+import numpy as np
+import core
+from scipy import optimize
+from physics.models.battery.battery_config import BatteryModelConfig
+
+
+class BatteryModel:
+    """
+    Class representing the Thevenin equivalent battery model with modular parameters.
+
+    Attributes:
+        R_P (float): Polarization resistance of the battery (Ohms).
+        C_P (float): Polarization capacitance of the battery (Farads).
+        max_current_capacity (float): Nominal capacity of the battery (Ah).
+        max_energy_capacity (float): Maximum energy capacity of the battery (Wh).
+        nominal_charge_capacity (float): Total charge capacity of the battery (Coulombs).
+        state_of_charge (float): Current state of charge (dimensionless, 0.0 to 1.0).
+        U_oc_coefficients (np.ndarray): Coefficients for the open-circuit voltage polynomial.
+        R_0_coefficients (np.ndarray): Coefficients for the ohmic resistance polynomial.
+        U_oc (callable): Function for open-circuit voltage as a function of state of charge (V).
+        R_0 (callable): Function for ohmic resistance as a function of state of charge (Ohms).
+        U_P (float): Current polarization potential (V).
+        U_L (float): Current terminal voltage (V).
+        tau (float): Time constant of the battery model (seconds).
+    """
+
+    def __init__(self, battery_config: BatteryModelConfig, state_of_charge=1):
+        """
+        Constructor for the BatteryModel class.
+
+        :param BatteryModelConfig battery_config: Configuration object containing the battery's parameters and data.
+        :param float state_of_charge: Initial state of charge of the battery (default is 1.0, fully charged).
+        """
+
+        # ----- Load Config -----
+
+        self.R_P = battery_config.R_P
+        self.C_P = battery_config.C_P
+        self.max_current_capacity = battery_config.max_current_capacity
+        self.max_energy_capacity = battery_config.max_energy_capacity
+        self.nominal_charge_capacity = battery_config.Q_total
+        Soc_data = battery_config.SOC_data
+        Uoc_data = battery_config.Uoc_data
+        R_0_data = battery_config.R_0_data
+
+        # ----- Initialize Parameters -----
+        def quintic_polynomial(x, x0, x1, x2, x3, x4):
+            return np.polyval(np.array([x0, x1, x2, x3, x4]), x)
+
+        self.U_oc_coefficients, _ = optimize.curve_fit(quintic_polynomial, Soc_data, Uoc_data)
+        self.R_0_coefficients, _ = optimize.curve_fit(quintic_polynomial, Soc_data, R_0_data)
+        self.U_oc = lambda soc: np.polyval(self.U_oc_coefficients, soc)  # V
+        self.R_0 = lambda soc: np.polyval(self.R_0_coefficients, soc)  # Ohms
+
+        self.U_P = 0.0  # V
+        self.U_L = 0.0  # V
+        self.state_of_charge = state_of_charge
+
+        self.tau = self.R_P * self.C_P  # Characteristic Time (seconds)
+
+        # calculated the charging and discharging currents
+        self.discharge_current = lambda P, U_oc, U_P, R_0: ((U_oc - U_P) - np.sqrt(
+            np.power((U_oc - U_P), 2) - 4 * R_0 * P)) / (2 * R_0)
+        self.charge_current = lambda P, U_oc, U_P, R_0: (-(U_oc + U_P) + np.sqrt(
+            np.power((U_oc + U_P), 2) + 4 * R_0 * P)) / (2 * R_0)
+
+    def _evolve(self, power: float, tick: float) -> None:
+        """
+        Update the battery state given the power and time elapsed.
+
+        :param float power: Power applied to the battery (W). Positive for charging, negative for discharging.
+        :param float T: Time interval over which the power is applied (seconds).
+        """
+        soc = self.state_of_charge  # State of Charge (dimensionless, 0 < soc < 1)
+        U_P = self.U_P  # Polarization Potential (V)
+        R_P = self.R_P  # Polarization Resistance (Ohms)
+        U_oc = self.U_oc(soc)  # Open-Circuit Potential (V)
+        R_0 = self.R_0(soc)  # Ohmic Resistance (Ohms)
+        Q = self.nominal_charge_capacity  # Nominal Charge Capacity (C)
+
+        current = self.discharge_current(power, U_oc, U_P, R_0) if power <= 0 else self.charge_current(power, U_oc, U_P, R_0)  # Current (A)
+
+        new_soc = soc + (current * tick / Q)
+        new_U_P = np.exp(-tick / self.tau) * U_P + current * R_P * (1 - np.exp(-tick / self.tau))
+
+        self.state_of_charge = new_soc
+        self.U_P = new_U_P
+        self.U_L = U_oc + U_P + (current * R_0)
+
+    def update_array(self, delta_energy_array, tick, rust=True):
+        """
+        Compute the battery's state of charge, voltage, and stored energy over time.
+        This function is a wrapper for the Rust-based and Python-based implementations.
+
+        :param np.ndarray delta_energy_array: Array of energy changes (J) at each time step.
+        :param float tick: Time interval for each step (seconds).
+        :param bool rust: If True, use Rust-based calculations (default is True).
+
+        :return: A tuple containing arrays for state-of-charge, voltage, and stored energy.
+        :rtype: tuple[np.ndarray, np.ndarray, np.ndarray]
+        """
+
+        if rust:
+            return core.update_battery_array(
+                delta_energy_array,
+                tick,
+                self.state_of_charge,
+                self.U_P,
+                self.R_P,
+                self.R_0_coefficients,
+                self.U_oc_coefficients,
+                self.tau,
+                self.nominal_charge_capacity
+            )
+        else:
+            return self._update_array_py(delta_energy_array, tick)
+
+    def _update_array_py(self, delta_energy_array, tick):
+        """
+        Perform energy calculations using Python (fallback method if Rust is disabled).
+
+        :param np.ndarray delta_energy_array: Array of energy changes (J) at each time step.
+        :param float tick: Time interval for each step (seconds).
+
+        :return: A tuple containing arrays for state-of-charge and voltage.
+        :rtype: tuple[np.ndarray, np.ndarray]
+        """
+        soc = np.empty_like(delta_energy_array, dtype=float)
+        voltage = np.empty_like(delta_energy_array, dtype=float)
+        for i, energy in enumerate(delta_energy_array):
+            self._evolve(energy, tick)
+            soc[i] = self.state_of_charge
+            voltage[i] = self.U_L
+
+        return soc, voltage

physics/models/battery/kalman_filter.py

@@ -0,0 +1,180 @@
+import numpy as np
+from scipy import optimize
+from filterpy.kalman import ExtendedKalmanFilter as EKF
+from physics.models.battery.battery_config import BatteryModelConfig
+
+
+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.
+
+        :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).
+        """
+        # Initial state
+        self.SOC = initial_SOC
+        self.Uc = initial_Uc  # Polarization Voltage
+
+        # 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 = 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): 
+        """
+        Return the current state of charge of the battery.
+
+        :return: The current state of charge.
+        :rtype: float
+        """
+        return self.SOC
+
+    def get_Uc(self):
+        """
+        Return the polarization voltage of the battery.
+
+        :return: The current polarization voltage.
+        :rtype: float
+        """
+        return self.Uc
+
+    def get_predicted_Ut(self):
+        """
+        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):
+        """
+        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.
+        """
+        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):
+        """
+        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 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.predict(u=I)
+        print(f'ekf prediction: {self.ekf.x_prior}')
+
+    def predict_then_update(self, measured_Ut, I, time_step):
+        """
+        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 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]}')
+
+    def _state_jacobian(self, time_step):
+        """
+        Return the state Jacobian matrix for the current time step.
+
+        :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
+        :return: The state Jacobian matrix.
+        :rtype: np.ndarray
+        """
+        return np.array([[1, 0], [0, np.exp(-time_step / self.tau)]])
+
+    def _measurement_jacobian(self, x):
+        """
+        Return the measurement Jacobian matrix for the current state vector.
+
+        :param list[float, float] x: The state vector [SOC, Uc].
+        :return: The measurement Jacobian matrix.
+        :rtype: np.ndarray
+        """
+        SOC = x[0]
+        derivative = self.Uoc_derivative(SOC)
+        return np.array([[derivative, -1]])
+
+    def _measurement_function(self, x, I):
+        """
+        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.")

physics/models/battery.rs

@@ -1 +1 @@
-mod battery;
+pub mod battery;

physics/models.rs

@@ -1,5 +1,5 @@
 mod arrays;
-mod battery;
+pub mod battery;
 mod lvs;
 mod motor;
 mod regen;

{ubc_solar_physics-1.0.5.dist-info → ubc_solar_physics-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ubc-solar-physics
-Version: 1.0.5
+Version: 1.2.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>
@@ -39,34 +39,40 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: backports.tarfile ==1.2.0
-Requires-Dist: certifi ==2024.7.4
-Requires-Dist: charset-normalizer ==3.3.2
-Requires-Dist: dill ==0.3.8
-Requires-Dist: haversine ==2.8.1
-Requires-Dist: idna ==3.7
-Requires-Dist: importlib-metadata ==8.2.0
-Requires-Dist: jaraco.classes ==3.4.0
-Requires-Dist: jaraco.context ==5.3.0
-Requires-Dist: jaraco.functools ==4.0.2
-Requires-Dist: keyring ==25.3.0
-Requires-Dist: llvmlite ==0.43.0
-Requires-Dist: markdown-it-py ==3.0.0
-Requires-Dist: mdurl ==0.1.2
-Requires-Dist: more-itertools ==10.4.0
-Requires-Dist: nh3 ==0.2.18
-Requires-Dist: numba ==0.60.0
-Requires-Dist: numpy ==2.0.1
-Requires-Dist: pkginfo ==1.10.0
-Requires-Dist: Pygments ==2.18.0
-Requires-Dist: readme-renderer ==44.0
-Requires-Dist: requests ==2.32.3
-Requires-Dist: requests-toolbelt ==1.0.0
-Requires-Dist: rfc3986 ==2.0.0
-Requires-Dist: rich ==13.7.1
-Requires-Dist: tqdm ==4.66.5
-Requires-Dist: urllib3 ==2.2.2
-Requires-Dist: zipp ==3.20.0
+Requires-Dist: backports.tarfile==1.2.0
+Requires-Dist: certifi==2024.7.4
+Requires-Dist: charset-normalizer==3.3.2
+Requires-Dist: dill==0.3.8
+Requires-Dist: haversine==2.8.1
+Requires-Dist: idna==3.7
+Requires-Dist: importlib_metadata==8.2.0
+Requires-Dist: jaraco.classes==3.4.0
+Requires-Dist: jaraco.context==5.3.0
+Requires-Dist: jaraco.functools==4.0.2
+Requires-Dist: keyring==25.3.0
+Requires-Dist: llvmlite==0.43.0
+Requires-Dist: markdown-it-py==3.0.0
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: more-itertools==10.4.0
+Requires-Dist: nh3==0.2.18
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==2.0.1
+Requires-Dist: pkginfo==1.10.0
+Requires-Dist: Pygments==2.18.0
+Requires-Dist: readme_renderer==44.0
+Requires-Dist: requests==2.32.3
+Requires-Dist: requests-toolbelt==1.0.0
+Requires-Dist: rfc3986==2.0.0
+Requires-Dist: rich==13.7.1
+Requires-Dist: tqdm==4.66.5
+Requires-Dist: urllib3==2.2.2
+Requires-Dist: zipp==3.20.0
+Requires-Dist: filterpy==1.4.5
+Requires-Dist: toml==0.10.2
+Requires-Dist: pandas
+Requires-Dist: pydantic==2.9.2
+Requires-Dist: scipy
+Requires-Dist: tomli
 
 # UBC Solar Physics
 

{ubc_solar_physics-1.0.5.dist-info → ubc_solar_physics-1.2.0.dist-info}/RECORD

@@ -1,26 +1,25 @@
-core.cp39-win_amd64.pyd,sha256=cPZNhvakej0H5rLKxNkVQEVczLMqo1z352Oey-IElfs,365568
+core.cp39-win_amd64.pyd,sha256=kdWR551aw-H-qoXz6vJoE104KevwzuO_WJpKzy8Ta3c,382976
 physics/__init__.py,sha256=jRV9J_eGh0vNXEfFrILqcM6xxVjyqm3XwKAg1B1IPBs,183
-physics/_version.py,sha256=woKIMJpGXhD8vlRlc_pXp8tq7OtKQDUDMRWt5L7aJ2g,427
+physics/_version.py,sha256=DnUqy-xWN4z1XWOsowoRN4Vz2GPuDm_18GEJc3VGkWg,427
 physics/environment.rs,sha256=OghmBkvHLZvzzuVsXUmV2lR3X_tEwuB9sT2TGZLQC6E,36
-physics/lib.rs,sha256=lH7bim9AIVvn58XmwzLk5RqhcotvX6l0IezT6Rm41zY,4246
-physics/models.rs,sha256=iyhO-vQsAYrIQJHYONUvtuTqQ3HtlaTeOIZqCOH3JkU,59
-physics/environment/__init__.py,sha256=kT6VKLewIz8zdnEGIv-E6h9mzflXYF105b_qNn9r72Y,315
+physics/lib.rs,sha256=FqnhKkotYKJCu8v1vbov2QW9s0apay7-BnEcUgxOakU,5798
+physics/models.rs,sha256=747ABP-D1XKxA6X_MNh1PbmST0zsxpxhP_pEWjbR46c,63
+physics/environment/__init__.py,sha256=se_LVo4aWZKcZgbbK1KwwhHG8SH2zS1g6TEPw0GOZSs,225
 physics/environment/environment.rs,sha256=-VztdV2_GSlRbyIV_Pt6gKPVxpuNXpjLgAmoervonLg,34
 physics/environment/gis.rs,sha256=9R7G0cjf5PxQAz-CSryA6-KGfrh1eSwRhJ6qF8KfjDE,12
 physics/environment/meteorology.rs,sha256=naWb7qYrtMkCE_tLAkM474fmxaufhCkyhy3TTUQ4Yw4,20
-physics/environment/race.py,sha256=XuZaNli-68pH0Fy2h2yVKcf4ICsFNE651VtY_aDE754,3017
 physics/environment/gis/__init__.py,sha256=SjqhVjuDbZln636zOFROq1tWPfadghkuYz8aheflyxA,96
 physics/environment/gis/base_gis.py,sha256=WJMwpuxjmHuV-dS5HwWvLxARNd7JRQyd3IBptuxNAI0,656
 physics/environment/gis/gis.py,sha256=I04ABXsNOmeikCajBtl9a5oW6NzMBPc8nG53oiIicqw,11737
 physics/environment/gis/gis.rs,sha256=jMkVmlUNl5cz7GF1QVkMNoRb58YUOe4D95EdhBJ4anM,876
 physics/environment/meteorology/__init__.py,sha256=mvjJw_0nNLIdh80F_yTaRC3Sw3oI-z1L0J5cOK_ei0k,157
 physics/environment/meteorology/base_meteorology.py,sha256=n0JsEXQLuciEatQp_S0QBXd_HQzCY5LeIQeVKgl5O-8,2487
-physics/environment/meteorology/clouded_meteorology.py,sha256=Vjeb0CM-6HgcGNrTTFCZJ10jKFeWBnIrM938wkPNQaQ,28135
-physics/environment/meteorology/irradiant_meteorology.py,sha256=IOPEKtU0J6aMZ8DixsssdARnpeKWMqlThjs6VcG80a4,5536
+physics/environment/meteorology/clouded_meteorology.py,sha256=H4jqQmaf1UiARQ4T5HmWE0ChS6IJhlvumj0lfoe52cw,28241
+physics/environment/meteorology/irradiant_meteorology.py,sha256=BNuINbPfNQO5dB9AE9bMMdN4IUWK5HpRmEXONSykpVc,5646
 physics/environment/meteorology/meteorology.rs,sha256=a5XlYhb34xvPKuGp1etTQZlSqm9qTd7UXuN6H0-jXfY,5142
 physics/models/__init__.py,sha256=YgSvt4iBbcoH55XskiK9uE3VXxqCh-ZoIbAWogNUK7U,268
 physics/models/arrays.rs,sha256=rtthXq7PDjL30lIt8y9L2xFAPJE5o_ltmCbOGzzOxrc,11
-physics/models/battery.rs,sha256=GzPA7uaF5FdewEFZL2eOt9ZeA1GzfRDQ9db_qkEpLR8,12
+physics/models/battery.rs,sha256=fTL9O20fQarT_CFsmMSqVEZNe_sTejWMaAR8Fc-z_ak,16
 physics/models/constants.py,sha256=GMD4hYO1FKoni3MNPvcyYg2EKGrgKxvOnxVKlEapUEc,839
 physics/models/lvs.rs,sha256=uyJ1ZZ1Phq8cWCzr2aevCWzt8MlhCw9DO5ObUvEs8ds,8
 physics/models/motor.rs,sha256=Iya1C_YF09KMy-9N-Mt-rBf1EIAs2Bf3Q4eDvyFuAoc,10
@@ -29,10 +28,13 @@ physics/models/arrays/__init__.py,sha256=Ds36SXwtCBnoq1xDOVlqA4kMBcOqS1wa9gLTn7T
 physics/models/arrays/arrays.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 physics/models/arrays/base_array.py,sha256=KjTX_0MCvWSEf4irXd3P1ITsgjhFUqK1Cf0MbSQwLuk,101
 physics/models/arrays/basic_array.py,sha256=-6yj85XkuySrjnLVmLnU35A4EOatiw4QpkLcC7n1WXU,1371
-physics/models/battery/__init__.py,sha256=y0sM5d4aUdpHnrcx4fNRLnThOHofCcCSAxDh7OIDGTY,138
+physics/models/battery/__init__.py,sha256=huRYMnfw035kqHyWeApAvdCaSf9yAQZMcQMnPutIXLE,376
 physics/models/battery/base_battery.py,sha256=yU-QopEEQ83kw4CUvJ2MEhYyj3AM3LYY_hvdZ2wwW7c,1232
-physics/models/battery/basic_battery.py,sha256=yFgFIXdTuNrp6E0jDYERowY9-pkTSWyoIs_Ksad2fyI,5896
-physics/models/battery/battery.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/battery/basic_battery.py,sha256=5o-7g5xflhNLKuJyeqOY-1rLIOSIy_CJ0U4GEqeQO1E,5894
+physics/models/battery/battery.rs,sha256=0wIQVli7UOWgKXT96cQLWisLQKo5UE08X4B9dl09USI,3649
+physics/models/battery/battery_config.py,sha256=Dsi7cXR8SL0v7aSTuihhB6il9-8h1a2P8qrGbdvlf8Q,617
+physics/models/battery/battery_model.py,sha256=kHn-xOyFBzWycpd-9Wn75fzHYZ512wXOi1dUrlt3a5M,6313
+physics/models/battery/kalman_filter.py,sha256=Lr7J2vwO1HwN6miNFAYCfhZiZ2j72bwmUt-vubpo0Ks,7371
 physics/models/lvs/__init__.py,sha256=ZBips6zW4Lot7SkQZMZt_OGRNUqgOfUlDtBA5lfUkM4,114
 physics/models/lvs/base_lvs.py,sha256=kVLfGd9Qwql4-6u86uwHbJoFCgYpG07r0cAR2Ngsq38,116
 physics/models/lvs/basic_lvs.py,sha256=xNXeN6RGSZkJLhtcW0n2xZU6YIOT4bKUIbOFdmh4zc0,621
@@ -45,8 +47,8 @@ physics/models/regen/__init__.py,sha256=JzyRYKwT89FQ6_p9ofCqusl2fnWGHulyiK4P4f8L
 physics/models/regen/base_regen.py,sha256=lY44jrTSHEo8Xv7hKCjo4C3Jx0PUgilyITHwQchT2bM,101
 physics/models/regen/basic_regen.py,sha256=RY730lQLJ_gKkm2wJ68t1OPTmcz9xxGmu0yBLwHCGoQ,1811
 physics/models/regen/regen.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ubc_solar_physics-1.0.5.dist-info/LICENSE,sha256=1Vq7OikLHh7N0xsmTPHCmPkOxk1AXrMK9k1a1icQFlk,1087
-ubc_solar_physics-1.0.5.dist-info/METADATA,sha256=eA7lGkqgTd_9qYl4GWk6DJIYKks26ZPnL99oAS7luwQ,4975
-ubc_solar_physics-1.0.5.dist-info/WHEEL,sha256=Z6c-bE0pUM47a70GvqO_SvH_XXU0lm62gEAKtoNJ08A,100
-ubc_solar_physics-1.0.5.dist-info/top_level.txt,sha256=aws060Zz-1h0Kx76JzcE1gLA_AfS1lrRtTCsyUYwDvM,8
-ubc_solar_physics-1.0.5.dist-info/RECORD,,
+ubc_solar_physics-1.2.0.dist-info/LICENSE,sha256=1Vq7OikLHh7N0xsmTPHCmPkOxk1AXrMK9k1a1icQFlk,1087
+ubc_solar_physics-1.2.0.dist-info/METADATA,sha256=nPuG2LtB0tkAdyZqiH_xYFiVCR4DmG0aFDQwPj-zBEU,5107
+ubc_solar_physics-1.2.0.dist-info/WHEEL,sha256=agy-BJge3afXwWznUXANATmKFW4eqelqRR0uf608A_0,99
+ubc_solar_physics-1.2.0.dist-info/top_level.txt,sha256=aws060Zz-1h0Kx76JzcE1gLA_AfS1lrRtTCsyUYwDvM,8
+ubc_solar_physics-1.2.0.dist-info/RECORD,,

{ubc_solar_physics-1.0.5.dist-info → ubc_solar_physics-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: false
 Tag: cp39-cp39-win_amd64
 

physics/environment/race.py

@@ -1,89 +0,0 @@
-"""
-This class collects the constants that are related to a specific competition.
-"""
-import pathlib
-
-import numpy as np
-import pickle
-import enum
-import json
-import os
-
-
-class Race:
-    class RaceType(enum.Enum):
-        ASC = "ASC"
-        FSGP = "FSGP"
-
-        def __str__(self):
-            match self.value:
-                case "ASC":
-                    return "ASC"
-                case "FSGP":
-                    return "FSGP"
-
-        def __reduce__(self):
-            return self.__class__, (self.name,)
-
-        def __contains__(self, item):
-            return item == "ASC" or item == "FSGP"
-
-        def __repr__(self):
-            return str(self)
-
-    ASC = RaceType.ASC
-    FSGP = RaceType.FSGP
-
-    def __init__(self, race_type: RaceType, race_constants: dict):
-        self.race_type = race_type
-
-        self.days = race_constants["days"]
-        self.tiling = race_constants["tiling"]
-        self.date = (race_constants["start_year"], race_constants["start_month"], race_constants["start_day"])
-
-        self.race_duration = len(self.days) * 24 * 60 * 60  # Duration (s)
-        self.driving_boolean = self.make_time_boolean("driving")
-        self.charging_boolean = self.make_time_boolean("charging")
-
-    def __str__(self):
-        return str(self.race_type)
-
-    def write(self, race_directory: pathlib.Path):
-        with open(race_directory / f"{str(self.race_type)}.pkl", 'wb') as outfile:
-            pickle.dump(self, outfile, protocol=pickle.HIGHEST_PROTOCOL)
-
-    def make_time_boolean(self, boolean_type: str):
-        boolean: np.ndarray = np.empty(self.race_duration, dtype=np.int8)
-        DAY_LENGTH: int = 24 * 60 * 60  # Length of a day in seconds
-
-        for tick in range(len(boolean)):
-            day: int = tick // DAY_LENGTH    # Integer division to determine how many days have passed
-            time_of_day = tick % DAY_LENGTH  # Time of day in seconds where 0 is midnight and 43200 is noon
-            begin, end = self.days[str(day)][boolean_type]
-
-            # If the time of day is between the beginning and end, then the boolean is True, else False
-            boolean[tick] = begin <= time_of_day < end
-
-        return boolean
-
-
-def load_race(race_type: Race.RaceType, race_directory: pathlib.Path) -> Race:
-    with open(race_directory / f"{str(race_type)}.pkl", 'rb') as infile:
-        return pickle.load(infile)
-
-
-def compile_races(config_directory: pathlib.Path, race_directory: pathlib.Path):
-    fsgp_config_path = os.path.join(config_directory, f"settings_FSGP.json")
-    asc_config_path = os.path.join(config_directory, f"settings_ASC.json")
-
-    with open(fsgp_config_path) as f:
-        fsgp_race_constants = json.load(f)
-
-    with open(asc_config_path) as f:
-        asc_race_constants = json.load(f)
-
-    fsgp = Race(Race.FSGP, fsgp_race_constants)
-    fsgp.write(race_directory)
-
-    asc = Race(Race.ASC, asc_race_constants)
-    asc.write(race_directory)