ubc-solar-physics 1.0.5__cp310-cp310-macosx_11_0_arm64.whl → 1.7.3__cp310-cp310-macosx_11_0_arm64.whl

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

physics/models/motor/base_motor.py

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

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)
 

physics/models/regen/basic_regen.py

@@ -12,6 +12,18 @@ class BasicRegen(BaseRegen):
         self.vehicle_mass = vehicle_mass
         self.kmh_to_mps = 0.278
 
+    def get_regen_efficiency(self, speed_array):
+        """
+        Returns a numpy array of regen efficiency percentage based on the vehicle speed in m/s.
+
+        :param speed_array: a numpy array of speeds in m/s
+        :returns: numpy array of regen efficiency percentage
+        """
+        # Efficiency polynomial, more details can be found in regen_analysis folder located in data_analysis
+        efficiency_poly = [0.022288416685942, 0.026545396753597]
+
+        return np.polyval(efficiency_poly, speed_array)
+
     def calculate_produced_energy(self, speed_kmh, gis_route_elevations, min_regen_speed, max_power):
         """
         Returns a numpy array containing the energy produced by regen
@@ -29,7 +41,8 @@ class BasicRegen(BaseRegen):
 
         # create regen energy produced array
         # if delta_energy is negative, we regen that energy back at the set efficiency rate; else 0 energy regen
-        produced_energy = np.where(delta_energy < 0, abs(delta_energy) * self.EFFICIENCY, 0)
+        efficiencies = self.get_regen_efficiency(speed_ms)
+        produced_energy = np.where(delta_energy < 0, abs(delta_energy) * efficiencies, 0)
 
         # Regen does not occur below a certain speed
         produced_energy = np.where(speed_ms >= min_regen_speed, produced_energy, 0)

physics/models.rs

@@ -1,5 +1,5 @@
 mod arrays;
-mod battery;
+pub mod battery;
 mod lvs;
 mod motor;
 mod regen;

physics_rs/__init__.pyi

@@ -0,0 +1,111 @@
+import numpy as np
+
+
+def constrain_speeds(speed_limits: np.ndarray, speeds: np.ndarray, tick: int) -> np.ndarray:
+    """
+    Constrains the vehicle speeds based on the speed limits and computes new speeds.
+
+    :param speed_limits: Array of speed limits (km/h) for each point.
+    :param speeds: Array of vehicle speeds (km/h).
+    :param tick: The time step (in some unit, e.g., seconds or ticks).
+
+    :return: A NumPy array of constrained vehicle speeds (km/h).
+    """
+    ...
+
+
+def calculate_array_ghi_times(python_local_times: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Calculates the array of GHI times based on local times.
+
+    :param python_local_times: Array of local times (UNIX timestamps or other format).
+
+    :return: A tuple of two NumPy arrays:
+        - Day of year (f64)
+        - Local time (f64)
+    """
+    ...
+
+
+def closest_gis_indices_loop(python_cumulative_distances: np.ndarray,
+                             python_average_distances: np.ndarray) -> np.ndarray:
+    """
+    Finds the closest GIS indices based on cumulative and average distances.
+
+    :param python_cumulative_distances: Array of cumulative distances.
+    :param python_average_distances: Array of average distances.
+
+    :return: A NumPy array of indices (i64) corresponding to the closest GIS indices.
+    """
+    ...
+
+
+def closest_weather_indices_loop(
+        python_cumulative_distances: np.ndarray,
+        python_average_distances: np.ndarray
+) -> np.ndarray:
+    """
+    Finds the closest weather indices based on cumulative and average distances.
+
+    :param python_cumulative_distances: Array of cumulative distances.
+    :param python_average_distances: Array of average distances.
+
+    :return: A NumPy array of indices (i64) corresponding to the closest weather indices.
+    """
+    ...
+
+
+def weather_in_time(
+        python_unix_timestamps: np.ndarray,
+        python_indices: np.ndarray,
+        python_weather_forecast: np.ndarray,
+        index: int
+) -> np.ndarray:
+    """
+    Retrieves the weather forecast at specific times for given indices.
+
+    :param python_unix_timestamps: Array of UNIX timestamps.
+    :param python_indices: Array of indices to look up.
+    :param python_weather_forecast: Array of weather forecasts.
+    :param index: A specific index to look up in the weather forecast.
+
+    :return: A NumPy array of weather values (f64) at the specified times and indices.
+    """
+    ...
+
+
+def update_battery_state(
+        python_energy_or_current_array: np.ndarray,
+        time_step: float,
+        initial_state_of_charge: float,
+        initial_polarization_potential: float,
+        python_internal_resistance_lookup: np.ndarray,
+        python_open_circuit_voltage_lookup: np.ndarray,
+        python_polarization_resistance_lookup: np.ndarray,
+        python_polarization_capacitance_lookup: np.ndarray,
+        nominal_charge_capacity: float,
+        is_power: bool,
+        quantization_step: float,
+        min_soc: float
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Updates the battery state (SOC and terminal voltage) based on energy/current input.
+
+    :param python_energy_or_current_array: Array of energy or current input values (f64).
+    :param time_step: Time step (f64).
+    :param initial_state_of_charge: Initial state of charge (f64).
+    :param initial_polarization_potential: Initial polarization potential (f64).
+    :param python_internal_resistance_lookup: Array of internal resistance values (f64).
+    :param python_open_circuit_voltage_lookup: Array of open-circuit voltage values (f64).
+    :param python_polarization_resistance_lookup: Array of polarization resistance values (f64).
+    :param python_polarization_capacitance_lookup: Array of polarization capacitance values (f64).
+    :param nominal_charge_capacity: Nominal charge capacity (f64).
+    :param is_power: Boolean flag to indicate if the input is power (`True`) or current (`False`).
+    :param quantization_step: The step size used to quantize the SOC (f64).
+    :param min_soc: The minimum SOC used when computing the lookup tables
+
+    :return: A tuple containing:
+        - An array of updated SOC values (f64).
+        - An array of updated terminal voltage values (f64).
+    """
+    ...

{ubc_solar_physics-1.0.5.dist-info → ubc_solar_physics-1.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.0.5
+Version: 1.7.3
 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>
@@ -42,7 +42,7 @@ License-File: LICENSE
 Requires-Dist: backports.tarfile ==1.2.0
 Requires-Dist: certifi ==2024.7.4
 Requires-Dist: charset-normalizer ==3.3.2
-Requires-Dist: dill ==0.3.8
+Requires-Dist: dill >=0.3.8
 Requires-Dist: haversine ==2.8.1
 Requires-Dist: idna ==3.7
 Requires-Dist: importlib-metadata ==8.2.0
@@ -50,13 +50,13 @@ 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
 Requires-Dist: nh3 ==0.2.18
-Requires-Dist: numba ==0.60.0
-Requires-Dist: numpy ==2.0.1
+Requires-Dist: numba
+Requires-Dist: numpy >=2
 Requires-Dist: pkginfo ==1.10.0
 Requires-Dist: Pygments ==2.18.0
 Requires-Dist: readme-renderer ==44.0
@@ -67,6 +67,13 @@ Requires-Dist: rich ==13.7.1
 Requires-Dist: tqdm ==4.66.5
 Requires-Dist: urllib3 ==2.2.2
 Requires-Dist: zipp ==3.20.0
+Requires-Dist: filterpy ==1.4.5
+Requires-Dist: toml ==0.10.2
+Requires-Dist: pandas
+Requires-Dist: pydantic ==2.9.2
+Requires-Dist: scipy
+Requires-Dist: tomli
+Requires-Dist: scipy-stubs
 
 # UBC Solar Physics
 

ubc_solar_physics-1.7.3.dist-info/RECORD

@@ -0,0 +1,57 @@
+physics_rs.cpython-310-darwin.so,sha256=xkBEPe7s7WjeQQHDfJ2QBYxEmXV4h_A3XVFSttVBpog,699728
+physics_rs/__init__.pyi,sha256=bMMIbLFgpSYq37i9xHpvdoVlMuI7IRZ9bdbLCcIBeO8,4235
+physics/_version.py,sha256=Lv0gR-NbC-8DxwfmwXEmOzSq6Hgx6MH4xF1fYh_opXo,411
+physics/lib.rs,sha256=BGgj8jwbWQ7mkBDfKyTqH5jZGKAAb9U0sSByUaI-Los,7169
+physics/models.rs,sha256=N5342VhLaLSlPLHZ7s1VDIEPY76-rQN03lY_wd2HS1A,59
+physics/__init__.py,sha256=7939mrehCy0ogupHq26hUk1MkAjh2xmbD30GscdC_D8,169
+physics/environment.rs,sha256=VWX1haUCO-WenD0dawS5FxY9dquiUT6Uud3p3dAnJZA,34
+physics/models/battery.rs,sha256=fTL9O20fQarT_CFsmMSqVEZNe_sTejWMaAR8Fc-z_ak,16
+physics/models/lvs.rs,sha256=uyJ1ZZ1Phq8cWCzr2aevCWzt8MlhCw9DO5ObUvEs8ds,8
+physics/models/constants.py,sha256=mw0IkjhSJe51inbbzvVpHnpGLY_AoWxIxjfjcUF4cd8,816
+physics/models/motor.rs,sha256=Iya1C_YF09KMy-9N-Mt-rBf1EIAs2Bf3Q4eDvyFuAoc,10
+physics/models/arrays.rs,sha256=rtthXq7PDjL30lIt8y9L2xFAPJE5o_ltmCbOGzzOxrc,11
+physics/models/__init__.py,sha256=msz4YtXe7fsGr-FsV-yJK0frN5XrmsXPSAkpS8lxHW8,255
+physics/models/regen.rs,sha256=WXwtzB72akG6L17wg-9Pz9kUe-57lqh4-PcSv1cKrGU,10
+physics/models/lvs/basic_lvs.py,sha256=UH6VmVWrSo-tKvcbSOm3Ptp0edz1xDQiQsM4HlOJ__0,603
+physics/models/lvs/lvs.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/lvs/__init__.py,sha256=GkO6SJxbbSnXYLdMDvsvTRhXotV3zaRNmYBgziQLGB8,107
+physics/models/lvs/base_lvs.py,sha256=PVwPgCaJ_TcV2mQf3X2pngi0aG-jTLTeloL-LQV3jMU,110
+physics/models/motor/advanced_motor.py,sha256=EL86tCDSQCTT55EdXnmtPaIL9YS2o5p2u3QiLuoZuCA,8758
+physics/models/motor/motor.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/motor/__init__.py,sha256=zkV7LiAozFNu9CRWWXeCbCDepjsaUIYT8Q2dkXJgLsM,183
+physics/models/motor/basic_motor.py,sha256=-_rKIFCRRLniC1yHr_8fRsmj6xvHuAzPqA168vTDkds,8626
+physics/models/motor/base_motor.py,sha256=34wy8x945HvJijn9267fdAR_JNHxH_7bYxYbVl71WBA,97
+physics/models/arrays/basic_array.py,sha256=cGBwyrYpR313ECJ-SwnrK3JzYo24NRE70j8sj-sxFQI,1332
+physics/models/arrays/base_array.py,sha256=ZUjehd7vwNOBdFLUk9WJUeGOi9DPopYplH1gqAMnKgA,95
+physics/models/arrays/arrays.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/arrays/__init__.py,sha256=yavs1K3JA6x3Aa-U1JCZJlcWggCOFrVxrrMCGsiceAw,119
+physics/models/battery/battery_config.toml,sha256=Fn1pb3NJJ_nclxm9nfGEQKmJYA2d5a9jCAUbwUGu6Uw,1092
+physics/models/battery/battery.rs,sha256=10NAAGg99gQ70Kjd4kVuVHBxp3J6AgXfxEYKZUzu5DQ,5275
+physics/models/battery/basic_battery.py,sha256=u0aO_iWKicVRECbDzLIs8goaWD5tLMnYGNe948lKC7U,5754
+physics/models/battery/__init__.py,sha256=bIESRM8eEpaKSYMoliXD7rs3TUkAawTN9i3-YB2WCZg,630
+physics/models/battery/battery_config.py,sha256=V4CfzUTcOFcizpDU9-Ujn2zXbUnAqrhyARN9QXGH6fk,4052
+physics/models/battery/kalman_filter.py,sha256=kcX3SU1mNiY4-2YCUWAvqyTX6Cww7Pq7zaxaqh8ltgM,8725
+physics/models/battery/base_battery.py,sha256=yK-bkA2OolE6nIDn5rf5nzi8gwm-AqQRmgsQioi_UOA,1203
+physics/models/battery/battery_model.py,sha256=kODVlBZAIpPD_EB0UPlOeQv5HP-tMu6S-C6mEOJMHv4,10264
+physics/models/regen/basic_regen.py,sha256=kcp6Wkw2o72xO_0-UCNABWSC_QIkexcS72iblNVQFBA,2350
+physics/models/regen/base_regen.py,sha256=nWtmsm47wp9mx261OmSILwja32yYhzCLSNXWnzt82TY,95
+physics/models/regen/__init__.py,sha256=51t_BHuQqIVPPy_0b14MO6QGZayOO326JR7wK1egy-g,119
+physics/models/regen/regen.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/environment/__init__.py,sha256=eFWp8YFvL3CSXE5cZ24AcIjmW7vMUyh97sr9HZabw_U,210
+physics/environment/gis.rs,sha256=9R7G0cjf5PxQAz-CSryA6-KGfrh1eSwRhJ6qF8KfjDE,12
+physics/environment/environment.rs,sha256=yvzrjKHZ5vRvVip6lM34i8E0Ell_5fC3zyJDsb0h5nc,33
+physics/environment/meteorology.rs,sha256=naWb7qYrtMkCE_tLAkM474fmxaufhCkyhy3TTUQ4Yw4,20
+physics/environment/meteorology/__init__.py,sha256=569as2j7kpv8Nh75M9xk9e7rTqsDPGo3Ii3nskD6F34,154
+physics/environment/meteorology/base_meteorology.py,sha256=d5TDNLUIBmTkLtJhv9qUq9KcfNKxzoM7xIOsfyNbwfI,2418
+physics/environment/meteorology/irradiant_meteorology.py,sha256=1kqX4nEOUw-CYrLTusG6BdoZbZt_GEpfKMyey8YzLr0,5615
+physics/environment/meteorology/clouded_meteorology.py,sha256=aEqlozaMOyhhxGK7CCD6BVHAn_HZDpSAUwGUngikkp4,27665
+physics/environment/meteorology/meteorology.rs,sha256=Q3toiZv8M1updhoAnFDZ87YPy1afC9chUkF2IP9uA-I,5004
+physics/environment/gis/base_gis.py,sha256=eVr4G7wAGlx6VsrCt2OuI8WzUMM50h2sHHvw8BOBur8,1046
+physics/environment/gis/__init__.py,sha256=Kp85UC1WvcAMBxbgvwaMTEk8ELYzwUJLCtP0e1hnMvM,90
+physics/environment/gis/gis.rs,sha256=_vXYMr7vNCC8Ip3CpQdyl6FA_3tCvOZeJd0-J5t4Eps,4865
+physics/environment/gis/gis.py,sha256=EAFDudUmLWCBtM5A_LO3-MV-98tj-Q3s7S2WaoJjUGg,13209
+ubc_solar_physics-1.7.3.dist-info/RECORD,,
+ubc_solar_physics-1.7.3.dist-info/LICENSE,sha256=DAej6EJNqQWTair3XPAQiqoJbly4BAT1JMOsZxoZvH0,1066
+ubc_solar_physics-1.7.3.dist-info/WHEEL,sha256=Sr6WlJF6U27nFVGVWvIEC4coXGfodvHZVfYGHD45Ez0,109
+ubc_solar_physics-1.7.3.dist-info/top_level.txt,sha256=jBZ5oyp1QQOrKodHG2UH9PMPEiZtza_q3y6fp3lEmQs,19
+ubc_solar_physics-1.7.3.dist-info/METADATA,sha256=GNE035peFVy6NH3Fy6Posh3nim_JTJhlgcV1BDtljeU,5002

{ubc_solar_physics-1.0.5.dist-info → ubc_solar_physics-1.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (74.1.3)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_11_0_arm64
 

ubc_solar_physics-1.7.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+physics
+physics_rs

physics/environment/race.py

@@ -1,89 +0,0 @@
-"""
-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)