ubc-solar-physics 1.0.5__cp313-cp313-macosx_10_13_x86_64.whl → 1.7.3__cp313-cp313-macosx_10_13_x86_64.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.7.3'
+__version_tuple__ = version_tuple = (1, 7, 3)

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/gis/base_gis.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import numpy as np
+from numpy.typing import ArrayLike, NDArray
 
 
 class BaseGIS(ABC):
@@ -22,3 +23,16 @@ class BaseGIS(ABC):
     @abstractmethod
     def get_path(self) -> np.ndarray:
         raise NotImplementedError
+
+    @abstractmethod
+    def calculate_current_heading_array(self) -> np.ndarray:
+        raise NotImplementedError
+
+    def calculate_driving_speeds(
+            self,
+            average_lap_speeds: ArrayLike,
+            simulation_dt: int,
+            driving_allowed: ArrayLike,
+            idle_time: int
+    ) -> NDArray[float]:
+        raise NotImplementedError

physics/environment/gis/gis.py

@@ -1,9 +1,10 @@
 import logging
 import math
-import core
+import physics_rs
 import numpy as np
 import sys
 
+from numpy.typing import ArrayLike, NDArray
 from tqdm import tqdm
 from xml.dom import minidom
 from haversine import haversine, Unit
@@ -80,13 +81,46 @@ 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,
+            average_lap_speeds: ArrayLike,
+            simulation_dt: int,
+            driving_allowed: ArrayLike,
+            idle_time: int
+    ) -> NDArray[float]:
+        """
+        Generate valid driving speeds as a simulation-time array given a set of average speeds for each
+        simulated lap.
+        Driving speeds will only be non-zero when we are allowed to drive, and the speed
+        for every tick during a lap will be that lap's corresponding desired average speed for as long
+        as it takes to complete the lap.
+
+        :param average_lap_speeds: An array of average speeds in m/s, one for each simulated lap.
+            If there are more speeds given than laps available, the unused speeds will be silently ignored.
+            If there are too few, an error will be returned.
+        :param simulation_dt: The simulated tick length.
+        :param driving_allowed: A simulation-time boolean where the `True` elements are when we
+            are allowed to drive, and `False` is when we are not. Requires that (at least) the first element is
+            `False` due to the race beginning in the morning before we are allowed to drive.
+        :param idle_time: The length of time to pause driving upon processing a "0m/s" average speed.
+        :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 physics_rs.get_driving_speeds(
+            np.array(average_lap_speeds).astype(np.float64),
+            simulation_dt,
+            np.array(driving_allowed).astype(bool),
+            self.path_length,
+            idle_time
+        )
 
     @staticmethod
     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.
 
         """
 

physics/environment/gis/gis.rs

@@ -1,5 +1,4 @@
-use chrono::{Datelike, NaiveDateTime, Timelike};
-use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
+use numpy::ndarray::{ArrayViewD, ArrayView1};
 
 pub fn rust_closest_gis_indices_loop(
     distances: ArrayViewD<'_, f64>,
@@ -15,6 +14,9 @@ pub fn rust_closest_gis_indices_loop(
         while distance_travelled > path_distances[current_coord_index] {
             distance_travelled -= path_distances[current_coord_index];
             current_coord_index += 1;
+            if current_coord_index >= path_distances.len() {
+                current_coord_index = 0;
+            }
         }
 
         current_coord_index = std::cmp::min(current_coord_index, path_distances.len() - 1);
@@ -22,4 +24,90 @@ pub fn rust_closest_gis_indices_loop(
     }
 
     result
-}
+}
+
+///
+/// Generate valid driving speeds as a simulation-time array given a set of average speeds for each
+/// simulated lap.
+/// Driving speeds will only be non-zero when we are allowed to drive, and the speed
+/// for every tick during a lap will be that lap's corresponding desired average speed for as long
+/// as it takes to complete the lap.
+/// An average speed of 0m/s for a lap will be interpreted as "sit and charge" for `idle_time`
+/// ticks.
+///
+/// # Arguments
+///
+/// * `average_speeds`: An array of average speeds in m/s, one for each simulated lap. If there are more
+/// speeds given than laps available, the unused speeds will be silently ignored. If there are too
+/// few, an error will be returned.
+/// * `simulation_dt`: The simulated tick length
+/// * `driving_allowed_boolean`: A simulation-time boolean where the `True` elements are when we
+/// are allowed to drive, and `False` is when we are not.
+/// * `track_length`: The length of the track in meters.
+/// * `idle_time`: The number of ticks to "sit and charge" when desired.
+///
+/// Returns: 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.
+///
+pub fn get_driving_speeds(
+    average_speeds: ArrayView1<'_, f64>,            // Average speeds in m/s
+    simulation_dt: i64,                             // Time step in seconds
+    driving_allowed_boolean: ArrayView1<'_, bool>,  // Simulation-time boolean array
+    track_length: f64,                              // Track length in meters
+    idle_time: i64                                  // Time to idle in seconds
+) -> Result<Vec<f64>, &'static str> {
+    let ticks_to_complete_lap: Vec<i64> = average_speeds.iter().map(| &average_speed | {
+        if average_speed > 0.0 {
+            // The number of ticks is the number of seconds, divided by seconds per tick
+            (track_length / average_speed / simulation_dt as f64).ceil() as i64
+        } else {
+            (idle_time as f64 / simulation_dt as f64).ceil() as i64
+        }
+    }).collect();
+
+    let mut lap_index: usize = 0;
+    let mut lap_speed: f64 = average_speeds[lap_index];
+
+    let mut ticks_to_lap_completion: i64 = ticks_to_complete_lap[lap_index];
+
+    let mut driving_speeds: Vec<f64> = Vec::with_capacity(driving_allowed_boolean.len());
+    for driving_allowed in driving_allowed_boolean.iter() {
+        if !driving_allowed {
+            // If we aren't allowed to drive, speed should be zero. Also, we should mark that we are
+            // done our lap since it means we ended the day in the middle of the lap, and we will
+            // start the next day at the beginning of a new lap, not where we ended off.
+
+            // If it's the first lap, we don't want to skip because we are probably in the morning
+            // where we haven't begun driving yet.
+            if lap_index > 0 {
+                ticks_to_lap_completion = 0;
+            }
+
+            driving_speeds.push(0.0)
+        } else {
+            // If we are driving, we should decrement ticks to lap completion. If its already
+            // zero, that means that we are done the lap and should move onto the next lap.
+            if ticks_to_lap_completion > 0 {
+                ticks_to_lap_completion -= 1;
+
+                driving_speeds.push(lap_speed)
+            } else {
+                // To advance to the next lap, increment the index and evaluate new variables
+                lap_index += 1;
+                if lap_index >= average_speeds.len() {
+                    return Err("Not enough average speeds!")
+                }
+
+                // We subtract 1 since this iteration counts for the next lap, not the one
+                // that we just finished
+                ticks_to_lap_completion = ticks_to_complete_lap[lap_index] - 1;
+                lap_speed = average_speeds[lap_index];
+
+                driving_speeds.push(lap_speed)
+            }
+        }
+
+    }
+
+    Ok(driving_speeds)
+}

physics/environment/meteorology/clouded_meteorology.py

@@ -1,9 +1,8 @@
 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
+import physics_rs
 from typing import Optional
 import datetime
 
@@ -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
 
@@ -71,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:
         """
@@ -97,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)
 
@@ -125,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)

physics/environment/meteorology/irradiant_meteorology.py

@@ -1,8 +1,7 @@
 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
+import physics_rs
 from typing import Optional
 
 
@@ -12,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
@@ -25,16 +25,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
 
@@ -52,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:
         """
@@ -75,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]
@@ -102,5 +105,3 @@ class IrradiantMeteorology(BaseMeteorology):
 
         """
         return self.solar_irradiance
-
-

physics/lib.rs

@@ -1,13 +1,13 @@
-use chrono::{Datelike, NaiveDateTime, Timelike};
-use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
-use numpy::{PyArray, PyArrayDyn, PyReadwriteArrayDyn};
+use numpy::ndarray::ArrayViewD;
+use numpy::{PyArray, PyArrayDyn, PyReadwriteArrayDyn, PyReadwriteArray1, PyReadonlyArray1, PyArray1};
 use pyo3::prelude::*;
 use pyo3::types::PyModule;
 
 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::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_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")]
@@ -94,5 +94,71 @@ fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
         py_result
     }
 
+    #[pyfn(m)]
+    #[pyo3(name = "update_battery_state")]
+    fn update_battery_state_py<'py>(
+        py: Python<'py>,
+        python_energy_or_current_array: PyReadwriteArray1<'py, f64>,
+        time_step: f64,
+        initial_state_of_charge: f64,
+        initial_polarization_potential: 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,
+        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,
+            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);
+        let py_voltage_array = PyArray::from_vec(py, voltage_array);
+        (py_soc_array, py_voltage_array)
+    }
+
+    #[pyfn(m)]
+    #[pyo3(name = "get_driving_speeds")]
+    fn py_get_driving_speeds<'py>(
+        py: Python<'py>,
+        py_average_speeds: PyReadonlyArray1<'py, f64>,            // Average speeds in m/s
+        simulation_dt: i64,                                       // Time step in seconds
+        py_driving_allowed_boolean: PyReadonlyArray1<'py, bool>,  // Simulation-time boolean array
+        track_length: f64,                                        // Track length in meters
+        idle_time: i64                                            // Time to idle in seconds
+    ) -> PyResult<&'py PyArray1<f64>> {
+        let average_speeds = py_average_speeds.as_array();
+        let driving_allowed_boolean = py_driving_allowed_boolean.as_array();
+
+        match get_driving_speeds(
+            average_speeds,
+            simulation_dt,
+            driving_allowed_boolean,
+            track_length,
+            idle_time
+        ) {
+            Ok(driving_speeds) => Ok(PyArray1::from_vec(py, driving_speeds)),
+            Err(error) => Err(pyo3::exceptions::PyValueError::new_err(error))
+        }
+    }
+
     Ok(())
 }

physics/models/battery/__init__.py

@@ -1,7 +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"
+    "BasicBattery",
+    "EquivalentCircuitBatteryModel",
+    "FilteredBatteryModel",
+    "BatteryModelConfig",
+    "load_battery_config",
+    "EquivalentCircuitModelConfig",
+    "FilteredBatteryModelConfig",
+    "KalmanFilterConfig",
+    "SOCDependent"
 ]

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,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)
+}