refactor: implement condition for direct consumer

Author: frodehk

src/libecalc/domain/condition.py

@@ -18,42 +18,37 @@ class Condition:
 
     def __init__(
         self,
+        expression_evaluator: ExpressionEvaluator,
         expression_input: ExpressionType | None,
     ):
         """
         Initialize a Condition instance.
 
         Args:
             expression_input (ExpressionType | None): The raw input for the condition expression.
+            expression_evaluator (ExpressionEvaluator): Evaluator for variable and condition expressions.
         """
+        self.expression_evaluator = expression_evaluator
         self._expression_input = expression_input
         self.expression = convert_expression(self._expression_input)
 
-    def as_vector(
-        self,
-        expression_evaluator: ExpressionEvaluator,
-    ) -> NDArray[np.int_] | None:
+    def as_vector(self) -> NDArray[np.int_] | None:
         """
         Evaluate the condition expression and return a vector indicating where the condition is met.
 
-        Args:
-            expression_evaluator (ExpressionEvaluator): Evaluator for variable and condition expressions.
-
         Returns:
             NDArray[np.int_] | None: An integer array (1 where condition is true, 0 otherwise),
             or None if no condition is set.
         """
         if self.expression is None:
             return None
 
-        condition = expression_evaluator.evaluate(expression=self.expression)
+        condition = self.expression_evaluator.evaluate(expression=self.expression)
         condition = (condition != 0).astype(int)
 
         return np.array(condition)
 
-    def _apply(
-        self, input_array: NDArray[np.float64], expression_evaluator: ExpressionEvaluator
-    ) -> NDArray[np.float64]:
+    def _apply(self, input_array: NDArray[np.float64]) -> NDArray[np.float64]:
         """
         Internal method containing the core logic for applying the condition to an array.
         This method performs the actual masking/zeroing operation based on the condition:
@@ -63,32 +58,31 @@ def _apply(
 
         Args:
             input_array (NDArray[np.float64]): The array to apply the condition to.
-            expression_evaluator (ExpressionEvaluator): Evaluator for the condition expression.
 
         Returns:
             NDArray[np.float64]: The resulting array after applying the condition.
 
         """
-        condition_vector = self.as_vector(expression_evaluator)
+        condition_vector = self.as_vector()
         if condition_vector is None:
             return input_array.copy()
         return np.where(condition_vector, input_array, 0)
 
-    def apply_to_array(self, input_array: np.ndarray, expression_evaluator: ExpressionEvaluator) -> np.ndarray:
+    def apply_to_array(self, input_array: np.ndarray) -> np.ndarray:
         """
         Convenience method for applying the condition and returning the result as a Python list.
 
         This is useful when a standard Python list is required . Internally, it calls `_apply`
         and converts the result to a list.
         """
-        return self._apply(input_array, expression_evaluator)
+        return self._apply(input_array)
 
-    def apply_to_array_as_list(self, input_array: np.ndarray, expression_evaluator: ExpressionEvaluator) -> list:
+    def apply_to_array_as_list(self, input_array: np.ndarray) -> list:
         """
         Apply the condition to a numpy array and return the result as a Python list.
 
         This method is a convenience wrapper around `apply_to_array` for cases where a standard
         Python list is needed instead of a numpy array, for example when serializing results
         or interfacing with code that does not use numpy.
         """
-        return self._apply(input_array, expression_evaluator).tolist()
+        return self._apply(input_array).tolist()

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

@@ -1,18 +1,16 @@
 import numpy as np
 
 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.condition import Condition
 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
@@ -23,19 +21,20 @@ class DirectExpressionConsumerFunction(ConsumerFunction):
     def __init__(
         self,
         energy_usage_type: EnergyUsageType,
-        condition: Expression | None = None,
+        condition: Condition,
         fuel_rate: Expression | None = None,
         load: Expression | None = None,
         power_loss_factor: Expression | None = None,
         consumption_rate_type: RateType = RateType.STREAM_DAY,
     ):
+        self.condition = condition
         expression = 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
 
     @property
@@ -68,26 +67,21 @@ def evaluate(
     ) -> 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,
+        energy_usage = self.condition.apply_to_array_as_list(
+            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
             )
-            if self._convert_to_stream_day
-            else energy_usage_expression_evaluated,
-            condition=condition,  # type: ignore[arg-type]
         )
 
         energy_function_result = EnergyFunctionGenericResult(
-            energy_usage=array_to_list(energy_usage),  # type: ignore[arg-type]
+            energy_usage=energy_usage,  # type: ignore[arg-type]
             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,13 +98,13 @@ 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(),
             is_valid=is_valid,
             energy_function_result=energy_function_result,
-            condition=condition,
+            condition=self.condition.as_vector(),
             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(

src/libecalc/domain/infrastructure/energy_components/legacy_consumer/tabulated/tabular_consumer_function.py

@@ -56,7 +56,7 @@ def __init__(
         energy_usage_adjustment_constant: float,
         energy_usage_adjustment_factor: float,
         variables_expressions: list[VariableExpression],
-        condition: Condition | None = None,
+        condition: Condition,
         power_loss_factor_expression: Expression | None = None,
     ):
         """Tabulated consumer function [MW] (energy) or [Sm3/day] (fuel)."""
@@ -70,7 +70,7 @@ def __init__(
         )
         self._variables_expressions = variables_expressions
 
-        self.condition = condition if condition is not None else Condition(None)
+        self.condition = condition
         # Typically used for power line loss subsea et.c.
         self._power_loss_factor_expression = power_loss_factor_expression
 
@@ -111,11 +111,11 @@ def evaluate(
         # for tabular, is_valid is based on energy_usage being NaN. This will also (correctly) change potential
         # invalid points to valid where the condition sets energy_usage to zero
         energy_function_result.energy_usage = self.condition.apply_to_array_as_list(
-            np.asarray(energy_function_result.energy_usage), expression_evaluator
+            np.asarray(energy_function_result.energy_usage)
         )
 
         energy_function_result.power = (
-            self.condition.apply_to_array_as_list(np.asarray(energy_function_result.power), expression_evaluator)
+            self.condition.apply_to_array_as_list(np.asarray(energy_function_result.power))
             if energy_function_result.power is not None
             else None
         )
@@ -129,7 +129,7 @@ def evaluate(
             periods=expression_evaluator.get_periods(),
             is_valid=np.asarray(energy_function_result.is_valid),
             energy_function_result=energy_function_result,
-            condition=self.condition.as_vector(expression_evaluator),
+            condition=self.condition.as_vector(),
             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(

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

@@ -152,7 +152,10 @@ class ConsumerMapper:
     def __init__(self, references: ReferenceService, target_period: Period):
         self.__references = references
         self._target_period = target_period
-        self.__energy_usage_model_mapper = ConsumerFunctionMapper(references=references, target_period=target_period)
+        self.__energy_usage_model_mapper = ConsumerFunctionMapper(
+            references=references,
+            target_period=target_period,
+        )
 
     def from_yaml_to_domain(
         self,
@@ -198,6 +201,7 @@ def create_error_from_yaml_path(
             energy_usage_model = self.__energy_usage_model_mapper.from_yaml_to_dto(
                 data.energy_usage_model,
                 consumes=consumes,
+                expression_evaluator=expression_evaluator,
             )
         except InvalidEnergyUsageModelException as e:
             energy_usage_model_yaml_path = yaml_path.append("ENERGY_USAGE_MODEL")

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

@@ -8,6 +8,7 @@
 from libecalc.common.temporal_model import TemporalModel
 from libecalc.common.time_utils import Period, define_time_model_for_period
 from libecalc.common.utils.rates import RateType
+from libecalc.common.variables import ExpressionEvaluator
 from libecalc.domain.condition import Condition
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function import ConsumerFunction
 from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function.compressor_consumer_function import (
@@ -182,9 +183,14 @@ def __init__(
         self._target_period = target_period
 
     def _map_direct(
-        self, model: YamlEnergyUsageModelDirectFuel | YamlEnergyUsageModelDirectElectricity, consumes: ConsumptionType
+        self,
+        model: YamlEnergyUsageModelDirectFuel | YamlEnergyUsageModelDirectElectricity,
+        consumes: ConsumptionType,
+        expression_evaluator: ExpressionEvaluator,
     ) -> DirectExpressionConsumerFunction:
-        condition = convert_expression(_map_condition(model))
+        condition_input = _map_condition(model)
+        condition = Condition(expression_input=condition_input, expression_evaluator=expression_evaluator)
+
         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):
@@ -193,7 +199,7 @@ def _map_direct(
             return DirectExpressionConsumerFunction(
                 energy_usage_type=EnergyUsageType.FUEL,
                 fuel_rate=convert_expression(model.fuel_rate),  # type: ignore[arg-type]
-                condition=condition,  # type: ignore[arg-type]
+                condition=condition,
                 power_loss_factor=power_loss_factor,  # type: ignore[arg-type]
                 consumption_rate_type=consumption_rate_type,
             )
@@ -206,12 +212,17 @@ def _map_direct(
             return DirectExpressionConsumerFunction(
                 energy_usage_type=EnergyUsageType.POWER,
                 load=convert_expression(model.load),  # type: ignore[arg-type]
-                condition=condition,  # type: ignore[arg-type]
+                condition=condition,
                 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:
+    def _map_tabular(
+        self,
+        model: YamlEnergyUsageModelTabulated,
+        consumes: ConsumptionType,
+        expression_evaluator: ExpressionEvaluator,
+    ) -> TabularConsumerFunction:
         energy_model = self.__references.get_tabulated_model(model.energy_function)
         energy_usage_type = energy_model.get_energy_usage_type()
         energy_usage_type_as_consumption_type = (
@@ -222,7 +233,7 @@ def _map_tabular(self, model: YamlEnergyUsageModelTabulated, consumes: Consumpti
             raise InvalidConsumptionType(actual=energy_usage_type_as_consumption_type, expected=consumes)
 
         condition_input = _map_condition(model)
-        condition = Condition(expression_input=condition_input)
+        condition = Condition(expression_input=condition_input, expression_evaluator=expression_evaluator)
 
         power_loss_factor = convert_expression(model.power_loss_factor)
 
@@ -503,14 +514,17 @@ def from_yaml_to_dto(
         self,
         data: YamlTemporalModel[YamlFuelEnergyUsageModel] | YamlTemporalModel[YamlElectricityEnergyUsageModel],
         consumes: ConsumptionType,
+        expression_evaluator: ExpressionEvaluator,
     ) -> TemporalModel[ConsumerFunction]:
         time_adjusted_model = define_time_model_for_period(data, target_period=self._target_period)
 
         temporal_dict: dict[Period, ConsumerFunction] = {}
         for period, model in 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, expression_evaluator=expression_evaluator
+                    )
                 elif isinstance(model, YamlEnergyUsageModelCompressor):
                     mapped_model = self._map_compressor(model, consumes=consumes)
                 elif isinstance(model, YamlEnergyUsageModelPump):
@@ -520,7 +534,9 @@ def from_yaml_to_dto(
                 elif isinstance(model, YamlEnergyUsageModelPumpSystem):
                     mapped_model = self._map_pump_system(model, consumes=consumes)
                 elif isinstance(model, YamlEnergyUsageModelTabulated):
-                    mapped_model = self._map_tabular(model=model, consumes=consumes)
+                    mapped_model = self._map_tabular(
+                        model=model, consumes=consumes, expression_evaluator=expression_evaluator
+                    )
                 elif isinstance(model, YamlEnergyUsageModelCompressorTrainMultipleStreams):
                     mapped_model = self._map_multiple_streams_compressor(model, consumes=consumes)
                 else: