ubc-solar-physics 1.7.10__cp313-cp313-win_amd64.whl → 1.8.0__cp313-cp313-win_amd64.whl

physics/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.7.10'
-__version_tuple__ = version_tuple = (1, 7, 10)
+__version__ = version = '1.8.0'
+__version_tuple__ = version_tuple = (1, 8, 0)

physics/environment/gis/base_gis.py

@@ -24,6 +24,11 @@ class BaseGIS(ABC):
     def get_path(self) -> np.ndarray:
         raise NotImplementedError
 
+    @staticmethod
+    @abstractmethod
+    def calculate_speeds_and_position(speeds_kmh: NDArray, track_speeds, path_distances, dt):
+        raise NotImplementedError
+
     @abstractmethod
     def calculate_current_heading_array(self) -> np.ndarray:
         raise NotImplementedError
@@ -33,6 +38,7 @@ class BaseGIS(ABC):
             average_lap_speeds: ArrayLike,
             simulation_dt: int,
             driving_allowed: ArrayLike,
-            idle_time: int
+            idle_time: int,
+            laps_per_speed: int
     ) -> NDArray[float]:
         raise NotImplementedError

physics/environment/gis/gis.py

@@ -34,21 +34,9 @@ class GIS(BaseGIS):
         self.path_time_zones = route_data['time_zones']
         self.num_unique_coords = route_data['num_unique_coords']
 
-        if current_coord is not None:
-            if not np.array_equal(current_coord, origin_coord):
-                logging.warning("Current position is not origin position. Modifying path data.\n")
-
-                # We need to find the closest coordinate along the path to the vehicle position
-                current_coord_index = GIS._find_closest_coordinate_index(current_coord, self.path)
-
-                # All coords before the current coordinate should be discarded
-                self.path = self.path[current_coord_index:]
-                self.path_elevations = self.path_elevations[current_coord_index:]
-                self.path_time_zones = self.path_time_zones[current_coord_index:]
-
-        self.path_distances = calculate_path_distances(self.path)
+        self.path_distances = calculate_path_distances(self.path)[:self.num_unique_coords]
         self.path_length = np.cumsum(calculate_path_distances(self.path[:self.num_unique_coords]))[-1]
-        self.path_gradients = calculate_path_gradients(self.path_elevations, self.path_distances)
+        self.path_gradients = calculate_path_gradients(self.path_elevations[:self.num_unique_coords], self.path_distances)
 
     @staticmethod
     def process_KML_file(route_file):
@@ -83,12 +71,58 @@ class GIS(BaseGIS):
         """
         return physics_rs.closest_gis_indices_loop(distances, self.path_distances)
 
+    def calculate_speeds_and_position(self, speeds_kmh: NDArray, track_speeds: NDArray, dt: int):
+        try:
+            return physics_rs.calculate_speeds_and_position(speeds_kmh, self.path_distances, track_speeds, dt)
+
+        except Exception:
+            return self._py_calculate_speeds_and_position(speeds_kmh, track_speeds, dt)
+
+    def _py_calculate_speeds_and_position(self, speeds_kmh: NDArray, track_speeds: NDArray, dt: int):
+        """
+        Given the original, lap-averaged `speeds_kmh` and an array of speed deviations in km/h for each track index,
+        compute the position and actual speed as simulation-time arrays.
+
+        :param speeds_kmh: Lap-averaged speeds in km/h.
+        :param track_speeds: A speed deviation in km/h for each track index. Expects the mean to be at 0.
+        :param dt:
+        :return:
+        """
+        result = []
+        actual_speeds_kmh = []
+
+        with tqdm(total=len(speeds_kmh), file=sys.stdout, desc="Calculating closest GIS indices") as pbar:
+            distance_travelled = 0
+            track_index = 0
+
+            for lap_speed in speeds_kmh:
+                if lap_speed > 0:
+                    actual_speed = lap_speed + track_speeds[track_index]
+                else:
+                    actual_speed = 0
+
+                actual_speeds_kmh.append(actual_speed)
+                distance_travelled += actual_speed * dt
+
+                while distance_travelled > self.path_distances[track_index]:
+                    distance_travelled -= self.path_distances[track_index]
+                    track_index += 1
+
+                    if track_index >= len(self.path_distances):
+                        track_index = 0
+
+                result.append(track_index)
+                pbar.update(1)
+
+        return np.array(result), np.array(actual_speeds_kmh)
+
     def calculate_driving_speeds(
             self,
             average_lap_speeds: ArrayLike,
             simulation_dt: int,
             driving_allowed: ArrayLike,
-            idle_time: int
+            idle_time: int,
+            laps_per_speed: int
     ) -> NDArray[float]:
         """
         Generate valid driving speeds as a simulation-time array given a set of average speeds for each
@@ -105,6 +139,7 @@ class GIS(BaseGIS):
             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.
+        :param laps_per_speed: The amount of laps that we expect to use with each speed value.
         :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.
         """
@@ -112,7 +147,7 @@ class GIS(BaseGIS):
             np.array(average_lap_speeds).astype(np.float64),
             simulation_dt,
             np.array(driving_allowed).astype(bool),
-            self.path_length,
+            self.path_length  * laps_per_speed,
             idle_time
         )
 

physics/environment/gis/gis.rs

@@ -26,6 +26,44 @@ pub fn rust_closest_gis_indices_loop(
     result
 }
 
+pub fn calculate_speeds_and_position(
+    speeds_kmh: ArrayView1<'_, f64>,
+    path_distances: ArrayView1<'_, f64>,
+    track_speeds: ArrayView1<'_, f64>,
+    simulation_dt: u32,
+) -> (Vec<usize>, Vec<f64>) {
+    let mut track_index: usize = 0;
+    let mut distance_travelled: f64 = 0.0;
+    let n = path_distances.len();
+
+    let mut result: Vec<usize> = Vec::with_capacity(speeds_kmh.len());
+    let mut actual_speeds_kmh: Vec<f64> = Vec::with_capacity(speeds_kmh.len());
+
+    for &speed in speeds_kmh {
+        let actual_speed = if speed > 0.0 {
+            speed + track_speeds[track_index]
+        } else {
+            0.0
+        };
+
+        actual_speeds_kmh.push(actual_speed);
+        distance_travelled += actual_speed * simulation_dt as f64;
+
+        while distance_travelled > path_distances[track_index] {
+            distance_travelled -= path_distances[track_index];
+            track_index += 1;
+
+            if track_index >= n {
+                track_index = 0;
+            }
+        }
+
+        result.push(track_index);
+    }
+
+    (result, actual_speeds_kmh)
+}
+
 ///
 /// Generate valid driving speeds as a simulation-time array given a set of average speeds for each
 /// simulated lap.

physics/lib.rs

@@ -5,7 +5,7 @@ use pyo3::types::PyModule;
 
 pub mod environment;
 pub mod models;
-use crate::environment::gis::gis::{rust_closest_gis_indices_loop, get_driving_speeds};
+use crate::environment::gis::gis::{rust_closest_gis_indices_loop, get_driving_speeds, calculate_speeds_and_position};
 use crate::environment::meteorology::meteorology::{rust_calculate_array_ghi_times, rust_closest_weather_indices_loop, rust_weather_in_time};
 use crate::models::battery::battery::update_battery_state;
 
@@ -135,6 +135,29 @@ fn rust_simulation(_py: Python, m: &PyModule) -> PyResult<()> {
         (py_soc_array, py_voltage_array)
     }
 
+    #[pyfn(m)]
+    #[pyo3(name = "calculate_speeds_and_position")]
+    fn calculate_speeds_and_position_py<'py>(
+        py: Python<'py>,
+        speeds_kmh_py: PyReadwriteArray1<'py, f64>,
+        path_distances_py: PyReadwriteArray1<'py, f64>,
+        track_speeds_py: PyReadwriteArray1<'py, f64>,
+        simulation_dt: u32,
+    ) -> (&'py PyArray1<usize>, &'py PyArray1<f64>) {
+        let speeds_kmh = speeds_kmh_py.as_array();
+        let path_distances = path_distances_py.as_array();
+        let track_speeds = track_speeds_py.as_array();
+        let (gis_indices, actual_speeds_kmh): (Vec<usize>, Vec<f64>) = calculate_speeds_and_position(
+            speeds_kmh,
+            path_distances,
+            track_speeds,
+            simulation_dt,
+        );
+        let gis_indices_py = PyArray::from_vec(py, gis_indices);
+        let actual_speeds_kmh_py = PyArray::from_vec(py, actual_speeds_kmh);
+        (gis_indices_py, actual_speeds_kmh_py)
+    }
+
     #[pyfn(m)]
     #[pyo3(name = "get_driving_speeds")]
     fn py_get_driving_speeds<'py>(

{ubc_solar_physics-1.7.10.dist-info → ubc_solar_physics-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.7.10
+Version: 1.8.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.7.10.dist-info → ubc_solar_physics-1.8.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-physics_rs.cp313-win_amd64.pyd,sha256=IODXdEkbXlIreLGKM8HZrnQYxR1Vsl4D5h1FlG0e_nA,403968
+physics_rs.cp313-win_amd64.pyd,sha256=dHh6gGtEaGbluby1Py82Vfk3OGKSHmPmsQTFwuIFhRk,402432
 physics/__init__.py,sha256=jRV9J_eGh0vNXEfFrILqcM6xxVjyqm3XwKAg1B1IPBs,183
-physics/_version.py,sha256=zbyvF0vz47l4h-H6959cL3Wr3-3fvCmzNwo4YNvowmQ,429
+physics/_version.py,sha256=P0uRCDtksTUMKDoGUCP6kcRBv2l_AtXyHqJM2GKICUI,427
 physics/environment.rs,sha256=OghmBkvHLZvzzuVsXUmV2lR3X_tEwuB9sT2TGZLQC6E,36
-physics/lib.rs,sha256=bvDbtWtLCH-YGSgvzsdKj-S7QVySc3sree6GUqfs-m0,7332
+physics/lib.rs,sha256=NgFabJsnZKqZ9qWDA4xuT1vHnhai3xhn1vhSLl4-rBM,8347
 physics/models.rs,sha256=747ABP-D1XKxA6X_MNh1PbmST0zsxpxhP_pEWjbR46c,63
 physics/environment/__init__.py,sha256=se_LVo4aWZKcZgbbK1KwwhHG8SH2zS1g6TEPw0GOZSs,225
 physics/environment/environment.rs,sha256=-VztdV2_GSlRbyIV_Pt6gKPVxpuNXpjLgAmoervonLg,34
 physics/environment/gis.rs,sha256=9R7G0cjf5PxQAz-CSryA6-KGfrh1eSwRhJ6qF8KfjDE,12
 physics/environment/meteorology.rs,sha256=naWb7qYrtMkCE_tLAkM474fmxaufhCkyhy3TTUQ4Yw4,20
 physics/environment/gis/__init__.py,sha256=SjqhVjuDbZln636zOFROq1tWPfadghkuYz8aheflyxA,96
-physics/environment/gis/base_gis.py,sha256=BsrF-r67XMwhjeKqB3zuNOmiC4jFV7HXfpZ_g6ZPASE,1084
-physics/environment/gis/gis.py,sha256=jESOVeHvBRxA1SXTLrjbLo5eqH1AmMmHNm1FVLY5FTU,13580
-physics/environment/gis/gis.rs,sha256=nyCekzEJCJTpm4Zy6shIm0AEoGsk6TljP-j7KlLn-38,4978
+physics/environment/gis/base_gis.py,sha256=gBoMRFx2OcGhMv4-6GUPdzF64kHDn_szZp53Gpf8_Q4,1290
+physics/environment/gis/gis.py,sha256=1_WFrmGhYa120kXNdfYISxlz1Pb1PQuE0M56bFkcQtk,14937
+physics/environment/gis/gis.rs,sha256=ay9jlparnvHnfYLxNWfsbVqdQVxH-RnqL4fGGdkOVqE,6098
 physics/environment/meteorology/__init__.py,sha256=mvjJw_0nNLIdh80F_yTaRC3Sw3oI-z1L0J5cOK_ei0k,157
 physics/environment/meteorology/base_meteorology.py,sha256=n0JsEXQLuciEatQp_S0QBXd_HQzCY5LeIQeVKgl5O-8,2487
 physics/environment/meteorology/clouded_meteorology.py,sha256=kaMUuQ42P-uvuzpyN8-l0NPk2AxvlfYZAdnxc0CHfuE,28265
@@ -50,8 +50,8 @@ physics/models/regen/base_regen.py,sha256=lY44jrTSHEo8Xv7hKCjo4C3Jx0PUgilyITHwQc
 physics/models/regen/basic_regen.py,sha256=SZl7nj75w-3uczfNfaZAMtcC4WO8M2mTmwbnB0HmrtU,2402
 physics/models/regen/regen.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 physics_rs/__init__.pyi,sha256=e34ADL3WjwR8ioVMwa0iDxgbgqUXrwNZvk_WVmrlkho,4346
-ubc_solar_physics-1.7.10.dist-info/LICENSE,sha256=1Vq7OikLHh7N0xsmTPHCmPkOxk1AXrMK9k1a1icQFlk,1087
-ubc_solar_physics-1.7.10.dist-info/METADATA,sha256=xDRYcUanrdpqeTSW_n1hoWM1GqM1TkJ740D_auWWH0s,5145
-ubc_solar_physics-1.7.10.dist-info/WHEEL,sha256=B1Vx2aiwhHpmSjbD9_IfE3D3lmEDXobmECRsgquMEQo,101
-ubc_solar_physics-1.7.10.dist-info/top_level.txt,sha256=jBZ5oyp1QQOrKodHG2UH9PMPEiZtza_q3y6fp3lEmQs,19
-ubc_solar_physics-1.7.10.dist-info/RECORD,,
+ubc_solar_physics-1.8.0.dist-info/LICENSE,sha256=1Vq7OikLHh7N0xsmTPHCmPkOxk1AXrMK9k1a1icQFlk,1087
+ubc_solar_physics-1.8.0.dist-info/METADATA,sha256=rC2TxVHjfSVobDcaAbVxvOnrHBYNFQwWs1PfmwFoKnw,5144
+ubc_solar_physics-1.8.0.dist-info/WHEEL,sha256=B1Vx2aiwhHpmSjbD9_IfE3D3lmEDXobmECRsgquMEQo,101
+ubc_solar_physics-1.8.0.dist-info/top_level.txt,sha256=jBZ5oyp1QQOrKodHG2UH9PMPEiZtza_q3y6fp3lEmQs,19
+ubc_solar_physics-1.8.0.dist-info/RECORD,,