refactor: use-setter-for-asv-recirculation-instead-of-passing-values

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

@@ -126,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.
@@ -160,8 +156,6 @@ def calculate_compressor_train(
             stage_result = stage.evaluate(
                 inlet_stream_stage=inlet_stream,
                 speed=self.shaft.get_speed(),
-                asv_rate_fraction=asv_rate_fraction,
-                asv_additional_mass_rate=asv_additional_mass_rate,
             )
             stage_results.append(stage_result)
 
@@ -705,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
@@ -838,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),
@@ -847,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

@@ -18,7 +18,7 @@
     maximize_x_given_boolean_condition_function,
 )
 from libecalc.domain.process.core.results.compressor import TargetPressureStatus
-from libecalc.domain.process.entities.shaft import Shaft, VariableSpeedShaft
+from libecalc.domain.process.entities.shaft import Shaft
 from libecalc.domain.process.value_objects.fluid_stream import FluidService, FluidStream
 from libecalc.domain.process.value_objects.fluid_stream.fluid_model import FluidModel
 
@@ -436,8 +436,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 +452,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,
@@ -509,8 +505,6 @@ def calculate_compressor_train(
                     rates_out_of_splitter=rates_out_of_splitter,
                     streams_in_to_mixer=streams_in_to_mixer,
                     speed=self.shaft.get_speed(),
-                    asv_rate_fraction=asv_rate_fraction,
-                    asv_additional_mass_rate=asv_additional_mass_rate,
                 )
             )
 
@@ -595,7 +589,8 @@ def find_and_calculate_for_compressor_train_with_two_pressure_requirements(
             lower_bound_for_speed=self.minimum_speed,  # Only search for a solution within the bounds of the
             upper_bound_for_speed=self.maximum_speed,  # original, complete compressor train
         )
-        if math.isclose(compressor_train_first_part.shaft.get_speed(), self.minimum_speed, rel_tol=EPSILON):
+        first_speed = compressor_train_first_part.shaft.get_speed()
+        if math.isclose(first_speed, self.minimum_speed, rel_tol=EPSILON):
             compressor_train_results_first_part_with_optimal_speed_result = (
                 compressor_train_first_part.evaluate_with_pressure_control_given_constraints(
                     constraints=constraints_first_part,
@@ -628,8 +623,8 @@ def find_and_calculate_for_compressor_train_with_two_pressure_requirements(
             lower_bound_for_speed=self.minimum_speed,
             upper_bound_for_speed=self.maximum_speed,
         )
-
-        if math.isclose(compressor_train_last_part.shaft.get_speed(), self.minimum_speed, rel_tol=EPSILON):
+        last_speed = compressor_train_last_part.shaft.get_speed()
+        if math.isclose(last_speed, 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(
                     constraints=constraints_last_part,
@@ -647,8 +642,8 @@ def find_and_calculate_for_compressor_train_with_two_pressure_requirements(
         Then run the last part as a single speed train with the speed chosen
         Fixme: Need to deliver the result in a proper format below.
         """
-        if compressor_train_first_part.shaft.get_speed() > compressor_train_last_part.shaft.get_speed():
-            compressor_train_last_part.shaft.set_speed(compressor_train_first_part.shaft.get_speed())
+        if first_speed > last_speed:
+            compressor_train_last_part.shaft.set_speed(first_speed)
             compressor_train_results_last_part_with_pressure_control = (
                 compressor_train_last_part.evaluate_with_pressure_control_given_constraints(
                     constraints=constraints_last_part,
@@ -660,7 +655,6 @@ def find_and_calculate_for_compressor_train_with_two_pressure_requirements(
             compressor_train_results_to_return_last_part = compressor_train_results_last_part_with_pressure_control
 
         else:
-            compressor_train_first_part.shaft.set_speed(compressor_train_last_part.shaft.get_speed())
             compressor_train_results_first_part_with_pressure_control = (
                 compressor_train_first_part.evaluate_with_pressure_control_given_constraints(
                     constraints=constraints_first_part,
@@ -775,7 +769,7 @@ def split_train_on_stage_number(
 
     compressor_train_first_part = CompressorTrainCommonShaftMultipleStreamsAndPressures(
         streams=streams_first_part,
-        shaft=VariableSpeedShaft(),
+        shaft=compressor_train.shaft,
         energy_usage_adjustment_constant=compressor_train.energy_usage_adjustment_constant,
         energy_usage_adjustment_factor=compressor_train.energy_usage_adjustment_factor,
         stages=compressor_train.stages[:stage_number],
@@ -823,7 +817,7 @@ def split_train_on_stage_number(
         energy_usage_adjustment_factor=compressor_train.energy_usage_adjustment_factor,
         stages=compressor_train.stages[stage_number:],
         fluid_service=compressor_train._fluid_service,
-        shaft=VariableSpeedShaft(),
+        shaft=compressor_train.shaft,
         calculate_max_rate=compressor_train.calculate_max_rate
         if compressor_train.calculate_max_rate is not None
         else False,

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

@@ -108,54 +108,22 @@ 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,
-        speed: float,
-        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.
-            speed (float): Compressor shaft speed.
-            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.compressor_chart.maximum_rate_as_function_of_speed(speed)
-        min_rate = self.compressor.compressor_chart.minimum_rate_as_function_of_speed(speed)
-
-        available_capacity = max(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,
         speed: float,
         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.
@@ -166,10 +134,6 @@ def evaluate(
             speed (float): The speed of the shaft driving the compressor
             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
@@ -212,11 +176,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,
-            speed=speed,
-            asv_rate_fraction=asv_rate_fraction,
-            asv_additional_mass_rate=asv_additional_mass_rate,
         )
 
         # Compressor
@@ -366,10 +327,10 @@ def evaluate_given_speed_and_target_discharge_pressure(
         if isinstance(self.compressor.compressor_chart, CompressorChart) and speed is None:
             speed = self.compressor.compressor_chart.minimum_speed
 
+        self.rate_modifier.mass_rate_to_recirculate = 0
         result_no_recirculation = self.evaluate(
             inlet_stream_stage=inlet_stream_stage,
             speed=speed,
-            asv_additional_mass_rate=0,
         )
 
         # result_no_recirculation.inlet_stream.density_kg_per_m3 will have correct pressure and temperature
@@ -382,9 +343,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,
             speed=speed,
         )
         if result_no_recirculation.discharge_pressure < target_discharge_pressure:
@@ -395,9 +356,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,
                 speed=speed,
             )