ubc-solar-physics 1.0.3__cp310-cp310-win32.whl

physics/environment/meteorology/irradiant_meteorology.py

@@ -0,0 +1,106 @@
+from physics.environment.meteorology.base_meteorology import BaseMeteorology
+from physics.environment.gis.gis import calculate_path_distances
+import numpy as np
+from physics.environment.race import Race
+import core
+from typing import Optional
+
+
+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) -> None:
+        """
+
+        :param np.ndarray cumulative_distances: NumPy Array representing cumulative distances theoretically achievable for a given input speed array
+        """
+        # if racing FSGP, 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:
+            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/race.py

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

physics/environment.rs

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

physics/lib.rs

@@ -0,0 +1,98 @@
+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};
+
+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
+    }
+
+    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")