ubc-solar-physics 1.7.3__cp39-cp39-macosx_10_12_x86_64.whl

physics/models/motor/basic_motor.py

@@ -0,0 +1,193 @@
+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
+
+
+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, *args, **kwargs):
+        """
+
+        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_net_force(self,
+                            required_speed_kmh: NDArray,
+                            wind_speeds: NDArray,
+                            gradients: NDArray
+                            ) -> tuple[NDArray, 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
+
+        acceleration_ms2 = np.clip(np.gradient(required_speed_ms), a_min=0, a_max=None)
+        acceleration_force = acceleration_ms2 * self.vehicle_mass
+
+        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
+
+        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)
+
+        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__()

physics/models/regen/basic_regen.py

@@ -0,0 +1,52 @@
+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 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
+        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
+        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)
+
+        # 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;
+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.7.3.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-1.7.3.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: ubc-solar-physics
+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>
+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/physics
+Project-URL: Documentation, https://ubc-solar-physics.readthedocs.io/en/latest/
+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
+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: haversine ==2.8.1
+Requires-Dist: idna ==3.7
+Requires-Dist: importlib-metadata ==8.2.0
+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
+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
+Requires-Dist: numpy >=2
+Requires-Dist: pkginfo ==1.10.0
+Requires-Dist: Pygments ==2.18.0
+Requires-Dist: readme-renderer ==44.0
+Requires-Dist: requests ==2.32.3
+Requires-Dist: requests-toolbelt ==1.0.0
+Requires-Dist: rfc3986 ==2.0.0
+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
+
+<!-- marker-index-start -->
+
+[![Documentation Status](https://readthedocs.org/projects/ubc-solar-physics/badge/?version=latest)](https://ubc-solar-physics.readthedocs.io/en/latest/?badge=latest)
+
+UBC Solar's physics and environment models for simulating our groundbreaking solar cars.
+
+The API is currently unstable, and backwards compatibility may not be maintained. 
+
+## Requirements
+
+Versions indicated are recommended
+
+* Git [^1]
+* Python >=3.9 [^2]
+* Rustc >=1.79.0 [^3]
+* Cargo >=1.79.0 [^4]
+
+## Installation
+
+First, clone this repository.
+
+```bash
+git clone https://github.com/UBC-Solar/physics.git
+```
+Then, create and activate a virtual environment.
+Next, install dependencies in editable mode.
+
+```bash
+pip3 install -e .
+```
+
+## Getting Started
+
+Example of calculating solar arrays produced energy
+
+```python
+from physics.models.arrays import BasicArray
+import numpy as np
+
+efficiency = 0.25  # 25.0% efficient
+panel_size = 4.0   # 4.0m^2 of panels
+tick = 1.0         # 1.0s interval
+
+arrays = BasicArray(panel_efficiency=efficiency, panel_size=panel_size)
+
+irradiance = np.full([5], 400.0)  # 10 seconds of 400.0W/m^2 irradiance
+
+solar_power_produced = arrays.calculate_produced_energy(solar_irradiance=irradiance, tick=tick)
+
+assert np.array_equal(solar_power_produced, np.array([400.0, 400.0, 400.0, 400.0, 400.0]))
+```
+
+## Appendix
+
+[^1]: use `git --version` to verify version
+
+[^2]: use `python3 --version` to verify version
+
+[^3]: use `rustc --version` to verify version
+
+[^4]: use `cargo --version` to verify version
+
+<!-- marker-index-end -->

ubc_solar_physics-1.7.3.dist-info/RECORD

@@ -0,0 +1,57 @@
+physics_rs.cpython-39-darwin.so,sha256=o8xaflAtvNFFbugV9I6z27vUGHXCXg4Q_t3Ewj_IZZo,678380
+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=m4IOf_1HRvKHILOz7tWshkOf86rqw7oHbHPVLDAMJNk,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.7.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.3)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_12_x86_64
+

ubc_solar_physics-1.7.3.dist-info/top_level.txt

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