refactor: use time series flow rate for direct consumer function

Author: frodehk

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

@@ -3,38 +3,32 @@
 from libecalc.common.energy_usage_type import EnergyUsageType
 from libecalc.common.list.list_utils import array_to_list
 from libecalc.common.units import Unit
-from libecalc.common.utils.rates import Rates, RateType
 from libecalc.common.variables import ExpressionEvaluator
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function import (
     ConsumerFunction,
     ConsumerFunctionResult,
 )
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.utils import (
-    apply_condition,
     apply_power_loss_factor,
-    get_condition_from_expression,
     get_power_loss_factor_from_expression,
 )
 from libecalc.domain.process.core.results import EnergyFunctionGenericResult
 from libecalc.expression import Expression
+from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
 
 
 class DirectExpressionConsumerFunction(ConsumerFunction):
     def __init__(
         self,
         energy_usage_type: EnergyUsageType,
         condition: Expression | None = None,
-        fuel_rate: Expression | None = None,
-        load: Expression | None = None,
+        fuel_rate: ExpressionTimeSeriesFlowRate = None,
+        load: ExpressionTimeSeriesFlowRate | None = None,
         power_loss_factor: Expression | None = None,
-        consumption_rate_type: RateType = RateType.STREAM_DAY,
     ):
-        expression = fuel_rate if energy_usage_type == EnergyUsageType.FUEL.value else load
+        self._energy_usage = fuel_rate if energy_usage_type == EnergyUsageType.FUEL.value else load
         power_loss_factor_expression = power_loss_factor
-        assert isinstance(consumption_rate_type, RateType)
         self._energy_usage_type = energy_usage_type
-        self._expression = expression
-        self._convert_to_stream_day = consumption_rate_type == RateType.CALENDAR_DAY
         self._condition_expression = condition
         self._power_loss_factor_expression = power_loss_factor_expression
 
@@ -66,28 +60,15 @@ def evaluate(
         expression_evaluator: ExpressionEvaluator,
         regularity: list[float],
     ) -> ConsumerFunctionResult:
-        energy_usage_expression_evaluated = expression_evaluator.evaluate(expression=self._expression)  # type: ignore[arg-type]
-
-        # Do conditioning first - set rates to zero if conditions are not met
-        condition = get_condition_from_expression(
-            expression_evaluator=expression_evaluator,
-            condition_expression=self._condition_expression,
-        )
-
-        energy_usage = apply_condition(
-            input_array=Rates.to_stream_day(
-                calendar_day_rates=energy_usage_expression_evaluated,
-                regularity=regularity,
-            )
-            if self._convert_to_stream_day
-            else energy_usage_expression_evaluated,
-            condition=condition,
-        )
+        energy_usage_raw = self._energy_usage.get_stream_day_values()
+        energy_usage = array_to_list(np.asarray(energy_usage_raw))
+        if energy_usage is None:
+            energy_usage = []
 
         energy_function_result = EnergyFunctionGenericResult(
-            energy_usage=array_to_list(energy_usage),  # type: ignore[arg-type]
+            energy_usage=energy_usage,
             energy_usage_unit=self.energy_usage_unit,
-            power=array_to_list(energy_usage) if self.is_electrical_consumer else None,
+            power=energy_usage if self.is_electrical_consumer else None,
             power_unit=self.power_unit if self.is_electrical_consumer else None,
         )
 
@@ -104,7 +85,7 @@ def evaluate(
         # but negative fuel rates are always invalid.
 
         if self.is_fuel_consumer:
-            is_valid[energy_usage < 0] = False
+            is_valid[np.asarray(energy_usage) < 0] = False
 
         consumer_function_result = ConsumerFunctionResult(
             periods=expression_evaluator.get_periods(),

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

@@ -3,7 +3,7 @@
 import numpy as np
 
 from libecalc.common.time_utils import Period
-from libecalc.common.utils.rates import Rates
+from libecalc.common.utils.rates import Rates, RateType
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.utils import (
     apply_condition,
     get_condition_from_expression,
@@ -18,20 +18,23 @@ class ExpressionTimeSeriesFlowRate(TimeSeriesFlowRate):
     """
     Provides flow rate values by evaluating a time series expression.
 
-    This class assumes that the input time series expression yields flow rates per calendar day.
-    - Stream day values are derived by converting calendar day rates using the specified regularity,
-      and then applying an optional condition expression to filter or modify the results.
-
+    This class supports configurable rate types via the `consumption_rate_type` parameter.
+    - If `consumption_rate_type` is set to calendar day (default), flow rates are converted to stream day rates using the specified regularity.
+    - If set to stream day, rates are used as-is.
+    - An optional condition expression can be applied to filter or modify the results.
     """
 
     def __init__(
         self,
         time_series_expression: TimeSeriesExpression,
         regularity: Regularity,
         condition_expression: Expression | dict[Period, Expression] | None = None,
+        consumption_rate_type: RateType | None = RateType.CALENDAR_DAY,
     ):
         self._time_series_expression = time_series_expression
         self._regularity = regularity
+        assert isinstance(consumption_rate_type, RateType)
+        self._consumption_rate_type = consumption_rate_type
         self.condition = get_condition_from_expression(
             expression_evaluator=self._time_series_expression.expression_evaluator,
             condition_expression=condition_expression,
@@ -46,12 +49,19 @@ def get_stream_day_values(self) -> Sequence[float]:
         """
 
         # if regularity is 0 for a calendar day rate, set stream day rate to 0 for that step
-        calendar_day_rate = self._time_series_expression.get_evaluated_expressions()
-        stream_day_rate = apply_condition(
-            input_array=Rates.to_stream_day(
-                calendar_day_rates=np.asarray(calendar_day_rate, dtype=np.float64),
+        rate = self._time_series_expression.get_evaluated_expressions()
+        rate_array = np.asarray(rate, dtype=np.float64)
+
+        if self._consumption_rate_type == RateType.CALENDAR_DAY:
+            rate_array = Rates.to_stream_day(
+                calendar_day_rates=rate_array,
                 regularity=self._regularity.get_values,
-            ),
+            )
+
+        # If already stream_day, no conversion needed
+        stream_day_rate = apply_condition(
+            input_array=rate_array,
             condition=self.condition,
         )
+
         return stream_day_rate

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

@@ -200,33 +200,51 @@ def __init__(
             self._period_subsets[period] = (period_regularity, period_evaluator)
 
     def _map_direct(
-        self, model: YamlEnergyUsageModelDirectFuel | YamlEnergyUsageModelDirectElectricity, consumes: ConsumptionType
+        self,
+        model: YamlEnergyUsageModelDirectFuel | YamlEnergyUsageModelDirectElectricity,
+        consumes: ConsumptionType,
+        period: Period,
     ) -> DirectExpressionConsumerFunction:
+        period_regularity, period_evaluator = self._period_subsets[period]
         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)
+            fuel_rate_expression = TimeSeriesExpression(
+                expressions=model.fuel_rate, expression_evaluator=period_evaluator
+            )
+            fuel_rate = ExpressionTimeSeriesFlowRate(
+                time_series_expression=fuel_rate_expression,
+                regularity=period_regularity,
+                condition_expression=condition,
+                consumption_rate_type=consumption_rate_type,
+            )
             return DirectExpressionConsumerFunction(
                 energy_usage_type=EnergyUsageType.FUEL,
-                fuel_rate=convert_expression(model.fuel_rate),  # type: ignore[arg-type]
+                fuel_rate=fuel_rate,
                 condition=condition,  # type: ignore[arg-type]
                 power_loss_factor=power_loss_factor,  # type: ignore[arg-type]
-                consumption_rate_type=consumption_rate_type,
             )
         else:
             assert isinstance(model, YamlEnergyUsageModelDirectElectricity)
 
             if consumes != ConsumptionType.ELECTRICITY:
                 raise InvalidConsumptionType(actual=ConsumptionType.ELECTRICITY, expected=consumes)
 
+            load_expression = TimeSeriesExpression(expressions=model.load, expression_evaluator=period_evaluator)
+            load = ExpressionTimeSeriesFlowRate(
+                time_series_expression=load_expression,
+                regularity=period_regularity,
+                condition_expression=condition,
+                consumption_rate_type=consumption_rate_type,
+            )
             return DirectExpressionConsumerFunction(
                 energy_usage_type=EnergyUsageType.POWER,
-                load=convert_expression(model.load),  # type: ignore[arg-type]
+                load=load,
                 condition=condition,  # type: ignore[arg-type]
                 power_loss_factor=power_loss_factor,  # type: ignore[arg-type]
-                consumption_rate_type=consumption_rate_type,
             )
 
     def _map_tabular(self, model: YamlEnergyUsageModelTabulated, consumes: ConsumptionType) -> TabularConsumerFunction:
@@ -543,7 +561,7 @@ def from_yaml_to_dto(
         for period, model in self._time_adjusted_model.items():
             try:
                 if isinstance(model, YamlEnergyUsageModelDirectElectricity | YamlEnergyUsageModelDirectFuel):
-                    mapped_model = self._map_direct(model=model, consumes=consumes)
+                    mapped_model = self._map_direct(model=model, consumes=consumes, period=period)
                 elif isinstance(model, YamlEnergyUsageModelCompressor):
                     mapped_model = self._map_compressor(model, consumes=consumes)
                 elif isinstance(model, YamlEnergyUsageModelPump):

tests/libecalc/conftest.py

@@ -2,34 +2,59 @@
 
 from libecalc.common.energy_usage_type import EnergyUsageType
 from libecalc.common.utils.rates import RateType
+from libecalc.common.variables import ExpressionEvaluator
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.direct_expression_consumer_function import (
     DirectExpressionConsumerFunction,
 )
-from libecalc.expression import Expression
+from libecalc.domain.regularity import Regularity
+from libecalc.expression.expression import ExpressionType
+from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
+from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
 
 
 @pytest.fixture
-def direct_expression_model_factory():
+def regularity_factory():
+    def create_regularity(expression_evaluator: ExpressionEvaluator, regularity_value: ExpressionType = 1):
+        regularity = Regularity(
+            expression_input=regularity_value,
+            expression_evaluator=expression_evaluator,
+            target_period=expression_evaluator.get_period(),
+        )
+        return regularity
+
+    return create_regularity
+
+
+@pytest.fixture
+def direct_expression_model_factory(regularity_factory):
     def create_direct_expression_model(
-        expression: Expression,
+        expression: ExpressionType,
         energy_usage_type: EnergyUsageType,
+        expression_evaluator: ExpressionEvaluator,
         consumption_rate_type: RateType = RateType.STREAM_DAY,
+        regularity: Regularity | None = None,
     ):
+        if regularity is None:
+            regularity = regularity_factory(expression_evaluator)
+
+        usage_expression = TimeSeriesExpression(expressions=expression, expression_evaluator=expression_evaluator)
+        usage = ExpressionTimeSeriesFlowRate(
+            time_series_expression=usage_expression, regularity=regularity, consumption_rate_type=consumption_rate_type
+        )
+
         if energy_usage_type == EnergyUsageType.POWER:
             return DirectExpressionConsumerFunction(
                 energy_usage_type=energy_usage_type,
                 condition=None,
-                load=expression,
+                load=usage,
                 power_loss_factor=None,
-                consumption_rate_type=consumption_rate_type,
             )
         else:
             return DirectExpressionConsumerFunction(
                 energy_usage_type=energy_usage_type,
                 condition=None,
-                fuel_rate=expression,
+                fuel_rate=usage,
                 power_loss_factor=None,
-                consumption_rate_type=consumption_rate_type,
             )
 
     return create_direct_expression_model

tests/libecalc/core/consumers/conftest.py

@@ -60,43 +60,38 @@ def create_tabulated_fuel_consumer(
 @pytest.fixture
 def electricity_consumer_factory(direct_expression_model_factory):
     def _create_electricity_consumer(
-        expression_evaluator: ExpressionEvaluator, energy_usage_model: TemporalModel = None
+        expression_evaluator: ExpressionEvaluator, energy_usage_model: TemporalModel = None, values: list[float] = None
     ) -> ElectricityConsumer:
+        regularity = Regularity(
+            expression_evaluator=expression_evaluator,
+            target_period=expression_evaluator.get_period(),
+            expression_input=1,
+        )
         if energy_usage_model is None:
+            periods = expression_evaluator.get_periods().periods
+            if values is None:
+                values = [0.0] * len(periods)
+            else:
+                # Pad or truncate values to match periods
+                values = (values + [0.0] * len(periods))[: len(periods)]
+
             energy_usage_model = TemporalModel(
                 {
-                    Period(datetime(2020, 1, 1), datetime(2021, 1, 1)): direct_expression_model_factory(
-                        expression=Expression.setup_from_expression(value=1),
-                        energy_usage_type=EnergyUsageType.POWER,
-                        consumption_rate_type=RateType.STREAM_DAY,
-                    ),
-                    Period(
-                        datetime(2021, 1, 1), datetime(2022, 1, 1)
-                    ): direct_expression_model_factory(  # Run above capacity
-                        expression=Expression.setup_from_expression(value=2),
+                    period: direct_expression_model_factory(
+                        expression=value,
                         energy_usage_type=EnergyUsageType.POWER,
                         consumption_rate_type=RateType.STREAM_DAY,
-                    ),
-                    Period(
-                        datetime(2022, 1, 1), datetime(2023, 1, 1)
-                    ): direct_expression_model_factory(  # Run above capacity
-                        expression=Expression.setup_from_expression(value=10),
-                        energy_usage_type=EnergyUsageType.POWER,
-                        consumption_rate_type=RateType.STREAM_DAY,
-                    ),
-                    Period(datetime(2023, 1, 1)): direct_expression_model_factory(  # Ensure we handle 0 load as well.
-                        expression=Expression.setup_from_expression(value=0),
-                        energy_usage_type=EnergyUsageType.POWER,
-                        consumption_rate_type=RateType.STREAM_DAY,
-                    ),
+                        expression_evaluator=expression_evaluator.get_subset(
+                            *period.get_period_indices(expression_evaluator.get_periods())
+                        ),
+                        regularity=regularity.get_subset(
+                            *period.get_period_indices(expression_evaluator.get_periods())
+                        ),
+                    )
+                    for period, value in zip(periods, values)
                 }
             )
 
-        regularity = Regularity(
-            expression_evaluator=expression_evaluator,
-            target_period=expression_evaluator.get_period(),
-            expression_input=1,
-        )
         return ElectricityConsumer(
             id=uuid4(),
             path_id=PathID("direct_consumer"),