refactor: move generation of generic from input chart

Author: olelod

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

@@ -119,6 +119,21 @@ def evaluate(
             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_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

src/libecalc/domain/process/compressor/core/base.py

@@ -49,6 +49,14 @@ def evaluate_rate_ps_pd(
         """
         raise NotImplementedError
 
+    def check_for_undefined_stages(
+        self,
+        rate: NDArray[np.float64],
+        suction_pressure: NDArray[np.float64],
+        discharge_pressure: NDArray[np.float64],
+    ) -> None:
+        pass
+
 
 class CompressorWithTurbineModel(CompressorModel):
     def __init__(

src/libecalc/domain/process/compressor/core/train/simplified_train.py

@@ -1,5 +1,4 @@
 import math
-from abc import abstractmethod
 
 import numpy as np
 from numpy.typing import NDArray
@@ -79,15 +78,62 @@ class CompressorTrainSimplified(CompressorTrainModel):
       given and the generic unified chart is scaled by these.
     """
 
-    @abstractmethod
-    def get_stages(
+    def check_for_undefined_stages(
         self,
         rate: NDArray[np.float64],
         suction_pressure: NDArray[np.float64],
         discharge_pressure: NDArray[np.float64],
-    ) -> list[CompressorTrainStage]:
-        """Implemented in subclasses."""
-        raise NotImplementedError
+    ) -> None:
+        # All stages are there, but compressor chart can still be None (GENERIC_FROM_INPUT)
+        self.stages = self.define_undefined_stages(
+            suction_pressure=suction_pressure,
+            discharge_pressure=discharge_pressure,
+        )
+        pressure_ratios_per_stage = self.calculate_pressure_ratios_per_stage(
+            suction_pressure=suction_pressure, discharge_pressure=discharge_pressure
+        )
+        stage_inlet_pressure = suction_pressure
+        mass_rate_kg_per_hour = self.fluid.standard_rate_to_mass_rate(standard_rates=rate)
+        for stage_number, stage in enumerate(self.stages):
+            inlet_temperature_kelvin = stage.inlet_temperature_kelvin
+            inlet_streams = self.fluid.get_fluid_streams(
+                pressure_bara=stage_inlet_pressure,
+                temperature_kelvin=np.full_like(rate, fill_value=inlet_temperature_kelvin, dtype=float),
+            )
+            inlet_densities_kg_per_m3 = np.asarray([stream.density for stream in inlet_streams])
+            inlet_actual_rate_m3_per_hour = mass_rate_kg_per_hour / inlet_densities_kg_per_m3
+            stage_outlet_pressure = np.multiply(stage_inlet_pressure, pressure_ratios_per_stage)
+            if isinstance(stage, UndefinedCompressorStage):
+                # Static efficiency regardless of rate and head. This happens if Generic chart from input is used.
+                def efficiency_as_function_of_rate_and_head(rates, heads):
+                    return np.full_like(rates, fill_value=stage.polytropic_efficiency, dtype=float)
+
+                polytropic_enthalpy_change_joule_per_kg, polytropic_efficiency = (
+                    calculate_enthalpy_change_head_iteration(
+                        inlet_streams=inlet_streams,
+                        inlet_temperature_kelvin=inlet_temperature_kelvin,
+                        inlet_pressure=stage_inlet_pressure,
+                        outlet_pressure=stage_outlet_pressure,
+                        molar_mass=self.fluid.molar_mass_kg_per_mol,
+                        polytropic_efficiency_vs_rate_and_head_function=efficiency_as_function_of_rate_and_head,
+                        inlet_actual_rate_m3_per_hour=inlet_actual_rate_m3_per_hour,
+                    )
+                )
+
+                head_joule_per_kg = polytropic_enthalpy_change_joule_per_kg * polytropic_efficiency
+                self.stages[stage_number] = CompressorTrainStage(
+                    compressor_chart=CompressorChartCreator.from_rate_and_head_values(
+                        actual_volume_rates_m3_per_hour=inlet_actual_rate_m3_per_hour,
+                        heads_joule_per_kg=head_joule_per_kg,
+                        polytropic_efficiency=stage.polytropic_efficiency,
+                    ),
+                    inlet_temperature_kelvin=stage.inlet_temperature_kelvin,
+                    remove_liquid_after_cooling=stage.remove_liquid_after_cooling,
+                    pressure_drop_ahead_of_stage=stage.pressure_drop_ahead_of_stage,
+                )
+            stage_inlet_pressure = stage_outlet_pressure
+
+        return None
 
     def _evaluate_rate_ps_pd(
         self,
@@ -111,10 +157,6 @@ def _evaluate_rate_ps_pd(
         :param discharge_pressure: discharge pressure [bara]
         :return: train result
         """
-        if isinstance(self, CompressorTrainSimplifiedUnknownStages):
-            self.stages = self.get_stages(
-                rate=rate, suction_pressure=suction_pressure, discharge_pressure=discharge_pressure
-            )
 
         pressure_ratios_per_stage = self.calculate_pressure_ratios_per_stage(
             suction_pressure=suction_pressure, discharge_pressure=discharge_pressure
@@ -348,9 +390,8 @@ def __init__(
         super().__init__(data_transfer_object)
         self.data_transfer_object = data_transfer_object
 
-    def get_stages(
+    def define_undefined_stages(
         self,
-        rate: NDArray[np.float64],
         suction_pressure: NDArray[np.float64],
         discharge_pressure: NDArray[np.float64],
     ) -> list[CompressorTrainStage]:
@@ -582,14 +623,13 @@ def __init__(
         super().__init__(data_transfer_object)
         self.data_transfer_object = data_transfer_object
 
-    def get_stages(
+    def define_undefined_stages(
         self,
-        rate: NDArray[np.float64],
         suction_pressure: NDArray[np.float64],
         discharge_pressure: NDArray[np.float64],
     ) -> list[CompressorTrainStage]:
-        if len(rate) == 0:
-            # Unable to figure out stages and pressure ratios if there are no rates as input
+        if len(suction_pressure) == 0:
+            # Unable to figure out stages and pressure ratios if there are no suction_pressures as input
             return []
 
         pressure_ratios = discharge_pressure / suction_pressure

tests/libecalc/core/models/compressor_modelling/test_simplified_compressor_train.py

@@ -148,7 +148,11 @@ def test_simplified_compressor_train_unknown_stages(simplified_compressor_train_
     compressor_train = CompressorTrainSimplifiedUnknownStages(
         data_transfer_object=simplified_compressor_train_unknown_stages_dto,
     )
-
+    compressor_train.check_for_undefined_stages(
+        rate=np.linspace(start=1000, stop=10000, num=10),
+        suction_pressure=np.linspace(start=10, stop=20, num=10),
+        discharge_pressure=np.linspace(start=200, stop=400, num=10),
+    )
     compressor_train.evaluate_rate_ps_pd(
         rate=np.linspace(start=1000, stop=10000, num=10),
         suction_pressure=np.linspace(start=10, stop=20, num=10),
@@ -162,6 +166,11 @@ def test_simplified_compressor_train_unknown_stages_with_constant_power_adjustme
     compressor_train_energy_function = CompressorTrainSimplifiedUnknownStages(
         data_transfer_object=simplified_compressor_train_unknown_stages_dto,
     )
+    compressor_train_energy_function.check_for_undefined_stages(
+        rate=np.linspace(start=1000, stop=10000, num=10),
+        suction_pressure=np.linspace(start=10, stop=20, num=10),
+        discharge_pressure=np.linspace(start=200, stop=400, num=10),
+    )
     result_comparison = compressor_train_energy_function.evaluate_rate_ps_pd(
         rate=np.linspace(start=1000, stop=10000, num=10),
         suction_pressure=np.linspace(start=10, stop=20, num=10),
@@ -401,7 +410,11 @@ def test_compressor_train_simplified_unknown_stages(
     simple_compressor_train_model = CompressorTrainSimplifiedUnknownStages(
         data_transfer_object=simplified_compressor_train_unknown_stages_generic_compressor_from_input_dto,
     )
-
+    simple_compressor_train_model.check_for_undefined_stages(
+        rate=rates,
+        suction_pressure=suction_pressures,
+        discharge_pressure=discharge_pressures,
+    )
     results = simple_compressor_train_model.evaluate_rate_ps_pd(
         rate=rates,
         suction_pressure=suction_pressures,