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

ubc_solar_physics-1.7.0/.gitattributes

@@ -0,0 +1 @@
+**/*.csv linguist-generated=true

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "android-tzdata"
@@ -64,15 +64,6 @@ dependencies = [
  "windows-targets",
 ]
 
-[[package]]
-name = "core"
-version = "0.1.0"
-dependencies = [
- "chrono",
- "numpy",
- "pyo3",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -248,6 +239,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "physics_rs"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "numpy",
+ "pyo3",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "core"
+name = "physics_rs"
 version = "0.1.0"
 edition = "2021"
 
 [lib]
-name = "core"
+name = "physics_rs"
 path = "physics/lib.rs"
 crate-type = ["cdylib"]
 

ubc_solar_physics-1.7.0/MANIFEST.in

@@ -0,0 +1 @@
+include physics_rs.pyi

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ubc-solar-physics
-Version: 1.5.0
+Version: 1.7.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>
@@ -73,6 +73,7 @@ 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.5.0 → ubc_solar_physics-1.7.0}/docs/docs_requirements.txt

@@ -38,7 +38,6 @@ rich
 snowballstemmer
 Sphinx
 sphinx-autodoc-typehints
-sphinx-rtd-theme==2.0.0
 sphinxcontrib-applehelp
 sphinxcontrib-devhelp
 sphinxcontrib-htmlhelp
@@ -50,4 +49,5 @@ tqdm
 urllib3
 zipp
 setuptools_scm
-pydata-sphinx-theme==0.15.4
+pydata-sphinx-theme==0.15.4
+ubc-solar-physics==1.5.0

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/docs/source/conf.py

@@ -1,16 +1,9 @@
-# from setuptools_scm import get_version
-# from pathlib import Path
-# import importlib
-
-# Generate the version file
-# version = get_version()
-# version_file = Path('physics/_version.py')
-# version_file.write_text(f"__version__ = '{version}'\n")
-
-# Dynamically import the version
-# importlib.invalidate_caches()
-# physics_module = importlib.import_module("physics")
-# __version__ = physics_module.__version__
+import os
+import sys
+sys.path.insert(0, os.path.abspath('../../'))  # Adjust as necessary
+print(sys.path)
+print(os.listdir(os.getcwd()))
+print(os.listdir(sys.path[0]))
 
 # Configuration file for the Sphinx documentation builder.
 #
@@ -23,7 +16,7 @@
 project = 'UBC Solar Physics'
 copyright = '2024, UBC Solar'
 author = 'Joshua Riefman'
-release = '1.0.0'
+release = "1.0.0"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/docs/source/models/battery.rst

@@ -21,7 +21,17 @@ Battery
    :undoc-members:
    :show-inheritance:
 
-.. autoclass:: physics.models.battery.load_battery_config
+.. autoclass:: physics.models.battery.KalmanFilterConfig
    :members:
    :undoc-members:
-   :show-inheritance:
+   :show-inheritance:
+
+.. autoclass:: physics.models.battery.EquivalentCircuitBatteryModel
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. autoclass:: physics.models.battery.FilteredBatteryModel
+   :members:
+   :undoc-members:
+   :show-inheritance:

ubc_solar_physics-1.7.0/examples/battery_model_examples/battery_config.toml

@@ -0,0 +1,6 @@
+R_0_data = [0.17953765302439662, 0.15580951404728172, 0.14176929930784543, 0.11043950958574644, 0.13930042505446938, 0.1552885289394773, 0.044070982259896085, 0.2208806896239539, 0.15116267852908616, 0.6553961767519164]
+R_P_data = [0.04153180244191346, 0.10674683402208612, 0.061085424180509884, 0.0781407642082238, 0.05537901113775878, 0.09732054673529467, 0.07662520885708152, 0.09799857401036915, 0.42622740149661487, 0.2718418915736874]
+C_P_data = [14824.398495212006, 1587.5971318119796, 341.1064063616048, 1243.182413110655, 619.5791066439332, 2252.7885790042164, 954.5884882581622, 515.7219779825028, 431.10892633451135, 195.14394897766627]
+Uoc_data = [131.88002282453857, 129.4574321366064, 125.5750277614186, 121.99586066440303, 118.69893412178982, 115.71854177322408, 111.99025635444923, 108.29354777060836, 98.23397960300946, 95.24125831782388]
+Q_total = 150000.0
+Soc_data = [1.0000113624123392, 0.8815263722745977, 0.7671918526292492, 0.6206071038045673, 0.4911613638651783, 0.3606311083423134, 0.23687514228021178, 0.12073345089992571, 0.01456057818183809, 0.0070648691224265425]

ubc_solar_physics-1.7.0/examples/battery_model_examples/battery_model_example.py

@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+import pathlib
+import matplotlib.pyplot as plt
+from physics.models.battery import EquivalentCircuitBatteryModel, BatteryModelConfig, load_battery_config
+
+
+# This test requires a voltage.csv and current.csv in the same directory to run
+def csv_to_timeseries_tuples(csv_file):
+    path = pathlib.Path(__file__).parent / csv_file
+    df = pd.read_csv(path)
+    df['Time'] = pd.to_datetime(df['Time'])
+    return np.array(list(zip(df['Time'].dt.to_pydatetime(), df['Value'])))
+
+
+def plot_results(soc_array, predicted_ut_array, voltage_data, window=None):
+    fig, ax = plt.subplots()
+
+    if window is None:
+        window = slice(0, len(predicted_ut_array), 1)
+
+    ax.plot(predicted_ut_array, label=r"Predicted $U_t$", color="tab:red")
+    ax.plot(voltage_data, label=r"Measured $U_t$", color="tab:orange")
+    ax.set_ylim(75, 140)
+    ax.set_xticks([])
+    ax.set_ylabel("Voltage")
+
+    ax2 = ax.twinx()
+    ax2.plot(soc_array[window], color="tab:blue", label="Filtered SOC")
+    ax2.set_ylabel("SOC")
+
+    ax.legend(loc='upper right')
+    ax2.legend(loc='lower left')
+
+    plt.title("Simulation of first-order Thevenin equivalent battery model")
+    plt.show()
+
+
+def battery_model():
+    voltage_data = csv_to_timeseries_tuples('voltage.csv')
+    current_data = csv_to_timeseries_tuples('current.csv')
+
+    # This dataset has 0.1s period between measurements
+    time_difference = 0.1
+
+    current_raw = current_data[:, 1]
+    current_error = np.polyval([-0.00388, 1547], current_raw * 1000.0)
+
+    current = current_raw - (current_error / 1000)
+    voltage = voltage_data[:, 1]
+
+    energy_array = current * voltage * time_difference
+
+    model_config: BatteryModelConfig = load_battery_config(pathlib.Path(__file__).parent / 'battery_config.toml')
+
+    battery_model = EquivalentCircuitBatteryModel(model_config, state_of_charge=1.04)
+
+    soc_array, predicted_ut_array = battery_model.update_array(tick=time_difference, current_array=np.array(-current, dtype=float))
+    # soc_array, predicted_ut_array = battery_model.update_array(tick=time_difference, delta_energy_array=np.array(-energy_array, dtype=float))
+
+    # example usage
+    plot_results(soc_array, predicted_ut_array, voltage)
+
+
+if __name__ == '__main__':
+    battery_model()

ubc_solar_physics-1.7.0/examples/kalman_filter_examples/battery_config.toml

@@ -0,0 +1,6 @@
+R_0_data = [0.17953765302439662, 0.15580951404728172, 0.14176929930784543, 0.11043950958574644, 0.13930042505446938, 0.1552885289394773, 0.044070982259896085, 0.2208806896239539, 0.15116267852908616, 0.6553961767519164]
+R_P_data = [0.04153180244191346, 0.10674683402208612, 0.061085424180509884, 0.0781407642082238, 0.05537901113775878, 0.09732054673529467, 0.07662520885708152, 0.09799857401036915, 0.42622740149661487, 0.2718418915736874]
+C_P_data = [14824.398495212006, 1587.5971318119796, 341.1064063616048, 1243.182413110655, 619.5791066439332, 2252.7885790042164, 954.5884882581622, 515.7219779825028, 431.10892633451135, 195.14394897766627]
+Uoc_data = [131.88002282453857, 129.4574321366064, 125.5750277614186, 121.99586066440303, 118.69893412178982, 115.71854177322408, 111.99025635444923, 108.29354777060836, 98.23397960300946, 95.24125831782388]
+Q_total = 145000.0
+Soc_data = [1.0000113624123392, 0.8815263722745977, 0.7671918526292492, 0.6206071038045673, 0.4911613638651783, 0.3606311083423134, 0.23687514228021178, 0.12073345089992571, 0.01456057818183809, 0.0070648691224265425]

ubc_solar_physics-1.7.0/examples/kalman_filter_examples/kalman_filter_example.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+import pathlib
+import matplotlib.pyplot as plt
+from physics.models.battery.kalman_filter import FilteredBatteryModel
+from physics.models.battery.battery_config import BatteryModelConfig, load_battery_config, KalmanFilterConfig
+
+
+# This test requires a voltage.csv and current.csv in the same directory to run
+def csv_to_timeseries_tuples(csv_file):
+    path = pathlib.Path(__file__).parent / csv_file
+    df = pd.read_csv(path)
+    df['Time'] = pd.to_datetime(df['Time'])
+    return np.array(list(zip(df['Time'].dt.to_pydatetime(), df['Value'])))
+
+
+def plot_kalman_results(measured_Ut, predicted_Ut_array, predicted_Uc_array, SOC_array, window=None):
+    fig, ax = plt.subplots()
+
+    if window is None:
+        window = slice(0, len(predicted_Ut_array), 1)
+
+    # ax.plot(predicted_Uoc_array[window], label="Predicted OCV", color="tab:cyan")
+    ax.plot(predicted_Ut_array[window], label=r"Filtered Predicted $U_t$", color="orange")
+    ax.plot(measured_Ut[window], label=r"Measured $U_t$", color="tab:red")
+    ax.plot(predicted_Uc_array[window] + 100, label=r"Predicted $U_c$", color="magenta")
+    ax.axhline(y=100, linestyle='dotted', color="magenta")
+    # ax.set_ylim(75, 140)
+    ax.set_xticks([])
+    ax.set_ylabel("Voltage")
+
+    ax2 = ax.twinx()
+    ax2.plot(SOC_array[window], color="tab:cyan", label="Filtered SOC")
+    ax2.set_ylabel("SOC")
+
+    ax.legend(loc='upper right')
+    ax2.legend(loc='lower left')
+
+    plt.title("Impact of Kalman filtering on equivalent-circuit battery modeling ")
+    plt.show()
+
+
+def kalman_filter():
+    
+    voltage_data = csv_to_timeseries_tuples('voltage.csv')
+    current_data = csv_to_timeseries_tuples('current.csv')
+
+    model_config: BatteryModelConfig = load_battery_config(pathlib.Path(__file__).parent / 'battery_config.toml')
+
+    filter_config: KalmanFilterConfig = KalmanFilterConfig(
+        model_config,
+        process_noise_matrix=np.diag([
+            1e-10 * 0.1,
+            1e-6 * 0.1
+        ]),
+        state_covariance_matrix=np.diag(
+            [1e-2 * 0.5,
+             1e-1]
+        ),
+        measurement_noise_vector=np.eye(1, dtype=float) * 1e0 * 0.5
+    )
+
+    ekf = FilteredBatteryModel(filter_config, initial_SOC=1.04, initial_Uc=0.0)
+
+    SOC_array = np.zeros(len(voltage_data))
+    Ut_array = np.zeros(len(voltage_data))
+    current_array = np.zeros(len(voltage_data))
+    predicted_Ut_array = np.zeros(len(voltage_data))
+    predicted_Uc_array = np.zeros(len(voltage_data))
+    predicted_Uoc_array = np.zeros(len(voltage_data))
+
+    # This dataset has 0.1s period between measurements
+    time_difference = 0.1
+
+    for i in range(int(len(voltage_data))):
+        # for i in range(20000):
+        # Calculate time difference between current and previous measurements
+
+        Ut = float(voltage_data[i][1])
+        I = float(current_data[i][1])
+
+        ekf.predict_then_update(Ut, I, time_difference)
+
+        SOC_array[i] = ekf.SOC
+        Ut_array[i] = Ut
+        current_array[i] = I
+        predicted_Ut_array[i] = ekf.Ut
+        predicted_Uc_array[i] = ekf.Uc
+        predicted_Uoc_array[i] = ekf._U_oc(ekf.SOC)
+
+    # example usage
+    plot_kalman_results(voltage_data[:, 1], predicted_Ut_array, predicted_Uc_array, SOC_array)
+
+
+if __name__ == '__main__':
+    kalman_filter()

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/physics/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.0'
-__version_tuple__ = version_tuple = (1, 5, 0)
+__version__ = version = '1.7.0'
+__version_tuple__ = version_tuple = (1, 7, 0)

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/physics/environment/gis/base_gis.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import numpy as np
+from numpy.typing import ArrayLike, NDArray
 
 
 class BaseGIS(ABC):
@@ -22,3 +23,16 @@ class BaseGIS(ABC):
     @abstractmethod
     def get_path(self) -> np.ndarray:
         raise NotImplementedError
+
+    @abstractmethod
+    def calculate_current_heading_array(self) -> np.ndarray:
+        raise NotImplementedError
+
+    def calculate_driving_speeds(
+            self,
+            average_lap_speeds: ArrayLike,
+            simulation_dt: int,
+            driving_allowed: ArrayLike,
+            idle_time: int
+    ) -> NDArray[float]:
+        raise NotImplementedError

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/physics/environment/gis/gis.py

@@ -1,9 +1,10 @@
 import logging
 import math
-import core
+import physics_rs
 import numpy as np
 import sys
 
+from numpy.typing import ArrayLike, NDArray
 from tqdm import tqdm
 from xml.dom import minidom
 from haversine import haversine, Unit
@@ -80,13 +81,46 @@ class GIS(BaseGIS):
         :rtype: np.ndarray
 
         """
-        return core.closest_gis_indices_loop(distances, self.path_distances)
+        return physics_rs.closest_gis_indices_loop(distances, self.path_distances)
+
+    def calculate_driving_speeds(
+            self,
+            average_lap_speeds: ArrayLike,
+            simulation_dt: int,
+            driving_allowed: ArrayLike,
+            idle_time: int
+    ) -> NDArray[float]:
+        """
+        Generate valid driving speeds as a simulation-time array given a set of average speeds for each
+        simulated lap.
+        Driving speeds will only be non-zero when we are allowed to drive, and the speed
+        for every tick during a lap will be that lap's corresponding desired average speed for as long
+        as it takes to complete the lap.
+
+        :param average_lap_speeds: An array of average speeds in m/s, one for each simulated lap.
+            If there are more speeds given than laps available, the unused speeds will be silently ignored.
+            If there are too few, an error will be returned.
+        :param simulation_dt: The simulated tick length.
+        :param driving_allowed: A simulation-time boolean where the `True` elements are when we
+            are allowed to drive, and `False` is when we are not. Requires that (at least) the first element is
+            `False` due to the race beginning in the morning before we are allowed to drive.
+        :param idle_time: The length of time to pause driving upon processing a "0m/s" average speed.
+        :return: A simulation-time array of driving speeds in m/s, or an error if there weren't enough
+            laps provided to fill the entire simulation time.
+        """
+        return physics_rs.get_driving_speeds(
+            np.array(average_lap_speeds).astype(np.float64),
+            simulation_dt,
+            np.array(driving_allowed).astype(bool),
+            self.path_length,
+            idle_time
+        )
 
     @staticmethod
     def _python_calculate_closest_gis_indices(distances, path_distances):
         """
 
-        Python implementation of rust core.closest_gis_indices_loop. See parent function for documentation details.
+        Python implementation of use_compiled core.closest_gis_indices_loop. See parent function for documentation details.
 
         """
 

ubc_solar_physics-1.7.0/physics/environment/gis/gis.rs

@@ -0,0 +1,113 @@
+use numpy::ndarray::{ArrayViewD, ArrayView1};
+
+pub fn rust_closest_gis_indices_loop(
+    distances: ArrayViewD<'_, f64>,
+    path_distances: ArrayViewD<'_, f64>,
+) -> Vec<i64> {
+    let mut current_coord_index: usize = 0;
+    let mut distance_travelled: f64 = 0.0;
+    let mut result: Vec<i64> = Vec::with_capacity(distances.len());
+
+    for &distance in distances {
+        distance_travelled += distance;
+
+        while distance_travelled > path_distances[current_coord_index] {
+            distance_travelled -= path_distances[current_coord_index];
+            current_coord_index += 1;
+            if current_coord_index >= path_distances.len() {
+                current_coord_index = 0;
+            }
+        }
+
+        current_coord_index = std::cmp::min(current_coord_index, path_distances.len() - 1);
+        result.push(current_coord_index as i64);
+    }
+
+    result
+}
+
+///
+/// Generate valid driving speeds as a simulation-time array given a set of average speeds for each
+/// simulated lap.
+/// Driving speeds will only be non-zero when we are allowed to drive, and the speed
+/// for every tick during a lap will be that lap's corresponding desired average speed for as long
+/// as it takes to complete the lap.
+/// An average speed of 0m/s for a lap will be interpreted as "sit and charge" for `idle_time`
+/// ticks.
+///
+/// # Arguments
+///
+/// * `average_speeds`: An array of average speeds in m/s, one for each simulated lap. If there are more
+/// speeds given than laps available, the unused speeds will be silently ignored. If there are too
+/// few, an error will be returned.
+/// * `simulation_dt`: The simulated tick length
+/// * `driving_allowed_boolean`: A simulation-time boolean where the `True` elements are when we
+/// are allowed to drive, and `False` is when we are not.
+/// * `track_length`: The length of the track in meters.
+/// * `idle_time`: The number of ticks to "sit and charge" when desired.
+///
+/// Returns: A simulation-time array of driving speeds in m/s, or an error if there weren't enough
+/// laps provided to fill the entire simulation time.
+///
+pub fn get_driving_speeds(
+    average_speeds: ArrayView1<'_, f64>,            // Average speeds in m/s
+    simulation_dt: i64,                             // Time step in seconds
+    driving_allowed_boolean: ArrayView1<'_, bool>,  // Simulation-time boolean array
+    track_length: f64,                              // Track length in meters
+    idle_time: i64                                  // Time to idle in seconds
+) -> Result<Vec<f64>, &'static str> {
+    let ticks_to_complete_lap: Vec<i64> = average_speeds.iter().map(| &average_speed | {
+        if average_speed > 0.0 {
+            // The number of ticks is the number of seconds, divided by seconds per tick
+            (track_length / average_speed / simulation_dt as f64).ceil() as i64
+        } else {
+            (idle_time as f64 / simulation_dt as f64).ceil() as i64
+        }
+    }).collect();
+
+    let mut lap_index: usize = 0;
+    let mut lap_speed: f64 = average_speeds[lap_index];
+
+    let mut ticks_to_lap_completion: i64 = ticks_to_complete_lap[lap_index];
+
+    let mut driving_speeds: Vec<f64> = Vec::with_capacity(driving_allowed_boolean.len());
+    for driving_allowed in driving_allowed_boolean.iter() {
+        if !driving_allowed {
+            // If we aren't allowed to drive, speed should be zero. Also, we should mark that we are
+            // done our lap since it means we ended the day in the middle of the lap, and we will
+            // start the next day at the beginning of a new lap, not where we ended off.
+
+            // If it's the first lap, we don't want to skip because we are probably in the morning
+            // where we haven't begun driving yet.
+            if lap_index > 0 {
+                ticks_to_lap_completion = 0;
+            }
+
+            driving_speeds.push(0.0)
+        } else {
+            // If we are driving, we should decrement ticks to lap completion. If its already
+            // zero, that means that we are done the lap and should move onto the next lap.
+            if ticks_to_lap_completion > 0 {
+                ticks_to_lap_completion -= 1;
+
+                driving_speeds.push(lap_speed)
+            } else {
+                // To advance to the next lap, increment the index and evaluate new variables
+                lap_index += 1;
+                if lap_index >= average_speeds.len() {
+                    return Err("Not enough average speeds!")
+                }
+
+                // We subtract 1 since this iteration counts for the next lap, not the one
+                // that we just finished
+                ticks_to_lap_completion = ticks_to_complete_lap[lap_index] - 1;
+                lap_speed = average_speeds[lap_index];
+
+                driving_speeds.push(lap_speed)
+            }
+        }
+
+    }
+
+    Ok(driving_speeds)
+}

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/physics/environment/meteorology/clouded_meteorology.py

@@ -2,7 +2,7 @@ from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
 from numba import jit
-import core
+import physics_rs
 from typing import Optional
 import datetime
 
@@ -70,7 +70,7 @@ class CloudedMeteorology(BaseMeteorology):
         # contains the average distance between two consecutive elements in the cumulative_weather_path_distances array
         average_distances = np.abs(np.diff(cumulative_weather_path_distances) / 2)
 
-        return core.closest_weather_indices_loop(cumulative_distances, average_distances)
+        return physics_rs.closest_weather_indices_loop(cumulative_distances, average_distances)
 
     def temporally_localize(self, unix_timestamps, start_time, tick) -> None:
         """
@@ -96,7 +96,7 @@ class CloudedMeteorology(BaseMeteorology):
         :rtype: np.ndarray
 
         """
-        weather_data = core.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64), self._weather_forecast, 4)
+        weather_data = physics_rs.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64), self._weather_forecast, 4)
         # roll_by_tick = int(3600 / tick) * (24 + start_hour - hour_from_unix_timestamp(weather_data[0, 2]))
         # weather_data = np.roll(weather_data, -roll_by_tick, 0)
 
@@ -124,7 +124,7 @@ class CloudedMeteorology(BaseMeteorology):
         :rtype: np.ndarray
 
         """
-        day_of_year, local_time = core.calculate_array_ghi_times(local_times)
+        day_of_year, local_time = physics_rs.calculate_array_ghi_times(local_times)
 
         ghi = self._calculate_GHI(coords[:, 0], coords[:, 1], time_zones,
                                   day_of_year, local_time, elevations, self._cloud_cover)

{ubc_solar_physics-1.5.0 → ubc_solar_physics-1.7.0}/physics/environment/meteorology/irradiant_meteorology.py

@@ -1,7 +1,7 @@
 from physics.environment.meteorology.base_meteorology import BaseMeteorology
 from physics.environment.gis.gis import calculate_path_distances
 import numpy as np
-import core
+import physics_rs
 from typing import Optional
 
 
@@ -11,6 +11,7 @@ class IrradiantMeteorology(BaseMeteorology):
     solar irradiance data, but not cloud cover.
 
     """
+
     def __init__(self, race, weather_forecasts):
         self._race = race
         self._raw_weather_data = weather_forecasts
@@ -53,7 +54,7 @@ class IrradiantMeteorology(BaseMeteorology):
         # contains the average distance between two consecutive elements in the cumulative_weather_path_distances array
         average_distances = np.abs(np.diff(cumulative_weather_path_distances) / 2)
 
-        self._weather_indices = core.closest_weather_indices_loop(cumulative_distances, average_distances)
+        self._weather_indices = physics_rs.closest_weather_indices_loop(cumulative_distances, average_distances)
 
     def temporally_localize(self, unix_timestamps, start_time, tick) -> None:
         """
@@ -76,8 +77,9 @@ class IrradiantMeteorology(BaseMeteorology):
         :returns: a SolcastEnvironment object with time_dt, latitude, longitude, wind_speed, wind_direction, and ghi.
         :rtype: SolcastEnvironment
         """
-        forecasts_array = core.weather_in_time(unix_timestamps.astype(np.int64), self._weather_indices.astype(np.int64),
-                                               self._raw_weather_data, 0)
+        forecasts_array = physics_rs.weather_in_time(unix_timestamps.astype(np.int64),
+                                                     self._weather_indices.astype(np.int64),
+                                                     self._raw_weather_data, 0)
 
         self._time_dt = forecasts_array[:, 0]
         self._latitude = forecasts_array[:, 1]
@@ -103,5 +105,3 @@ class IrradiantMeteorology(BaseMeteorology):
 
         """
         return self.solar_irradiance
-
-