WIP : Refactor/send list of streams with mixer splitter

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

@@ -7,6 +7,7 @@
 from libecalc.domain.process.compressor.core.base import CompressorWithTurbineModel
 from libecalc.domain.process.compressor.core.sampled import CompressorModelSampled
 from libecalc.domain.process.compressor.core.train.base import CompressorTrainModel
+from libecalc.domain.process.compressor.core.train.utils.common import EPSILON
 from libecalc.domain.process.core.results import EnergyFunctionResult
 from libecalc.domain.process.pump.pump import PumpModel
 from libecalc.domain.process.value_objects.fluid_stream.fluid_factory import FluidFactoryInterface
@@ -35,11 +36,14 @@ def get_max_standard_rate(
     ) -> NDArray[np.float64]:
         model = self._facility_model
         if isinstance(model, CompressorTrainModel):
-            return model.get_max_standard_rate(
-                suction_pressures=suction_pressure,
-                discharge_pressures=discharge_pressure,
+            assert self._fluid_factory is not None
+            model.set_evaluation_input(
+                suction_pressure=suction_pressure,
+                discharge_pressure=discharge_pressure,
                 fluid_factory=self._fluid_factory,
+                rate=np.full_like(suction_pressure, EPSILON),
             )
+            return model.get_max_standard_rate()
         elif isinstance(model, PumpModel):
             assert fluid_density is not None
             return model.get_max_standard_rates(
@@ -49,20 +53,26 @@ def get_max_standard_rate(
             )
         elif isinstance(model, CompressorWithTurbineModel):
             if isinstance(model.compressor_model, CompressorModelSampled):
-                return model.get_max_standard_rate(
-                    suction_pressures=suction_pressure,
-                    discharge_pressures=discharge_pressure,
+                model.set_evaluation_input(
+                    suction_pressure=suction_pressure,
+                    discharge_pressure=discharge_pressure,
+                    rate=np.full_like(suction_pressure, EPSILON),
                 )
-            return model.get_max_standard_rate(
-                suction_pressures=suction_pressure,
-                discharge_pressures=discharge_pressure,
+                return model.get_max_standard_rate()
+            model.set_evaluation_input(
+                suction_pressure=suction_pressure,
+                discharge_pressure=discharge_pressure,
                 fluid_factory=self._fluid_factory,
+                rate=np.full_like(suction_pressure, EPSILON),
             )
+            return model.get_max_standard_rate()
         elif isinstance(model, CompressorModelSampled):
-            return model.get_max_standard_rate(
-                suction_pressures=suction_pressure,
-                discharge_pressures=discharge_pressure,
+            model.set_evaluation_input(
+                suction_pressure=suction_pressure,
+                discharge_pressure=discharge_pressure,
+                rate=np.full_like(suction_pressure, EPSILON),
             )
+            return model.get_max_standard_rate()
         else:
             assert_never(model)
 

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

@@ -14,7 +14,6 @@
 from libecalc.domain.process.compressor.core.train.utils.common import POWER_CALCULATION_TOLERANCE
 from libecalc.domain.process.compressor.core.train.utils.numeric_methods import find_root
 from libecalc.domain.process.core.results import CompressorTrainResult
-from libecalc.domain.process.value_objects.fluid_stream.fluid_factory import FluidFactoryInterface
 
 
 class CompressorWithTurbineModel:
@@ -97,39 +96,17 @@ def _calculate_remaining_capacity_in_train_given_standard_rate(
             return 0.0  # Return 0 if no power value available
         return float(energy_result.power.values[0]) - (max_power - POWER_CALCULATION_TOLERANCE)
 
-    def get_max_standard_rate(
-        self,
-        suction_pressures: NDArray[np.float64],
-        discharge_pressures: NDArray[np.float64],
-        fluid_factory: FluidFactoryInterface | None = None,
-    ) -> NDArray[np.float64]:
+    def get_max_standard_rate(self) -> NDArray[np.float64]:
         """Validate that the compressor has enough power to handle the set maximum standard rate.
         If there is insufficient power find new maximum rate.
         """
         compressor_model = self.compressor_model
-        if fluid_factory is not None:
-            compressor_model._fluid_factory = fluid_factory
-
-        max_standard_rate = compressor_model.get_max_standard_rate(
-            suction_pressures=suction_pressures, discharge_pressures=discharge_pressures
-        )
+        suction_pressures = compressor_model._suction_pressure
+        discharge_pressures = compressor_model._discharge_pressure
+        assert suction_pressures is not None
+        assert discharge_pressures is not None
+        max_standard_rate = compressor_model.get_max_standard_rate()
         assert max_standard_rate is not None
-        # Check if the obtained results are within the maximum load that the turbine can deliver
-        if isinstance(compressor_model, CompressorTrainModel):
-            compressor_model.set_evaluation_input(
-                fluid_factory=compressor_model._fluid_factory,
-                rate=max_standard_rate,
-                suction_pressure=suction_pressures,
-                discharge_pressure=discharge_pressures,
-            )
-        elif isinstance(compressor_model, CompressorModelSampled):
-            compressor_model.set_evaluation_input(
-                rate=max_standard_rate,
-                suction_pressure=suction_pressures,
-                discharge_pressure=discharge_pressures,
-            )
-        else:
-            assert_never(compressor_model)
 
         results_max_standard_rate = compressor_model.evaluate()
         energy_result = results_max_standard_rate.get_energy_result()

src/libecalc/domain/process/compressor/core/sampled/compressor_model_sampled.py

@@ -149,15 +149,13 @@ def get_consumption_type(self) -> ConsumptionType:
 
     def get_max_standard_rate(
         self,
-        suction_pressures: NDArray[np.float64] | None = None,
-        discharge_pressures: NDArray[np.float64] | None = None,
     ) -> NDArray[np.float64] | None:
         """Get max rate given suction pressure and a discharge pressure.
 
         :param suction_pressures: Suction pressure [bar]
         :param discharge_pressures: Discharge pressure [bar]
         """
-        number_of_calculation_points = len(suction_pressures) if suction_pressures is not None else 1
+        number_of_calculation_points = len(self._suction_pressure) if self._suction_pressure is not None else 1
         if self.support_max_rate:
             if self._qhull_sampled.support_max_rate:
                 return np.full(