chore: init process simulation

Author: jsolaas

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

@@ -141,7 +141,7 @@ def _validate_nonnegative_stage_rates(self, constraints: CompressorTrainEvaluati
     def evaluate_given_constraints(
         self,
         constraints: CompressorTrainEvaluationInput,
-        fixed_speed: float | None = None,
+        fixed_speed: float | None = None,  # TODO: not used?
     ) -> CompressorTrainResultSingleTimeStep:
         self.reset_rate_modifiers()
         self._validate_nonnegative_stage_rates(constraints)
@@ -1111,13 +1111,14 @@ def _calculate_compressor_train(_speed: float) -> CompressorTrainResultSingleTim
                 constraints=constraints,
             )
 
-        train_result_for_minimum_speed = _calculate_compressor_train(_speed=minimum_speed)
         train_result_for_maximum_speed = _calculate_compressor_train(_speed=maximum_speed)
 
         if not train_result_for_maximum_speed.within_capacity:
             # will not find valid result - the rate is above maximum rate, return invalid results at maximum speed
             self.shaft.set_speed(maximum_speed)
             return maximum_speed
+
+        train_result_for_minimum_speed = _calculate_compressor_train(_speed=minimum_speed)
         if not train_result_for_minimum_speed.within_capacity:
             # rate is above maximum rate for minimum speed. Find the lowest minimum speed which gives a valid result
             minimum_speed = -maximize_x_given_boolean_condition_function(

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

@@ -0,0 +1,27 @@
+from libecalc.domain.process.process_system.process_unit import ProcessUnit
+from libecalc.domain.process.value_objects.fluid_stream import FluidService, FluidStream
+
+
+class Choke(ProcessUnit):
+    def __init__(
+        self,
+        fluid_service: FluidService,
+        delta_pressure: float = 0,
+    ):
+        self._delta_pressure = delta_pressure
+        self._fluid_service = fluid_service
+
+    def get_delta_pressure(self) -> float:
+        return self._delta_pressure
+
+    def set_delta_pressure(self, delta_pressure: float) -> None:
+        self._delta_pressure = delta_pressure
+
+    def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream | None:
+        choked_inlet_pressure = inlet_stream.pressure_bara - self._delta_pressure
+        return self._fluid_service.create_stream_from_standard_rate(
+            fluid_model=inlet_stream.fluid_model,
+            pressure_bara=choked_inlet_pressure,
+            temperature_kelvin=inlet_stream.pressure_bara,
+            standard_rate_m3_per_day=inlet_stream.standard_rate_sm3_per_day,
+        )

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

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Boundary:
+    min: float
+    max: float

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

@@ -0,0 +1,26 @@
+from libecalc.domain.process.process_solver.solver import Solver
+from libecalc.domain.process.process_solver.stream_constraint import StreamConstraint
+from libecalc.domain.process.process_system.process_system import ProcessSystem
+from libecalc.domain.process.value_objects.fluid_stream import FluidStream
+
+
+class ProcessSolver:
+    def __init__(
+        self,
+        inlet_stream: FluidStream,
+        process_system: ProcessSystem,
+        solvers: list[Solver],
+        stream_constraint: StreamConstraint,
+    ):
+        self._process_system = process_system
+        self._inlet_stream = inlet_stream
+        self._solvers = solvers
+        self._stream_constraint = stream_constraint
+
+    def find_solution(self) -> bool:
+        for solver in self._solvers:
+            outlet_stream = solver.solve(process_system=self._process_system, inlet_stream=self._inlet_stream)
+            if self._stream_constraint.check(outlet_stream):
+                return True
+
+        return False

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

@@ -0,0 +1,9 @@
+import abc
+
+from libecalc.domain.process.process_system.process_system import ProcessSystem
+from libecalc.domain.process.value_objects.fluid_stream import FluidStream
+
+
+class Solver(abc.ABC):
+    @abc.abstractmethod
+    def solve(self, process_system: ProcessSystem, inlet_stream: FluidStream) -> FluidStream | None: ...

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

@@ -0,0 +1,19 @@
+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 FluidStream
+
+
+class DownstreamChokeSolver(Solver):
+    def __init__(self, outlet_pressure: float):
+        self._outlet_pressure = outlet_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, "DownstreamChoke solver needs a downstream choke"
+        if outlet_stream is not None and outlet_stream.pressure_bara >= self._outlet_pressure:
+            delta_pressure = self._outlet_pressure - outlet_stream.pressure_bara
+            downstream_choke.set_delta_pressure(delta_pressure)
+            # Adjust pressure
+            return process_system.propagate_stream(inlet_stream=inlet_stream)
+        return outlet_stream

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

@@ -0,0 +1,68 @@
+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_system import ProcessSystem
+from libecalc.domain.process.value_objects.fluid_stream import FluidStream
+
+
+class SpeedSolver(Solver):
+    def __init__(self, boundary: Boundary, target_pressure: float):
+        self._boundary = boundary
+        self._target_pressure = target_pressure
+
+    def solve(
+        self,
+        process_system: ProcessSystem,
+        inlet_stream: FluidStream,
+    ) -> FluidStream | None:
+        shaft = process_system.get_shaft()
+
+        def get_outlet_stream(speed: float) -> FluidStream | None:
+            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
+
+        minimum_speed = self._boundary.min
+        minimum_speed_outlet_stream = get_outlet_stream(speed=minimum_speed)
+        if minimum_speed_outlet_stream is None:
+            # rate is above maximum rate for minimum speed. Find the lowest minimum speed which gives a valid result
+            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,
+            )
+            minimum_speed_outlet_stream = get_outlet_stream(speed=minimum_speed)
+
+        if (
+            minimum_speed_outlet_stream.pressure_bara
+            <= self._target_pressure
+            <= 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)
+                assert out is not None, "What to do"
+                return out.pressure_bara - self._target_pressure
+
+            speed = find_root(
+                lower_bound=minimum_speed,
+                upper_bound=maximum_speed,
+                func=f,
+            )
+            return get_outlet_stream(speed=speed)
+        elif self._target_pressure < minimum_speed_outlet_stream.pressure_bara:
+            # Solution 2, target pressure is too low
+            shaft.set_speed(minimum_speed)
+            return minimum_speed_outlet_stream
+
+        # Solution 3, target discharge pressure is too high
+        shaft.set_speed(maximum_speed)
+        return maximum_speed_outlet_stream

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

@@ -0,0 +1,37 @@
+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, outlet_pressure: float, fluid_service: FluidService, inlet_pressure_boundary: Boundary):
+        self._outlet_pressure = outlet_pressure
+        self._fluid_service = fluid_service
+        self._inlet_pressure_boundary = inlet_pressure_boundary
+
+    def solve(self, process_system: ProcessSystem, inlet_stream: FluidStream) -> FluidStream | None:
+        def get_outlet_pressure(inlet_pressure: float) -> float:
+            choked_inlet_stream = self._fluid_service.create_stream_from_standard_rate(
+                fluid_model=inlet_stream.fluid_model,
+                pressure_bara=inlet_pressure,
+                temperature_kelvin=inlet_stream.pressure_bara,
+                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, "What to do"
+            return outlet_stream.pressure_bara
+
+        choked_inlet_pressure = find_root(
+            lower_bound=self._inlet_pressure_boundary.min,
+            upper_bound=self._inlet_pressure_boundary.max,
+            func=lambda x: get_outlet_pressure(inlet_pressure=x) - self._outlet_pressure,
+        )
+
+        return self._fluid_service.create_stream_from_standard_rate(
+            fluid_model=inlet_stream.fluid_model,
+            pressure_bara=choked_inlet_pressure,
+            temperature_kelvin=inlet_stream.pressure_bara,
+            standard_rate_m3_per_day=inlet_stream.standard_rate_sm3_per_day,
+        )