Refactor: Introduce TimeSeriesExpression and ExpressionTimeSeriesFlowRate (#1008)

* refactor: introduce TimeSeriesExpression and ExpressionTimeSeriesFlowRate

Author: frodehk

src/libecalc/domain/infrastructure/emitters/venting_emitter.py

@@ -170,7 +170,7 @@ def get_emissions(self) -> dict[str, TimeSeriesStreamDayRate]:
                 condition_expression=emission.emission_rate.condition,
             )
             emission_rate = self._evaluate_emission_rate(emission)
-            emission_rate = apply_condition(input_array=emission_rate, condition=condition)  # type: ignore[arg-type]
+            emission_rate = apply_condition(input_array=emission_rate, condition=condition)
             emissions[emission.name] = self._create_time_series(emission_rate)
         return emissions
 
@@ -214,7 +214,7 @@ def get_oil_rates(self, regularity: [TimeSeriesFloat, list[float]]) -> TimeSerie
             condition_expression=self.volume.oil_volume_rate.condition,
         )
 
-        oil_rates = apply_condition(input_array=oil_rates, condition=condition)  # type: ignore[arg-type]
+        oil_rates = apply_condition(input_array=oil_rates, condition=condition)
 
         return TimeSeriesStreamDayRate(
             periods=self.expression_evaluator.get_periods(),

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

@@ -121,7 +121,7 @@ def evaluate(
         )
         stream_day_rate_after_condition = apply_condition(
             input_array=stream_day_rate,
-            condition=condition,  # type: ignore[arg-type]
+            condition=condition,
         )
 
         # If the compressor model is supposed to have stages, make sure they are defined
@@ -158,7 +158,6 @@ def evaluate(
             periods=expression_evaluator.get_periods(),
             is_valid=np.asarray(compressor_train_result.is_valid),
             energy_function_result=compressor_train_result,
-            condition=condition,
             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(

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

@@ -81,7 +81,7 @@ def evaluate(
             )
             if self._convert_to_stream_day
             else energy_usage_expression_evaluated,
-            condition=condition,  # type: ignore[arg-type]
+            condition=condition,
         )
 
         energy_function_result = EnergyFunctionGenericResult(
@@ -110,7 +110,6 @@ def evaluate(
             periods=expression_evaluator.get_periods(),
             is_valid=is_valid,
             energy_function_result=energy_function_result,
-            condition=condition,
             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/consumer_function/pump_consumer_function.py

@@ -1,18 +1,16 @@
 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.pump.pump import PumpModel
+from libecalc.domain.time_series_flow_rate import TimeSeriesFlowRate
 from libecalc.expression import Expression
 
 
@@ -34,20 +32,18 @@ class PumpConsumerFunction(ConsumerFunction):
     def __init__(
         self,
         pump_function: PumpModel,
-        rate_expression: Expression,
+        rate: TimeSeriesFlowRate,
         suction_pressure_expression: Expression,
         discharge_pressure_expression: Expression,
         fluid_density_expression: Expression,
-        condition_expression: Expression = None,
         power_loss_factor_expression: Expression = None,
     ):
         self._pump_function = pump_function
-        self._rate_expression = rate_expression
+        self._rate = rate
         self._suction_pressure_expression = suction_pressure_expression
         self._discharge_pressure_expression = discharge_pressure_expression
         self._fluid_density_expression = fluid_density_expression
 
-        self._condition_expression = condition_expression
         # Typically used for power line loss subsea et.c.
         self._power_loss_factor_expression = power_loss_factor_expression
 
@@ -59,26 +55,15 @@ def evaluate(
         """Evaluate the pump consumer function
 
         Args:
-            variables_map: Variables map is the VariablesMap-object holding all the data to be evaluated.
+            expression_evaluator: expression evaluator is the ExpressionEvaluator-object holding all the data to be evaluated.
             regularity: The regularity of the pump consumer function (same as for installation pump is part of)
 
         Returns:
             Pump consumer function result
         """
-        condition = get_condition_from_expression(
-            expression_evaluator=expression_evaluator,
-            condition_expression=self._condition_expression,
-        )
-        calendar_day_rate = expression_evaluator.evaluate(expression=self._rate_expression)
 
-        # if regularity is 0 for a calendar day rate, set stream day rate to 0 for that step
-        stream_day_rate = apply_condition(
-            input_array=Rates.to_stream_day(
-                calendar_day_rates=calendar_day_rate,
-                regularity=regularity,
-            ),
-            condition=condition,  # type: ignore[arg-type]
-        )
+        stream_day_rate = self._rate.get_stream_day_values()
+
         suction_pressure = expression_evaluator.evaluate(expression=self._suction_pressure_expression)
         discharge_pressure = expression_evaluator.evaluate(expression=self._discharge_pressure_expression)
         fluid_density = expression_evaluator.evaluate(expression=self._fluid_density_expression)
@@ -101,7 +86,6 @@ def evaluate(
             is_valid=np.asarray(energy_function_result.is_valid),
             energy_function_result=energy_function_result,
             energy_usage_before_power_loss_factor=np.asarray(energy_function_result.energy_usage),
-            condition=condition,
             power_loss_factor=power_loss_factor,
             energy_usage=apply_power_loss_factor(
                 energy_usage=np.asarray(energy_function_result.energy_usage),

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

@@ -32,7 +32,6 @@ def __init__(
         is_valid: NDArray,
         energy_usage: NDArray,
         energy_usage_before_power_loss_factor: NDArray | None = None,
-        condition: NDArray | None = None,
         power_loss_factor: NDArray | None = None,
         energy_function_result: EnergyFunctionResult | list[EnergyFunctionResult] | None = None,
         # New! to support fuel to power rate...for e.g. compressors emulating turbine
@@ -43,7 +42,6 @@ def __init__(
         self.is_valid = is_valid
         self.energy_usage = energy_usage
         self.energy_usage_before_power_loss_factor = energy_usage_before_power_loss_factor
-        self.condition = condition
         self.power_loss_factor = power_loss_factor
         self.energy_function_result = energy_function_result
         self.power = power
@@ -65,7 +63,6 @@ def __init__(
         energy_usage: NDArray,
         typ: Literal[ConsumerFunctionType.SINGLE] = ConsumerFunctionType.SINGLE,
         energy_usage_before_power_loss_factor: NDArray | None = None,
-        condition: NDArray | None = None,
         power_loss_factor: NDArray | None = None,
         energy_function_result: EnergyFunctionResult | list[EnergyFunctionResult] | None = None,
         power: NDArray | None = None,
@@ -76,7 +73,6 @@ def __init__(
             is_valid,
             energy_usage,
             energy_usage_before_power_loss_factor,
-            condition,
             power_loss_factor,
             energy_function_result,
             power,
@@ -86,7 +82,6 @@ def __init__(
         self.is_valid = is_valid
         self.energy_usage = energy_usage
         self.energy_usage_before_power_loss_factor = energy_usage_before_power_loss_factor
-        self.condition = condition
         self.power_loss_factor = power_loss_factor
         self.energy_function_result = energy_function_result
         self.power = power

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

@@ -3,13 +3,14 @@
 import numpy as np
 from numpy.typing import NDArray
 
+from libecalc.common.time_utils import Period
 from libecalc.common.variables import ExpressionEvaluator
 from libecalc.expression import Expression
 
 
 def get_condition_from_expression(
     expression_evaluator: ExpressionEvaluator,
-    condition_expression: Expression | None,
+    condition_expression: Expression | dict[Period, Expression] | None,
 ) -> NDArray[np.int_] | None:
     """Evaluate condition expression and compute resulting condition vector.
 
@@ -29,7 +30,9 @@ def get_condition_from_expression(
     return np.array(condition)
 
 
-def apply_condition(input_array: NDArray[np.float64], condition: NDArray[np.float64] | None) -> NDArray[np.float64]:
+def apply_condition(
+    input_array: NDArray[np.float64], condition: NDArray[np.float64] | NDArray[np.int_] | None
+) -> NDArray[np.float64]:
     """Apply condition to input array in the following way:
         - Input values kept as is if condition is 1
         - Input values set to 0 if condition is 0

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

@@ -167,7 +167,6 @@ def evaluate(  # type: ignore[override]
             consumer_results=[consumer_results],
             cross_over_used=cross_over_used,
             energy_usage_before_power_loss_factor=energy_usage,
-            condition=condition,
             power_loss_factor=power_loss_factor,
             energy_usage=apply_power_loss_factor(
                 energy_usage=energy_usage,

src/libecalc/domain/infrastructure/energy_components/legacy_consumer/system/results.py

@@ -124,7 +124,6 @@ def __init__(
         is_valid: NDArray = None,
         energy_usage: NDArray = None,
         energy_usage_before_power_loss_factor: NDArray | None = None,
-        condition: NDArray | None = None,
         power_loss_factor: NDArray | None = None,
         energy_function_result: EnergyFunctionResult | list[EnergyFunctionResult] | None = None,
         power: NDArray | None = None,
@@ -135,7 +134,6 @@ def __init__(
             is_valid=is_valid,
             energy_usage=energy_usage,
             energy_usage_before_power_loss_factor=energy_usage_before_power_loss_factor,
-            condition=condition,
             power_loss_factor=power_loss_factor,
             energy_function_result=energy_function_result,
             power=power,

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

@@ -118,14 +118,14 @@ def evaluate(
         energy_function_result.energy_usage = array_to_list(
             apply_condition(
                 input_array=np.asarray(energy_function_result.energy_usage),
-                condition=condition,  # type: ignore[arg-type]
+                condition=condition,
             )
         )
         energy_function_result.power = (
             array_to_list(
                 apply_condition(
                     input_array=np.asarray(energy_function_result.power),
-                    condition=condition,  # type: ignore[arg-type]
+                    condition=condition,
                 )
             )
             if energy_function_result.power is not None
@@ -141,7 +141,6 @@ def evaluate(
             periods=expression_evaluator.get_periods(),
             is_valid=np.asarray(energy_function_result.is_valid),
             energy_function_result=energy_function_result,
-            condition=condition,
             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/regularity.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Self
 
 from libecalc.common.time_utils import Period
 from libecalc.common.units import Unit
@@ -37,6 +38,10 @@ def __init__(
         )
         self.validate()
 
+    @property
+    def get_values(self) -> list[float]:
+        return self.time_series.values
+
     @property
     def time_series(self) -> TimeSeriesFloat:
         """
@@ -71,3 +76,21 @@ def validate(self):
         if invalid_values:
             msg = f"REGULARITY must evaluate to fractions between 0 and 1. " f"Invalid values: {invalid_values}"
             raise InvalidRegularity(message=msg)
+
+    def get_subset(self, start_index: int, end_index: int) -> Self:
+        """
+        Returns a new Regularity object for the given index range.
+        """
+        period_evaluator = self.expression_evaluator.get_subset(
+            start_index=start_index,
+            end_index=end_index,
+        )
+        periods = period_evaluator.get_periods().periods
+
+        new_target_period = Period(start=periods[0].start, end=periods[-1].end)
+
+        return self.__class__(
+            expression_evaluator=period_evaluator,
+            target_period=new_target_period,
+            expression_input=self.temporal_expression.expression,
+        )