refactor: use setter for asv recirculation instead of passing values (#1283)

chore: update snapshot

Author: olelod

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

@@ -121,6 +121,10 @@ def set_evaluation_input(
         self._intermediate_pressure = intermediate_pressure
         self._fluid_model = fluid_model
 
+    def reset_rate_modifiers(self):
+        for stage in self.stages:
+            stage.rate_modifier.reset()
+
     def evaluate(
         self,
     ) -> CompressorTrainResult:
@@ -162,6 +166,7 @@ def evaluate(
             else [None] * len(self._suction_pressure),
             self._discharge_pressure,
         ):
+            self.reset_rate_modifiers()
             if isinstance(rate_value, np.ndarray):
                 rate_value = list(rate_value)
                 constraints_rate = rate_value[0]

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

@@ -102,6 +102,7 @@ def evaluate_given_constraints(
         fixed_speed: float | None = None,
     ) -> CompressorTrainResultSingleTimeStep:
         if constraints.rate > 0:  # type: ignore[operator]
+            self.reset_rate_modifiers()
             if fixed_speed is None:
                 self.find_fixed_shaft_speed_given_constraints(constraints=constraints)
             train_result = self.calculate_compressor_train(
@@ -125,15 +126,11 @@ def evaluate_given_constraints(
     def calculate_compressor_train(
         self,
         constraints: CompressorTrainEvaluationInput,
-        asv_rate_fraction: float = 0.0,
-        asv_additional_mass_rate: float = 0.0,
     ) -> CompressorTrainResultSingleTimeStep:
         """Calculate compressor train result given inlet conditions and speed
 
         Args:
             constraints (CompressorTrainEvaluationInput): The constraints for the evaluation.
-            asv_rate_fraction:
-            asv_additional_mass_rate:
 
         Returns:
             results including conditions and calculations for each stage and power.
@@ -158,8 +155,6 @@ def calculate_compressor_train(
             inlet_stream = outlet_stream
             stage_result = stage.evaluate(
                 inlet_stream_stage=inlet_stream,
-                asv_rate_fraction=asv_rate_fraction,
-                asv_additional_mass_rate=asv_additional_mass_rate,
             )
             stage_results.append(stage_result)
 
@@ -704,9 +699,10 @@ def _calculate_train_result_given_asv_rate_margin(
             asv_rate_fraction: float,
         ) -> CompressorTrainResultSingleTimeStep:
             """Note that we use outside variables for clarity and to avoid class instances."""
+            for stage in self.stages:
+                stage.rate_modifier.fraction_of_available_capacity_to_recirculate = asv_rate_fraction
             return self.calculate_compressor_train(
                 constraints=constraints,
-                asv_rate_fraction=asv_rate_fraction,
             )
 
         minimum_asv_fraction = 0.0
@@ -837,6 +833,7 @@ def _evaluate_train_with_common_asv(
         def _calculate_train_result_given_mass_rate(
             mass_rate_kg_per_hour: float,
         ) -> CompressorTrainResultSingleTimeStep:
+            self.reset_rate_modifiers()
             return self.calculate_compressor_train(
                 constraints=constraints.create_conditions_with_new_input(
                     new_rate=self._fluid_service.mass_rate_to_standard_rate(fluid_model, mass_rate_kg_per_hour),
@@ -846,9 +843,10 @@ def _calculate_train_result_given_mass_rate(
         def _calculate_train_result_given_additional_mass_rate(
             additional_mass_rate_kg_per_hour: float,
         ) -> CompressorTrainResultSingleTimeStep:
+            for stage in self.stages:
+                stage.rate_modifier.mass_rate_to_recirculate = additional_mass_rate_kg_per_hour
             return self.calculate_compressor_train(
                 constraints=constraints,
-                asv_additional_mass_rate=additional_mass_rate_kg_per_hour,
             )
 
         # outer bounds for minimum and maximum mass rate without individual recirculation on stages will be the

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

@@ -393,6 +393,7 @@ def _calculate_train_result(std_rate_for_stream: float) -> CompressorTrainResult
             """Partial function of self.evaluate_given_constraints
             where we only pass std_rate_per_stream.
             """
+            self.reset_rate_modifiers()
             std_rates_std_m3_per_day_per_stream[constraints.stream_to_maximize] = std_rate_for_stream
             return self.evaluate_given_constraints(
                 constraints=constraints.create_conditions_with_new_input(
@@ -405,6 +406,7 @@ def _calculate_train_result(std_rate_for_stream: float) -> CompressorTrainResult
             constraints=constraints,
         )
         if not train_result.is_valid:
+            self.reset_rate_modifiers()
             zero_stream_result = _calculate_train_result(std_rate_for_stream=EPSILON)
             if not zero_stream_result.is_valid:
                 return 0.0
@@ -436,8 +438,6 @@ def _calculate_train_result(std_rate_for_stream: float) -> CompressorTrainResult
     def calculate_compressor_train(
         self,
         constraints: CompressorTrainEvaluationInput,
-        asv_rate_fraction: float = 0.0,
-        asv_additional_mass_rate: float = 0.0,
     ) -> CompressorTrainResultSingleTimeStep:
         """
         Simulate the compressor train for the given inlet conditions, stream rates, and shaft speed.
@@ -454,8 +454,6 @@ def calculate_compressor_train(
 
         Args:
             constraints (CompressorTrainEvaluationInput): Pressures, stream rates, and speed for the simulation.
-            asv_rate_fraction (float, optional): Fraction of anti-surge valve recirculation. Defaults to 0.0.
-            asv_additional_mass_rate (float, optional): Additional mass rate for recirculation. Defaults to 0.0.
 
         Returns:
             CompressorTrainResultSingleTimeStep: Object containing inlet/outlet streams, per-stage results, speed,
@@ -508,8 +506,6 @@ def calculate_compressor_train(
                     inlet_stream_stage=stage_inlet_stream,
                     rates_out_of_splitter=rates_out_of_splitter,
                     streams_in_to_mixer=streams_in_to_mixer,
-                    asv_rate_fraction=asv_rate_fraction,
-                    asv_additional_mass_rate=asv_additional_mass_rate,
                 )
             )
 
@@ -624,13 +620,13 @@ def find_and_calculate_for_compressor_train_with_two_pressure_requirements(
         assert isinstance(compressor_train_last_part._fluid_model, list)  # for mypy
         compressor_train_last_part._fluid_model[0] = compressor_train_last_part.streams[0].fluid_model
 
+        # Get the speed found for the last part - will be used to compare with the first part
         shaft_speed_last_part = compressor_train_last_part.find_fixed_shaft_speed_given_constraints(
             constraints=constraints_last_part,
             lower_bound_for_speed=self.minimum_speed,
             upper_bound_for_speed=self.maximum_speed,
         )
 
-        # Get the speed found for the last part - will be used to compare with the first part
         if math.isclose(shaft_speed_last_part, self.minimum_speed, rel_tol=EPSILON):
             compressor_train_results_last_part_with_optimal_speed_result = (
                 compressor_train_last_part.evaluate_with_pressure_control_given_constraints(

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

@@ -101,51 +101,21 @@ def modify_pressure(self, inlet_stream_stage: FluidStream) -> FluidStream:
             return self.pressure_modifier.modify_pressure(inlet_stream_stage)
         return inlet_stream_stage
 
-    def add_recirculation_rate(
-        self,
-        inlet_stream_stage: FluidStream,
-        asv_rate_fraction: float | None = 0.0,
-        asv_additional_mass_rate: float | None = 0.0,
-    ) -> FluidStream:
-        """Add recirculation rate to the inlet stream.
-
-        Args:
-            inlet_stream_stage (FluidStream): Inlet fluid stream conditions.
-            asv_rate_fraction (float): Fraction of available capacity for pressure control. Defaults to 0.0.
-            asv_additional_mass_rate (float): Additional recirculated mass rate. Defaults to 0.0.
-
-        Returns:
-            FluidStream: Updated inlet stream.
-        """
-        has_asv_rate_fraction = asv_rate_fraction is not None and asv_rate_fraction > 0
-        has_asv_additional_mass_rate = asv_additional_mass_rate is not None and asv_additional_mass_rate > 0
-        if has_asv_rate_fraction and has_asv_additional_mass_rate:
-            raise IllegalStateException("asv_rate_fraction and asv_additional_mass_rate cannot both be > 0")
-        if asv_rate_fraction is not None and not (0.0 <= asv_rate_fraction <= 1.0):
-            raise IllegalStateException("asv_rate_fraction must be in [0.0, 1.0]")
-
-        actual_rate = inlet_stream_stage.volumetric_rate_m3_per_hour
-        max_rate = self.compressor.get_max_rate()
-        min_rate = self.compressor.get_min_rate()
-
-        available_capacity = max(0.0, max_rate - actual_rate)
-        additional_rate = max(
-            min_rate - actual_rate,
-            asv_rate_fraction * available_capacity if asv_rate_fraction else 0.0,
-            asv_additional_mass_rate / inlet_stream_stage.density if asv_additional_mass_rate else 0.0,
+    def add_rate(self, inlet_stream_stage: FluidStream) -> FluidStream:
+        return self.rate_modifier.add_rate(
+            stream=inlet_stream_stage,
         )
 
-        self.rate_modifier.recirculation_mass_rate = additional_rate * inlet_stream_stage.density
-
-        return self.rate_modifier.add_rate(inlet_stream_stage)
+    def remove_rate(self, outlet_stream_stage: FluidStream) -> FluidStream:
+        return self.rate_modifier.remove_rate(
+            stream=outlet_stream_stage,
+        )
 
     def evaluate(
         self,
         inlet_stream_stage: FluidStream,
         rates_out_of_splitter: list[float] | None = None,
         streams_in_to_mixer: list[FluidStream] | None = None,
-        asv_rate_fraction: float | None = 0.0,
-        asv_additional_mass_rate: float | None = 0.0,
     ) -> CompressorTrainStageResultSingleTimeStep:
         """Evaluates a compressor train stage given the conditions and rate of the inlet stream, and the speed
         of the shaft driving the compressor if given.
@@ -155,10 +125,6 @@ def evaluate(
                 the first one is the stage inlet stream, the others enter the stage at the Mixer.
             rates_out_of_splitter (list[float] | None, optional): Additional rates to the Splitter if defined.
             streams_in_to_mixer (list[FluidStream] | None, optional): Additional streams to the Mixer if defined.
-            asv_rate_fraction (float | None, optional): Fraction of the available capacity of the compressor to fill
-                using some kind of pressure control (on the interval [0,1]). Defaults to 0.0.
-            asv_additional_mass_rate (float | None, optional): Additional recirculated mass rate due to
-                pressure control. Defaults to 0.0.
 
         Returns:
             CompressorTrainStageResultSingleTimeStep: The result of the evaluation for the compressor stage
@@ -201,10 +167,8 @@ def evaluate(
         inlet_stream_compressor = inlet_stream_after_liquid_remover
 
         # Then additional rate is added by the RateModifier (if defined),
-        inlet_stream_compressor_including_asv = self.add_recirculation_rate(
+        inlet_stream_compressor_including_asv = self.add_rate(
             inlet_stream_stage=inlet_stream_compressor,
-            asv_rate_fraction=asv_rate_fraction,
-            asv_additional_mass_rate=asv_additional_mass_rate,
         )
 
         # Compressor
@@ -332,9 +296,9 @@ def evaluate_given_speed_and_target_discharge_pressure(
         """
         # If no speed is defined for CompressorChart, use the minimum speed
 
+        self.rate_modifier.mass_rate_to_recirculate = 0
         result_no_recirculation = self.evaluate(
             inlet_stream_stage=inlet_stream_stage,
-            asv_additional_mass_rate=0,
         )
 
         # result_no_recirculation.inlet_stream.density_kg_per_m3 will have correct pressure and temperature
@@ -347,9 +311,9 @@ def evaluate_given_speed_and_target_discharge_pressure(
             - EPSILON,
             0,
         )
+        self.rate_modifier.mass_rate_to_recirculate = max_recirculation
         result_max_recirculation = self.evaluate(
             inlet_stream_stage=inlet_stream_stage,
-            asv_additional_mass_rate=max_recirculation,
         )
         if result_no_recirculation.discharge_pressure < target_discharge_pressure:
             return result_no_recirculation
@@ -359,9 +323,9 @@ def evaluate_given_speed_and_target_discharge_pressure(
         def _calculate_compressor_stage(
             additional_mass_rate: float,
         ) -> CompressorTrainStageResultSingleTimeStep:
+            self.rate_modifier.mass_rate_to_recirculate = additional_mass_rate
             return self.evaluate(
                 inlet_stream_stage=inlet_stream_stage,
-                asv_additional_mass_rate=additional_mass_rate,
             )
 
         result_mass_rate = find_root(