domainiac 8.0.6__tar.gz → 8.0.9__tar.gz

{domainiac-8.0.6 → domainiac-8.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: domainiac
-Version: 8.0.6
+Version: 8.0.9
 Summary: Package for working with Energinet data, but with specialized functions used for Enigma.
 Author: Team Enigma
 Author-email: gridop-enigma@energinet.dk
@@ -10,4 +10,5 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Dist: datamazing (>=5.0.2,<6.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: scikit-learn (>=1.3.0,<2.0.0)
+Requires-Dist: scipy (>=1.15.3,<2.0.0)
 Requires-Dist: typeguard (>=4.2.1,<5.0.0)

domainiac-8.0.9/domainiac/functions/conversions.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+ORIGIN = np.datetime64("2020-01-01")
+UNIT = np.timedelta64(1, "s")
+
+
+def as_array(values):
+    return np.array(values)
+
+
+def timedelta_to_float(values):
+    return as_array(values).astype("timedelta64") / UNIT
+
+
+def float_to_timedelta(values):
+    return as_array(values) * UNIT
+
+
+def datetime_to_float(values):
+    return timedelta_to_float(as_array(values).astype("datetime64") - ORIGIN)
+
+
+def float_to_datetime(values):
+    return float_to_timedelta(values) + ORIGIN

domainiac-8.0.9/domainiac/functions/interpolation.py

@@ -0,0 +1,121 @@
+import numpy as np
+from numpy.typing import NDArray
+from scipy import integrate, interpolate
+
+from domainiac.functions.typing import IntegrableRealFunction
+
+
+def cumulative_integral(
+    f: IntegrableRealFunction,
+    x: NDArray[np.float64],
+    step_size: np.float64,
+) -> NDArray[np.float64]:
+    """Given an integrable real function f : R -> R,
+    calculate the cumulative integral values
+
+        int_{x0}^{x}f(s)ds
+
+    The calculation is numerical, using the trapezoid
+    rule with the specified step size.
+
+    Args:
+        f (IntegrableUnivariate): Function
+        x (NDArray[np.float64]): Points to evaluate at.
+        step_size (np.float64): Step size used in the quadrature.
+
+    Returns:
+        NDArray[np.float64]: Values of the cumulative integral
+            at the specified points
+    """
+    xi = np.arange(start=x[0], stop=x[-1] + step_size, step=step_size)
+    yi = f(xi)
+
+    Yi = integrate.cumulative_trapezoid(yi, xi, initial=0)
+
+    Y = Yi[np.searchsorted(xi, x)]
+
+    return Y
+
+
+def midpoint(x: NDArray) -> NDArray:
+    """Calculate the midpoints of intervals
+    giving a sequence of points.
+
+    Args:
+        x (NDArray): Sequence of points defining the intervals (size N)
+
+    Returns:
+        NDArray: Midpoints of intervals (size N-1)
+    """
+    return x[:-1] + 0.5 * np.diff(x)
+
+
+def binned_index_interpolation(
+    profile: IntegrableRealFunction,
+    x: NDArray[np.float64],
+    y_avg: NDArray[np.float64],
+    quad_step_size: float,
+) -> IntegrableRealFunction:
+    """
+    Compute binned index interpolation function. The setup here is as follows:
+    Suppose you have an unknown function f, but which is known to have the
+    form f=i*profile, where i is an function taking values between 0 and 1.
+    Given is only the average value of f on a sequence of intervals.
+
+    This method calculates the ratios
+
+        (integral of f on interval i)/(integral of profile on interval i)
+
+    i is then estimated by doing spline interpolation between these ratios.
+
+    Note:
+        This method does NOT ensure that the average values are preserved.
+        To accomplish this, a different method is required, but is has been
+        decided to not go further into this topic, as the preliminary results
+        seem promising enough.
+
+    Args:
+        profile (IntegrableRealFunction): Profile function
+        x (NDArray[np.float64]): Sequence of points defining the intervals (size N)
+        y_avg (NDArray[np.float64]): Average value on the intervals (size N-1)
+        --- additional settings for solver ---
+        quad_step_size (float): Step size used in quadrature of profile function.
+
+    Returns:
+        IntegrableRealFunction: Estimated base function.
+    """
+    x = np.array(x)
+    y_avg = np.array(y_avg)
+
+    Yp = cumulative_integral(profile, x, step_size=quad_step_size)
+
+    yp_avg = (Yp[1:] - Yp[:-1]) / (x[1:] - x[:-1])
+
+    bin_index = y_avg / yp_avg
+
+    bin_midpoints = midpoint(x)
+
+    # if the index is invalid (due to the profile being zero)
+    # we set the index to 1. Since the profile is zero in this
+    # case, it will not matter to the final function (though
+    # it might have an impact on the values surrounding these
+    # point)
+    is_valid = ~np.isnan(bin_index) & ~np.isinf(bin_index)
+
+    bin_index[~is_valid] = 1
+
+    # the index might be outside the expected range
+    # due to errors in the input data. In this case
+    # we clip it
+    bin_index = np.clip(bin_index, a_min=0, a_max=1)
+
+    index = interpolate.make_interp_spline(
+        x=bin_midpoints,
+        y=bin_index,
+        k=2,
+    )
+
+    def estimate(x: NDArray[np.float64]) -> NDArray[np.float64]:
+        return index(x) * profile(x)
+
+    return estimate

domainiac-8.0.9/domainiac/functions/solar.py

@@ -0,0 +1,68 @@
+import numpy as np
+import pandas as pd
+import pvlib
+from numpy.typing import NDArray
+
+from domainiac.functions import conversions, interpolation
+from domainiac.modeling import Coordinate
+
+
+def clearsky_irradiance(
+    times: NDArray[np.datetime64], coordinate: Coordinate
+) -> NDArray[np.float64]:
+    """Get the clearsky irradiance (W/m2) for a specific coordinate
+
+    Args:
+        times (NDArray[np.datetime64]): Times
+        coordinate (Coordinate): Coordinate
+    """
+
+    location = pvlib.location.Location(coordinate.latitude, coordinate.longitude)
+
+    # ensure 1D-array both when input is
+    # scalar and 1D-array already
+    array = conversions.as_array([times])
+    if array.size != 1:
+        array = array.squeeze()
+
+    times = pd.DatetimeIndex(array)
+    # pvlibs `get_clearsky` will return 0
+    # if datetime unit is anything else than
+    # nanoseconds (probably due to some
+    # internal conversion going wrong)
+    times = times.as_unit("ns")
+
+    clearsky = location.get_clearsky(times)
+
+    return clearsky["ghi"].to_numpy()
+
+
+def interpolate_irradiance(
+    coordinate: Coordinate, times: pd.Series, radiation_avg: pd.Series
+):
+    """Interpolate solar irradiance (i.e. instantaneous values) using
+    binned index interpolation (using the clearsky irradiance as the reference profile)
+    between observed values of solar radiance (i.e. binned average values)
+
+    Args:
+        coordinate (Coordinate): Coordinate
+        times (pd.Series): Sequence of times defining the intervals of observations
+        radiation (pd.Series): Observed values of radiation
+    """
+
+    def profile(x: NDArray[np.float64]) -> NDArray[np.float64]:
+        times = conversions.float_to_datetime(x)
+        return clearsky_irradiance(times, coordinate)
+
+    x = conversions.datetime_to_float(times)
+    y_avg = conversions.as_array(radiation_avg)
+    # 5-minute step size should be sufficient for evaluating the clearsky integral
+    quad_step_size = conversions.timedelta_to_float(pd.Timedelta("PT5M"))
+
+    f = interpolation.binned_index_interpolation(profile, x, y_avg, quad_step_size)
+
+    def estimate(times: pd.Series) -> NDArray[np.float64]:
+        x = conversions.datetime_to_float(times)
+        return f(x)
+
+    return estimate

domainiac-8.0.9/domainiac/functions/typing.py

@@ -0,0 +1,8 @@
+from typing import Callable
+
+import numpy as np
+from numpy.typing import NDArray
+
+IntegrableRealFunction = Callable[[NDArray[np.float64]], NDArray[np.float64]]
+
+RealFunction = Callable[[NDArray[np.float64]], NDArray[np.float64]]

{domainiac-8.0.6 → domainiac-8.0.9}/domainiac/managers/masterdata_manager.py

@@ -28,6 +28,7 @@ class MasterdataManager:
     def _get_operational_entities(self, table: str) -> pd.DataFrame:
         filters = {"standing_entity_state": "InOperation"}
         df = self.db.query(table, filters=filters)
+        df = df[df["decommission_date_utc"].isna()].reset_index(drop=True)
         return df
 
     @typechecked

{domainiac-8.0.6 → domainiac-8.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "domainiac"
-version = "8.0.6"
+version = "8.0.9"
 description = "Package for working with Energinet data, but with specialized functions used for Enigma."
 authors = ["Team Enigma <gridop-enigma@energinet.dk>"]
 packages = [
@@ -13,6 +13,7 @@ pandas = "^2.2.0"
 datamazing = "^5.0.2"
 typeguard = "^4.2.1"
 scikit-learn = "^1.3.0"
+scipy = "^1.15.3"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7"
@@ -20,6 +21,8 @@ pytest-cov = "^3.0.0"
 pre-commit = "^2.20.0"
 pytype = "^2023.7"
 parameterized = "^0.9.0"
+plotly = "^6.0.0"
+pvlib = "^0.13.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]