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

{ubc_solar_physics-1.4.1 → ubc_solar_physics-1.5.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.1 → ubc_solar_physics-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.4.1
+Version: 1.5.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>
@@ -50,7 +50,7 @@ Requires-Dist: jaraco.classes==3.4.0
 Requires-Dist: jaraco.context==5.3.0
 Requires-Dist: jaraco.functools==4.0.2
 Requires-Dist: keyring==25.3.0
-Requires-Dist: llvmlite==0.43.0
+Requires-Dist: llvmlite
 Requires-Dist: markdown-it-py==3.0.0
 Requires-Dist: mdurl==0.1.2
 Requires-Dist: more-itertools==10.4.0

{ubc_solar_physics-1.4.1 → ubc_solar_physics-1.5.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.1'
-__version_tuple__ = version_tuple = (1, 4, 1)
+__version__ = version = '1.5.0'
+__version_tuple__ = version_tuple = (1, 5, 0)

{ubc_solar_physics-1.4.1 → ubc_solar_physics-1.5.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.5.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.1 → ubc_solar_physics-1.5.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.1 → ubc_solar_physics-1.5.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)
 

{ubc_solar_physics-1.4.1 → ubc_solar_physics-1.5.0}/pyproject.toml

@@ -1,7 +1,7 @@
 # This file is maintained according to STG Specification #2: Physics Publishing
 
 [build-system]
-requires = ["setuptools>=64", "setuptools-scm>=8", "setuptools-rust"]
+requires = ["setuptools<75", "setuptools-scm<8.2.0", "setuptools-rust"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -60,7 +60,7 @@ dependencies = [
     "jaraco.context==5.3.0",
     "jaraco.functools==4.0.2",
     "keyring==25.3.0",
-    "llvmlite==0.43.0",
+    "llvmlite",
     "markdown-it-py==3.0.0",
     "mdurl==0.1.2",
     "more-itertools==10.4.0",
@@ -104,7 +104,7 @@ py-limited-api = "auto"  # Default value, can be omitted
 
 [tool.cibuildwheel]
 archs = "auto"  # Automatically detects architectures (e.g., x86, ARM)
-skip = ["pp*", "*-musllinux_*", "*-win32"]  # Skip PyPy (only want CPython), Musllinux, win32 wheels
+skip = ["pp*", "*-musllinux_*", "*-win32", "*i686"]  # Skip PyPy (only want CPython), Musllinux, win32, i686 wheels
 manylinux-x86_64-image = "manylinux2014"
 manylinux-i686-image = "manylinux2014"
-manylinux-aarch64-image = "manylinux2014"
+manylinux-aarch64-image = "manylinux2014"

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.4.1
+Version: 1.5.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>
@@ -50,7 +50,7 @@ Requires-Dist: jaraco.classes==3.4.0
 Requires-Dist: jaraco.context==5.3.0
 Requires-Dist: jaraco.functools==4.0.2
 Requires-Dist: keyring==25.3.0
-Requires-Dist: llvmlite==0.43.0
+Requires-Dist: llvmlite
 Requires-Dist: markdown-it-py==3.0.0
 Requires-Dist: mdurl==0.1.2
 Requires-Dist: more-itertools==10.4.0

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

@@ -81,6 +81,7 @@ physics/models/lvs/base_lvs.py
 physics/models/lvs/basic_lvs.py
 physics/models/lvs/lvs.rs
 physics/models/motor/__init__.py
+physics/models/motor/advanced_motor.py
 physics/models/motor/base_motor.py
 physics/models/motor/basic_motor.py
 physics/models/motor/motor.rs

{ubc_solar_physics-1.4.1 → ubc_solar_physics-1.5.0}/ubc_solar_physics.egg-info/requires.txt

@@ -9,7 +9,7 @@ jaraco.classes==3.4.0
 jaraco.context==5.3.0
 jaraco.functools==4.0.2
 keyring==25.3.0
-llvmlite==0.43.0
+llvmlite
 markdown-it-py==3.0.0
 mdurl==0.1.2
 more-itertools==10.4.0