domainiac 8.0.10__tar.gz → 9.0.0__tar.gz

{domainiac-8.0.10 → domainiac-9.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: domainiac
-Version: 8.0.10
+Version: 9.0.0
 Summary: Package for working with Energinet data, but with specialized functions used for Enigma.
 Author: Team Enigma
 Author-email: gridop-enigma@energinet.dk

domainiac-9.0.0/domainiac/functions/__init__.py

@@ -0,0 +1,3 @@
+from .solar import interpolate_irradiance
+from .temperature import interpolate_temperature
+from .wind import interpolate_wind_components

{domainiac-8.0.10 → domainiac-9.0.0}/domainiac/managers/nwp_manager.py

@@ -3,6 +3,8 @@ import numpy as np
 import pandas as pd
 from sklearn.neighbors import KDTree
 
+from domainiac import functions
+
 from ..modeling.nwp import Coordinate, Neighborhood, NWPParameter, NWPProvider
 
 
@@ -15,32 +17,6 @@ class NWPManager:
     - Finding closest NWP coordinates
     """
 
-    NWP_INTERPOLATION_METHODS = {
-        # Wind and temperature are estimates
-        # of the instantaneous value at time t.
-        # We use linear interpolation.
-        NWPParameter.WIND: ("linear", "instantanous"),
-        NWPParameter.TEMPERATURE: ("linear", "instantanous"),
-        # solar is an estimate of the average value
-        # in the interval [t-1, t].
-        # We use PCHIP interpolation to ensure
-        # a smooth shape and non-negative values
-        # (https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.PchipInterpolator.html)
-        NWPParameter.SOLAR: ("pchip", "interval_average"),
-    }
-
-    NWP_RESOLUTIONS = {
-        (NWPProvider.ECMWF, NWPParameter.WIND): pd.Timedelta("PT3H"),
-        (NWPProvider.ECMWF, NWPParameter.TEMPERATURE): pd.Timedelta("PT3H"),
-        (NWPProvider.ECMWF, NWPParameter.SOLAR): pd.Timedelta("PT1H"),
-        (NWPProvider.DMI, NWPParameter.WIND): pd.Timedelta("PT1H"),
-        (NWPProvider.DMI, NWPParameter.TEMPERATURE): pd.Timedelta("PT1H"),
-        (NWPProvider.DMI, NWPParameter.SOLAR): pd.Timedelta("PT1H"),
-        (NWPProvider.CONWX, NWPParameter.WIND): pd.Timedelta("PT1H"),
-        (NWPProvider.CONWX, NWPParameter.TEMPERATURE): pd.Timedelta("PT1H"),
-        (NWPProvider.CONWX, NWPParameter.SOLAR): pd.Timedelta("PT1H"),
-    }
-
     def __init__(
         self,
         db: pdz.Database,
@@ -54,22 +30,6 @@ class NWPManager:
         self._nwp_coordinates_kd_tree = dict()
         self._nwp_table_name_prefix = "forecastNwp"
 
-    @classmethod
-    def get_nwp_resolution(
-        cls, provider: NWPProvider, parameter: NWPParameter
-    ) -> pd.Timedelta:
-        """
-        Get the resolution of the NWP parameter.
-        """
-        return cls.NWP_RESOLUTIONS[(provider, parameter)]
-
-    @classmethod
-    def get_nwp_interpolation_method(cls, parameter: NWPParameter) -> tuple[str, str]:
-        """
-        Get the interpolation method and temporal aggregation for the NWP parameter.
-        """
-        return cls.NWP_INTERPOLATION_METHODS[parameter]
-
     @staticmethod
     def calculate_wind_speed_from_vectors(u: pd.Series, v: pd.Series) -> pd.Series:
         return np.sqrt(u**2 + v**2)
@@ -167,14 +127,14 @@ class NWPManager:
             "altitude_m": coordinate.altitude,
         }
 
-        # Pad time interval with one resolution
-        # This is needed for the interpolation to work as we shift back in time
-        nwp_resolution = self.get_nwp_resolution(provider, parameter)
-
-        # Pad time interval to make sure interpolation is possible
+        # Since we need to interpolate along the time dimension, we need to pad
+        # the desired time interval when querying data, so we ensure we have data
+        # points to interpolate between. Padding with 6 hours should be enough
+        # for all our current NWP providers
+        query_margin = pd.Timedelta("P6H")
         padded_time_interval = pdz.TimeInterval(
-            self.time_interval.left - (nwp_resolution / 2),
-            self.time_interval.right + (nwp_resolution * 1.5),
+            self.time_interval.left - query_margin,
+            self.time_interval.right + query_margin,
         )
 
         df = self.db.query(table, padded_time_interval, filters=filters)
@@ -205,41 +165,43 @@ class NWPManager:
         """
         df = self._get_nwp_parameter(provider, parameter, coordinate)
 
-        nwp_resolution = self.get_nwp_resolution(provider, parameter)
-        interpolation_method, temporal_aggregation = self.get_nwp_interpolation_method(
-            parameter
+        df = df.sort_values(by="time_utc")
+
+        if parameter == NWPParameter.TEMPERATURE:
+            column_names = "temperature_K"
+            interpolated_function = functions.interpolate_temperature(
+                times=df["time_utc"], temperature=df[column_names]
+            )
+        elif parameter == NWPParameter.SOLAR:
+            column_names = "global_radiation_W_m2"
+            interpolated_function = functions.interpolate_irradiance(
+                coordinate=coordinate,
+                times=df["time_utc"],
+                radiation_avg=df[column_names].iloc[1:],
+            )
+        elif parameter == NWPParameter.WIND:
+            column_names = ["wind_u_m_s", "wind_v_m_s"]
+            interpolated_function = functions.interpolate_wind_components(
+                times=df["time_utc"],
+                wind_components=df[column_names],
+            )
+
+        df_interpolated = self.time_interval.to_range(freq=self.resolution).to_frame(
+            name="time_utc"
         )
 
-        match temporal_aggregation:
-            # if the parameter is an interval average,
-            # it makes best sense to interpolate from
-            # midpoint to midpoint. Otherwise, we just
-            # interpolate regularly.
-            case "interval_average":
-                shift = -1 / 2
-            case "instantanous":
-                shift = 0
-
-        df_shifted = pdz.shift_time(df, on="time_utc", period=shift * nwp_resolution)
-
-        # Interpolate
-        df_resampled = pdz.resample(
-            df_shifted, on="time_utc", resolution=self.resolution / 2
-        ).interpolate(interpolation_method)
-
-        # Shift back time, so that the output time series again represents
-        # the value by the endpoint.
-        df_re_shifted = pdz.shift_time(
-            df_resampled, on="time_utc", period=-shift * self.resolution
+        df_interpolated[column_names] = interpolated_function(
+            df_interpolated["time_utc"]
         )
 
-        # Make sure times is divisible by the resolution
-        df_resolution = df_re_shifted[
-            df_re_shifted["time_utc"].dt.round(self.resolution)
-            == df_re_shifted["time_utc"]
+        # disallow extrapolation
+        df_interpolated = df_interpolated[
+            df_interpolated["time_utc"].between(
+                df["time_utc"].min(), df["time_utc"].max()
+            )
         ]
 
-        return df_resolution
+        return df_interpolated
 
     def get_nwp_parameter(
         self,

{domainiac-8.0.10 → domainiac-9.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domainiac"
-version = "8.0.10"
+version = "9.0.0"
 description = "Package for working with Energinet data, but with specialized functions used for Enigma."
 authors = ["Team Enigma <gridop-enigma@energinet.dk>"]
 packages = [