refactor: use TimeSeries interfaces for CompressorConsumerFunction

Author: jsolaas

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

@@ -1,35 +1,26 @@
 import numpy as np
 
-from libecalc.common.utils.rates import Rates
 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.compressor.core.base import CompressorModel, CompressorWithTurbineModel
-from libecalc.domain.process.compressor.core.train.variable_speed_compressor_train_common_shaft_multiple_streams_and_pressures import (
-    VariableSpeedCompressorTrainCommonShaftMultipleStreamsAndPressures,
-)
-from libecalc.domain.process.core.results import CompressorTrainResult
-from libecalc.expression import Expression
+from libecalc.domain.process.compressor.dto import VariableSpeedCompressorTrainMultipleStreamsAndPressures
+from libecalc.domain.time_series_flow_rate import TimeSeriesFlowRate
+from libecalc.domain.time_series_power_loss_factor import TimeSeriesPowerLossFactor
+from libecalc.domain.time_series_pressure import TimeSeriesPressure
 
 
 class CompressorConsumerFunction(ConsumerFunction):
     def __init__(
         self,
         compressor_function: CompressorModel,
-        rate_expression: Expression | list[Expression],
-        suction_pressure_expression: Expression,
-        discharge_pressure_expression: Expression,
-        condition_expression: Expression | None,
-        power_loss_factor_expression: Expression | None,
-        intermediate_pressure_expression: Expression | None = None,
+        rate_expression: TimeSeriesFlowRate | list[TimeSeriesFlowRate],
+        suction_pressure_expression: TimeSeriesPressure | None,
+        discharge_pressure_expression: TimeSeriesPressure | None,
+        power_loss_factor_expression: TimeSeriesPowerLossFactor | None,
+        intermediate_pressure_expression: TimeSeriesPressure | None = None,
     ):
         """Note: If multiple streams and pressures, there will be  list of rate-Expressions, and there
             may be specification of intermediate pressure, stage number for intermediate pressure and specific
@@ -42,25 +33,24 @@ def __init__(
             or a list of rates expressions for multiple streams and pressures.
         :param suction_pressure_expression: Suction pressure expression [bara]
         :param discharge_pressure_expression: Discharge pressure expression [bara]
-        :param condition_expression: Optional condition expression
         :param power_loss_factor_expression: Optional power loss factor expression.
             Typically used for power line loss subsea et.c.
         :param intermediate_pressure_expression: Used for multiple streams and pressures model.
         """
         self._compressor_function = compressor_function
         self._rate_expression = rate_expression if isinstance(rate_expression, list) else [rate_expression]
+        assert len(self._rate_expression) > 0
         self._suction_pressure_expression = suction_pressure_expression
         self._discharge_pressure_expression = discharge_pressure_expression
-        self._condition_expression = condition_expression
         self._power_loss_factor_expression = power_loss_factor_expression
         self._intermediate_pressure_expression = intermediate_pressure_expression
 
     @property
-    def suction_pressure(self) -> Expression:
+    def suction_pressure(self) -> TimeSeriesPressure | None:
         return self._suction_pressure_expression
 
     @property
-    def discharge_pressure(self) -> Expression:
+    def discharge_pressure(self) -> TimeSeriesPressure | None:
         return self._discharge_pressure_expression
 
     def evaluate(
@@ -73,102 +63,70 @@ def evaluate(
         :param regularity:
         :return:
         """
-        calendar_day_rates = np.array(
-            [expression_evaluator.evaluate(expression=rate_expression) for rate_expression in self._rate_expression]
-        )
-        # Squeeze to remove axes of length one -> non-multiple streams will be 1d and not 2d.
-        # But we don't want to squeeze multiple streams model with only one date.
-        # That goes for CompressorWithTurbineModel with a MultipleStreamsAndPressures-train as well
         if isinstance(self._compressor_function, CompressorWithTurbineModel):
             compressor_model = self._compressor_function.compressor_model
         else:
             compressor_model = self._compressor_function
-        if isinstance(compressor_model, VariableSpeedCompressorTrainCommonShaftMultipleStreamsAndPressures):
-            stream_day_rate = Rates.to_stream_day(
-                calendar_day_rates=calendar_day_rates,
-                regularity=regularity,
-            )
-        else:
-            stream_day_rate = np.atleast_1d(
-                np.squeeze(
-                    Rates.to_stream_day(
-                        calendar_day_rates=calendar_day_rates,
-                        regularity=regularity,
-                    )
-                )
-            )
+
+        stream_day_rate = np.array([rate.get_stream_day_values() for rate in self._rate_expression], dtype=np.float64)
+
+        if not isinstance(compressor_model, VariableSpeedCompressorTrainMultipleStreamsAndPressures):
+            stream_day_rate = np.atleast_1d(np.squeeze(stream_day_rate))
 
         intermediate_pressure = (
-            expression_evaluator.evaluate(expression=self._intermediate_pressure_expression)
-            if self._intermediate_pressure_expression
+            np.asarray(self._intermediate_pressure_expression.get_values(), dtype=np.float64)
+            if self._intermediate_pressure_expression is not None
             else None
         )
         suction_pressure = (
-            expression_evaluator.evaluate(expression=self._suction_pressure_expression)
+            np.asarray(self._suction_pressure_expression.get_values(), dtype=np.float64)
             if self._suction_pressure_expression is not None
             else None
         )
         discharge_pressure = (
-            expression_evaluator.evaluate(expression=self._discharge_pressure_expression)
-            if self._discharge_pressure_expression is not None
+            np.asarray(self._discharge_pressure_expression.get_values(), dtype=np.float64)
+            if self._suction_pressure_expression is not None
             else None
         )
 
-        # 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,
-        )
-        stream_day_rate_after_condition = apply_condition(
-            input_array=stream_day_rate,
-            condition=condition,
-        )
-
         # If the compressor model is supposed to have stages, make sure they are defined
         # (compressor sampled does not have stages)
-        if isinstance(self._compressor_function, CompressorWithTurbineModel):
-            self._compressor_function.compressor_model.check_for_undefined_stages(
-                rate=stream_day_rate_after_condition,
-                suction_pressure=suction_pressure,
-                discharge_pressure=discharge_pressure,
-            )
-        else:
-            self._compressor_function.check_for_undefined_stages(
-                rate=stream_day_rate_after_condition,
-                suction_pressure=suction_pressure,
-                discharge_pressure=discharge_pressure,
-            )
+        compressor_model.check_for_undefined_stages(
+            rate=stream_day_rate,
+            suction_pressure=suction_pressure,  # type: ignore[arg-type]
+            discharge_pressure=discharge_pressure,  # type: ignore[arg-type]
+        )
 
-        compressor_train_result: CompressorTrainResult
-        # Do not input regularity to compressor function. Handled outside
         # intermediate_pressure will only be different from None when we have a MultipleStreamsAndPressures train
         compressor_train_result = self._compressor_function.evaluate(
-            rate=stream_day_rate_after_condition,
-            suction_pressure=suction_pressure,
-            discharge_pressure=discharge_pressure,
+            rate=stream_day_rate,
+            suction_pressure=suction_pressure,  # type: ignore[arg-type]
+            discharge_pressure=discharge_pressure,  # type: ignore[arg-type]
             intermediate_pressure=intermediate_pressure,
         )
 
-        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_expression is not None:
+            energy_usage = self._power_loss_factor_expression.apply(np.asarray(compressor_train_result.energy_usage))
+            power = (
+                self._power_loss_factor_expression.apply(np.asarray(compressor_train_result.power))
+                if compressor_train_result.power is not None
+                else None
+            )
+        else:
+            energy_usage = compressor_train_result.energy_usage
+            power = compressor_train_result.power
+
+        periods = self._rate_expression[0].get_periods()
 
         consumer_function_result = ConsumerFunctionResult(
-            periods=expression_evaluator.get_periods(),
+            periods=periods,
             is_valid=np.asarray(compressor_train_result.is_valid),
             energy_function_result=compressor_train_result,
             energy_usage_before_power_loss_factor=np.asarray(compressor_train_result.energy_usage),
-            power_loss_factor=power_loss_factor,
-            energy_usage=apply_power_loss_factor(
-                energy_usage=np.asarray(compressor_train_result.energy_usage),
-                power_loss_factor=power_loss_factor,
-            ),
-            power=apply_power_loss_factor(
-                energy_usage=np.asarray(compressor_train_result.power),
-                power_loss_factor=power_loss_factor,
-            )
-            if compressor_train_result.power is not None
+            power_loss_factor=np.asarray(self._power_loss_factor_expression.get_values(), dtype=np.float64)
+            if self._power_loss_factor_expression is not None
             else None,
+            energy_usage=np.asarray(energy_usage),
+            power=np.asarray(power) if power is not None else None,
         )
         return consumer_function_result

src/libecalc/domain/time_series_pressure.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from libecalc.common.time_utils import Periods
+
 
 class TimeSeriesPressure(ABC):
     """
@@ -10,6 +12,14 @@ class TimeSeriesPressure(ABC):
 
     """
 
+    @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
+
     @abstractmethod
     def get_values(self) -> list[float]:
         """