ubc-solar-physics 1.4.2__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.4.2 → ubc_solar_physics-1.6.0}/.github/workflows/build_and_publish.yaml

@@ -20,12 +20,12 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0  # Required to fetch full history including tags, so setuptools_scm can determine version
 
       - name: Setup Python
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v4
         with:
           python-version: '3.9'
 
@@ -59,7 +59,7 @@ jobs:
           fetch-depth: 0  # Required to fetch full history including tags, so setuptools_scm can determine version
 
       - name: Set up Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
 
       # We run `python -m setuptools_scm` and `git status` for debugging purposes, to verify that
       # setuptools_scm is properly identifying the version based on the tag
@@ -92,7 +92,7 @@ jobs:
         run: cibuildwheel --output-dir dist
         env:
           CIBW_ARCHS_MACOS: "x86_64 arm64"  # Make sure both x86_64 and arm64 wheels are built for macOS
-          CIBW_ENVIRONMENT: 'PATH="$HOME/.cargo/bin:$PATH"'
+          CIBW_ENVIRONMENT: 'PATH="$HOME/.cargo/bin:$PATH" MACOSX_DEPLOYMENT_TARGET="10.12"'
           CIBW_ENVIRONMENT_WINDOWS: 'PATH="$UserProfile\.cargo\bin;$PATH"'
           CIBW_BEFORE_BUILD: >
             pip install -U setuptools-rust &&

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.4.2
+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.4.2 → 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.4.2 → 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.4.2 → ubc_solar_physics-1.6.0}/physics/_version.py

@@ -1,13 +1,8 @@
-# file generated by setuptools-scm
+# file generated by setuptools_scm
 # don't change, don't track in version control
-
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
-
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
+    from typing import Tuple, Union
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -17,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.4.2'
-__version_tuple__ = version_tuple = (1, 4, 2)
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)

{ubc_solar_physics-1.4.2 → 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.4.2 → 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.4.2 → 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.4.2 → ubc_solar_physics-1.6.0}/physics/models/motor/__init__.py

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

ubc_solar_physics-1.6.0/physics/models/motor/advanced_motor.py

@@ -0,0 +1,196 @@
+import numpy as np
+from haversine import haversine, Unit
+from numpy.typing import NDArray
+from physics.models.motor import BasicMotor
+
+
+class AdvancedMotor(BasicMotor):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.cornering_coefficient = 15  # tuned to Day 1 and 3 FSGP data
+
+    def calculate_energy_in(self, required_speed_kmh, gradients, wind_speeds, tick, coords):
+        """
+        A function which takes in array of elevation, array of wind speed, required
+            speed, returns the consumed energy.
+
+        :param np.ndarray required_speed_kmh: (float[N]) required speed array in km/h
+        :param np.ndarray gradients: (float[N]) gradient at parts of the road
+        :param np.ndarray wind_speeds: (float[N]) speeds of wind in m/s, where > 0 means against the direction of the vehicle
+        :param float tick: length of 1 update cycle in seconds
+        :param np.ndarray coords: ([float[N,2]) The lat,lon coordinate  of the car at each tick
+        :returns: (float[N]) energy expended by the motor at every tick
+        :rtype: np.ndarray
+
+        """
+        net_force, required_angular_speed_rads = self.calculate_net_force(required_speed_kmh, wind_speeds, gradients)
+
+        cornering_work = self.calculate_cornering_losses(required_speed_kmh, coords, tick)
+
+        motor_output_energies = required_angular_speed_rads * net_force * self.tire_radius * tick + cornering_work
+        motor_output_energies = np.clip(motor_output_energies, a_min=0, a_max=None)
+
+        e_m = self.calculate_motor_efficiency(required_angular_speed_rads, motor_output_energies, tick)
+        e_mc = self.calculate_motor_controller_efficiency(required_angular_speed_rads, motor_output_energies, tick)
+
+        motor_controller_input_energies = motor_output_energies / (e_m * e_mc)
+
+        # Filter out and replace negative energy consumption as 0
+        motor_controller_input_energies = np.where(motor_controller_input_energies > 0,
+                                                   motor_controller_input_energies, 0)
+
+        return motor_controller_input_energies
+
+    def calculate_cornering_losses(self, required_speed_kmh, coords, tick):
+        """
+        Calculate the energy losses due to cornering based on vehicle speed and trajectory.
+
+        :param np.ndarray required_speed_kmh: (float[N]) Required speed array in km/h
+        :param np.ndarray coords: (float[N, 2]) Array containing latitude and longitude coordinates of the car at each tick
+        :param float tick: Length of one update cycle in seconds
+        :returns: (float[N]) Energy loss due to cornering at each tick
+        :rtype: np.ndarray
+        """
+        required_speed_ms = required_speed_kmh / 3.6
+        cornering_radii = self.calculate_radii(coords)
+
+        centripetal_lateral_force = self.vehicle_mass * (required_speed_ms ** 2) / cornering_radii
+        centripetal_lateral_force = np.clip(centripetal_lateral_force, a_min=0, a_max=10000)
+
+        slip_angles_degrees = self.get_slip_angle_for_tire_force(centripetal_lateral_force)
+        slip_angles_radians = np.radians(slip_angles_degrees)
+        slip_distances = np.tan(slip_angles_radians) * required_speed_ms * tick
+
+        return slip_distances * centripetal_lateral_force * self.cornering_coefficient
+
+    def calculate_radii(self, coords):
+        """
+        Calculate the cornering radii for a given set of waypoints.
+
+        :param np.ndarray coords: (float[N, 2]) Array containing latitude and longitude coordinates of the car's path
+        :returns: (float[N]) Array of cornering radii at each waypoint
+        :rtype: np.ndarray
+        """
+
+        # pop off last coordinate if first and last coordinate are the same
+        repeated_last_coordinate = False
+        if np.array_equal(coords[0], coords[len(coords) - 1]):
+            coords = coords[:-1]
+            repeated_last_coordinate = True
+
+        cornering_radii = np.empty(len(coords))
+        for i in range(len(coords)):
+            # if the next point or previous point is out of bounds, wrap the index around the array
+            i2 = (i - 1) % len(coords)
+            i3 = (i + 1) % len(coords)
+            current_point = coords[i]
+            previous_point = coords[i2]
+            next_point = coords[i3]
+
+            x1 = 0
+            y1 = 0
+            x2, y2 = self.calculate_meter_distance(current_point, previous_point)
+            x3, y3 = self.calculate_meter_distance(current_point, next_point)
+            cornering_radii[i] = self.radius_of_curvature(x1, y1, x2, y2, x3, y3)
+
+        # If the last coordinate was removed, duplicate the first radius value to the end of the array
+        if repeated_last_coordinate:
+            cornering_radii = np.append(cornering_radii, cornering_radii[0])
+
+        # ensure that super large radii are bounded by a large number, like 10000
+        cornering_radii = np.where(np.isnan(cornering_radii), 10000, cornering_radii)
+        cornering_radii = np.where(cornering_radii > 10000, 10000, cornering_radii)
+
+        return cornering_radii
+
+    def generate_slip_angle_lookup(self, min_degrees, max_degrees, num_elements):
+        """
+        Generate a lookup table of slip angles and corresponding tire forces using Pacejka's Magic Formula.
+
+        https://www.edy.es/dev/docs/pacejka-94-parameters-explained-a-comprehensive-guide/
+
+        :param float min_degrees: Minimum slip angle in degrees
+        :param float max_degrees: Maximum slip angle in degrees
+        :param int num_elements: Number of discrete elements in the lookup table
+        :returns: (float[num_elements], float[num_elements]) Arrays of slip angles (degrees) and corresponding tire forces (Newtons)
+        :rtype: tuple[np.ndarray, np.ndarray]
+        """
+
+        b = .25  # Stiffness
+        c = 2.2  # Shape
+        d = 2.75  # Peak
+        e = 1.0  # Curvature
+
+        fz = self.vehicle_mass * 9.81  # Newtons
+
+        slip_angles = np.linspace(min_degrees, max_degrees, num_elements)
+        tire_forces = fz * d * np.sin(
+            c * np.arctan(b * slip_angles - e * (b * slip_angles - np.arctan(b * slip_angles))))
+
+        return slip_angles, tire_forces
+
+    def get_slip_angle_for_tire_force(self, desired_tire_force):
+        slip_angles, tire_forces = self.generate_slip_angle_lookup(0, 70, 100000)
+
+        # Use the numpy interpolation function to find slip angle for the given tire force
+        estimated_slip_angle = np.interp(desired_tire_force, tire_forces, slip_angles)
+
+        return estimated_slip_angle
+
+    @staticmethod
+    def calculate_meter_distance(coord1: NDArray, coord2: NDArray):
+        """
+        Calculate the x and y distance in meters between two latitude-longitude coordinates.
+
+        :param tuple coord1: (float[2]) The (latitude, longitude) coordinates of the first point
+        :param tuple coord2: (float[2]) The (latitude, longitude) coordinates of the second point
+        :returns: (float[2]) The x (longitude) and y (latitude) distances in meters
+        :rtype: tuple
+        """
+        lat1, lon1 = coord1
+        lat2, lon2 = coord2
+
+        # Base coordinate
+        coord_base = (lat1, lon1)
+        # Coordinate for latitude difference (keep longitude the same)
+        coord_lat = (lat2, lon1)
+        # Coordinate for longitude difference (keep latitude the same)
+        coord_long = (lat1, lon2)
+
+        # Calculate y distance (latitude difference)
+        y_distance = haversine(coord_base, coord_lat, unit=Unit.METERS)
+        # Calculate x distance (longitude difference)
+        x_distance = haversine(coord_base, coord_long, unit=Unit.METERS)
+
+        if lat2 < lat1:
+            y_distance = -y_distance
+        if lon2 < lon1:
+            x_distance = -x_distance
+
+        return x_distance, y_distance
+
+    @staticmethod
+    def radius_of_curvature(x1, y1, x2, y2, x3, y3):
+        """
+        Uses the circumcircle the radius of curvature of a circle passing through three points.
+
+        :param float x1: X-coordinate of the first point
+        :param float y1: Y-coordinate of the first point
+        :param float x2: X-coordinate of the second point
+        :param float y2: Y-coordinate of the second point
+        :param float x3: X-coordinate of the third point
+        :param float y3: Y-coordinate of the third point
+        :returns: Radius of curvature of the circle passing through the three points
+        :rtype: float
+        """
+        numerator = np.sqrt(
+            ((x3 - x2) ** 2 + (y3 - y2) ** 2) *
+            ((x1 - x3) ** 2 + (y1 - y3) ** 2) *
+            ((x2 - x1) ** 2 + (y2 - y1) ** 2)
+        )
+
+        denominator = 2 * abs(
+            ((x2 - x1) * (y1 - y3) - (x1 - x3) * (y2 - y1))
+        )
+
+        return numerator / denominator

{ubc_solar_physics-1.4.2 → ubc_solar_physics-1.6.0}/physics/models/motor/base_motor.py

@@ -4,3 +4,5 @@ from abc import ABC
 class BaseMotor(ABC):
     def __init__(self):
         super().__init__()
+
+

{ubc_solar_physics-1.4.2 → ubc_solar_physics-1.6.0}/physics/models/motor/basic_motor.py

@@ -1,6 +1,6 @@
 import math
 import numpy as np
-
+from numpy.typing import NDArray
 from physics.models.motor.base_motor import BaseMotor
 from physics.models.constants import ACCELERATION_G, AIR_DENSITY
 
@@ -33,7 +33,7 @@ class BasicMotor(BaseMotor):
         # print("torque experienced by motor: {} Nm".format(self.constant_torque))
 
     @staticmethod
-    def calculate_motor_efficiency(motor_angular_speed, motor_output_energy, tick):
+    def calculate_motor_efficiency(motor_angular_speed, motor_output_energy, tick, *args, **kwargs):
         """
 
         Calculates a NumPy array of motor efficiency from NumPy array of operating angular speeds and NumPy array
@@ -98,19 +98,20 @@ class BasicMotor(BaseMotor):
 
         return e_mc
 
-    def calculate_energy_in(self, required_speed_kmh, gradients, wind_speeds, tick):
+    def calculate_net_force(self,
+                            required_speed_kmh: NDArray,
+                            wind_speeds: NDArray,
+                            gradients: NDArray
+                            ) -> tuple[NDArray, NDArray]:
         """
-
-        Create a function which takes in array of elevation, array of wind speed, required
-            speed, returns the consumed energy.
-
-        :param np.ndarray required_speed_kmh: (float[N]) required speed array in km/h
-        :param np.ndarray gradients: (float[N]) gradient at parts of the road
-        :param np.ndarray wind_speeds: (float[N]) speeds of wind in m/s, where > 0 means against the direction of the vehicle
-        :param float tick: length of 1 update cycle in seconds
-        :returns: (float[N]) energy expended by the motor at every tick
-        :rtype: np.ndarray
-
+        Calculate the net force on the car, and the required wheel angular velocity.
+        Currently, considers:
+            1. Rolling resistance of the wheels on the road
+            2. Drag force (wind + forward velocity)
+            3. Acceleration force (a = F / m)
+            4. Gravitational force (force to go uphill)
+
+        :return: net force in N, wheel angular velocity in rad/s
         """
         required_speed_ms = required_speed_kmh / 3.6
 
@@ -129,6 +130,24 @@ class BasicMotor(BaseMotor):
 
         net_force = road_friction_array + drag_forces + g_forces + acceleration_force
 
+        return net_force, required_angular_speed_rads
+
+    def calculate_energy_in(self, required_speed_kmh, gradients, wind_speeds, tick, **kwargs):
+        """
+
+        Create a function which takes in array of elevation, array of wind speed, required
+            speed, returns the consumed energy.
+
+        :param np.ndarray required_speed_kmh: (float[N]) required speed array in km/h
+        :param np.ndarray gradients: (float[N]) gradient at parts of the road
+        :param np.ndarray wind_speeds: (float[N]) speeds of wind in m/s, where > 0 means against the direction of the vehicle
+        :param float tick: length of 1 update cycle in seconds
+        :returns: (float[N]) energy expended by the motor at every tick
+        :rtype: np.ndarray
+
+        """
+        net_force, required_angular_speed_rads = self.calculate_net_force(required_speed_kmh, wind_speeds, gradients)
+
         motor_output_energies = required_angular_speed_rads * net_force * self.tire_radius * tick
         motor_output_energies = np.clip(motor_output_energies, a_min=0, a_max=None)