refactor: direct consumer function time series power loss factor

Author: frodehk

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

@@ -7,14 +7,10 @@
     ConsumerFunction,
     ConsumerFunctionResult,
 )
-from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.utils import (
-    apply_power_loss_factor,
-    get_power_loss_factor_from_expression,
-)
 from libecalc.domain.process.core.results import EnergyFunctionGenericResult
 from libecalc.domain.time_series_flow_rate import TimeSeriesFlowRate
 from libecalc.domain.time_series_power import TimeSeriesPower
-from libecalc.expression import Expression
+from libecalc.domain.time_series_power_loss_factor import TimeSeriesPowerLossFactor
 
 
 class DirectConsumerFunction(ConsumerFunction):
@@ -23,12 +19,11 @@ def __init__(
         energy_usage_type: EnergyUsageType,
         fuel_rate: TimeSeriesFlowRate | None = None,
         load: TimeSeriesPower | None = None,
-        power_loss_factor: Expression | None = None,
+        power_loss_factor: TimeSeriesPowerLossFactor | None = None,
     ):
         self._energy_usage = fuel_rate if energy_usage_type == EnergyUsageType.FUEL.value else load
-        power_loss_factor_expression = power_loss_factor
         self._energy_usage_type = energy_usage_type
-        self._power_loss_factor_expression = power_loss_factor_expression
+        self._power_loss_factor = power_loss_factor
 
     @property
     def is_electrical_consumer(self) -> bool:
@@ -67,10 +62,14 @@ def evaluate(
             power_unit=self.power_unit if self.is_electrical_consumer else None,
         )
 
-        power_loss_factor = get_power_loss_factor_from_expression(
-            expression_evaluator=expression_evaluator,
-            power_loss_factor_expression=self._power_loss_factor_expression,
-        )
+        if self._power_loss_factor is not None:
+            energy_usage = self._power_loss_factor.apply(
+                energy_usage=np.asarray(energy_function_result.energy_usage, dtype=np.float64)
+            )
+            power_loss_factor = self._power_loss_factor.get_values(length=len(energy_usage))
+        else:
+            energy_usage = energy_function_result.energy_usage
+            power_loss_factor = None
 
         is_valid = np.asarray(energy_function_result.is_valid)
 
@@ -83,15 +82,12 @@ def evaluate(
             is_valid[np.asarray(energy_usage) < 0] = False
 
         consumer_function_result = ConsumerFunctionResult(
-            periods=expression_evaluator.get_periods(),
+            periods=self._energy_usage.get_periods(),
             is_valid=is_valid,
             energy_function_result=energy_function_result,
-            energy_usage_before_power_loss_factor=np.asarray(energy_function_result.energy_usage),
-            power_loss_factor=power_loss_factor,
-            energy_usage=apply_power_loss_factor(
-                energy_usage=np.asarray(energy_function_result.energy_usage),
-                power_loss_factor=power_loss_factor,
-            ),
+            energy_usage_before_power_loss_factor=np.asarray(energy_function_result.energy_usage, dtype=np.float64),
+            power_loss_factor=np.asarray(power_loss_factor, dtype=np.float64),
+            energy_usage=np.asarray(energy_usage, dtype=np.float64),
         )
 
         return consumer_function_result

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

@@ -76,7 +76,7 @@ def evaluate(
             power_loss_factor = self._power_loss_factor.get_values(length=len(energy_usage))
         else:
             energy_usage = energy_function_result.energy_usage
-            power_loss_factor = np.zeros_like(np.asarray(energy_usage, dtype=np.float64), dtype=np.float64)
+            power_loss_factor = None
 
         pump_consumer_function_result = ConsumerFunctionResult(
             periods=expression_evaluator.get_periods(),

src/libecalc/domain/time_series_flow_rate.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from libecalc.common.time_utils import Periods
+
 
 class TimeSeriesFlowRate(ABC):
     """
@@ -16,3 +18,11 @@ def get_stream_day_values(self) -> list[float | None]:
         Returns the evaluated flow rate values for each stream day.
         """
         pass
+
+    @abstractmethod
+    def get_periods(self) -> Periods:
+        """
+        Returns the periods associated with the flow rate time series.
+        This is used to align the flow rate values with the corresponding periods.
+        """
+        pass

src/libecalc/domain/time_series_power.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from libecalc.common.time_utils import Periods
+
 
 class TimeSeriesPower(ABC):
     """
@@ -16,3 +18,11 @@ def get_stream_day_values(self) -> list[float | None]:
         Returns the evaluated power values for each stream day.
         """
         pass
+
+    @abstractmethod
+    def get_periods(self) -> Periods:
+        """
+        Returns the periods associated with the flow rate time series.
+        This is used to align the flow rate values with the corresponding periods.
+        """
+        pass

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

@@ -1,6 +1,6 @@
 import numpy as np
 
-from libecalc.common.time_utils import Period
+from libecalc.common.time_utils import Period, Periods
 from libecalc.common.utils.rates import Rates, RateType
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.utils import (
     apply_condition,
@@ -63,3 +63,11 @@ def get_stream_day_values(self) -> list[float | None]:
         )
 
         return stream_day_rate.tolist()
+
+    def get_periods(self) -> Periods:
+        """
+        Returns the periods associated with the time series expression.
+
+        This is used to align the flow rate values with the corresponding periods.
+        """
+        return self._time_series_expression.expression_evaluator.get_periods()

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

@@ -1,6 +1,6 @@
 import numpy as np
 
-from libecalc.common.time_utils import Period
+from libecalc.common.time_utils import Period, Periods
 from libecalc.common.utils.rates import Rates, RateType
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.utils import (
     apply_condition,
@@ -63,3 +63,11 @@ def get_stream_day_values(self) -> list[float | None]:
         )
 
         return stream_day_power.tolist()
+
+    def get_periods(self) -> Periods:
+        """
+        Returns the periods associated with the time series expression.
+
+        This is used to align the flow rate values with the corresponding periods.
+        """
+        return self._time_series_expression.expression_evaluator.get_periods()

src/libecalc/presentation/yaml/mappers/consumer_function_mapper.py

@@ -211,9 +211,15 @@ def _map_direct(
         period: Period,
     ) -> DirectConsumerFunction:
         period_regularity, period_evaluator = self._period_subsets[period]
+
+        power_loss_factor_expression = TimeSeriesExpression(
+            expressions=model.power_loss_factor, expression_evaluator=period_evaluator
+        )
+        power_loss_factor = ExpressionTimeSeriesPowerLossFactor(time_series_expression=power_loss_factor_expression)
+
         condition = convert_expression(_map_condition(model))
         consumption_rate_type = RateType((model.consumption_rate_type or ConsumptionRateType.STREAM_DAY).value)
-        power_loss_factor = convert_expression(model.power_loss_factor)
+
         if isinstance(model, YamlEnergyUsageModelDirectFuel):
             if consumes != ConsumptionType.FUEL:
                 raise InvalidConsumptionType(actual=ConsumptionType.FUEL, expected=consumes)
@@ -229,7 +235,7 @@ def _map_direct(
             return DirectConsumerFunction(
                 energy_usage_type=EnergyUsageType.FUEL,
                 fuel_rate=fuel_rate,
-                power_loss_factor=power_loss_factor,  # type: ignore[arg-type]
+                power_loss_factor=power_loss_factor,
             )
         else:
             assert isinstance(model, YamlEnergyUsageModelDirectElectricity)
@@ -247,7 +253,7 @@ def _map_direct(
             return DirectConsumerFunction(
                 energy_usage_type=EnergyUsageType.POWER,
                 load=load,
-                power_loss_factor=power_loss_factor,  # type: ignore[arg-type]
+                power_loss_factor=power_loss_factor,
             )
 
     def _map_tabular(self, model: YamlEnergyUsageModelTabulated, consumes: ConsumptionType) -> TabularConsumerFunction:

tests/libecalc/core/consumers/consumer_function/test_direct_expression_consumer_function.py

@@ -17,6 +17,10 @@
 from libecalc.domain.regularity import Regularity
 from libecalc.expression import Expression
 from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
+from libecalc.presentation.yaml.domain.expression_time_series_power import ExpressionTimeSeriesPower
+from libecalc.presentation.yaml.domain.expression_time_series_power_loss_factor import (
+    ExpressionTimeSeriesPowerLossFactor,
+)
 from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
 
 
@@ -213,10 +217,13 @@ def test_direct_expression_consumer_function(expression_evaluator_factory):
     fuel_rate_expression = TimeSeriesExpression(expressions="2", expression_evaluator=variables_map)
     fuel_rate = ExpressionTimeSeriesFlowRate(time_series_expression=fuel_rate_expression, regularity=regularity)
 
+    power_loss_factor_expression = TimeSeriesExpression(expressions=0.2, expression_evaluator=variables_map)
+    power_loss_factor = ExpressionTimeSeriesPowerLossFactor(time_series_expression=power_loss_factor_expression)
+
     np.testing.assert_allclose(
         actual=DirectConsumerFunction(
             fuel_rate=fuel_rate,
-            power_loss_factor=Expression.setup_from_expression(value=0.2),
+            power_loss_factor=power_loss_factor,
             energy_usage_type=libecalc.common.energy_usage_type.EnergyUsageType.FUEL,
         )
         .evaluate(
@@ -243,7 +250,7 @@ def test_direct_expression_consumer_function_consumption_rate_type(direct_variab
     load_expression = TimeSeriesExpression(
         expressions=stream_day_consumption, expression_evaluator=direct_variables_map
     )
-    load_stream_day = ExpressionTimeSeriesFlowRate(
+    load_stream_day = ExpressionTimeSeriesPower(
         time_series_expression=load_expression,
         regularity=regularity,
         consumption_rate_type=libecalc.common.utils.rates.RateType.STREAM_DAY,
@@ -258,7 +265,7 @@ def test_direct_expression_consumer_function_consumption_rate_type(direct_variab
     load_expression = TimeSeriesExpression(
         expressions=calendar_day_consumption, expression_evaluator=direct_variables_map
     )
-    load_calendar_day = ExpressionTimeSeriesFlowRate(
+    load_calendar_day = ExpressionTimeSeriesPower(
         time_series_expression=load_expression,
         regularity=regularity,
         consumption_rate_type=libecalc.common.utils.rates.RateType.CALENDAR_DAY,