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

ubc_solar_physics-1.6.0/.gitattributes

@@ -0,0 +1 @@
+**/*.csv linguist-generated=true

ubc_solar_physics-1.6.0/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,24 @@
+# [FEAT/FIX/DOCS]: Pull Request Name 
+
+- [ ] Linter Check Succeeded
+- [ ] All Tests Succeeded
+- [ ] Module Documentation
+- [ ] Method/Class/Function Documentation
+- [ ] Documentation Correctly Builds
+- [x] Pull Request Completed 
+
+## What's New
+[What has been added?]
+
+## Bugfixes
+[Have you added any bug fixes?]
+
+## Deprecated/Removed
+[Has anything been removed or deprecated?]
+
+## Dependencies
+[Any changes in dependencies?]
+
+## Notes
+[Anything else relevant?]
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.5.0
+Version: 1.6.0
 Summary: UBC Solar's Simulation Environment
 Author: Fisher Xue, Mihir Nimgade, Chris Chang, David Widjaja, Justin Hua, Ilya Veksler, Renu Rajamagesh, Ritchie Xia, Erik Langille, Chris Aung, Nicolas Ric, Ishaan Trivedi, Jason Liang, Felix Toft, Mack Wilson, Jonah Lee, Tamzeed Quazi, Joshua Riefman
 Author-email: UBC Solar <strategy@ubcsolar.com>

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.6.0}/docs/docs_requirements.txt

@@ -38,7 +38,6 @@ rich
 snowballstemmer
 Sphinx
 sphinx-autodoc-typehints
-sphinx-rtd-theme==2.0.0
 sphinxcontrib-applehelp
 sphinxcontrib-devhelp
 sphinxcontrib-htmlhelp
@@ -50,4 +49,5 @@ tqdm
 urllib3
 zipp
 setuptools_scm
-pydata-sphinx-theme==0.15.4
+pydata-sphinx-theme==0.15.4
+ubc-solar-physics==1.5.0

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.6.0}/docs/source/conf.py

@@ -1,16 +1,9 @@
-# from setuptools_scm import get_version
-# from pathlib import Path
-# import importlib
-
-# Generate the version file
-# version = get_version()
-# version_file = Path('physics/_version.py')
-# version_file.write_text(f"__version__ = '{version}'\n")
-
-# Dynamically import the version
-# importlib.invalidate_caches()
-# physics_module = importlib.import_module("physics")
-# __version__ = physics_module.__version__
+import os
+import sys
+sys.path.insert(0, os.path.abspath('../../'))  # Adjust as necessary
+print(sys.path)
+print(os.listdir(os.getcwd()))
+print(os.listdir(sys.path[0]))
 
 # Configuration file for the Sphinx documentation builder.
 #
@@ -23,7 +16,7 @@
 project = 'UBC Solar Physics'
 copyright = '2024, UBC Solar'
 author = 'Joshua Riefman'
-release = '1.0.0'
+release = "1.0.0"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

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

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

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.6.0}/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

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

@@ -4,6 +4,7 @@ import core
 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
@@ -82,6 +83,39 @@ class GIS(BaseGIS):
         """
         return core.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 core.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):
         """

ubc_solar_physics-1.6.0/physics/environment/gis/gis.rs

@@ -0,0 +1,113 @@
+use numpy::ndarray::{ArrayViewD, ArrayView1};
+
+pub fn rust_closest_gis_indices_loop(
+    distances: ArrayViewD<'_, f64>,
+    path_distances: ArrayViewD<'_, f64>,
+) -> Vec<i64> {
+    let mut current_coord_index: usize = 0;
+    let mut distance_travelled: f64 = 0.0;
+    let mut result: Vec<i64> = Vec::with_capacity(distances.len());
+
+    for &distance in distances {
+        distance_travelled += distance;
+
+        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);
+        result.push(current_coord_index as i64);
+    }
+
+    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)
+}

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

@@ -1,13 +1,12 @@
-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, 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_array;
 
 fn constrain_speeds(speed_limits: ArrayViewD<f64>,  speeds: ArrayViewD<f64>, tick: i32) -> Vec<f64> {
@@ -128,5 +127,30 @@ fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
         (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(())
 }

ubc_solar_physics-1.6.0/tests/gis_tests/test_calculate_driving_speeds.py

@@ -0,0 +1,70 @@
+import core
+import numpy as np
+import pytest
+
+
+def test_calculate_driving_speeds_simple():
+    """
+    Test a simple case of the driving speeds with no rounding
+    """
+    average_speeds = np.array([10, 14, 30, 0, 10, 20, 30], dtype=np.float64)
+    track_length = 30
+    simulation_dt = 1
+
+    idle_time = 3
+    driving_allowed = np.array([0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=bool)
+    driving_speeds = core.get_driving_speeds(average_speeds, simulation_dt, driving_allowed, track_length, idle_time)
+
+    assert np.all(np.equal(driving_speeds, [0, 10, 10, 10, 14, 14, 0, 0, 0, 0, 0, 30, 0, 0, 0, 10, 10, 10, 20, 20, 30]))
+
+
+def test_calculate_driving_speeds_fp():
+    """
+    Test the driving speeds with floating point rounding going on
+    :return:
+    """
+    average_speeds = np.array([9.9, 30.7, 15.2, 15.3], dtype=np.float64)
+    track_length = 30.6
+    simulation_dt = 1
+
+    idle_time = 3
+    driving_allowed = np.array([0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=bool)
+    driving_speeds = core.get_driving_speeds(average_speeds, simulation_dt, driving_allowed, track_length, idle_time)
+
+    assert np.allclose(driving_speeds, np.array([0, 0, 9.9, 9.9, 9.9, 9.9, 30.7, 15.2, 15.2, 15.2, 15.3, 15.3]), atol=1e-3)
+
+
+def test_calculate_driving_speeds_fp_with_tick():
+    """
+    Test the driving speeds with floating point rounding going on and tick != 1.
+    """
+    average_speeds = np.array([10.2, 30.7, 15.2, 15.3], dtype=np.float64)
+    track_length = 30.6
+    simulation_dt = 2
+
+    idle_time = 3
+    driving_allowed = np.array([0, 0, 1, 1, 1, 1, 1, 1], dtype=bool)
+    driving_speeds = core.get_driving_speeds(average_speeds, simulation_dt, driving_allowed, track_length, idle_time)
+
+    assert np.allclose(driving_speeds, np.array([0, 0, 10.2, 10.2, 30.7, 15.2, 15.2, 15.3]), atol=1e-3)
+    pass
+
+
+def test_failure():
+    """
+    Test that nothing fails when too many average speeds are provided, and that ValueError is raised when
+    not enough laps are provided.
+    """
+    average_speeds_too_many = np.array([10, 14, 30, 0, 10, 20, 30, 10, 10], dtype=np.float64)
+    average_speeds_too_few = np.array([10, 14, 30, 0, 10, 20], dtype=np.float64)
+    track_length = 30
+    simulation_dt = 1
+    idle_time = 3
+    driving_allowed = np.array([0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=bool)
+
+    with pytest.raises(ValueError):
+        core.get_driving_speeds(average_speeds_too_few, simulation_dt, driving_allowed, track_length, idle_time)
+
+    driving_speeds = core.get_driving_speeds(average_speeds_too_many, simulation_dt, driving_allowed, track_length, idle_time)
+
+    assert np.all(np.equal(driving_speeds, [0, 10, 10, 10, 14, 14, 0, 0, 0, 0, 0, 30, 0, 0, 0, 10, 10, 10, 20, 20, 30]))

ubc_solar_physics-1.6.0/tests/gis_tests/test_gis_driving_speeds.py

@@ -0,0 +1,322 @@
+from physics.environment import GIS
+import numpy as np
+import math
+
+
+coordinates = [
+    [36.99932082, -86.37230251],
+    [36.99940337, -86.37214797],
+    [36.99948814, -86.37199725],
+    [36.99958754, -86.37189043],
+    [36.99970528, -86.37178738],
+    [36.99982625, -86.37169183],
+    [36.99997073, -86.37159181],
+    [37.00011471, -86.3714889],
+    [37.00027357, -86.37138907],
+    [37.0003852, -86.37123775],
+    [37.00042033, -86.37099884],
+    [37.00038811, -86.3707825],
+    [37.00031195, -86.37062837],
+    [37.00026491, -86.37041498],
+    [37.00030254, -86.37020247],
+    [37.00038472, -86.3700261],
+    [37.0004699, -86.36984594],
+    [37.00056383, -86.36964375],
+    [37.00064015, -86.3694857],
+    [37.00070993, -86.36934481],
+    [37.0008098, -86.36912411],
+    [37.00090662, -86.36891836],
+    [37.00098578, -86.36874579],
+    [37.00107373, -86.36854755],
+    [37.0011529, -86.36837867],
+    [37.00122817, -86.3682181],
+    [37.00133071, -86.36801267],
+    [37.00143614, -86.36779264],
+    [37.00152389, -86.3675912],
+    [37.00160574, -86.36740819],
+    [37.00167596, -86.36725066],
+    [37.00175285, -86.36709064],
+    [37.00183166, -86.36691875],
+    [37.00192538, -86.36670617],
+    [37.00200136, -86.36653034],
+    [37.00208623, -86.36635086],
+    [37.00215644, -86.36619701],
+    [37.00222549, -86.36603626],
+    [37.00229839, -86.3658645],
+    [37.00237732, -86.36569622],
+    [37.00245038, -86.36553914],
+    [37.00252912, -86.36537128],
+    [37.00259904, -86.36521818],
+    [37.00266755, -86.36507091],
+    [37.00274639, -86.36490341],
+    [37.00283342, -86.36471029],
+    [37.00291248, -86.36454704],
+    [37.00298517, -86.36439075],
+    [37.0030636, -86.36423803],
+    [37.00313338, -86.36408574],
+    [37.00320937, -86.36393701],
+    [37.00330797, -86.36377724],
+    [37.00343811, -86.36368662],
+    [37.00357758, -86.36365019],
+    [37.00372489, -86.36360692],
+    [37.00388711, -86.36356354],
+    [37.00405472, -86.36352621],
+    [37.00423763, -86.36348621],
+    [37.00437129, -86.36338074],
+    [37.00448184, -86.36323899],
+    [37.00457515, -86.36307953],
+    [37.0047012, -86.36286956],
+    [37.00486024, -86.36273924],
+    [37.00505061, -86.36270756],
+    [37.00527945, -86.36272947],
+    [37.00548802, -86.36263566],
+    [37.00565341, -86.36245496],
+    [37.00573513, -86.3621647],
+    [37.00568611, -86.36182869],
+    [37.00548782, -86.36157939],
+    [37.0052881, -86.36149696],
+    [37.00511652, -86.36149669],
+    [37.0049746, -86.36158761],
+    [37.00485989, -86.3616726],
+    [37.00469955, -86.3617696],
+    [37.00451492, -86.36178471],
+    [37.00435852, -86.36173599],
+    [37.00419576, -86.36162316],
+    [37.00409127, -86.36146652],
+    [37.00404463, -86.3612301],
+    [37.00407232, -86.36097832],
+    [37.00415922, -86.36078578],
+    [37.00426711, -86.36066944],
+    [37.00439509, -86.36060407],
+    [37.00452844, -86.36057503],
+    [37.00466778, -86.36054604],
+    [37.004833, -86.36050987],
+    [37.00499495, -86.36047743],
+    [37.00514229, -86.36044484],
+    [37.00524902, -86.36041601],
+    [37.00541074, -86.36037856],
+    [37.00558676, -86.36034575],
+    [37.00578957, -86.36038183],
+    [37.00596102, -86.36045445],
+    [37.00607154, -86.36065091],
+    [37.0061651, -86.36090615],
+    [37.00626234, -86.3611639],
+    [37.00637312, -86.36147776],
+    [37.00642557, -86.36179897],
+    [37.00644459, -86.36216748],
+    [37.00637929, -86.36250433],
+    [37.00629836, -86.36273906],
+    [37.00622229, -86.36291634],
+    [37.00611158, -86.36309997],
+    [37.00600738, -86.36323379],
+    [37.00589169, -86.3633461],
+    [37.00576471, -86.36344689],
+    [37.00564905, -86.36353398],
+    [37.00551878, -86.36359932],
+    [37.00537978, -86.36365448],
+    [37.00525188, -86.36370605],
+    [37.0051236, -86.36376501],
+    [37.00497727, -86.36382802],
+    [37.00484855, -86.36391978],
+    [37.00471266, -86.36403361],
+    [37.0045783, -86.36422396],
+    [37.00447907, -86.36439954],
+    [37.00435695, -86.36453807],
+    [37.00424813, -86.36465022],
+    [37.00411061, -86.36480228],
+    [37.00397977, -86.36492984],
+    [37.0038682, -86.36504946],
+    [37.00376295, -86.36516126],
+    [37.00365436, -86.36527329],
+    [37.00354759, -86.36539144],
+    [37.00341675, -86.36552332],
+    [37.00329206, -86.3656715],
+    [37.00316095, -86.36581567],
+    [37.00303256, -86.36594441],
+    [37.00291203, -86.36607157],
+    [37.00278014, -86.36622802],
+    [37.00269333, -86.36641303],
+    [37.00260606, -86.36659437],
+    [37.00252845, -86.36675984],
+    [37.00243487, -86.36695271],
+    [37.00234795, -86.36716654],
+    [37.00226102, -86.36735999],
+    [37.00218046, -86.36754144],
+    [37.00210026, -86.36771854],
+    [37.00202358, -86.36787901],
+    [37.00194406, -86.36806693],
+    [37.00185835, -86.36825428],
+    [37.00177578, -86.36843604],
+    [37.00169902, -86.36860048],
+    [37.0016732, -86.3687928],
+    [37.001679, -86.3689974],
+    [37.00168488, -86.36919051],
+    [37.00169122, -86.36938766],
+    [37.00169469, -86.3695562],
+    [37.00170118, -86.36974238],
+    [37.00171055, -86.36993991],
+    [37.00167198, -86.37010864],
+    [37.00158558, -86.37021273],
+    [37.00148934, -86.37030898],
+    [37.00139295, -86.37041757],
+    [37.00129011, -86.37051816],
+    [37.00120286, -86.37061913],
+    [37.00112253, -86.37073184],
+    [37.00106144, -86.37085264],
+    [37.00099678, -86.37100197],
+    [37.00092255, -86.37116696],
+    [37.00083249, -86.37137665],
+    [37.00073506, -86.37159438],
+    [37.00065426, -86.37177611],
+    [37.00057398, -86.37196168],
+    [37.00060097, -86.37214635],
+    [37.00074272, -86.37221467],
+    [37.0009059, -86.37222018],
+    [37.00107657, -86.37218846],
+    [37.00122503, -86.37211976],
+    [37.00133803, -86.37204677],
+    [37.00145467, -86.37192099],
+    [37.00156457, -86.37178347],
+    [37.00167114, -86.37162599],
+    [37.00176434, -86.37145299],
+    [37.00183833, -86.37126821],
+    [37.00188646, -86.37112396],
+    [37.0019441, -86.37095574],
+    [37.00197296, -86.370787],
+    [37.00202945, -86.37067751],
+    [37.00209668, -86.37048098],
+    [37.00218305, -86.37031655],
+    [37.00228558, -86.37016005],
+    [37.00238818, -86.37002764],
+    [37.00249377, -86.36991909],
+    [37.00259639, -86.36983868],
+    [37.00270864, -86.36976266],
+    [37.00281411, -86.3697033],
+    [37.00292264, -86.36964769],
+    [37.00303847, -86.369599],
+    [37.00316942, -86.36952703],
+    [37.00332578, -86.36939126],
+    [37.00342743, -86.36921198],
+    [37.00346211, -86.36901195],
+    [37.00343231, -86.36879509],
+    [37.00336736, -86.36861758],
+    [37.00327983, -86.36847602],
+    [37.00316589, -86.36828932],
+    [37.00305696, -86.36810259],
+    [37.00296937, -86.36793662],
+    [37.00293802, -86.36773416],
+    [37.00295792, -86.36753614],
+    [37.00301643, -86.36739089],
+    [37.00307192, -86.36724611],
+    [37.00312788, -86.36711056],
+    [37.00320856, -86.36698638],
+    [37.00331523, -86.36684361],
+    [37.00340519, -86.36672019],
+    [37.00350264, -86.36658791],
+    [37.00361135, -86.36649982],
+    [37.00374245, -86.36645177],
+    [37.00387034, -86.3664758],
+    [37.00395668, -86.36655587],
+    [37.00402368, -86.36670753],
+    [37.00407807, -86.36686779],
+    [37.00412607, -86.36701603],
+    [37.00418686, -86.36718831],
+    [37.00427315, -86.36742386],
+    [37.00436296, -86.3676927],
+    [37.00442144, -86.36790543],
+    [37.00445858, -86.36815496],
+    [37.00447715, -86.36847342],
+    [37.00444541, -86.36882644],
+    [37.00434238, -86.36911386],
+    [37.00425654, -86.36927291],
+    [37.00418289, -86.36939303],
+    [37.00410293, -86.36950912],
+    [37.00399731, -86.36962489],
+    [37.00390147, -86.36973254],
+    [37.00379293, -86.36984054],
+    [37.00369701, -86.36994104],
+    [37.00359474, -86.37004514],
+    [37.0034838, -86.3701598],
+    [37.00338477, -86.37024376],
+    [37.00327609, -86.37032788],
+    [37.00318982, -86.37040789],
+    [37.00306205, -86.37049992],
+    [37.00294389, -86.37059192],
+    [37.00283177, -86.37070006],
+    [37.00272312, -86.37083897],
+    [37.00264003, -86.37094293],
+    [37.00255683, -86.37103895],
+    [37.00249914, -86.37115127],
+    [37.00243497, -86.37126771],
+    [37.00236746, -86.3713964],
+    [37.00230001, -86.37152106],
+    [37.00223561, -86.37164596],
+    [37.00217132, -86.37175865],
+    [37.0021135, -86.37187932],
+    [37.00204601, -86.37200003],
+    [37.00196791, -86.37211434],
+    [37.00188761, -86.3722312],
+    [37.00180726, -86.37233202],
+    [37.00173651, -86.37241676],
+    [37.00165284, -86.37250555],
+    [37.00155067, -86.3726109],
+    [37.00144762, -86.37271211],
+    [37.00136704, -86.37279282],
+    [37.00126713, -86.37288565],
+    [37.00115123, -86.37299929],
+    [37.00103518, -86.37310829],
+    [37.0009191, -86.37321738],
+    [37.00082561, -86.37329809],
+    [37.00072863, -86.37339546],
+    [37.00061364, -86.37350099],
+    [37.00051698, -86.37360214],
+    [37.00042667, -86.37368311],
+    [37.00032338, -86.37378434],
+    [37.00022342, -86.37387665],
+    [37.00012018, -86.3739737],
+    [37.00002051, -86.37405916],
+    [36.99991404, -86.37415222],
+    [36.99981076, -86.37423248],
+    [36.99970432, -86.37430523],
+    [36.99958169, -86.37432571],
+    [36.99946928, -86.37430399],
+    [36.99934964, -86.37428072],
+    [36.99922365, -86.37425686],
+    [36.99908793, -86.37422888],
+    [36.99899069, -86.37413638],
+    [36.99896465, -86.37397888],
+    [36.9989808, -86.37380904],
+    [36.99900664, -86.37362303],
+    [36.99904589, -86.37342887],
+    [36.9990885, -86.37323096],
+    [36.99912743, -86.3730292],
+    [36.99916641, -86.37284378],
+    [36.99921127, -86.37261758],
+    [36.99924349, -86.37245211],
+]
+
+
+def test_gis():
+    route_data = {
+        "path": coordinates,
+        "elevations": np.ones(len(coordinates)),
+        "time_zones": np.ones(len(coordinates)),
+        "num_unique_coords": len(coordinates),
+    }
+
+    gis = GIS(route_data, origin_coord=coordinates[0])
+
+    track_length = gis.path_length
+    speed = 120
+    time_to_complete_lap = math.ceil(track_length / speed)
+    idle_time = 30
+
+    driving_allowed = [False] * 10 + [True] * time_to_complete_lap + [True] * idle_time + [False] * 10
+
+    driving_speeds = gis.calculate_driving_speeds(
+        average_lap_speeds=[speed, 0],
+        driving_allowed=driving_allowed,
+        idle_time=idle_time,
+        simulation_dt=1)
+
+    assert np.allclose(driving_speeds, np.array([[0] * 10 + [speed] * time_to_complete_lap + [0] * idle_time + [0] * 10]), atol=1e-3)

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.6.0}/ubc_solar_physics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.5.0
+Version: 1.6.0
 Summary: UBC Solar's Simulation Environment
 Author: Fisher Xue, Mihir Nimgade, Chris Chang, David Widjaja, Justin Hua, Ilya Veksler, Renu Rajamagesh, Ritchie Xia, Erik Langille, Chris Aung, Nicolas Ric, Ishaan Trivedi, Jason Liang, Felix Toft, Mack Wilson, Jonah Lee, Tamzeed Quazi, Joshua Riefman
 Author-email: UBC Solar <strategy@ubcsolar.com>

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.6.0}/ubc_solar_physics.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+.gitattributes
 .gitignore
 .readthedocs.yaml
 Cargo.lock
@@ -6,7 +7,7 @@ LICENSE
 README.md
 data.png
 pyproject.toml
-.github/pull_request_template.md
+.github/PULL_REQUEST_TEMPLATE.md
 .github/workflows/build_and_publish.yaml
 .github/workflows/run_tests.yaml
 docs/Makefile
@@ -91,6 +92,8 @@ physics/models/regen/basic_regen.py
 physics/models/regen/regen.rs
 tests/battery_config.toml
 tests/test_versioning.py
+tests/gis_tests/test_calculate_driving_speeds.py
+tests/gis_tests/test_gis_driving_speeds.py
 tests/kalman_filter_tests/current.csv
 tests/kalman_filter_tests/test_basic_kalman_filter.py
 tests/kalman_filter_tests/test_filter_real_data.py

ubc_solar_physics-1.5.0/.github/pull_request_template.md

@@ -1 +0,0 @@
-# Physics Pull Request Template

ubc_solar_physics-1.5.0/physics/environment/gis/gis.rs

@@ -1,25 +0,0 @@
-use chrono::{Datelike, NaiveDateTime, Timelike};
-use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
-
-pub fn rust_closest_gis_indices_loop(
-    distances: ArrayViewD<'_, f64>,
-    path_distances: ArrayViewD<'_, f64>,
-) -> Vec<i64> {
-    let mut current_coord_index: usize = 0;
-    let mut distance_travelled: f64 = 0.0;
-    let mut result: Vec<i64> = Vec::with_capacity(distances.len());
-
-    for &distance in distances {
-        distance_travelled += distance;
-
-        while distance_travelled > path_distances[current_coord_index] {
-            distance_travelled -= path_distances[current_coord_index];
-            current_coord_index += 1;
-        }
-
-        current_coord_index = std::cmp::min(current_coord_index, path_distances.len() - 1);
-        result.push(current_coord_index as i64);
-    }
-
-    result
-}