chore: implement interface

Author: frodehk

src/libecalc/domain/infrastructure/energy_components/legacy_consumer/consumer_function/pump_consumer_function.py

@@ -8,10 +8,8 @@
 from libecalc.domain.process.pump.pump import PumpModel
 from libecalc.domain.time_series_flow_rate import TimeSeriesFlowRate
 from libecalc.domain.time_series_fluid_density import TimeSeriesFluidDensity
+from libecalc.domain.time_series_power_loss_factor import TimeSeriesPowerLossFactor
 from libecalc.domain.time_series_pressure import TimeSeriesPressure
-from libecalc.presentation.yaml.domain.expression_time_series_power_loss_factor import (
-    ExpressionTimeSeriesPowerLossFactor,
-)
 
 
 class PumpConsumerFunction(ConsumerFunction):
@@ -35,7 +33,7 @@ def __init__(
         suction_pressure: TimeSeriesPressure,
         discharge_pressure: TimeSeriesPressure,
         fluid_density: TimeSeriesFluidDensity,
-        power_loss_factor: ExpressionTimeSeriesPowerLossFactor | None = None,
+        power_loss_factor: TimeSeriesPowerLossFactor | None = None,
     ):
         self._pump_function = pump_function
         self._rate = rate

src/libecalc/domain/time_series_power_loss_factor.py

@@ -1,18 +1,27 @@
 from abc import ABC, abstractmethod
 
+import numpy as np
+
 
 class TimeSeriesPowerLossFactor(ABC):
     """
     Interface for evaluating power loss factor time series.
 
     Implementations should provide methods to evaluate and return
-    power loss factor values, for each stream day.
+    power loss factor values.
 
     """
 
     @abstractmethod
-    def get_stream_day_values(self) -> list[float]:
+    def get_values(self, length=None) -> list[float]:
+        """
+        Returns the evaluated power loss factor values as a list.
+        """
+        pass
+
+    @abstractmethod
+    def apply(self, energy_usage: list[float | None] | np.ndarray) -> list[float]:
         """
-        Returns the evaluated power loss factor values for each stream day.
+        Apply the power loss factor to the given energy usage.
         """
         pass

src/libecalc/presentation/yaml/domain/expression_time_series_power_loss_factor.py

@@ -1,11 +1,10 @@
-from collections.abc import Sequence
-
 import numpy as np
 
+from libecalc.domain.time_series_power_loss_factor import TimeSeriesPowerLossFactor
 from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
 
 
-class ExpressionTimeSeriesPowerLossFactor:
+class ExpressionTimeSeriesPowerLossFactor(TimeSeriesPowerLossFactor):
     """
     Provides power loss factor values by evaluating a time series expression.
     """
@@ -27,14 +26,21 @@ def get_values(self, length=None) -> list[float]:
 
     def apply(
         self,
-        energy_usage: Sequence[float | None] | np.ndarray,
+        energy_usage: list[float | None] | np.ndarray,
     ) -> list[float]:
         """
-        Apply resulting required power taking a (cable/motor...) power loss factor into account.
+        Adjusts the input energy usage to account for power losses.
+
+        Converts the input sequence to a NumPy array, replaces missing values (None or NaN) with 0.0,
+        retrieves the corresponding power loss factor for each time step, and returns the adjusted
+        energy usage as a list, where each value is calculated as:
+            adjusted = energy_usage / (1 - power_loss_factor)
+
         Args:
-            energy_usage: initial required energy usage [MW]
+            energy_usage: Sequence or array of initial energy usage values [MW], may contain None.
+
         Returns:
-            energy usage where power loss is accounted for, i.e. energy_usage/(1-power_loss_factor)
+            List of energy usage values adjusted for power loss.
         """
 
         energy_usage_arr = np.asarray(energy_usage, dtype=np.float64)