fix: only validate pressures when rates and regularity are positive

Author: olelod

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

@@ -40,12 +40,14 @@ def __init__(
         assert isinstance(consumption_rate_type, RateType)
         self._consumption_rate_type = consumption_rate_type
         self._rate_values = self._get_stream_day_values()
-        self._validate()
+        if self._rate_values is not None:
+            self._validate()
 
     def _validate(self):
         """Validate that all flow rate values are positive."""
         for rate in self._rate_values:
-            if rate is not None and rate < 0:
+            assert rate is not None
+            if rate < 0:
                 raise InvalidFlowRateException(rate, str(self._time_series_expression.get_expression()))
 
     def _get_stream_day_values(self) -> list[float | None]:

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

@@ -24,20 +24,24 @@ class ExpressionTimeSeriesPressure(TimeSeriesPressure):
     def __init__(
         self,
         time_series_expression: TimeSeriesExpression,
+        validation_mask: list[bool] | None = None,
     ):
         self._time_series_expression = time_series_expression
         self._pressure_values = self._time_series_expression.get_evaluated_expression()
+        self._validation_mask = validation_mask
         self._validate()
 
     def _validate(self):
-        """Validate that all pressure values are non-negative."""
-        # TODO: Currently all pressures must be non-negative, but in the future we want to only allow positive pressures
-        #       There are many situations where input values of zero means that equipment should be turned off
-        #       When the rest of the codebase is more mature with this respect (specific start/end dates for equipment,
-        #       instead of using rates/pressures of zero), we can tighten this validation
-        for pressure in self._pressure_values:
-            if pressure < 0:
-                raise InvalidPressureException(pressure, str(self._time_series_expression.get_expression()))
+        """Validate that all pressure values are positive, except where masked by the condition."""
+        if self._validation_mask is None:
+            self._validation_mask = [True] * len(self._pressure_values)
+
+        for pressure, should_validate in zip(self._pressure_values, self._validation_mask):
+            if should_validate:
+                # TODO: this comparison should in reality be <= 0, but since there are slight confusion around units
+                #       bara vs barg in the input data, we allow 0 for now. Will be tightened up in future.
+                if pressure < 0:
+                    raise InvalidPressureException(pressure, str(self._time_series_expression.get_expression()))
 
     def get_periods(self) -> Periods:
         """
@@ -56,3 +60,10 @@ def get_values(self) -> list[float]:
         pressure_values = self._pressure_values
 
         return list(pressure_values)
+
+    def get_validation_mask(self) -> list[bool]:
+        """
+        Returns the mask indicating which pressure values were validated.
+
+        """
+        return self._validation_mask

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

@@ -125,28 +125,36 @@ def map_rate_fractions(
 
 
 def validate_increasing_pressure(
-    suction_pressure: list[float],
-    discharge_pressure: list[float],
-    intermediate_pressure: list[float] | None = None,
+    suction_pressure: ExpressionTimeSeriesPressure,
+    discharge_pressure: ExpressionTimeSeriesPressure,
+    intermediate_pressure: ExpressionTimeSeriesPressure | None = None,
 ):
-    # TODO: Currently all pressures must be non-negative, meaning that we allow zero pressures. This also means that we
-    #       allow zero discharge pressure, which is not physically meaningful in most cases. The compressor does no work.
-    #       In the future we want to only allow positive pressures, and then we can tighten this validation to require
-    #       strictly increasing pressures (i.e. suction < discharge, and suction < intermediate < discharge).
-    for i in range(len(suction_pressure)):
-        sp = suction_pressure[i]
-        dp = discharge_pressure[i]
-        if intermediate_pressure:
-            ip = intermediate_pressure[i]
-            if not (sp <= ip <= dp):
-                raise ProcessPressureRatioValidationException(
-                    message=f"Invalid pressures at index {i+1}: suction pressure ({sp}) must be less than intermediate pressure ({ip}), which must be less than discharge pressure ({dp})."
-                )
-        else:
-            if not (sp <= dp):
-                raise ProcessPressureRatioValidationException(
-                    message=f"Invalid pressures at index {i+1}: suction pressure ({sp}) must be less than discharge pressure ({dp})."
-                )
+    validation_mask = suction_pressure.get_validation_mask()
+    assert validation_mask == discharge_pressure.get_validation_mask()
+    suction_pressure_values = suction_pressure.get_values()
+    discharge_pressure_values = discharge_pressure.get_values()
+
+    if intermediate_pressure is not None:
+        assert validation_mask == intermediate_pressure.get_validation_mask()
+        intermediate_pressure_values = intermediate_pressure.get_values()
+    else:
+        intermediate_pressure_values = None
+
+    for i in range(len(suction_pressure_values)):
+        if validation_mask[i]:
+            sp = suction_pressure_values[i]
+            dp = discharge_pressure_values[i]
+            if intermediate_pressure_values is not None:
+                ip = intermediate_pressure_values[i]
+                if not (sp <= ip <= dp):
+                    raise ProcessPressureRatioValidationException(
+                        message=f"Invalid pressures at index {i+1}: suction pressure ({sp}) must be less than intermediate pressure ({ip}), which must be less than discharge pressure ({dp})."
+                    )
+            else:
+                if not (sp <= dp):
+                    raise ProcessPressureRatioValidationException(
+                        message=f"Invalid pressures at index {i+1}: suction pressure ({sp}) must be less than discharge pressure ({dp})."
+                    )
 
 
 class ConsumerFunctionMapper:
@@ -289,19 +297,31 @@ def _map_pump(
         )
         fluid_density = ExpressionTimeSeriesFluidDensity(time_series_expression=fluid_density_expression)
 
+        pressure_validation_mask = [
+            bool(_rate * _regularity > 0)
+            for _rate, _regularity in zip(rate_standard_m3_day.get_stream_day_values(), period_regularity.values)
+            if _rate is not None
+        ]
+
         suction_pressure_expression = TimeSeriesExpression(
             expression=model.suction_pressure, expression_evaluator=period_evaluator
         )
-        suction_pressure = ExpressionTimeSeriesPressure(time_series_expression=suction_pressure_expression)
+        suction_pressure = ExpressionTimeSeriesPressure(
+            time_series_expression=suction_pressure_expression,
+            validation_mask=pressure_validation_mask,
+        )
 
         discharge_pressure_expression = TimeSeriesExpression(
             expression=model.discharge_pressure, expression_evaluator=period_evaluator
         )
-        discharge_pressure = ExpressionTimeSeriesPressure(time_series_expression=discharge_pressure_expression)
+        discharge_pressure = ExpressionTimeSeriesPressure(
+            time_series_expression=discharge_pressure_expression,
+            validation_mask=pressure_validation_mask,
+        )
 
         validate_increasing_pressure(
-            suction_pressure=suction_pressure.get_values(),
-            discharge_pressure=discharge_pressure.get_values(),
+            suction_pressure=suction_pressure,
+            discharge_pressure=discharge_pressure,
         )
 
         return PumpConsumerFunction(
@@ -333,42 +353,52 @@ def _map_multiple_streams_compressor(
             if model.power_loss_factor is not None
             else None
         )
+
+        rates_per_stream: list[TimeSeriesFlowRate] = [
+            ExpressionTimeSeriesFlowRate(
+                time_series_expression=TimeSeriesExpression(
+                    rate_expression, expression_evaluator=expression_evaluator, condition=_map_condition(model)
+                ),
+                regularity=regularity,
+                consumption_rate_type=RateType.CALENDAR_DAY,
+            )
+            for rate_expression in model.rate_per_stream
+        ]
+
+        rates_per_stream_values = [rates.get_stream_day_values() for rates in rates_per_stream]
+        sum_of_rates = [sum(values) for values in zip(*rates_per_stream_values)]
+
+        validation_mask = [bool(_rate * _regularity > 0) for _rate, _regularity in zip(sum_of_rates, regularity.values)]
+
         suction_pressure = ExpressionTimeSeriesPressure(
             time_series_expression=TimeSeriesExpression(
                 model.suction_pressure, expression_evaluator=expression_evaluator
-            )
+            ),
+            validation_mask=validation_mask,
         )
         discharge_pressure = ExpressionTimeSeriesPressure(
             time_series_expression=TimeSeriesExpression(
                 model.discharge_pressure, expression_evaluator=expression_evaluator
-            )
+            ),
+            validation_mask=validation_mask,
         )
         interstage_control_pressure = (
             ExpressionTimeSeriesPressure(
                 time_series_expression=TimeSeriesExpression(
                     model.interstage_control_pressure, expression_evaluator=expression_evaluator
-                )
+                ),
+                validation_mask=validation_mask,
             )
             if model.interstage_control_pressure is not None
             else None
         )
 
         validate_increasing_pressure(
-            suction_pressure=suction_pressure.get_values(),
-            discharge_pressure=discharge_pressure.get_values(),
-            intermediate_pressure=interstage_control_pressure.get_values(),
+            suction_pressure=suction_pressure,
+            discharge_pressure=discharge_pressure,
+            intermediate_pressure=interstage_control_pressure,
         )
 
-        rates_per_stream: list[TimeSeriesFlowRate] = [
-            ExpressionTimeSeriesFlowRate(
-                time_series_expression=TimeSeriesExpression(
-                    rate_expression, expression_evaluator=expression_evaluator, condition=_map_condition(model)
-                ),
-                regularity=regularity,
-                consumption_rate_type=RateType.CALENDAR_DAY,
-            )
-            for rate_expression in model.rate_per_stream
-        ]
         return CompressorConsumerFunction(
             power_loss_factor_expression=power_loss_factor,
             compressor_function=compressor_train_model,
@@ -402,20 +432,36 @@ def _map_compressor(
             else None
         )
 
+        stream_day_rate = ExpressionTimeSeriesFlowRate(
+            time_series_expression=TimeSeriesExpression(
+                model.rate, expression_evaluator=expression_evaluator, condition=_map_condition(model)
+            ),
+            consumption_rate_type=RateType.CALENDAR_DAY,
+            regularity=regularity,
+        )
+
+        validation_mask = [
+            bool(_rate * _regularity > 0)
+            for _rate, _regularity in zip(stream_day_rate.get_stream_day_values(), regularity.values)
+            if _rate is not None
+        ]
         suction_pressure = (
             ExpressionTimeSeriesPressure(
                 time_series_expression=TimeSeriesExpression(
                     model.suction_pressure, expression_evaluator=expression_evaluator
-                )
+                ),
+                validation_mask=validation_mask,
             )
             if model.suction_pressure
             else None
         )
+
         discharge_pressure = (
             ExpressionTimeSeriesPressure(
                 time_series_expression=TimeSeriesExpression(
                     model.discharge_pressure, expression_evaluator=expression_evaluator
-                )
+                ),
+                validation_mask=validation_mask,
             )
             if model.discharge_pressure
             else None
@@ -425,20 +471,14 @@ def _map_compressor(
             suction_pressure is not None and discharge_pressure is not None
         ):  # to handle compressor sampled which may not have pressures
             validate_increasing_pressure(
-                suction_pressure=suction_pressure.get_values(),
-                discharge_pressure=discharge_pressure.get_values(),
+                suction_pressure=suction_pressure,
+                discharge_pressure=discharge_pressure,
             )
 
         return CompressorConsumerFunction(
             power_loss_factor_expression=power_loss_factor,
             compressor_function=compressor_model,
-            rate_expression=ExpressionTimeSeriesFlowRate(
-                time_series_expression=TimeSeriesExpression(
-                    model.rate, expression_evaluator=expression_evaluator, condition=_map_condition(model)
-                ),
-                consumption_rate_type=RateType.CALENDAR_DAY,
-                regularity=regularity,
-            ),
+            rate_expression=stream_day_rate,
             suction_pressure_expression=suction_pressure,
             discharge_pressure_expression=discharge_pressure,
             intermediate_pressure_expression=None,
@@ -510,25 +550,39 @@ def _map_compressor_system(
                     for rate_expr in operational_setting.rates
                 ]
 
-            number_of_compressors = len(compressors)
+            validation_mask = [
+                [
+                    bool(_rate * _regularity > 0)
+                    for _rate, _regularity in zip(rate.get_stream_day_values(), regularity.values)
+                    if _rate is not None
+                ]
+                for rate in rates
+            ]
 
             if operational_setting.suction_pressure is not None:
                 suction_pressures = [
                     ExpressionTimeSeriesPressure(
                         time_series_expression=TimeSeriesExpression(
-                            expression=operational_setting.suction_pressure, expression_evaluator=expression_evaluator
-                        )
+                            expression=operational_setting.suction_pressure,
+                            expression_evaluator=expression_evaluator,
+                        ),
+                        validation_mask=mask,
                     )
-                ] * number_of_compressors
+                    for mask in validation_mask
+                ]
             else:
                 assert operational_setting.suction_pressures is not None
                 suction_pressures = [
                     ExpressionTimeSeriesPressure(
                         time_series_expression=TimeSeriesExpression(
                             expression=pressure_expr, expression_evaluator=expression_evaluator
-                        )
+                        ),
+                        validation_mask=mask,
+                    )
+                    for pressure_expr, mask in zip(
+                        operational_setting.suction_pressures,
+                        validation_mask,
                     )
-                    for pressure_expr in operational_setting.suction_pressures
                 ]
 
             if operational_setting.discharge_pressure is not None:
@@ -537,24 +591,30 @@ def _map_compressor_system(
                         time_series_expression=TimeSeriesExpression(
                             expression=operational_setting.discharge_pressure,
                             expression_evaluator=expression_evaluator,
-                        )
+                        ),
+                        validation_mask=mask,
                     )
-                ] * number_of_compressors
+                    for mask in validation_mask
+                ]
             else:
                 assert operational_setting.discharge_pressures is not None
                 discharge_pressures = [
                     ExpressionTimeSeriesPressure(
                         time_series_expression=TimeSeriesExpression(
                             expression=pressure_expr, expression_evaluator=expression_evaluator
-                        )
+                        ),
+                        validation_mask=mask,
+                    )
+                    for pressure_expr, mask in zip(
+                        operational_setting.discharge_pressures,
+                        validation_mask,
                     )
-                    for pressure_expr in operational_setting.discharge_pressures
                 ]
 
             for suction_pressure, discharge_pressure in zip(suction_pressures, discharge_pressures):
                 validate_increasing_pressure(
-                    suction_pressure=suction_pressure.get_values(),
-                    discharge_pressure=discharge_pressure.get_values(),
+                    suction_pressure=suction_pressure,
+                    discharge_pressure=discharge_pressure,
                 )
 
             core_setting = CompressorSystemOperationalSettingExpressions(
@@ -683,8 +743,8 @@ def _map_pump_system(
 
             for suction_pressure, discharge_pressure in zip(suction_pressures, discharge_pressures):
                 validate_increasing_pressure(
-                    suction_pressure=suction_pressure.get_values(),
-                    discharge_pressure=discharge_pressure.get_values(),
+                    suction_pressure=suction_pressure,
+                    discharge_pressure=discharge_pressure,
                 )
             operational_settings.append(
                 PumpSystemOperationalSettingExpressions(