ubc-solar-physics 1.6.0__tar.gz → 1.7.0__tar.gz

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "android-tzdata"
@@ -64,15 +64,6 @@ dependencies = [
  "windows-targets",
 ]
 
-[[package]]
-name = "core"
-version = "0.1.0"
-dependencies = [
- "chrono",
- "numpy",
- "pyo3",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -248,6 +239,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "physics_rs"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "numpy",
+ "pyo3",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "core"
+name = "physics_rs"
 version = "0.1.0"
 edition = "2021"
 
 [lib]
-name = "core"
+name = "physics_rs"
 path = "physics/lib.rs"
 crate-type = ["cdylib"]
 

ubc_solar_physics-1.7.0/MANIFEST.in

@@ -0,0 +1 @@
+include physics_rs.pyi

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.6.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
 

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/docs/source/models/battery.rst

@@ -21,7 +21,17 @@ Battery
    :undoc-members:
    :show-inheritance:
 
-.. autoclass:: physics.models.battery.load_battery_config
+.. autoclass:: physics.models.battery.KalmanFilterConfig
    :members:
    :undoc-members:
-   :show-inheritance:
+   :show-inheritance:
+
+.. autoclass:: physics.models.battery.EquivalentCircuitBatteryModel
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. autoclass:: physics.models.battery.FilteredBatteryModel
+   :members:
+   :undoc-members:
+   :show-inheritance:

ubc_solar_physics-1.7.0/examples/battery_model_examples/battery_config.toml

@@ -0,0 +1,6 @@
+R_0_data = [0.17953765302439662, 0.15580951404728172, 0.14176929930784543, 0.11043950958574644, 0.13930042505446938, 0.1552885289394773, 0.044070982259896085, 0.2208806896239539, 0.15116267852908616, 0.6553961767519164]
+R_P_data = [0.04153180244191346, 0.10674683402208612, 0.061085424180509884, 0.0781407642082238, 0.05537901113775878, 0.09732054673529467, 0.07662520885708152, 0.09799857401036915, 0.42622740149661487, 0.2718418915736874]
+C_P_data = [14824.398495212006, 1587.5971318119796, 341.1064063616048, 1243.182413110655, 619.5791066439332, 2252.7885790042164, 954.5884882581622, 515.7219779825028, 431.10892633451135, 195.14394897766627]
+Uoc_data = [131.88002282453857, 129.4574321366064, 125.5750277614186, 121.99586066440303, 118.69893412178982, 115.71854177322408, 111.99025635444923, 108.29354777060836, 98.23397960300946, 95.24125831782388]
+Q_total = 150000.0
+Soc_data = [1.0000113624123392, 0.8815263722745977, 0.7671918526292492, 0.6206071038045673, 0.4911613638651783, 0.3606311083423134, 0.23687514228021178, 0.12073345089992571, 0.01456057818183809, 0.0070648691224265425]

ubc_solar_physics-1.7.0/examples/battery_model_examples/battery_model_example.py

@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+import pathlib
+import matplotlib.pyplot as plt
+from physics.models.battery import EquivalentCircuitBatteryModel, BatteryModelConfig, load_battery_config
+
+
+# This test requires a voltage.csv and current.csv in the same directory to run
+def csv_to_timeseries_tuples(csv_file):
+    path = pathlib.Path(__file__).parent / csv_file
+    df = pd.read_csv(path)
+    df['Time'] = pd.to_datetime(df['Time'])
+    return np.array(list(zip(df['Time'].dt.to_pydatetime(), df['Value'])))
+
+
+def plot_results(soc_array, predicted_ut_array, voltage_data, window=None):
+    fig, ax = plt.subplots()
+
+    if window is None:
+        window = slice(0, len(predicted_ut_array), 1)
+
+    ax.plot(predicted_ut_array, label=r"Predicted $U_t$", color="tab:red")
+    ax.plot(voltage_data, label=r"Measured $U_t$", color="tab:orange")
+    ax.set_ylim(75, 140)
+    ax.set_xticks([])
+    ax.set_ylabel("Voltage")
+
+    ax2 = ax.twinx()
+    ax2.plot(soc_array[window], color="tab:blue", label="Filtered SOC")
+    ax2.set_ylabel("SOC")
+
+    ax.legend(loc='upper right')
+    ax2.legend(loc='lower left')
+
+    plt.title("Simulation of first-order Thevenin equivalent battery model")
+    plt.show()
+
+
+def battery_model():
+    voltage_data = csv_to_timeseries_tuples('voltage.csv')
+    current_data = csv_to_timeseries_tuples('current.csv')
+
+    # This dataset has 0.1s period between measurements
+    time_difference = 0.1
+
+    current_raw = current_data[:, 1]
+    current_error = np.polyval([-0.00388, 1547], current_raw * 1000.0)
+
+    current = current_raw - (current_error / 1000)
+    voltage = voltage_data[:, 1]
+
+    energy_array = current * voltage * time_difference
+
+    model_config: BatteryModelConfig = load_battery_config(pathlib.Path(__file__).parent / 'battery_config.toml')
+
+    battery_model = EquivalentCircuitBatteryModel(model_config, state_of_charge=1.04)
+
+    soc_array, predicted_ut_array = battery_model.update_array(tick=time_difference, current_array=np.array(-current, dtype=float))
+    # soc_array, predicted_ut_array = battery_model.update_array(tick=time_difference, delta_energy_array=np.array(-energy_array, dtype=float))
+
+    # example usage
+    plot_results(soc_array, predicted_ut_array, voltage)
+
+
+if __name__ == '__main__':
+    battery_model()

ubc_solar_physics-1.7.0/examples/kalman_filter_examples/battery_config.toml

@@ -0,0 +1,6 @@
+R_0_data = [0.17953765302439662, 0.15580951404728172, 0.14176929930784543, 0.11043950958574644, 0.13930042505446938, 0.1552885289394773, 0.044070982259896085, 0.2208806896239539, 0.15116267852908616, 0.6553961767519164]
+R_P_data = [0.04153180244191346, 0.10674683402208612, 0.061085424180509884, 0.0781407642082238, 0.05537901113775878, 0.09732054673529467, 0.07662520885708152, 0.09799857401036915, 0.42622740149661487, 0.2718418915736874]
+C_P_data = [14824.398495212006, 1587.5971318119796, 341.1064063616048, 1243.182413110655, 619.5791066439332, 2252.7885790042164, 954.5884882581622, 515.7219779825028, 431.10892633451135, 195.14394897766627]
+Uoc_data = [131.88002282453857, 129.4574321366064, 125.5750277614186, 121.99586066440303, 118.69893412178982, 115.71854177322408, 111.99025635444923, 108.29354777060836, 98.23397960300946, 95.24125831782388]
+Q_total = 145000.0
+Soc_data = [1.0000113624123392, 0.8815263722745977, 0.7671918526292492, 0.6206071038045673, 0.4911613638651783, 0.3606311083423134, 0.23687514228021178, 0.12073345089992571, 0.01456057818183809, 0.0070648691224265425]

ubc_solar_physics-1.7.0/examples/kalman_filter_examples/kalman_filter_example.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+import pathlib
+import matplotlib.pyplot as plt
+from physics.models.battery.kalman_filter import FilteredBatteryModel
+from physics.models.battery.battery_config import BatteryModelConfig, load_battery_config, KalmanFilterConfig
+
+
+# This test requires a voltage.csv and current.csv in the same directory to run
+def csv_to_timeseries_tuples(csv_file):
+    path = pathlib.Path(__file__).parent / csv_file
+    df = pd.read_csv(path)
+    df['Time'] = pd.to_datetime(df['Time'])
+    return np.array(list(zip(df['Time'].dt.to_pydatetime(), df['Value'])))
+
+
+def plot_kalman_results(measured_Ut, predicted_Ut_array, predicted_Uc_array, SOC_array, window=None):
+    fig, ax = plt.subplots()
+
+    if window is None:
+        window = slice(0, len(predicted_Ut_array), 1)
+
+    # ax.plot(predicted_Uoc_array[window], label="Predicted OCV", color="tab:cyan")
+    ax.plot(predicted_Ut_array[window], label=r"Filtered Predicted $U_t$", color="orange")
+    ax.plot(measured_Ut[window], label=r"Measured $U_t$", color="tab:red")
+    ax.plot(predicted_Uc_array[window] + 100, label=r"Predicted $U_c$", color="magenta")
+    ax.axhline(y=100, linestyle='dotted', color="magenta")
+    # ax.set_ylim(75, 140)
+    ax.set_xticks([])
+    ax.set_ylabel("Voltage")
+
+    ax2 = ax.twinx()
+    ax2.plot(SOC_array[window], color="tab:cyan", label="Filtered SOC")
+    ax2.set_ylabel("SOC")
+
+    ax.legend(loc='upper right')
+    ax2.legend(loc='lower left')
+
+    plt.title("Impact of Kalman filtering on equivalent-circuit battery modeling ")
+    plt.show()
+
+
+def kalman_filter():
+    
+    voltage_data = csv_to_timeseries_tuples('voltage.csv')
+    current_data = csv_to_timeseries_tuples('current.csv')
+
+    model_config: BatteryModelConfig = load_battery_config(pathlib.Path(__file__).parent / 'battery_config.toml')
+
+    filter_config: KalmanFilterConfig = KalmanFilterConfig(
+        model_config,
+        process_noise_matrix=np.diag([
+            1e-10 * 0.1,
+            1e-6 * 0.1
+        ]),
+        state_covariance_matrix=np.diag(
+            [1e-2 * 0.5,
+             1e-1]
+        ),
+        measurement_noise_vector=np.eye(1, dtype=float) * 1e0 * 0.5
+    )
+
+    ekf = FilteredBatteryModel(filter_config, initial_SOC=1.04, initial_Uc=0.0)
+
+    SOC_array = np.zeros(len(voltage_data))
+    Ut_array = np.zeros(len(voltage_data))
+    current_array = np.zeros(len(voltage_data))
+    predicted_Ut_array = np.zeros(len(voltage_data))
+    predicted_Uc_array = np.zeros(len(voltage_data))
+    predicted_Uoc_array = np.zeros(len(voltage_data))
+
+    # This dataset has 0.1s period between measurements
+    time_difference = 0.1
+
+    for i in range(int(len(voltage_data))):
+        # for i in range(20000):
+        # Calculate time difference between current and previous measurements
+
+        Ut = float(voltage_data[i][1])
+        I = float(current_data[i][1])
+
+        ekf.predict_then_update(Ut, I, time_difference)
+
+        SOC_array[i] = ekf.SOC
+        Ut_array[i] = Ut
+        current_array[i] = I
+        predicted_Ut_array[i] = ekf.Ut
+        predicted_Uc_array[i] = ekf.Uc
+        predicted_Uoc_array[i] = ekf._U_oc(ekf.SOC)
+
+    # example usage
+    plot_kalman_results(voltage_data[:, 1], predicted_Ut_array, predicted_Uc_array, SOC_array)
+
+
+if __name__ == '__main__':
+    kalman_filter()

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/physics/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.0'
-__version_tuple__ = version_tuple = (1, 6, 0)
+__version__ = version = '1.7.0'
+__version_tuple__ = version_tuple = (1, 7, 0)

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/physics/environment/gis/gis.py

@@ -1,6 +1,6 @@
 import logging
 import math
-import core
+import physics_rs
 import numpy as np
 import sys
 
@@ -81,7 +81,7 @@ class GIS(BaseGIS):
         :rtype: np.ndarray
 
         """
-        return core.closest_gis_indices_loop(distances, self.path_distances)
+        return physics_rs.closest_gis_indices_loop(distances, self.path_distances)
 
     def calculate_driving_speeds(
             self,
@@ -108,7 +108,7 @@ class GIS(BaseGIS):
         :return: A simulation-time array of driving speeds in m/s, or an error if there weren't enough
             laps provided to fill the entire simulation time.
         """
-        return core.get_driving_speeds(
+        return physics_rs.get_driving_speeds(
             np.array(average_lap_speeds).astype(np.float64),
             simulation_dt,
             np.array(driving_allowed).astype(bool),
@@ -120,7 +120,7 @@ class GIS(BaseGIS):
     def _python_calculate_closest_gis_indices(distances, path_distances):
         """
 
-        Python implementation of rust core.closest_gis_indices_loop. See parent function for documentation details.
+        Python implementation of use_compiled core.closest_gis_indices_loop. See parent function for documentation details.
 
         """
 

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/physics/environment/meteorology/clouded_meteorology.py

@@ -2,7 +2,7 @@ from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
 from numba import jit
-import core
+import physics_rs
 from typing import Optional
 import datetime
 
@@ -70,7 +70,7 @@ class CloudedMeteorology(BaseMeteorology):
         # contains the average distance between two consecutive elements in the cumulative_weather_path_distances array
         average_distances = np.abs(np.diff(cumulative_weather_path_distances) / 2)
 
-        return core.closest_weather_indices_loop(cumulative_distances, average_distances)
+        return physics_rs.closest_weather_indices_loop(cumulative_distances, average_distances)
 
     def temporally_localize(self, unix_timestamps, start_time, tick) -> None:
         """
@@ -96,7 +96,7 @@ class CloudedMeteorology(BaseMeteorology):
         :rtype: np.ndarray
 
         """
-        weather_data = core.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64), self._weather_forecast, 4)
+        weather_data = physics_rs.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64), self._weather_forecast, 4)
         # roll_by_tick = int(3600 / tick) * (24 + start_hour - hour_from_unix_timestamp(weather_data[0, 2]))
         # weather_data = np.roll(weather_data, -roll_by_tick, 0)
 
@@ -124,7 +124,7 @@ class CloudedMeteorology(BaseMeteorology):
         :rtype: np.ndarray
 
         """
-        day_of_year, local_time = core.calculate_array_ghi_times(local_times)
+        day_of_year, local_time = physics_rs.calculate_array_ghi_times(local_times)
 
         ghi = self._calculate_GHI(coords[:, 0], coords[:, 1], time_zones,
                                   day_of_year, local_time, elevations, self._cloud_cover)

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/physics/environment/meteorology/irradiant_meteorology.py

@@ -1,7 +1,7 @@
 from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
-import core
+import physics_rs
 from typing import Optional
 
 
@@ -11,6 +11,7 @@ class IrradiantMeteorology(BaseMeteorology):
     solar irradiance data, but not cloud cover.
 
     """
+
     def __init__(self, race, weather_forecasts):
         self._race = race
         self._raw_weather_data = weather_forecasts
@@ -53,7 +54,7 @@ class IrradiantMeteorology(BaseMeteorology):
         # contains the average distance between two consecutive elements in the cumulative_weather_path_distances array
         average_distances = np.abs(np.diff(cumulative_weather_path_distances) / 2)
 
-        self._weather_indices = core.closest_weather_indices_loop(cumulative_distances, average_distances)
+        self._weather_indices = physics_rs.closest_weather_indices_loop(cumulative_distances, average_distances)
 
     def temporally_localize(self, unix_timestamps, start_time, tick) -> None:
         """
@@ -76,8 +77,9 @@ class IrradiantMeteorology(BaseMeteorology):
         :returns: a SolcastEnvironment object with time_dt, latitude, longitude, wind_speed, wind_direction, and ghi.
         :rtype: SolcastEnvironment
         """
-        forecasts_array = core.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64),
-                                               self._raw_weather_data, 0)
+        forecasts_array = physics_rs.weather_in_time(unix_timestamps.astype(np.int64),
+                                                     self._weather_indices.astype(np.int64),
+                                                     self._raw_weather_data, 0)
 
         self._time_dt = forecasts_array[:, 0]
         self._latitude = forecasts_array[:, 1]
@@ -103,5 +105,3 @@ class IrradiantMeteorology(BaseMeteorology):
 
         """
         return self.solar_irradiance
-
-

{ubc_solar_physics-1.6.0 → ubc_solar_physics-1.7.0}/physics/lib.rs

@@ -1,5 +1,5 @@
 use numpy::ndarray::ArrayViewD;
-use numpy::{PyArray, PyArrayDyn, PyReadwriteArrayDyn, PyReadonlyArray1, PyArray1};
+use numpy::{PyArray, PyArrayDyn, PyReadwriteArrayDyn, PyReadwriteArray1, PyReadonlyArray1, PyArray1};
 use pyo3::prelude::*;
 use pyo3::types::PyModule;
 
@@ -7,7 +7,7 @@ pub mod environment;
 pub mod models;
 use crate::environment::gis::gis::{rust_closest_gis_indices_loop, get_driving_speeds};
 use crate::environment::meteorology::meteorology::{rust_calculate_array_ghi_times, rust_closest_weather_indices_loop, rust_weather_in_time};
-use crate::models::battery::battery::update_battery_array;
+use crate::models::battery::battery::update_battery_state;
 
 fn constrain_speeds(speed_limits: ArrayViewD<f64>,  speeds: ArrayViewD<f64>, tick: i32) -> Vec<f64> {
     let mut distance: f64 = 0.0;
@@ -25,7 +25,7 @@ fn constrain_speeds(speed_limits: ArrayViewD<f64>,  speeds: ArrayViewD<f64>, tic
 
 /// A Python module implemented in Rust. The name of this function is the Rust module name!
 #[pymodule]
-#[pyo3(name = "core")]
+#[pyo3(name = "physics_rs")]
 fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
     #[pyfn(m)]
         #[pyo3(name = "constrain_speeds")]
@@ -95,35 +95,43 @@ fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
     }
 
     #[pyfn(m)]
-    #[pyo3(name = "update_battery_array")]
-    fn update_battery_array_py<'py>(
+    #[pyo3(name = "update_battery_state")]
+    fn update_battery_state_py<'py>(
         py: Python<'py>,
-        python_delta_energy_array: PyReadwriteArrayDyn<'py, f64>,
+        python_energy_or_current_array: PyReadwriteArray1<'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,
+        python_internal_resistance_lookup: PyReadwriteArray1<'py, f64>,
+        python_open_circuit_voltage_lookup: PyReadwriteArray1<'py, f64>,
+        python_polarization_resistance_lookup: PyReadwriteArray1<'py, f64>,
+        python_polarization_capacitance_lookup: PyReadwriteArray1<'py, 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,
+        is_power: bool,
+        quantization_step: f64,
+        min_soc: f64,
+    ) -> (&'py PyArray1<f64>, &'py PyArray1<f64>) {
+        let energy_or_current_array = python_energy_or_current_array.as_array();
+        let internal_resistance_lookup = python_internal_resistance_lookup.as_array();
+        let open_circuit_voltage_lookup = python_open_circuit_voltage_lookup.as_array();
+        let polarization_resistance_lookup = python_polarization_resistance_lookup.as_array();
+        let polarization_capacitance_lookup = python_polarization_capacitance_lookup.as_array();
+        let (soc_array, voltage_array): (Vec<f64>, Vec<f64>) = update_battery_state(
+            energy_or_current_array,
             time_step,
             initial_state_of_charge,
             initial_polarization_potential,
-            polarization_resistance,
-            internal_resistance_coeffs,
-            open_circuit_voltage_coeffs,
-            time_constant,
+            internal_resistance_lookup,
+            open_circuit_voltage_lookup,
+            polarization_resistance_lookup,
+            polarization_capacitance_lookup,
             nominal_charge_capacity,
+            is_power,
+            quantization_step,
+            min_soc
         );
-        let py_soc_array = PyArray::from_vec(py, soc_array).to_dyn();
-        let py_voltage_array = PyArray::from_vec(py, voltage_array).to_dyn();
+        let py_soc_array = PyArray::from_vec(py, soc_array);
+        let py_voltage_array = PyArray::from_vec(py, voltage_array);
         (py_soc_array, py_voltage_array)
     }
 

ubc_solar_physics-1.7.0/physics/models/battery/__init__.py

@@ -0,0 +1,18 @@
+from .base_battery import BaseBattery
+from .basic_battery import BasicBattery
+from .battery_model import EquivalentCircuitBatteryModel, EquivalentCircuitModelConfig, SOCDependent
+from .kalman_filter import FilteredBatteryModel, FilteredBatteryModelConfig
+from .battery_config import BatteryModelConfig, load_battery_config, KalmanFilterConfig
+
+__all__ = [
+    "BaseBattery",
+    "BasicBattery",
+    "EquivalentCircuitBatteryModel",
+    "FilteredBatteryModel",
+    "BatteryModelConfig",
+    "load_battery_config",
+    "EquivalentCircuitModelConfig",
+    "FilteredBatteryModelConfig",
+    "KalmanFilterConfig",
+    "SOCDependent"
+]

ubc_solar_physics-1.7.0/physics/models/battery/battery.rs

@@ -0,0 +1,102 @@
+use std::f64;
+use numpy::ndarray::{ArrayView1};
+
+fn get_lookup_index(soc: f64, quantization_step: f64, num_indices: usize, min_soc: f64) -> usize {
+    // Apply the same formula as in Python
+    let index = ((soc - min_soc) / quantization_step).floor() as usize;
+
+    // Clamp the index to be between 0 and num_indices - 1
+    index.min(num_indices - 1)  // equivalent to max(0, min(num_indices - 1, index))
+}
+
+/// Evaluate a polynomial given coefficients and an input value (x)
+fn evaluate_lookup(lookup: &[f64], quantization_step: f64, value: f64, min_soc: f64) -> f64 {
+    let index = get_lookup_index(value, quantization_step, lookup.len(), min_soc);
+    lookup[index]
+}
+
+/// Evolve the battery state for a single step
+fn battery_evolve(
+    current: f64,                  // Amperes
+    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) {
+    // 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)
+}
+
+// Update battery state, using either energy or current draw
+pub fn update_battery_state(
+    energy_or_current_array: ArrayView1<'_, f64>,  // Power (W*s) or current (Amperes)
+    tick: f64,                                     // Seconds
+    initial_state_of_charge: f64,                  // dimensionless, 0 < SOC < 1
+    initial_polarization_potential: f64,           // Volts
+    internal_resistance_lookup: ArrayView1<'_, f64>,// Coefficients for internal resistance
+    open_circuit_voltage_lookup: ArrayView1<'_, f64>, // Coefficients for open-circuit voltage
+    polarization_resistance_lookup: ArrayView1<'_, f64>, // Coefficients for polarization resistance
+    capacitance_lookup: ArrayView1<'_, f64>,        // Coefficients for polarization capacitance
+    nominal_charge_capacity: f64,                   // Coulombs
+    is_energy_input: bool,                          // Whether the input is power or current,
+    quantization_step: f64,                         // The quantization step size of SOC for lookup tables
+    min_soc: f64,
+
+) -> (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(energy_or_current_array.len());
+    let mut voltage_array: Vec<f64> = Vec::with_capacity(energy_or_current_array.len());
+
+    for &input in energy_or_current_array.iter() {
+        // Interpolate values from coefficient
+        let open_circuit_voltage = evaluate_lookup(open_circuit_voltage_lookup.as_slice().unwrap(), quantization_step, state_of_charge, min_soc);
+        let internal_resistance = evaluate_lookup(internal_resistance_lookup.as_slice().unwrap(), quantization_step, state_of_charge, min_soc);
+        let polarization_resistance = evaluate_lookup(polarization_resistance_lookup.as_slice().unwrap(), quantization_step, state_of_charge, min_soc);
+        let capacitance = evaluate_lookup(capacitance_lookup.as_slice().unwrap(), quantization_step, state_of_charge, min_soc);
+        let time_constant = polarization_resistance * capacitance;
+
+        // Calculate current from power or use the current directly
+        let current: f64 = if is_energy_input {
+            // Use the last voltage to calculate current, or an absurdly large number if it is the
+            // first, because we don't know voltage yet, so we will have a very small initial
+            // current, no matter what. We shouldn't be starting to simulate when the battery is
+            // in an active state anyway, so this should be an alright compromise.
+            input / (tick * voltage_array.last().unwrap_or(&10000.0)) // I = (E / dt) / V
+        } else {
+            input // Current is directly given in the current input array
+        };
+
+        let (new_state_of_charge, new_polarization_potential, terminal_voltage) = battery_evolve(
+            current,
+            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)
+}