ubc-solar-physics 0.1.0__cp311-cp311-macosx_13_0_universal2.whl

physics/environment/weather_forecasts/weather_forecasts.rs

@@ -0,0 +1,116 @@
+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
+}

physics/environment/weather_forecasts.rs

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

physics/environment.rs

@@ -0,0 +1,3 @@
+pub mod gis;
+pub mod solar_calculations;
+pub mod weather_forecasts;

physics/lib.rs

@@ -0,0 +1,76 @@
+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::solar_calculations::solar_calculations::rust_calculate_array_ghi_times;
+use crate::environment::weather_forecasts::weather_forecasts::{rust_closest_weather_indices_loop, rust_weather_in_time, rust_closest_timestamp_indices};
+
+/// 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 = "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
+    }
+
+    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,7 @@
+from .base_battery import BaseBattery
+from .basic_battery import BasicBattery
+
+__all__ = [
+    "BaseBattery",
+    "BasicBattery"
+]

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,141 @@
+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)

physics/models/battery.rs

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

physics/models/constants.py

@@ -0,0 +1,23 @@
+# Radius of the Earth (m)
+EARTH_RADIUS = 6371009
+
+# Acceleration caused by gravity (m/s^2)
+ACCELERATION_G = 9.81
+
+# Density of Air at 15C and 101kPa (kg/m^3)
+AIR_DENSITY = 1.225
+
+# Maximum number of waypoints that can be given to generate route data
+MAX_WAYPOINTS = 10
+
+# Solar Irradiance (W/m^2)
+SOLAR_IRRADIANCE = 1353
+
+# As we currently have a limited number of API calls(60) every minute with the
+# current Weather API, we must shrink the dataset significantly. As the
+# OpenWeatherAPI models have a resolution of between 2.5 - 70 km, we will
+# go for a resolution of 25km. Assuming we travel at 100km/h for 12 hours,
+# 1200 kilometres/25 = 48 API calls
+# As the Google Maps API has a resolution of around 40m between points,
+# for ASC, we must cull at 625:1 (because 25,000m / 40m = 625)
+REDUCTION_FACTOR = 625

physics/models/lvs/__init__.py

@@ -0,0 +1,7 @@
+from .base_lvs import BaseLVS
+from .basic_lvs import BasicLVS
+
+__all__ = [
+    "BaseLVS",
+    "BasicLVS"
+]

physics/models/lvs/base_lvs.py

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

physics/models/lvs/basic_lvs.py

@@ -0,0 +1,18 @@
+from physics.models.lvs.base_lvs import BaseLVS
+
+
+class BasicLVS(BaseLVS):
+
+    def __init__(self, consumed_energy, lvs_current, lvs_voltage):
+        super().__init__(consumed_energy)
+        self.lvs_current = lvs_current
+        self.lvs_voltage = lvs_voltage
+
+    def get_consumed_energy(self, tick):
+        """
+            Get the energy consumption of the Low Voltage System (current * voltage * time)
+
+            :param tick - (int) tick time passed
+            :returns: consumed_energy - (number) value of energy consumed
+        """
+        return self.lvs_current * self.lvs_voltage * tick

physics/models/lvs.rs

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

physics/models/motor/__init__.py

@@ -0,0 +1,7 @@
+from .base_motor import BaseMotor
+from .basic_motor import BasicMotor
+
+__all__ = [
+    "BaseMotor",
+    "BasicMotor"
+]

physics/models/motor/base_motor.py

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