chore: implement asv solver (#1394)

This includes all three asv solvers, individual_asv_rate, individual_asv_pressure and common_asv
Tests comparing new and legacy code has also been added

Refs.
equinor/ecalc-internal#1538

Author: olelod

src/libecalc/domain/process/process_solver/asv_solvers.py

@@ -13,6 +13,9 @@ def __init__(
     ):
         self._process_units = process_units
 
+    def get_process_units(self):
+        return self._process_units
+
     def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         current_inlet = inlet_stream
         for process_unit in self._process_units:

src/libecalc/domain/process/process_solver/common_asv_solver.py

@@ -2,8 +2,8 @@
 
 from libecalc.domain.process.compressor.core.train.stage import CompressorTrainStage
 from libecalc.domain.process.entities.shaft import Shaft
+from libecalc.domain.process.process_solver.asv_solvers import CompressorStageProcessUnit
 from libecalc.domain.process.process_solver.boundary import Boundary
-from libecalc.domain.process.process_solver.common_asv_solver import CompressorStageProcessUnit
 from libecalc.domain.process.process_solver.search_strategies import (
     CONVERGENCE_TOLERANCE,
     BinarySearchStrategy,
@@ -194,12 +194,25 @@ def get_speed_boundary(self) -> Boundary:
     def get_maximum_standard_rate(self, inlet_stream: FluidStream) -> float:
         compressor_inlet_stream = self._compressor_stage.get_compressor_inlet_stream(inlet_stream_stage=inlet_stream)
         density = compressor_inlet_stream.density
-        max_actual_rate = self._compressor_stage.compressor.compressor_chart.maximum_rate
+        max_actual_rate = self._compressor_stage.compressor.compressor_chart.maximum_rate_as_function_of_speed(
+            self._compressor_stage.compressor.speed
+        )
         max_mass_rate = max_actual_rate * density
         return self._compressor_stage.fluid_service.mass_rate_to_standard_rate(
             fluid_model=compressor_inlet_stream.fluid_model, mass_rate_kg_per_h=max_mass_rate
         )
 
+    def get_minimum_standard_rate(self, inlet_stream: FluidStream) -> float:
+        compressor_inlet_stream = self._compressor_stage.get_compressor_inlet_stream(inlet_stream_stage=inlet_stream)
+        density = compressor_inlet_stream.density
+        min_actual_rate = self._compressor_stage.compressor.compressor_chart.minimum_rate_as_function_of_speed(
+            self._compressor_stage.compressor.speed
+        )
+        min_mass_rate = min_actual_rate * density
+        return self._compressor_stage.fluid_service.mass_rate_to_standard_rate(
+            fluid_model=compressor_inlet_stream.fluid_model, mass_rate_kg_per_h=min_mass_rate
+        )
+
     def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         result = self._compressor_stage.evaluate(inlet_stream_stage=inlet_stream)
         if result.chart_area_flag == ChartAreaFlag.ABOVE_MAXIMUM_FLOW_RATE:

src/libecalc/domain/process/process_system/process_system.py

@@ -2,7 +2,7 @@
 from inline_snapshot import snapshot
 
 from libecalc.domain.process.entities.shaft import VariableSpeedShaft
-from libecalc.domain.process.process_solver.common_asv_solver import CommonASVSolver
+from libecalc.domain.process.process_solver.asv_solvers import ASVSolver
 from libecalc.domain.process.process_solver.float_constraint import FloatConstraint
 
 
@@ -28,7 +28,7 @@ def test_common_asv_solver(
     stage1_chart_data = chart_data_factory.from_design_point(rate=1200, head=70000, efficiency=0.75)
     stage2_chart_data = chart_data_factory.from_design_point(rate=900, head=50000, efficiency=0.72)
 
-    common_asv_solver = CommonASVSolver(
+    common_asv_solver = ASVSolver(
         shaft=shaft,
         compressors=[
             compressor_train_stage_process_unit_factory(
@@ -39,14 +39,15 @@ def test_common_asv_solver(
             compressor_train_stage_process_unit_factory(chart_data=stage2_chart_data, shaft=shaft),
         ],
         fluid_service=fluid_service,
+        individual_asv_control=False,
     )
 
     inlet_stream = stream_factory(
         standard_rate_m3_per_day=500_000.0, pressure_bara=30.0, temperature_kelvin=temperature
     )
     assert inlet_stream.volumetric_rate_m3_per_hour == snapshot(681.2529349883239)
 
-    speed_solution, recirculation_solution = common_asv_solver.find_common_asv_solution(
+    speed_solution, recirculation_solution = common_asv_solver.find_asv_solution(
         pressure_constraint=target_pressure,
         inlet_stream=inlet_stream,
     )
@@ -59,15 +60,15 @@ def test_common_asv_solver(
     ).solve(common_asv_solver.get_recirculation_func(inlet_stream=inlet_stream))
 
     assert speed_solution.success
-    assert speed_solution.configuration.speed == snapshot(94.38349228734866)
-    assert recirculation_solution.success
+    assert speed_solution.configuration.speed == snapshot(94.4000351009834)
+    assert recirculation_solution[0].success
 
     recirculation_rate_at_capacity = recirculation_at_capacity_solution.configuration.recirculation_rate
-    recirculation_rate_after_pressure_control = recirculation_solution.configuration.recirculation_rate
+    recirculation_rate_after_pressure_control = recirculation_solution[0].configuration.recirculation_rate
 
-    assert recirculation_rate_at_capacity == snapshot(335543.7583238268)
+    assert recirculation_rate_at_capacity == snapshot(336261.09561854857)
     assert recirculation_rate_after_pressure_control >= recirculation_rate_at_capacity
 
-    recirculation_loop.set_recirculation_rate(recirculation_solution.configuration.recirculation_rate)
+    recirculation_loop.set_recirculation_rate(recirculation_solution[0].configuration.recirculation_rate)
     outlet_stream = recirculation_loop.propagate_stream(inlet_stream=inlet_stream)
     assert outlet_stream.pressure_bara == target_pressure

tests/libecalc/domain/process/conftest.py

@@ -5,7 +5,7 @@
 from libecalc.domain.process.compressor.core.results import CompressorTrainResultSingleTimeStep
 from libecalc.domain.process.compressor.core.train.train_evaluation_input import CompressorTrainEvaluationInput
 from libecalc.domain.process.entities.shaft import VariableSpeedShaft
-from libecalc.domain.process.process_solver.common_asv_solver import CommonASVSolver
+from libecalc.domain.process.process_solver.asv_solvers import ASVSolver
 from libecalc.domain.process.process_solver.float_constraint import FloatConstraint
 from libecalc.domain.process.value_objects.chart import ChartCurve
 from libecalc.domain.process.value_objects.fluid_stream import FluidModel, FluidService
@@ -132,18 +132,19 @@ def test_common_asv_solver_vs_legacy_train(
     )
     stages_new = [stage1_new, stage2_new]
 
-    train_solver = CommonASVSolver(
+    train_solver = ASVSolver(
         compressors=stages_new,
         fluid_service=fluid_service,
         shaft=shaft_new,
+        individual_asv_control=False,
     )
-    speed_solution, recirculation_solution = train_solver.find_common_asv_solution(
+    speed_solution, recirculation_solution = train_solver.find_asv_solution(
         pressure_constraint=FloatConstraint(target_pressure),
         inlet_stream=inlet_stream,
     )
     recirculation_loop = train_solver.get_recirculation_loop()
     shaft_new.set_speed(speed_solution.configuration.speed)
-    recirculation_loop.set_recirculation_rate(recirculation_solution.configuration.recirculation_rate)
+    recirculation_loop.set_recirculation_rate(recirculation_solution[0].configuration.recirculation_rate)
     new_outlet_stream = recirculation_loop.propagate_stream(inlet_stream=inlet_stream)
 
     assert new_outlet_stream.volumetric_rate_m3_per_hour == pytest.approx(
@@ -153,14 +154,20 @@ def test_common_asv_solver_vs_legacy_train(
         old_outlet_stream.pressure_bara, rel=0.00000001
     )  # 0.000001 %
     assert new_outlet_stream.density == pytest.approx(old_outlet_stream.density, rel=0.001)  # 0.1 %
-    assert shaft_new.get_speed() == pytest.approx(shaft_old.get_speed(), rel=0.021)  # 2.1 %
+    assert shaft_new.get_speed() > shaft_old.get_speed()  # only recirc in one compressor in old result
 
     # For now new and old recirculation rate is not expected to match - as the old train recirculates individual stages and finds a solution
     # without common asv
-    new_recirculation_rate = recirculation_solution.configuration.recirculation_rate
-    old_recirculation_rate = _calc_recirculation_rate_from_loss_mw(
-        fluid_service=fluid_service, result=old_result, fluid_model=old_outlet_stream.fluid_model
+    new_recirculation_rate = recirculation_solution[0].configuration.recirculation_rate
+    old_recirculation_rate_1 = (
+        old_result.stage_results[0].standard_rate_asv_corrected_sm3_per_day
+        - old_result.stage_results[0].standard_rate_sm3_per_day
+    )
+    old_recirculation_rate_2 = (
+        old_result.stage_results[1].standard_rate_asv_corrected_sm3_per_day
+        - old_result.stage_results[1].standard_rate_sm3_per_day
     )
 
-    assert new_recirculation_rate == snapshot(250211.12092008846)
-    assert old_recirculation_rate == snapshot(141127.6427142186)
+    assert new_recirculation_rate == snapshot(250007.5)
+    assert old_recirculation_rate_1 == snapshot(249999.99999999988)
+    assert old_recirculation_rate_2 == 0.0