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

physics/environment/solar_calculations/OpenweatherSolarCalculations.py

@@ -0,0 +1,529 @@
+#!/usr/bin/env python
+
+"""
+A class to perform calculation and approximations for obtaining quantities
+    such as solar time, solar position, and the various types of solar irradiance.
+"""
+
+import datetime
+import numpy as np
+
+from physics.environment.race import Race
+from physics.environment.solar_calculations.base_solar_calculations import BaseSolarCalculations
+from physics.environment.openweather_environment import OpenweatherEnvironment
+import core
+from numba import jit
+
+
+class OpenweatherSolarCalculations(BaseSolarCalculations):
+
+    def __init__(self, race: Race):
+        """
+
+        Initializes the instance of a SolarCalculations class
+
+        """
+        self.S_0 = 1367  # Solar Constant: W/m^2
+        self.race = race
+
+    # ----- Calculation of solar position in the sky -----
+
+    @staticmethod
+    def _calculate_hour_angle(time_zone_utc, day_of_year, local_time, longitude):
+        """
+
+        Calculates and returns the Hour Angle of the Sun in the sky.
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/solar-time
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+        :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray local_time: The local time in hours from midnight. (Adjust for Daylight Savings)
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :returns: The Hour Angle in degrees.
+        :rtype: np.ndarray
+
+        """
+
+        lst = local_time_to_apparent_solar_time(time_zone_utc / 3600, day_of_year,
+                                                        local_time, longitude)
+
+        hour_angle = 15 * (lst - 12)
+
+        return hour_angle
+
+    def _calculate_elevation_angle(self, latitude, longitude, time_zone_utc, day_of_year,
+                                   local_time):
+        """
+
+        Calculates the Elevation Angle of the Sun relative to a location on the Earth
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/elevation-angle
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray latitude: The latitude of a location on Earth
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset. For example, Vancouver has time_zone_utc = -7
+        :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray  local_time: The local time in hours from midnight. (Adjust for Daylight Savings)
+        :returns: The elevation angle in degrees
+        :rtype: np.ndarray
+
+        """
+
+        # Negative declination angles: Northern Hemisphere winter
+        # 0 declination angle : Equinoxes (March 22, Sept 22)
+        # Positive declination angle: Northern Hemisphere summer
+        declination_angle = calculate_declination_angle(day_of_year)
+
+        # Negative hour angles: Morning
+        # 0 hour angle : Solar noon
+        # Positive hour angle: Afternoon
+        hour_angle = self._calculate_hour_angle(time_zone_utc, day_of_year,
+                                                local_time, longitude)
+        # From: https://en.wikipedia.org/wiki/Hour_angle#:~:text=At%20solar%20noon%20the%20hour,times%201.5%20hours%20before%20noon).
+        # "For example, at 10:30 AM local apparent time
+        # the hour angle is −22.5° (15° per hour times 1.5 hours before noon)."
+
+        # mathy part is delegated to a helper function to optimize for numba compilation
+        return compute_elevation_angle_math(declination_angle, hour_angle, latitude)
+
+    def _calculate_zenith_angle(self, latitude, longitude, time_zone_utc, day_of_year,
+                                local_time):
+        """
+
+        Calculates the Zenith Angle of the Sun relative to a location on the Earth
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/azimuth-angle
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param latitude: The latitude of a location on Earth
+        :param longitude: The longitude of a location on Earth
+        :param time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+        :param day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param local_time: The local time in hours from midnight. (Adjust for Daylight Savings)
+        :return: The zenith angle in degrees
+        :rtype: float
+
+        """
+
+        elevation_angle = self._calculate_elevation_angle(latitude, longitude,
+                                                          time_zone_utc, day_of_year, local_time)
+
+        return 90 - elevation_angle
+
+    def _calculate_azimuth_angle(self, latitude, longitude, time_zone_utc, day_of_year,
+                                local_time):
+        """
+
+        Calculates the Azimuth Angle of the Sun relative to a location on the Earth.
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/azimuth-angle
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param latitude: The latitude of a location on Earth
+        :param longitude: The longitude of a location on Earth
+        :param time_zone_utc: The UTC time zone of your area in hours of UTC offset. For example, Vancouver has time_zone_utc = -7
+        :param day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param local_time: The local time in hours from midnight. (Adjust for Daylight Savings)
+        :returns: The azimuth angle in degrees
+        :rtype: np.ndarray
+
+        """
+
+        declination_angle = calculate_declination_angle(day_of_year)
+        hour_angle = self._calculate_hour_angle(time_zone_utc, day_of_year,
+                                                local_time, longitude)
+
+        term_1 = np.sin(np.radians(declination_angle)) * \
+            np.sin(np.radians(latitude))
+
+        term_2 = np.cos(np.radians(declination_angle)) * \
+            np.sin(np.radians(latitude)) * \
+            np.cos(np.radians(hour_angle))
+
+        elevation_angle = self._calculate_elevation_angle(latitude, longitude,
+                                                          time_zone_utc, day_of_year, local_time)
+
+        term_3 = np.float_(term_1 - term_2) / \
+            np.cos(np.radians(elevation_angle))
+
+        if term_3 < -1:
+            term_3 = -1
+        elif term_3 > 1:
+            term_3 = 1
+
+        azimuth_angle = np.arcsin(term_3)
+
+        return np.degrees(azimuth_angle)
+
+    # ----- Calculation of sunrise and sunset times -----
+
+    # ----- Calculation of modes of solar irradiance -----
+
+    def _calculate_DNI(self, latitude, longitude, time_zone_utc, day_of_year,
+                       local_time, elevation):
+        """
+
+        Calculates the Direct Normal Irradiance from the Sun, relative to a location
+        on the Earth (clearsky)
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray latitude: The latitude of a location on Earth
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+        :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray local_time: The local time in hours from midnight. (Adjust for Daylight Savings)
+        :param np.ndarray elevation: The local elevation of a location in metres
+        :returns: The Direct Normal Irradiance in W/m2
+        :rtype: np.ndarray
+
+        """
+
+        zenith_angle = self._calculate_zenith_angle(latitude, longitude,
+                                                    time_zone_utc, day_of_year, local_time)
+        a = 0.14
+
+        # https://www.pveducation.org/pvcdrom/properties-of-sunlight/air-mass
+        # air_mass = 1 / (math.cos(math.radians(zenith_angle)) + \
+        #            0.50572*pow((96.07995 - zenith_angle), -1.6364))
+
+        with np.errstate(invalid="ignore"):
+            air_mass = np.float_(1) / (np.float_(np.cos(np.radians(zenith_angle)))
+                                       + 0.50572*np.power((96.07995 - zenith_angle), -1.6364))
+
+        with np.errstate(over="ignore"):
+            DNI = self.S_0 * ((1 - a * elevation * 0.001) * np.power(0.7, np.power(air_mass, 0.678))
+                                  + a * elevation * 0.001)
+
+        return np.where(zenith_angle > 90, 0, DNI)
+
+    def _calculate_DHI(self, latitude, longitude, time_zone_utc, day_of_year,
+                       local_time, elevation):
+        """
+
+        Calculates the Diffuse Horizontal Irradiance from the Sun, relative to a location
+        on the Earth (clearsky)
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray latitude: The latitude of a location on Earth
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+        :param np.ndarray np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray local_time: The local time in hours from midnight
+        :param np.ndarray elevation: The local elevation of a location in metres
+        :returns: The Diffuse Horizontal Irradiance in W/m2
+        :rtype: np.ndarray
+
+        """
+
+        DNI = self._calculate_DNI(latitude, longitude, time_zone_utc, day_of_year,
+                                  local_time, elevation)
+
+        DHI = 0.1 * DNI
+
+        return DHI
+
+    def _calculate_GHI(self, latitude, longitude, time_zone_utc, day_of_year,
+                       local_time, elevation, cloud_cover):
+        """
+
+        Calculates the Global Horizontal Irradiance from the Sun, relative to a location
+        on the Earth
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray latitude: The latitude of a location on Earth
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset, without including the effects of Daylight Savings Time. For example, Vancouver has time_zone_utc = -8 year-round.
+        :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray local_time: The local time in hours from midnight.
+        :param np.ndarray elevation: The local elevation of a location in metres
+        :param np.ndarray cloud_cover: A NumPy array representing cloud cover as a percentage from 0 to 100
+        :returns: The Global Horizontal Irradiance in W/m^2
+        :rtype: np.ndarray
+
+        """
+
+        DHI = self._calculate_DHI(latitude, longitude, time_zone_utc, day_of_year,
+                                  local_time, elevation)
+
+        DNI = self._calculate_DNI(latitude, longitude, time_zone_utc, day_of_year,
+                                  local_time, elevation)
+
+        zenith_angle = self._calculate_zenith_angle(latitude, longitude,
+                                                    time_zone_utc, day_of_year, local_time)
+
+        GHI = DNI * np.cos(np.radians(zenith_angle)) + DHI
+
+        return self._apply_cloud_cover(GHI=GHI, cloud_cover=cloud_cover)
+
+    @staticmethod
+    def _apply_cloud_cover(GHI, cloud_cover):
+        """
+
+        Applies a cloud cover model to the GHI data.
+
+        Cloud cover adjustment follows the equation laid out here:
+        http://www.shodor.org/os411/courses/_master/tools/calculators/solarrad/
+
+        :param np.ndarray GHI: Global Horizontal Index in W/m^2
+        :param np.ndarray cloud_cover: A NumPy array representing cloud cover as a percentage from 0 to 100
+
+        :returns: GHI after considering cloud cover data
+        :rtype: np.ndarray
+
+        """
+
+        assert np.logical_and(cloud_cover >= 0, cloud_cover <= 100).all()
+
+        scaled_cloud_cover = cloud_cover / 100
+
+        assert np.logical_and(scaled_cloud_cover >= 0,
+                              scaled_cloud_cover <= 1).all()
+
+        return GHI * (1 - (0.75 * np.power(scaled_cloud_cover, 3.4)))
+
+    # ----- Calculation of modes of solar irradiance, but returning numpy arrays -----
+    @staticmethod
+    def _python_calculate_array_GHI_times(local_times):
+        date = list(map(datetime.datetime.utcfromtimestamp, local_times))
+        day_of_year = np.array(list(map(get_day_of_year_map, date)), dtype=np.float64)
+        local_time = np.array(list(map(OpenweatherSolarCalculations._date_convert, date)))
+        return day_of_year, local_time
+
+    @staticmethod
+    def _date_convert(date):
+        """
+
+        Convert a date into local time.
+
+        :param datetime.datetime date: date to be converted
+        :return: a date converted into local time.
+        :rtype: int
+
+        """
+
+        return date.hour + (float(date.minute * 60 + date.second) / 3600)
+
+    def calculate_array_GHI(self, coords, time_zones, local_times,
+                            elevations, environment: OpenweatherEnvironment):
+        """
+
+        Calculates the Global Horizontal Irradiance from the Sun, relative to a location
+        on the Earth, for arrays of coordinates, times, elevations and weathers
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local_times and time_zones are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray coords: (float[N][lat, lng]) array of latitudes and longitudes
+        :param np.ndarray time_zones: (int[N]) time zones at different locations in seconds relative to UTC
+        :param np.ndarray local_times: (int[N]) unix time that the vehicle will be at each location. (Adjusted for Daylight Savings)
+        :param np.ndarray elevations: (float[N]) elevation from sea level in m
+        :param OpenweatherEnvironment environment: environment data object
+        :returns: (float[N]) Global Horizontal Irradiance in W/m2
+        :rtype: np.ndarray
+
+        """
+        day_of_year, local_time = core.calculate_array_ghi_times(local_times)
+
+        ghi = self._calculate_GHI(coords[:, 0], coords[:, 1], time_zones,
+                                  day_of_year, local_time, elevations, environment.cloud_cover)
+
+        stationary_irradiance = self._calculate_angled_irradiance(coords[:, 0], coords[:, 1], time_zones, day_of_year,
+                                                                  local_time, elevations, environment.cloud_cover)
+
+        # Use stationary irradiance when the car is not driving
+        effective_irradiance = np.where(
+            np.logical_not(self.race.driving_boolean),
+            stationary_irradiance,
+            ghi)
+
+        return effective_irradiance
+
+    def _calculate_angled_irradiance(self, latitude, longitude, time_zone_utc, day_of_year,
+                                     local_time, elevation, cloud_cover, array_angles=np.array([0, 15, 30, 45])):
+        """
+
+        Determine the direct and diffuse irradiance on an array which can be mounted at different angles.
+        During stationary charging, the car can mount the array at different angles, resulting in a higher
+        component of direct irradiance captured.
+
+        Uses the GHI formula, GHI = DNI*cos(zenith)+DHI but with an 'effective zenith',
+        the angle between the mounted panel's normal and the sun.
+
+        :param np.ndarray latitude: The latitude of a location on Earth
+        :param np.ndarray longitude: The longitude of a location on Earth
+        :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset, without including the effects of Daylight Savings Time. For example, Vancouver has time_zone_utc = -8 year-round.
+        :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+        :param np.ndarray local_time: The local time in hours from midnight.
+        :param np.ndarray elevation: The local elevation of a location in metres
+        :param np.ndarray cloud_cover: A NumPy array representing cloud cover as a percentage from 0 to 100
+        :param np.ndarray array_angles: An array containing the discrete angles on which the array can be mounted
+        :returns: The "effective Global Horizontal Irradiance" in W/m^2
+        :rtype: np.ndarray
+
+        """
+
+        DHI = self._calculate_DHI(latitude, longitude, time_zone_utc, day_of_year,
+                                  local_time, elevation)
+
+        DNI = self._calculate_DNI(latitude, longitude, time_zone_utc, day_of_year,
+                                  local_time, elevation)
+
+        zenith_angle = self._calculate_zenith_angle(latitude, longitude,
+                                                    time_zone_utc, day_of_year, local_time)
+
+        # Calculate the absolute differences
+        differences = np.abs(zenith_angle[:, np.newaxis] - array_angles)
+
+        # Find the minimum difference for each element in zenith_angle
+        effective_zenith = np.min(differences, axis=1)
+
+        # Now effective_zenith contains the minimum absolute difference for each element in zenith_angle
+
+        GHI = DNI * np.cos(np.radians(effective_zenith)) + DHI
+
+        return self._apply_cloud_cover(GHI=GHI, cloud_cover=cloud_cover)
+
+
+def local_time_to_apparent_solar_time(time_zone_utc, day_of_year, local_time,
+                                      longitude):
+    """
+
+    Converts between the local time to the apparent solar time and returns the apparent
+    solar time.
+    https://www.pveducation.org/pvcdrom/properties-of-sunlight/solar-time
+
+    Note: If local time and time_zone_utc are both unadjusted for Daylight Savings, the
+        calculation will end up just the same
+
+    :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+    :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+    :param np.ndarray local_time: The local time in hours from midnight (Adjust for Daylight Savings)
+    :param np.ndarray longitude: The longitude of a location on Earth
+    :returns: The Apparent Solar Time of a location, in hours from midnight
+    :rtype: np.ndarray
+
+    """
+
+    lstm = calculate_LSTM(time_zone_utc)
+    eot = calculate_eot_correction(day_of_year)
+
+    # local solar time
+    lst = local_time + np.float_(longitude - lstm) / 15 + np.float_(eot) / 60
+
+    return lst
+
+
+@jit(nopython=True)
+def calculate_LSTM(time_zone_utc):
+    """
+
+    Calculates and returns the LSTM, or Local Solar Time Meridian.
+    https://www.pveducation.org/pvcdrom/properties-of-sunlight/solar-time
+
+    :param np.ndarray time_zone_utc: The UTC time zone of your area in hours of UTC offset.
+    :returns: The Local Solar Time Meridian in degrees
+    :rtype: np.ndarray
+
+    """
+
+    return 15 * time_zone_utc
+
+
+@jit(nopython=True)
+def calculate_eot_correction(day_of_year):
+    """
+
+    Approximates and returns the correction factor between the apparent
+    solar time and the mean solar time
+
+    :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+    :returns: The Equation of Time correction EoT in minutes, where apparent Solar Time = Mean Solar Time + EoT
+    :rtype: np.ndarray
+
+    """
+
+    b = np.radians((np.float_(360) / 364) * (day_of_year - 81))
+
+    eot = 9.87 * np.sin(2 * b) - 7.83 * np.cos(b) - 1.5 * np.sin(b)
+
+    return eot
+
+
+def get_day_of_year_map(date):
+    """
+
+    Extracts day, month, year, from datetime object
+
+    :param datetime.date date: date to be decomposed
+
+    """
+    return get_day_of_year(date.day, date.month, date.year)
+
+
+def get_day_of_year(day, month, year):
+    """
+
+    Calculates the day of the year, given the day, month and year.
+    Day refers to a number representing the nth day of the year. So, Jan 1st will be the 1st day of the year
+
+    :param int day: nth day of the year
+    :param int month: month
+    :param int year: year
+    :returns: day of year
+    :rtype: int
+
+    """
+
+    return (datetime.date(year, month, day) - datetime.date(year, 1, 1)).days + 1
+
+
+@jit(nopython=True)
+def calculate_declination_angle(day_of_year):
+    """
+
+    Calculates the Declination Angle of the Earth at a given day
+    https://www.pveducation.org/pvcdrom/properties-of-sunlight/declination-angle
+
+    :param np.ndarray day_of_year: The number of the day of the current year, with January 1 being the first day of the year.
+    :returns: The declination angle of the Earth relative to the Sun, in degrees
+    :rtype: np.ndarray
+
+    """
+
+    declination_angle = -23.45 * np.cos(np.radians((np.float_(360) / 365) *
+                                                   (day_of_year + 10)))
+
+    return declination_angle
+
+
+@jit(nopython=True)
+def compute_elevation_angle_math(declination_angle, hour_angle, latitude):
+    """
+
+    Gets the two terms to calculate and return elevation angle, given the
+    declination angle, hour angle, and latitude.
+
+    This method separates the math part of the calculation from its caller
+    method to optimize for numba compilation.
+
+    :param np.ndarray latitude: array of latitudes
+    :param np.ndarray declination_angle: The declination angle of the Earth relative to the Sun
+    :param np.ndarray hour_angle: The hour angle of the sun in the sky
+    :returns: The elevation angle in degrees
+    :rtype: np.ndarray
+
+    """
+
+    term_1 = np.sin(np.radians(declination_angle)) * np.sin(np.radians(latitude))
+    term_2 = np.cos(np.radians(declination_angle)) * np.cos(np.radians(latitude)) * np.cos(np.radians(hour_angle))
+    elevation_angle = np.arcsin(term_1 + term_2)
+
+    return np.degrees(elevation_angle)

physics/environment/solar_calculations/SolcastSolarCalculations.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+"""
+A class to perform calculation and approximations for obtaining quantities
+    such as solar time, solar position, and the various types of solar irradiance.
+"""
+from physics.environment.race import Race
+from physics.environment.solar_calculations.base_solar_calculations import BaseSolarCalculations
+from physics.environment import SolcastEnvironment
+
+
+class SolcastSolarCalculations(BaseSolarCalculations):
+
+    def __init__(self, race: Race):
+        """
+
+        Initializes the instance of a SolarCalculations class
+
+        """
+        self.race = race
+
+    def calculate_array_GHI(self, coords, time_zones, local_times,
+                            elevations, environment: SolcastEnvironment):
+        """
+
+        Calculates the Global Horizontal Irradiance from the Sun, relative to a location
+        on the Earth, for arrays of coordinates, times, elevations and weathers
+        https://www.pveducation.org/pvcdrom/properties-of-sunlight/calculation-of-solar-insolation
+        Note: If local_times and time_zones are both unadjusted for Daylight Savings, the
+                calculation will end up just the same
+
+        :param np.ndarray coords: (float[N][lat, lng]) array of latitudes and longitudes
+        :param np.ndarray time_zones: (int[N]) time zones at different locations in seconds relative to UTC
+        :param np.ndarray local_times: (int[N]) unix time that the vehicle will be at each location. (Adjusted for Daylight Savings)
+        :param np.ndarray elevations: (float[N]) elevation from sea level in m
+        :param SolcastEnvironment environment: environment data object
+        :returns: (float[N]) Global Horizontal Irradiance in W/m2
+        :rtype: np.ndarray
+
+        """
+        return environment.ghi

physics/environment/solar_calculations/__init__.py

@@ -0,0 +1,9 @@
+from .base_solar_calculations import BaseSolarCalculations
+from .SolcastSolarCalculations import SolcastSolarCalculations
+from .OpenweatherSolarCalculations import OpenweatherSolarCalculations
+
+__all__ = [
+    "BaseSolarCalculations",
+    "SolcastSolarCalculations",
+    "OpenweatherSolarCalculations"
+]

physics/environment/solar_calculations/base_solar_calculations.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+import numpy as np
+
+
+class BaseSolarCalculations(ABC):
+    @abstractmethod
+    def calculate_array_GHI(self, coords, time_zones, local_times,
+                            elevations, environment) -> np.ndarray:
+        raise NotImplementedError

physics/environment/solar_calculations/solar_calculations.rs

@@ -0,0 +1,24 @@
+use chrono::{Datelike, NaiveDateTime, Timelike};
+use numpy::ndarray::{s, Array, Array2, ArrayViewD, ArrayViewMut2, ArrayViewMut3, Axis};
+
+pub fn rust_calculate_array_ghi_times<'a>(
+    local_times: ArrayViewD<'_, u64>,
+) -> (Vec<f64>, Vec<f64>) {
+    let mut datetimes: Vec<_> = Vec::with_capacity(local_times.len());
+
+    for &unix_time_stamp in local_times {
+        let datetime = NaiveDateTime::from_timestamp_opt(unix_time_stamp as i64, 0).unwrap();
+        datetimes.push(datetime);
+    }
+
+    let day_of_year_out: Vec<f64> = datetimes
+        .iter()
+        .map(|&date| date.date().ordinal() as f64)
+        .collect();
+    let local_time_out: Vec<f64> = datetimes
+        .iter()
+        .map(|&date| date.time().num_seconds_from_midnight() as f64 / 3600.0)
+        .collect();
+
+    (day_of_year_out, local_time_out)
+}

physics/environment/solar_calculations.rs

@@ -0,0 +1 @@
+pub mod solar_calculations;

physics/environment/solcast_environment.py

@@ -0,0 +1,18 @@
+from physics.environment.base_environment import BaseEnvironment
+
+
+class SolcastEnvironment(BaseEnvironment):
+    def __init__(self):
+        super().__init__()
+        self._ghi = None
+
+    @property
+    def ghi(self):
+        if (value := self._ghi) is not None:
+            return value
+        else:
+            raise ValueError("ghi is None!")
+
+    @ghi.setter
+    def ghi(self, value):
+        self._ghi = value