refactor: raise exception when process system is outside capacity

Instead of returning None we should raise exception when a process
system or process unit is outside capacity.

Author: jsolaas

src/libecalc/domain/process/entities/choke.py

@@ -14,7 +14,7 @@ def __init__(
     def set_target_pressure(self, target_pressure: float) -> None:
         self._target_pressure = target_pressure
 
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         if self._target_pressure is None:
             # Delta pressure = 0, i.e. don't do anything
             return inlet_stream

src/libecalc/domain/process/process_solver/solvers/downstream_choke_solver.py

@@ -8,14 +8,13 @@ def __init__(self, target_pressure: float):
         self._target_pressure = target_pressure
 
     def solve(self, process_system: ProcessSystem, inlet_stream: FluidStream) -> FluidStream | None:
-        outlet_stream = process_system.propagate_stream(inlet_stream=inlet_stream)
         downstream_choke = process_system.get_downstream_choke()
         assert downstream_choke is not None, "DownstreamChokeSolver needs a downstream choke"
 
-        if outlet_stream is None or outlet_stream.pressure_bara <= self._target_pressure:
+        outlet_stream = process_system.propagate_stream(inlet_stream=inlet_stream)
+        if outlet_stream.pressure_bara <= self._target_pressure:
             # Don't use choke if outlet pressure is below target
             return outlet_stream
 
         downstream_choke.set_target_pressure(self._target_pressure)
-        # Adjust pressure
         return process_system.propagate_stream(inlet_stream=inlet_stream)

src/libecalc/domain/process/process_solver/solvers/speed_solver.py

@@ -1,12 +1,17 @@
+import logging
+
 from libecalc.domain.process.compressor.core.train.utils.numeric_methods import (
     find_root,
     maximize_x_given_boolean_condition_function,
 )
 from libecalc.domain.process.process_solver.boundary import Boundary
 from libecalc.domain.process.process_solver.solver import Solver
+from libecalc.domain.process.process_system.process_error import ProcessError
 from libecalc.domain.process.process_system.process_system import ProcessSystem
 from libecalc.domain.process.value_objects.fluid_stream import FluidStream
 
+logger = logging.getLogger(__name__)
+
 
 class SpeedSolver(Solver):
     def __init__(self, boundary: Boundary, target_pressure: float):
@@ -20,24 +25,36 @@ def solve(
     ) -> FluidStream | None:
         shaft = process_system.get_shaft()
 
-        def get_outlet_stream(speed: float) -> FluidStream | None:
+        def get_outlet_stream(speed: float) -> FluidStream:
             shaft.set_speed(speed)
             return process_system.propagate_stream(inlet_stream)
 
         maximum_speed = self._boundary.max
-        maximum_speed_outlet_stream = get_outlet_stream(speed=maximum_speed)
-        if maximum_speed_outlet_stream is None:
-            # Outside capacity
-            return maximum_speed_outlet_stream
+        try:
+            maximum_speed_outlet_stream = get_outlet_stream(speed=maximum_speed)
+        except ProcessError as e:
+            logger.debug(f"No solution found for maximum speed: {maximum_speed}", exc_info=e)
+            return None
 
         minimum_speed = self._boundary.min
-        minimum_speed_outlet_stream = get_outlet_stream(speed=minimum_speed)
-        if minimum_speed_outlet_stream is None:
+        try:
+            minimum_speed_outlet_stream = get_outlet_stream(speed=minimum_speed)
+        except ProcessError as e:
+            logger.debug(f"No solution found for minimum speed: {minimum_speed}", exc_info=e)
+
             # rate is above maximum rate for minimum speed. Find the lowest minimum speed which gives a valid result
+            def bool_speed_func(x):
+                try:
+                    get_outlet_stream(speed=x)
+                    return True
+                except ProcessError as e:
+                    logger.debug(f"No solution found for speed: {x}", exc_info=e)
+                    return False
+
             minimum_speed = -maximize_x_given_boolean_condition_function(
                 x_min=-maximum_speed,
                 x_max=-minimum_speed,
-                bool_func=lambda x: get_outlet_stream(speed=x) is not None,
+                bool_func=bool_speed_func,
             )
             minimum_speed_outlet_stream = get_outlet_stream(speed=minimum_speed)
 
@@ -47,17 +64,16 @@ def get_outlet_stream(speed: float) -> FluidStream | None:
             <= maximum_speed_outlet_stream.pressure_bara
         ):
             # Solution 1, iterate on speed until target discharge pressure is found
-            def f(speed: float) -> float:
-                out = get_outlet_stream(speed=speed)
+            def root_speed_func(x: float) -> float:
                 # We should be able to produce an outlet stream since we adjust minimum speed above,
                 # or exit if max speed is not enough
-                assert out is not None, "Unable to produce an outlet stream"
+                out = get_outlet_stream(speed=x)
                 return out.pressure_bara - self._target_pressure
 
             speed = find_root(
                 lower_bound=minimum_speed,
                 upper_bound=maximum_speed,
-                func=f,
+                func=root_speed_func,
             )
             return get_outlet_stream(speed=speed)
         elif self._target_pressure < minimum_speed_outlet_stream.pressure_bara:

src/libecalc/domain/process/process_solver/solvers/upstream_choke_solver.py

@@ -1,23 +1,21 @@
 from libecalc.domain.process.compressor.core.train.utils.numeric_methods import find_root
-from libecalc.domain.process.process_solver.boundary import Boundary
 from libecalc.domain.process.process_solver.solver import Solver
 from libecalc.domain.process.process_system.process_system import ProcessSystem
 from libecalc.domain.process.value_objects.fluid_stream import FluidService, FluidStream
 
 
 class UpstreamChokeSolver(Solver):
-    def __init__(self, target_pressure: float, fluid_service: FluidService, inlet_pressure_boundary: Boundary):
+    def __init__(self, target_pressure: float, fluid_service: FluidService, minimum_pressure: float):
         self._target_pressure = target_pressure
         self._fluid_service = fluid_service
-        self._inlet_pressure_boundary = inlet_pressure_boundary
+        self._minimum_pressure = minimum_pressure
 
     def solve(self, process_system: ProcessSystem, inlet_stream: FluidStream) -> FluidStream | None:
         upstream_choke = process_system.get_upstream_choke()
         assert upstream_choke is not None, "UpstreamChokeSolver needs an upstream choke"
 
         outlet_stream = process_system.propagate_stream(inlet_stream)
-
-        if outlet_stream is None or outlet_stream.pressure_bara <= self._target_pressure:
+        if outlet_stream.pressure_bara <= self._target_pressure:
             # Don't use choke if outlet pressure is below target
             return outlet_stream
 
@@ -29,15 +27,13 @@ def get_outlet_pressure(inlet_pressure: float) -> float:
                 standard_rate_m3_per_day=inlet_stream.standard_rate_sm3_per_day,
             )
             outlet_stream = process_system.propagate_stream(inlet_stream=choked_inlet_stream)
-            assert outlet_stream is not None, "Unable to produce an outlet stream"
             return outlet_stream.pressure_bara
 
         choked_inlet_pressure = find_root(
-            lower_bound=self._inlet_pressure_boundary.min,
-            upper_bound=self._inlet_pressure_boundary.max,
+            lower_bound=self._minimum_pressure,
+            upper_bound=inlet_stream.pressure_bara,
             func=lambda x: get_outlet_pressure(inlet_pressure=x) - self._target_pressure,
         )
 
         upstream_choke.set_target_pressure(choked_inlet_pressure)
-
         return process_system.propagate_stream(inlet_stream=inlet_stream)

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

@@ -0,0 +1,11 @@
+from libecalc.common.errors.exceptions import EcalcError
+
+
+class ProcessError(EcalcError):
+    def __init__(self, message: str = None):
+        self.message = message
+        super().__init__(title=None, message=message)
+
+
+class OutsideCapacityError(ProcessError):
+    pass

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

@@ -28,7 +28,7 @@ def get_downstream_choke(self) -> Choke | None:
     def get_upstream_choke(self) -> Choke | None:
         return self._upstream_choke
 
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         process_units: list[ProcessUnit] = []
         if self._upstream_choke is not None:
             process_units.append(self._upstream_choke)

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

@@ -5,4 +5,4 @@
 
 class ProcessUnit(abc.ABC):
     @abc.abstractmethod
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None: ...
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream: ...

tests/libecalc/domain/process/conftest.py

@@ -4,6 +4,7 @@
 from libecalc.domain.process.entities.choke import Choke
 from libecalc.domain.process.entities.shaft import Shaft, VariableSpeedShaft
 from libecalc.domain.process.process_solver.stream_constraint import PressureStreamConstraint
+from libecalc.domain.process.process_system.process_error import OutsideCapacityError
 from libecalc.domain.process.process_system.process_system import ProcessSystem
 from libecalc.domain.process.process_system.process_unit import ProcessUnit
 from libecalc.domain.process.value_objects.chart.chart import ChartData
@@ -137,7 +138,7 @@ def __init__(self, pressure_multiplier: float, fluid_service: FluidService):
         self._pressure_multiplier = pressure_multiplier
         self._fluid_service = fluid_service
 
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         return self._fluid_service.create_stream_from_standard_rate(
             fluid_model=inlet_stream.fluid_model,
             pressure_bara=inlet_stream.pressure_bara * self._pressure_multiplier,
@@ -177,8 +178,10 @@ def __init__(self, compressor_stage: CompressorTrainStage):
     def get_shaft(self) -> Shaft:
         return self._compressor_stage.compressor.shaft
 
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         result = self._compressor_stage.evaluate(inlet_stream_stage=inlet_stream)
+        if not result.within_capacity:
+            raise OutsideCapacityError("Unable to produce an outlet stream, operational point is outside capacity.")
         return result.outlet_stream
 
 

tests/libecalc/domain/process/solvers/test_speed_solver.py

@@ -12,7 +12,7 @@ def __init__(self, shaft: Shaft, fluid_service: FluidService):
         self._shaft = shaft
         self._fluid_service = fluid_service
 
-    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
         speed = self._shaft.get_speed()
         return self._fluid_service.create_stream_from_standard_rate(
             fluid_model=inlet_stream.fluid_model,

tests/libecalc/domain/process/solvers/test_upstream_choke_solver.py

@@ -2,7 +2,6 @@
 
 from libecalc.domain.process.compressor.core.train.utils.common import EPSILON
 from libecalc.domain.process.entities.choke import Choke
-from libecalc.domain.process.process_solver.boundary import Boundary
 from libecalc.domain.process.process_solver.solvers.upstream_choke_solver import UpstreamChokeSolver
 
 
@@ -33,10 +32,7 @@ def test_upstream_choke_solver(
     upstream_choke_solver = UpstreamChokeSolver(
         fluid_service=fluid_service,
         target_pressure=target_pressure,
-        inlet_pressure_boundary=Boundary(
-            min=EPSILON,  # Should be higher than pressure drop ahead of first stage
-            max=target_pressure,
-        ),
+        minimum_pressure=EPSILON,
     )
     outlet_stream = upstream_choke_solver.solve(process_system, inlet_stream)