ubc-solar-physics 1.3.0__cp311-cp311-win_amd64.whl

physics/environment/meteorology/irradiant_meteorology.py

@@ -0,0 +1,107 @@
+from physics.environment.meteorology.base_meteorology import BaseMeteorology
+from physics.environment.gis.gis import calculate_path_distances
+import numpy as np
+import core
+from typing import Optional
+
+
+class IrradiantMeteorology(BaseMeteorology):
+    """
+    IrradiantMeteorology encapsulates meteorological data that includes
+    solar irradiance data, but not cloud cover.
+
+    """
+    def __init__(self, race, weather_forecasts):
+        self._race = race
+        self._raw_weather_data = weather_forecasts
+
+        self._time_dt: Optional[np.ndarray] = None
+        self._ghi: Optional[np.ndarray] = None
+        self._longitude: Optional[np.ndarray] = None
+        self._latitude: Optional[np.ndarray] = None
+
+        self.last_updated_time = self._raw_weather_data[0, 0, 0]
+
+        super().__init__()
+
+    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 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 simplify_weather:
+            self._weather_indices = np.zeros_like(cumulative_distances, dtype=int)
+            return
+
+        # a list of all the coordinates that we have weather data for
+        weather_coords = self._raw_weather_data[:, 0, 1:3]
+
+        # distances between all the coordinates that we have weather data for
+        weather_path_distances = calculate_path_distances(weather_coords)
+        cumulative_weather_path_distances = np.cumsum(weather_path_distances)
+
+        # makes every even-index element negative, this allows the use of np.diff() to calculate the sum of consecutive
+        # elements
+        cumulative_weather_path_distances[::2] *= -1
+
+        # 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)
+
+    def temporally_localize(self, unix_timestamps, start_time, tick) -> None:
+        """
+
+        Takes in an array of indices of the weather_forecast array, and an array of timestamps. Uses those to figure out
+        what the weather forecast is at each time step being simulated.
+
+        we only have weather at discrete timestamps. The car however can be in any timestamp in
+        between. Therefore, we must be able to choose the weather timestamp that is closest to the one that the car is in
+        so that we can more accurately determine the weather experienced by the car at that timestamp.
+
+        For example, imagine the car is at some coordinate (x,y) at timestamp 100. Imagine we know the weather forecast
+        at (x,y) for five different timestamps: 0, 30, 60, 90, and 120. Which weather forecast should we
+        choose? Clearly, we should choose the weather forecast at 90 since it is the closest to 100. That's what the
+        below code is accomplishing.
+
+        :param np.ndarray unix_timestamps: (int[N]) unix timestamps of the vehicle's journey
+        :param int start_time: time since the start of the race that simulation is beginning
+        :param int tick: length of a tick in seconds
+        :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)
+
+        self._time_dt = forecasts_array[:, 0]
+        self._latitude = forecasts_array[:, 1]
+        self._longitude = forecasts_array[:, 2]
+        self._wind_speed = forecasts_array[:, 3]
+        self._wind_direction = forecasts_array[:, 4]
+        self._solar_irradiance = forecasts_array[:, 5]
+
+    def calculate_solar_irradiances(self, coords, time_zones, local_times, elevations):
+        """
+        Calculates the Global Horizontal Irradiance from the Sun, relative to a location
+        on the Earth, for arrays of coordinates, times, elevations and weathers
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local_times and time_zones are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray coords: (float[N][lat, lng]) array of latitudes and longitudes
+        :param np.ndarray time_zones: (int[N]) time zones at different locations in seconds relative to UTC
+        :param np.ndarray local_times: (int[N]) unix time that the vehicle will be at each location. (Adjusted for Daylight Savings)
+        :param np.ndarray elevations: (float[N]) elevation from sea level in m
+        :returns: (float[N]) Global Horizontal Irradiance in W/m2
+        :rtype: np.ndarray
+
+        """
+        return self.solar_irradiance
+
+

physics/environment/meteorology/meteorology.rs

@@ -0,0 +1,138 @@
+use chrono::{Datelike, NaiveDateTime, Timelike};
+use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
+
+
+pub fn rust_closest_weather_indices_loop(
+    cumulative_distances: ArrayViewD<'_, f64>,
+    average_distances: ArrayViewD<'_, f64>,
+) -> Vec<i64> {
+    let mut current_coord_index: usize = 0;
+    let mut result: Vec<i64> = Vec::with_capacity(cumulative_distances.len());
+
+    for &distance in cumulative_distances {
+        current_coord_index = std::cmp::min(current_coord_index, average_distances.len() - 1);
+
+        if distance > average_distances[current_coord_index] {
+            current_coord_index += 1;
+
+            current_coord_index =
+                std::cmp::min(current_coord_index, average_distances.len() - 1);
+        }
+
+        result.push(current_coord_index as i64);
+    }
+
+    result
+}
+
+pub fn rust_weather_in_time(
+    unix_timestamps: ArrayViewD<'_, i64>,
+    indices: ArrayViewD<'_, i64>,
+    weather_forecast: ArrayViewD<f64>,
+    dt_index: u8
+) -> Array2<f64> {
+    // Obtain dimensions for arrays and slices
+    let weather_forecast_raw_dim = weather_forecast.raw_dim();
+    let full_forecast_shape = (
+        weather_forecast_raw_dim[0],
+        weather_forecast_raw_dim[1],
+        weather_forecast_raw_dim[2],
+    );
+    let weather_at_coord_shape = (full_forecast_shape.1, full_forecast_shape.2);
+    let weather_in_time_shape = (indices.len(), full_forecast_shape.2);
+
+    // Create an empty full_weather_forecast_at_coords array (all zeros)
+    let indexed_weather_shape = (indices.len(), full_forecast_shape.1, full_forecast_shape.2);
+    let mut placeholder1: Vec<f64> =
+        vec![0.0; indexed_weather_shape.0 * indexed_weather_shape.1 * indexed_weather_shape.2];
+    let mut indexed_forecast =
+        ArrayViewMut3::from_shape(indexed_weather_shape, &mut placeholder1).unwrap();
+
+    // Fill full_weather_forecast_at_coords with the 2d slices at [indices]
+    for (out_index, &coord_index) in indices.iter().enumerate() {
+        let slice_2d = weather_forecast
+            .slice(s![coord_index as usize, .., ..])
+            .into_shape(weather_at_coord_shape)
+            .unwrap();
+        indexed_forecast
+            .slice_mut(s![out_index, .., ..])
+            .assign(&slice_2d);
+    }
+
+    let mut dt_local_array = Vec::with_capacity(full_forecast_shape.1);
+    // Populate dt_local_array with the list of forecast's timestamps at the first coordinate
+    // I don't really understand how this works
+    let dt_local_arrayview = weather_forecast
+        .index_axis_move(Axis(0), 0)
+        .index_axis_move(Axis(1), dt_index as usize);
+    for &timestamp in dt_local_arrayview {
+        dt_local_array.push(timestamp as i64);
+    }
+
+    let closest_timestamp_indices =
+        rust_closest_timestamp_indices(unix_timestamps, dt_local_array);
+
+    // Create a mutable array of the desired shape with dummy initial values
+    let mut placeholder2: Vec<f64> =
+        vec![0.0; weather_in_time_shape.0 * weather_in_time_shape.1];
+    let mut weather_in_time_arrayview =
+        ArrayViewMut2::from_shape(weather_in_time_shape, &mut placeholder2).unwrap();
+    for (index_1, &index_2) in closest_timestamp_indices.iter().enumerate() {
+        let slice_1d = indexed_forecast
+            .slice(s![index_1, index_2, ..])
+            .into_shape(full_forecast_shape.2)
+            .unwrap();
+        weather_in_time_arrayview
+            .slice_mut(s![index_1, ..])
+            .assign(&slice_1d);
+    }
+
+    weather_in_time_arrayview.into_owned()
+}
+
+pub fn rust_closest_timestamp_indices(
+    unix_timestamps: ArrayViewD<'_, i64>,
+    dt_local_array: Vec<i64>,
+) -> Vec<usize> {
+    let mut closest_time_stamp_indices: Vec<usize> = Vec::new();
+
+    for unix_timestamp in unix_timestamps {
+        let unix_timestamp_array =
+            Array::from_elem(dt_local_array.len(), unix_timestamp as &i64);
+        let mut differences: Vec<i64> = Vec::new();
+
+        for i in 0..unix_timestamp_array.len() {
+            differences.push((unix_timestamp - dt_local_array[i]).abs());
+        }
+
+        let (min_index, _) = differences
+            .iter()
+            .enumerate()
+            .min_by_key(|(_, &v)| v)
+            .unwrap();
+        closest_time_stamp_indices.push(min_index)
+    }
+    closest_time_stamp_indices
+}
+
+pub fn rust_calculate_array_ghi_times<'a>(
+    local_times: ArrayViewD<'_, u64>,
+) -> (Vec<f64>, Vec<f64>) {
+    let mut datetimes: Vec<_> = Vec::with_capacity(local_times.len());
+
+    for &unix_time_stamp in local_times {
+        let datetime = NaiveDateTime::from_timestamp_opt(unix_time_stamp as i64, 0).unwrap();
+        datetimes.push(datetime);
+    }
+
+    let day_of_year_out: Vec<f64> = datetimes
+        .iter()
+        .map(|&date| date.date().ordinal() as f64)
+        .collect();
+    let local_time_out: Vec<f64> = datetimes
+        .iter()
+        .map(|&date| date.time().num_seconds_from_midnight() as f64 / 3600.0)
+        .collect();
+
+    (day_of_year_out, local_time_out)
+}

physics/environment/meteorology.rs

@@ -0,0 +1 @@
+pub mod meteorology;

physics/environment.rs

@@ -0,0 +1,2 @@
+pub mod gis;
+pub mod meteorology;

physics/lib.rs

@@ -0,0 +1,132 @@
+use chrono::{Datelike, NaiveDateTime, Timelike};
+use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
+use numpy::{PyArray, PyArrayDyn, PyReadwriteArrayDyn};
+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::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;
+    static KMH_TO_MS: f64 = 1.0 / 3.6;
+
+    let ret: Vec<f64> = speeds.iter().map(| speed: &f64 | {
+        let speed_limit: f64 = speed_limits[distance.floor() as usize];
+        let vehicle_speed: f64 =f64::min(speed_limit, *speed);
+        distance += vehicle_speed * KMH_TO_MS * tick as f64;
+        vehicle_speed
+    }).collect();
+
+    return ret
+}
+
+/// A Python module implemented in Rust. The name of this function is the Rust module name!
+#[pymodule]
+#[pyo3(name = "core")]
+fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
+    #[pyfn(m)]
+        #[pyo3(name = "constrain_speeds")]
+        fn constrain_speeds_py<'py>(py: Python<'py>, x: PyReadwriteArrayDyn<'py, f64>, y: PyReadwriteArrayDyn<'py, f64>, z: i32) -> &'py PyArrayDyn<f64> {
+            let x = x.as_array();
+            let y = y.as_array();
+            let result = constrain_speeds(x, y, z);
+            return PyArray::from_vec(py, result).to_dyn();
+    }
+
+    #[pyfn(m)]
+    #[pyo3(name = "calculate_array_ghi_times")]
+    fn calculate_array_ghi_times<'py>(
+        py: Python<'py>,
+        python_local_times: PyReadwriteArrayDyn<'py, u64>,
+    ) -> (&'py PyArrayDyn<f64>, &'py PyArrayDyn<f64>) {
+        let local_times = python_local_times.as_array();
+        let (day_of_year_out, local_time_out) = rust_calculate_array_ghi_times(local_times);
+        let py_day_out = PyArray::from_vec(py, day_of_year_out).to_dyn();
+        let py_time_out = PyArray::from_vec(py, local_time_out).to_dyn();
+        (py_day_out, py_time_out)
+    }
+
+    #[pyfn(m)]
+    #[pyo3(name = "closest_gis_indices_loop")]
+    fn closest_gis_indices_loop<'py>(
+        py: Python<'py>,
+        python_cumulative_distances: PyReadwriteArrayDyn<'py, f64>,
+        python_average_distances: PyReadwriteArrayDyn<'py, f64>,
+    ) -> &'py PyArrayDyn<i64> {
+        let average_distances = python_average_distances.as_array();
+        let cumulative_distances = python_cumulative_distances.as_array();
+        let result = rust_closest_gis_indices_loop(cumulative_distances, average_distances);
+        let py_result = PyArray::from_vec(py, result).to_dyn();
+        py_result
+    }
+
+    #[pyfn(m)]
+    #[pyo3(name = "closest_weather_indices_loop")]
+    fn closest_weather_indices_loop<'py>(
+        py: Python<'py>,
+        python_cumulative_distances: PyReadwriteArrayDyn<'py, f64>,
+        python_average_distances: PyReadwriteArrayDyn<'py, f64>,
+    ) -> &'py PyArrayDyn<i64> {
+        let average_distances = python_average_distances.as_array();
+        let cumulative_distances = python_cumulative_distances.as_array();
+        let result = rust_closest_weather_indices_loop(cumulative_distances, average_distances);
+        let py_result = PyArray::from_vec(py, result).to_dyn();
+        py_result
+    }
+
+    #[pyfn(m)]
+    #[pyo3(name = "weather_in_time")]
+    fn weather_in_time<'py>(
+        py: Python<'py>,
+        python_unix_timestamps: PyReadwriteArrayDyn<'py, i64>,
+        python_indices: PyReadwriteArrayDyn<'py, i64>,
+        python_weather_forecast: PyReadwriteArrayDyn<'py, f64>,
+        index: u8
+    ) -> &'py PyArrayDyn<f64> {
+        let unix_timestamps = python_unix_timestamps.as_array();
+        let indices = python_indices.as_array();
+        let weather_forecast = python_weather_forecast.as_array();
+        let mut result = rust_weather_in_time(unix_timestamps, indices, weather_forecast, index);
+        let py_result = PyArray::from_array(py, &mut result).to_dyn();
+        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/__init__.py

@@ -0,0 +1,13 @@
+from .arrays import BasicArray
+from .battery import BasicBattery
+from .lvs import BasicLVS
+from .motor import BasicMotor
+from .regen import BasicRegen
+
+__all__ = [
+    "BasicArray",
+    "BasicBattery",
+    "BasicLVS",
+    "BasicMotor",
+    "BasicRegen"
+]

physics/models/arrays/__init__.py

@@ -0,0 +1,7 @@
+from .basic_array import BasicArray
+from .base_array import BaseArray
+
+__all__ = [
+    "BasicArray",
+    "BaseArray"
+]

physics/models/arrays/base_array.py

@@ -0,0 +1,6 @@
+from abc import ABC
+
+
+class BaseArray(ABC):
+    def __init__(self):
+        super().__init__()

physics/models/arrays/basic_array.py

@@ -0,0 +1,39 @@
+from physics.models.arrays.base_array import BaseArray
+
+
+class BasicArray(BaseArray):
+
+    # incident_sunlight:
+    def __init__(self, panel_efficiency, panel_size):
+        super().__init__()
+
+        # solar cell efficiency
+        self.panel_efficiency = panel_efficiency
+
+        # solar panel size in m^2
+        self.panel_size = panel_size
+
+        # please do not use this.
+        self.solar_irradiance = 1200
+
+    def calculate_produced_energy(self, solar_irradiance, tick):
+        """
+
+        Returns a numpy array with the energy produced by the solar panels across
+        each the length of each tick
+
+        :param np.ndarray solar_irradiance: (float[N]) the global horizontal irradiance(GHI) at
+            each moment experienced by the vehicle, in W/m2
+        :param float tick: (float) the duration of a time step in seconds
+
+        :returns: (float[N]) array of energy produced by the solar panels on the vehicle
+            in Joules
+        :rtype: np.ndarray
+
+        """
+        return solar_irradiance * self.panel_efficiency * self.panel_size * tick
+
+    def __str__(self):
+        return(f"BasicArray: incident_sunlight: {self.solar_irradiance}W/m^2\n"
+               f"BasicArray: panel_size: {self.panel_size}m^2\n"
+               f"BasicArray: panel_efficiency: {self.panel_efficiency * 100}%\n")

physics/models/arrays.rs

@@ -0,0 +1 @@
+mod arrays;

physics/models/battery/__init__.py

@@ -0,0 +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",
+    "BatteryModel",
+    "EKF_SOC",
+    "BatteryModelConfig",
+    "load_battery_config"
+]

physics/models/battery/base_battery.py

@@ -0,0 +1,29 @@
+from abc import ABC
+
+
+class BaseBattery(ABC):
+    def __init__(self, initial_energy, max_current_capacity, max_energy_capacity,
+                 max_voltage, min_voltage, voltage, state_of_charge):
+        super().__init__()
+
+        # Constants
+        self.max_current_capacity = max_current_capacity  # max capacity of battery (Ah)
+        self.max_energy_capacity = max_energy_capacity  # max energy inside battery (Wh)
+
+        self.max_voltage = max_voltage  # maximum battery voltage (V)
+        self.min_voltage = min_voltage  # battery cut-off voltage (V)
+
+        # Variables
+        self.stored_energy = initial_energy  # energy inside battery (Wh)
+        self.state_of_charge = state_of_charge  # battery state of charge
+        self.voltage = voltage  # terminal voltage of the battery (V)
+
+        if self.state_of_charge > 0:
+            self.empty = False  # 1 if battery is empty, 0 if battery is not empty
+        else:
+            self.empty = True
+
+    def __str__(self):
+        return (f"Battery stored energy: {self.stored_energy:.2f}Wh\n"
+                f"Battery state of charge: {self.state_of_charge * 100:.1f}%\n"
+                f"Battery voltage: {self.voltage:.2f}V\n")

physics/models/battery/basic_battery.py

@@ -0,0 +1,140 @@
+import numpy as np
+from numpy.polynomial import Polynomial
+from physics.models.battery.base_battery import BaseBattery
+
+
+class BasicBattery(BaseBattery):
+    """
+    Class representing the DayBreak battery pack.
+
+    Attributes:
+        max_voltage (float): maximum voltage of the DayBreak battery pack (V)
+        min_voltage (float): minimum voltage of the DayBreak battery pack (V)
+        max_current_capacity (float): nominal capacity of the DayBreak battery pack (Ah)
+        max_energy_capacity (float): nominal energy capacity of the DayBreak battery pack (Wh)
+
+        state_of_charge (float): instantaneous battery state-of-charge (0.00 - 1.00)
+        discharge_capacity (float): instantaneous amount of charge extracted from battery (Ah)
+        voltage (float): instantaneous voltage of the battery (V)
+        stored_energy (float): instantaneous energy stored in the battery (Wh)
+    """
+
+    def __init__(self, state_of_charge, max_voltage, min_voltage, max_current_capacity, max_energy_capacity):
+        """
+
+        Constructor for BasicBattery class.
+
+        :param float state_of_charge: initial battery state of charge
+
+        """
+
+        # ----- DayBreak battery constants -----
+
+        self.max_voltage = max_voltage
+        self.min_voltage = min_voltage
+        self.max_current_capacity = max_current_capacity
+        self.max_energy_capacity = max_energy_capacity
+
+        # ----- DayBreak battery equations -----
+
+        self.calculate_voltage_from_discharge_capacity = calculate_voltage_from_discharge_capacity()
+
+        self.calculate_energy_from_discharge_capacity = calculate_energy_from_discharge_capacity()
+
+        self.calculate_soc_from_discharge_capacity = calculate_soc_from_discharge_capacity(self.max_current_capacity)
+
+        self.calculate_discharge_capacity_from_soc = calculate_discharge_capacity_from_soc(self.max_current_capacity)
+
+        self.calculate_discharge_capacity_from_energy = calculate_discharge_capacity_from_energy()
+
+        # ----- DayBreak battery variables -----
+
+        self.state_of_charge = state_of_charge
+
+        # SOC -> discharge_capacity
+        self.discharge_capacity = self.calculate_discharge_capacity_from_soc(self.state_of_charge)
+
+        # discharge_capacity -> voltage
+        self.voltage = self.calculate_voltage_from_discharge_capacity(self.discharge_capacity)
+
+        # discharge_capacity -> energy
+        self.stored_energy = self.max_energy_capacity - self.calculate_energy_from_discharge_capacity(
+            self.discharge_capacity)
+
+        # ----- DayBreak battery initialisation -----
+
+        super().__init__(self.stored_energy, self.max_current_capacity, self.max_energy_capacity,
+                         self.max_voltage, self.min_voltage, self.voltage, self.state_of_charge)
+
+    def update_array(self, cumulative_energy_array):
+        """
+        Performs energy calculations with NumPy arrays
+
+        :param cumulative_energy_array: a NumPy array containing the cumulative energy changes at each time step
+        experienced by the battery
+
+        :return: soc_array – a NumPy array containing the battery state of charge at each time step
+
+        :return: voltage_array – a NumPy array containing the voltage of the battery at each time step
+
+        :return: stored_energy_array– a NumPy array containing the energy stored in the battery at each time step
+
+        """
+
+        stored_energy_array = np.full_like(cumulative_energy_array, fill_value=self.stored_energy)
+        stored_energy_array += cumulative_energy_array / 3600
+        stored_energy_array = np.clip(stored_energy_array, a_min=0, a_max=self.max_energy_capacity)
+
+        energy_discharged_array = np.full_like(cumulative_energy_array, fill_value=self.max_energy_capacity) - \
+                                  stored_energy_array
+
+        discharge_capacity_array = self.calculate_discharge_capacity_from_energy(energy_discharged_array)
+
+        soc_array = self.calculate_soc_from_discharge_capacity(discharge_capacity_array)
+        voltage_array = self.calculate_voltage_from_discharge_capacity(discharge_capacity_array)
+
+        return soc_array, voltage_array, stored_energy_array
+
+    def get_raw_soc(self, cumulative_energy_array):
+        """
+
+        Return the not truncated (SOC is allowed to go above 100% and below 0%) state of charge.
+
+        :param np.ndarray cumulative_energy_array: a NumPy array containing the cumulative energy changes at each time step
+        experienced by the battery
+
+        :return: a NumPy array containing the battery state of charge at each time step
+        :rtype: np.ndarray
+
+        """
+
+        stored_energy_array = np.full_like(cumulative_energy_array, fill_value=self.stored_energy)
+        stored_energy_array += cumulative_energy_array / 3600
+
+        energy_discharged_array = np.full_like(cumulative_energy_array, fill_value=self.max_energy_capacity) - stored_energy_array
+
+        discharge_capacity_array = self.calculate_discharge_capacity_from_energy(energy_discharged_array)
+
+        soc_array = self.calculate_soc_from_discharge_capacity(discharge_capacity_array)
+
+        return soc_array
+
+
+def calculate_voltage_from_discharge_capacity():
+    return Polynomial([117.6, -0.858896])  # -0.8589x + 117.6
+
+
+def calculate_energy_from_discharge_capacity():
+    return Polynomial([0, 117.6, -0.429448])  # -0.4294x^2 + 117.6x
+
+
+def calculate_soc_from_discharge_capacity(max_current_capacity):
+    return Polynomial([1, -1 / max_current_capacity])
+
+
+def calculate_discharge_capacity_from_soc(max_current_capacity):
+    return Polynomial([max_current_capacity, -max_current_capacity])
+
+
+def calculate_discharge_capacity_from_energy():
+    return lambda x: 136.92 - np.sqrt(18747.06027 - 2.32857 * x)