ubc-solar-physics 0.1.0__cp311-cp311-macosx_13_0_universal2.whl

physics/models/motor/basic_motor.py

@@ -0,0 +1,179 @@
+import math
+import numpy as np
+
+from physics.models.motor.base_motor import BaseMotor
+from physics.models.constants import ACCELERATION_G, AIR_DENSITY
+
+
+class BasicMotor(BaseMotor):
+    def __init__(self, vehicle_mass, road_friction, tire_radius, vehicle_frontal_area, drag_coefficient):
+        super().__init__()
+
+        # Instantaneous voltage supplied by the battery to the motor controller
+        self.dc_v = 0
+
+        # Instantaneous current supplied by the battery to the motor controller
+        self.dc_i = 0
+
+        self.input_power = 0
+        self.vehicle_mass = vehicle_mass
+        self.acceleration_g = ACCELERATION_G
+        self.road_friction = road_friction
+        self.tire_radius = tire_radius
+
+        self.air_density = AIR_DENSITY
+        self.vehicle_frontal_area = vehicle_frontal_area
+        self.drag_coefficient = drag_coefficient
+
+        self.friction_force = (self.vehicle_mass * self.acceleration_g * self.road_friction)
+
+        self.e_mc = 0.98  # motor controller efficiency, subject to change
+        self.e_m = 0.9  # motor efficiency, subject to change
+
+        # print("torque experienced by motor: {} Nm".format(self.constant_torque))
+
+    @staticmethod
+    def calculate_motor_efficiency(motor_angular_speed, motor_output_energy, tick):
+        """
+
+        Calculates a NumPy array of motor efficiency from NumPy array of operating angular speeds and NumPy array
+            of output power. Based on data obtained from NGM SC-M150 Datasheet and modelling done in MATLAB
+
+        r squared value: 0.873
+
+        :param np.ndarray motor_angular_speed: (float[N]) angular speed motor operates in rad/s
+        :param np.ndarray motor_output_energy: (float[N]) energy motor outputs to the wheel in J
+        :param float tick: length of 1 update cycle in seconds
+        :returns e_m: (float[N]) efficiency of the motor
+        :rtype: np.ndarray
+
+        """
+
+        # Power = Energy / Time
+        motor_output_power = motor_output_energy * tick
+        rads_rpm_conversion_factor = 30 / math.pi
+
+        revolutions_per_minute = motor_angular_speed * rads_rpm_conversion_factor
+
+        e_m = calculate_motor_efficiency(motor_output_power, revolutions_per_minute)
+
+        e_m[e_m < 0.7382] = 0.7382
+        e_m[e_m > 1] = 1
+
+        return e_m
+
+    @staticmethod
+    def calculate_motor_controller_efficiency(motor_angular_speed, motor_output_energy, tick):
+        """
+
+        Calculates a NumPy array of motor controller efficiency from NumPy array of operating angular speeds and
+        NumPy array of output power. Based on data obtained from the WaveSculptor Motor Controller Datasheet efficiency
+        curve for a 90 V DC Bus and modelling done in MATLAB.
+
+        r squared value: 0.7431
+
+        :param np.ndarray motor_angular_speed: (float[N]) angular speed motor operates in rad/s
+        :param np.ndarray motor_output_energy: (float[N]) energy motor outputs to the wheel in J
+        :param float tick: length of 1 update cycle in seconds
+        :returns e_mc (float[N]) efficiency of the motor controller
+        :rtype: np.ndarray
+
+        """
+
+        # Ignore nan warning. Set nan value to 0
+        np.seterr(divide='ignore', invalid='ignore')
+
+        # Power = Energy / Time
+        motor_output_power = motor_output_energy / tick
+
+        # Torque = Power / Angular Speed
+        motor_torque_array = np.nan_to_num(motor_output_power / motor_angular_speed)
+
+        np.seterr(divide='warn', invalid='warn')
+
+        e_mc = calculate_motor_controller_efficiency(motor_angular_speed, motor_torque_array)
+
+        e_mc[e_mc < 0.9] = 0.9
+        e_mc[e_mc > 1] = 1
+
+        return e_mc
+
+    def calculate_energy_in(self, required_speed_kmh, gradients, wind_speeds, tick, parameters=None):
+        """
+
+        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
+
+        """
+        if parameters is None:
+            parameters = self.parameters
+
+        required_speed_ms = required_speed_kmh / 3.6
+
+        acceleration_ms2 = np.clip(np.gradient(required_speed_ms), a_min=0, a_max=None)
+        acceleration_force = acceleration_ms2 * self.vehicle_mass
+        acceleration_force *= np.polyval([parameters[0], parameters[1]], acceleration_ms2)
+
+        required_angular_speed_rads = required_speed_ms / self.tire_radius
+
+        drag_forces = 0.5 * self.air_density * (
+                (required_speed_ms + wind_speeds) ** 2) * self.drag_coefficient * self.vehicle_frontal_area
+
+        angles = np.arctan(gradients)
+        g_forces = self.vehicle_mass * self.acceleration_g * np.sin(angles)
+
+        road_friction_array = self.road_friction * self.vehicle_mass * self.acceleration_g * np.cos(angles)
+
+        net_force = road_friction_array + drag_forces + g_forces + acceleration_force
+
+        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)
+        motor_output_energies *= np.polyval([parameters[2], parameters[3]], motor_output_energies)
+
+        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 __str__(self):
+        return (f"Tire radius: {self.tire_radius}m\n"
+                f"Rolling resistance coefficient: {self.road_friction}\n"
+                f"Vehicle mass: {self.vehicle_mass}kg\n"
+                f"Acceleration of gravity: {self.acceleration_g}m/s^2\n"
+                f"Motor controller efficiency: {self.e_mc}%\n"
+                f"Motor efficiency: {self.e_m}%\n")
+
+
+def calculate_motor_efficiency(motor_output_power, revolutions_per_minute):
+    return 0.7382 - (6.281e-5 * motor_output_power) + (6.708e-4 * revolutions_per_minute) \
+        - (2.89e-8 * motor_output_power ** 2) + (2.416e-7 * motor_output_power * revolutions_per_minute) \
+        - (8.672e-7 * revolutions_per_minute ** 2) + (5.653e-12 * motor_output_power ** 3) \
+        - (1.74e-11 * motor_output_power ** 2 * revolutions_per_minute) \
+        - (7.322e-11 * motor_output_power * revolutions_per_minute ** 2) \
+        + (3.263e-10 * revolutions_per_minute ** 3)
+
+
+def calculate_motor_controller_efficiency(motor_angular_speed, motor_torque_array):
+    return 0.7694 + (0.007818 * motor_angular_speed) + (0.007043 * motor_torque_array) \
+        - (1.658e-4 * motor_angular_speed ** 2) - (1.806e-5 * motor_torque_array * motor_angular_speed) \
+        - (1.909e-4 * motor_torque_array ** 2) + (1.602e-6 * motor_angular_speed ** 3) \
+        + (4.236e-7 * motor_angular_speed ** 2 * motor_torque_array) \
+        - (2.306e-7 * motor_angular_speed * motor_torque_array ** 2) \
+        + (2.122e-06 * motor_torque_array ** 3) - (5.701e-09 * motor_angular_speed ** 4) \
+        - (2.054e-9 * motor_angular_speed ** 3 * motor_torque_array) \
+        - (3.126e-10 * motor_angular_speed ** 2 * motor_torque_array ** 2) \
+        + (1.708e-09 * motor_angular_speed * motor_torque_array ** 3) \
+        - (8.094e-09 * motor_torque_array ** 4)

physics/models/motor.rs

@@ -0,0 +1 @@
+mod motor;

physics/models/regen/__init__.py

@@ -0,0 +1,7 @@
+from .base_regen import BaseRegen
+from .basic_regen import BasicRegen
+
+__all__ = [
+    "BasicRegen",
+    "BaseRegen"
+]

physics/models/regen/base_regen.py

@@ -0,0 +1,6 @@
+from abc import ABC
+
+
+class BaseRegen(ABC):
+    def __init__(self):
+        super().__init__(self)

physics/models/regen/basic_regen.py

@@ -0,0 +1,39 @@
+from physics.models.regen import BaseRegen
+import numpy as np
+
+
+class BasicRegen(BaseRegen):
+    GRAVITY = 9.81
+    EFFICIENCY = 0.5  # currently set to 50% but best case scenario is 60-70%
+
+    def __init__(self, vehicle_mass):
+        super().__init__()
+        self.min_decel_mag = 0
+        self.vehicle_mass = vehicle_mass
+        self.kmh_to_mps = 0.278
+
+    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
+        during each tick of the race based on the change in energy in that tick
+        :param speed_kmh: an array containing the speeds at each tick
+        :param gis_route_elevations: an array containing elevations on the route at each tick
+        """
+        # get the changes of energy from tick i to tick i + 1
+        speed_ms = speed_kmh / 3.6  # Convert to m/s from km/h
+        delta_kinetic_energy = np.diff((1 / 2) * self.vehicle_mass * pow(speed_ms, 2), append=[0])
+        delta_potential_energy = np.diff(self.vehicle_mass * self.GRAVITY * gis_route_elevations, append=[0])
+
+        # get the total change in energy at each tick
+        delta_energy = delta_kinetic_energy + delta_potential_energy
+
+        # 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)
+
+        # Regen does not occur below a certain speed
+        produced_energy = np.where(speed_ms >= min_regen_speed, produced_energy, 0)
+
+        # Regen power is capped by current limitations
+
+        return np.clip(produced_energy, a_min=0, a_max=max_power)

physics/models/regen.rs

@@ -0,0 +1 @@
+mod regen;

physics/models.rs

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

ubc_solar_physics-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 UBC Solar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ubc_solar_physics-0.1.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: ubc-solar-physics
+Version: 0.1.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>
+Maintainer: Renu Rajamagmesh, Felix Toft, Mack Wilson, Jonah Lee, Tamzeed Quazi
+Maintainer-email: UBC Solar <strategy@ubcsolar.com>, Joshua Riefman <joshuariefman@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 UBC Solar
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://ubcsolar.com
+Project-URL: Repository, https://github.com/UBC-Solar/Simulation
+Project-URL: Documentation, https://wiki.ubcsolar.com
+Keywords: car,simulation,solar
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# physics
+UBC Solar's physics and environment models for simulating our groundbreaking solar cars 

ubc_solar_physics-0.1.0.dist-info/RECORD

@@ -0,0 +1,60 @@
+core.cpython-311-darwin.so,sha256=qusHdJJSNgWcLgfw15VEwv4aoDOLfAAah4eI8HhZj6c,624752
+physics/__init__.py,sha256=mwlnk0K9sdBVXO8ys0SZWA_HzrVwDNqu10JfMrFH0H0,194
+physics/environment.rs,sha256=TTW3iI6S2My8KL3AamgGztSRstocw6EE2SEJUy6LUWU,68
+physics/lib.rs,sha256=Nd92mZFs1-Y2qQVEYo2FzjYiOUv-jXE8dB6WjBvtqa0,3336
+physics/models.rs,sha256=KfvtkWTmbsqr7Y6hN0jPe7hTTgCN6Osydkb4fLnZHwA,55
+physics/environment/__init__.py,sha256=p-PWwx79pDn7nCoHprLIzLOGxMwvTQ-fwuqUsQ7QXNM,655
+physics/environment/base_environment.py,sha256=IoUZb9m5DztI2FHszUO-zcChajeRdDnmFWCCdKeyl5c,1563
+physics/environment/environment.rs,sha256=jKilexdyGut0BqL7jo9X-xrn3Qo3ZEw3mYM8JzwYEoU,67
+physics/environment/gis.rs,sha256=9R7G0cjf5PxQAz-CSryA6-KGfrh1eSwRhJ6qF8KfjDE,12
+physics/environment/openweather_environment.py,sha256=mT0zQ8kMeI_a6IgweXt_5uKqCmDc2686S5K1bY3SOh8,478
+physics/environment/race.py,sha256=0h-T0tfJ_GLaO3c711bzCVnvG5K2Cv4do6Y25KOqZww,2928
+physics/environment/solar_calculations.rs,sha256=brqvMLAUJXrKRKQQ84EYiTLnOnNTrp0UszfFDALRxeI,27
+physics/environment/solcast_environment.py,sha256=yQoZyqBYeS2GkRuDD4L1TedZW6hdco_jbomu8NUnvRY,418
+physics/environment/weather_forecasts.rs,sha256=6ZH1L-sidv_WAczD-uTt9UFF2hBcguoyLG-x5086YHs,26
+physics/environment/gis/__init__.py,sha256=Kp85UC1WvcAMBxbgvwaMTEk8ELYzwUJLCtP0e1hnMvM,90
+physics/environment/gis/base_gis.py,sha256=PBaCz2irEArQs3k8HVG7BmAfC1HzA8FLPuYSiMxDmJo,632
+physics/environment/gis/gis.py,sha256=-swnOTegpyALCkClaykTIXRm39VqrczO62SZDnRjMlU,12683
+physics/environment/gis/gis.rs,sha256=ZCd7MbrENFXFl7MaLMGUl_kbqWKLc695Bf-MeWgo1S0,852
+physics/environment/solar_calculations/OpenweatherSolarCalculations.py,sha256=zJFOA8SwzQ6HoQRBzMJJcsi4WKHxzLHq4EbZbRbGUNs,23044
+physics/environment/solar_calculations/SolcastSolarCalculations.py,sha256=orCA-42_zU7CUR77A2iLoGanJXeDgDrmRJ6jvRStrgc,1771
+physics/environment/solar_calculations/__init__.py,sha256=HDOKsHS0PL1cI-VmVB-JzhkXZSKJuLgxVnzIwbHcH2k,304
+physics/environment/solar_calculations/base_solar_calculations.py,sha256=xrBoQuaFundXOHBtDKfGaPrTV2rLTuMtiXKzmkNDCAY,280
+physics/environment/solar_calculations/solar_calculations.rs,sha256=WWGqoxVMSckQoEZRuWmdERi6gwaV_-tkCXzoJaKKwHo,829
+physics/environment/weather_forecasts/OpenWeatherForecast.py,sha256=UO64bRD-BNyTaPvjbUxckQY8bN279fW0mXciYjMr89w,13722
+physics/environment/weather_forecasts/SolcastForecasts.py,sha256=2Rm7Rf8y2Zh9mkHJ3UWii6mHrw_l1FIaf9_RAagV-yA,10913
+physics/environment/weather_forecasts/__init__.py,sha256=RNdn0ASziRJETusV4yTyeJQkKZoDoNWiWXd5k6LkhDA,250
+physics/environment/weather_forecasts/base_weather_forecasts.py,sha256=EqD8McRl_ej0WWURrsCQOXZa0O8eGsB_0DwzMAAxOI0,2170
+physics/environment/weather_forecasts/weather_forecasts.rs,sha256=_-4V9y1NU0QY8ZohNQ4CCsGLchOQp6XEWR2sbkRG2Es,4311
+physics/models/__init__.py,sha256=msz4YtXe7fsGr-FsV-yJK0frN5XrmsXPSAkpS8lxHW8,255
+physics/models/arrays.rs,sha256=rtthXq7PDjL30lIt8y9L2xFAPJE5o_ltmCbOGzzOxrc,11
+physics/models/battery.rs,sha256=GzPA7uaF5FdewEFZL2eOt9ZeA1GzfRDQ9db_qkEpLR8,12
+physics/models/constants.py,sha256=mw0IkjhSJe51inbbzvVpHnpGLY_AoWxIxjfjcUF4cd8,816
+physics/models/lvs.rs,sha256=uyJ1ZZ1Phq8cWCzr2aevCWzt8MlhCw9DO5ObUvEs8ds,8
+physics/models/motor.rs,sha256=Iya1C_YF09KMy-9N-Mt-rBf1EIAs2Bf3Q4eDvyFuAoc,10
+physics/models/regen.rs,sha256=WXwtzB72akG6L17wg-9Pz9kUe-57lqh4-PcSv1cKrGU,10
+physics/models/arrays/__init__.py,sha256=yavs1K3JA6x3Aa-U1JCZJlcWggCOFrVxrrMCGsiceAw,119
+physics/models/arrays/arrays.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/arrays/base_array.py,sha256=ZUjehd7vwNOBdFLUk9WJUeGOi9DPopYplH1gqAMnKgA,95
+physics/models/arrays/basic_array.py,sha256=cGBwyrYpR313ECJ-SwnrK3JzYo24NRE70j8sj-sxFQI,1332
+physics/models/battery/__init__.py,sha256=BIaUG06jULcloNv0hDFKjyGmdzWp02ZiV6MI_OZ8wb4,131
+physics/models/battery/base_battery.py,sha256=yK-bkA2OolE6nIDn5rf5nzi8gwm-AqQRmgsQioi_UOA,1203
+physics/models/battery/basic_battery.py,sha256=xkY77UpWz9qTuqT2t_tm5CZbtScQE6r3vkzlMXlnXog,5755
+physics/models/battery/battery.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/lvs/__init__.py,sha256=GkO6SJxbbSnXYLdMDvsvTRhXotV3zaRNmYBgziQLGB8,107
+physics/models/lvs/base_lvs.py,sha256=Xpj_5PmPtKtCoW7pWvcnb5hKJGeuWCDubua9PH9_H7g,125
+physics/models/lvs/basic_lvs.py,sha256=UH6VmVWrSo-tKvcbSOm3Ptp0edz1xDQiQsM4HlOJ__0,603
+physics/models/lvs/lvs.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/motor/__init__.py,sha256=tDFCMk8rdv2c_0Qp0EAtTpw0uKBnza-9BlMaNthcw0c,119
+physics/models/motor/base_motor.py,sha256=uTSdkIQPk_q6l4wrPVBYWe5wUCzbA7k-khidW58rnas,99
+physics/models/motor/basic_motor.py,sha256=jrFLhEsuBGE-ZqFA03Yp_SqpBIltOv5d_DdgQg8_e8A,8008
+physics/models/motor/motor.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physics/models/regen/__init__.py,sha256=51t_BHuQqIVPPy_0b14MO6QGZayOO326JR7wK1egy-g,119
+physics/models/regen/base_regen.py,sha256=VKOppL9x-E6tqpH5hN57XuXhzNXeXgliO4Vt7c3RLaY,99
+physics/models/regen/basic_regen.py,sha256=eAQAb-bWA-CINGFK2Xykh7rIm4c16DwyZzHjdOzANrg,1772
+physics/models/regen/regen.rs,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ubc_solar_physics-0.1.0.dist-info/LICENSE,sha256=DAej6EJNqQWTair3XPAQiqoJbly4BAT1JMOsZxoZvH0,1066
+ubc_solar_physics-0.1.0.dist-info/METADATA,sha256=ajwirs1MfaE7_IE5M1A_tC7pPb_iAcqd7AGSb1B7SxU,2388
+ubc_solar_physics-0.1.0.dist-info/WHEEL,sha256=Lzvkiqi70HXhQLkDg5wgK7U0ZY4U3ls4sN2N5bd6S4o,115
+ubc_solar_physics-0.1.0.dist-info/top_level.txt,sha256=aws060Zz-1h0Kx76JzcE1gLA_AfS1lrRtTCsyUYwDvM,8
+ubc_solar_physics-0.1.0.dist-info/RECORD,,

ubc_solar_physics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_13_0_universal2
+

ubc_solar_physics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+physics