chore: expose configuration handlers

Author: jsolaas

src/libecalc/ecalc_model/process_simulation.py

@@ -1,43 +1,50 @@
-from dataclasses import dataclass
+from collections.abc import Sequence
 from typing import Final, Literal, NewType, Self, assert_never
 from uuid import UUID
 
+from libecalc.common.ddd import value_object
 from libecalc.common.ddd.entity import Entity
 from libecalc.common.utils.ecalc_uuid import ecalc_id_generator
+from libecalc.ecalc_model.time_series_configuration import (
+    TimeSeriesChokeConfiguration,
+    TimeSeriesTemperatureSetterConfiguration,
+)
 from libecalc.ecalc_model.time_series_stream import TimeSeriesStream
 from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
 from libecalc.process.process_pipeline.process_pipeline import ProcessPipelineId
+from libecalc.process.process_solver.configuration import ConfigurationHandlerId
+from libecalc.process.process_solver.configuration_handler import ConfigurationHandler
 from libecalc.process.stream_distribution.common_stream_distribution import Overflow
 
 
-@dataclass
+@value_object
 class CommonStreamSettings:
     rate_fractions: list[TimeSeriesExpression]
     overflow: list[Overflow]
 
 
-@dataclass
+@value_object
 class CommonStreamDistributionConfig:  # TODO: Rather a strategy that splits a stream in a method according to a policy?
     inlet_stream: TimeSeriesStream
     settings: list[CommonStreamSettings]
 
 
-@dataclass
+@value_object
 class IndividualStreamDistributionConfig:
     inlet_streams: list[TimeSeriesStream]
 
 
-@dataclass
+@value_object
 class Constraint:  # should this instead be more flexible wrt. matching one or more stream conditions?
     outlet_pressure: TimeSeriesExpression
 
 
-@dataclass
+@value_object
 class PressureControlConfig:  # Spec
     type: Literal["UPSTREAM_CHOKE", "DOWNSTREAM_CHOKE", "COMMON_ASV", "INDIVIDUAL_ASV_RATE", "INDIVIDUAL_ASV_PRESSURE"]
 
 
-@dataclass
+@value_object
 class AntiSurgeConfig:
     type: Literal["INDIVIDUAL_ASV", "COMMON_ASV"]
 
@@ -55,13 +62,20 @@ def __init__(
         pressure_control_strategy: PressureControlConfig,
         anti_surge_strategy: AntiSurgeConfig,
         constraint: Constraint,
+        configuration_handlers: Sequence[ConfigurationHandler],
         process_pipeline_id: ProcessPipelineId,
+        configurations: dict[
+            ConfigurationHandlerId, TimeSeriesChokeConfiguration | TimeSeriesTemperatureSetterConfiguration
+        ]
+        | None = None,
         process_problem_id: ProcessProblemId | None = None,
     ):
         self.pressure_control_strategy = pressure_control_strategy
         self.anti_surge_strategy = anti_surge_strategy
         self.constraint = constraint
         self.process_pipeline_id = process_pipeline_id
+        self.configuration_handlers = configuration_handlers
+        self.configurations = configurations or []
         self._id: Final[ProcessProblemId] = process_problem_id or ProcessProblem._create_id()
 
     def get_id(self) -> ProcessProblemId:

src/libecalc/ecalc_model/time_series_configuration.py

@@ -0,0 +1,12 @@
+from libecalc.common.ddd import value_object
+from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
+
+
+@value_object
+class TimeSeriesChokeConfiguration:
+    delta_pressure: TimeSeriesExpression
+
+
+@value_object
+class TimeSeriesTemperatureSetterConfiguration:
+    temperature: TimeSeriesExpression

src/libecalc/ecalc_model/time_series_stream.py

@@ -1,11 +1,10 @@
-from dataclasses import dataclass
-
+from libecalc.common.ddd import value_object
 from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
 from libecalc.presentation.yaml.domain.time_series_expression import TimeSeriesExpression
 from libecalc.process.fluid_stream.fluid_model import FluidModel
 
 
-@dataclass(frozen=True)
+@value_object
 class TimeSeriesStream:
     fluid_model: FluidModel
     pressure_bara: TimeSeriesExpression

src/libecalc/presentation/yaml/mappers/process_simulation_mapper.py

@@ -19,6 +19,10 @@
     ProcessProblem,
     ProcessSimulation,
 )
+from libecalc.ecalc_model.time_series_configuration import (
+    TimeSeriesChokeConfiguration,
+    TimeSeriesTemperatureSetterConfiguration,
+)
 from libecalc.ecalc_model.time_series_stream import TimeSeriesStream
 from libecalc.expression.expression import ExpressionType
 from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
@@ -63,6 +67,9 @@
 from libecalc.process.process_solver.process_runner import ProcessRunner
 from libecalc.process.process_solver.recirculation_loop import RecirculationLoop
 from libecalc.process.process_solver.search_strategies import ScipyRootFindingStrategy
+from libecalc.process.process_solver.temperature_setter_configuration_handler import (
+    TemperatureSetterConfigurationHandler,
+)
 from libecalc.process.process_units.choke import Choke
 from libecalc.process.process_units.compressor import Compressor
 from libecalc.process.process_units.direct_mixer import DirectMixer
@@ -286,6 +293,11 @@ def map_process_simulation(
         constraints: dict[ProcessPipelineId, Constraint] = {}
         pressure_control_configs: dict[ProcessPipelineId, PressureControlConfig] = {}
         anti_surge_configs: dict[ProcessPipelineId, AntiSurgeConfig] = {}
+        configuration_handlers: dict[ProcessPipelineId, Sequence[ConfigurationHandler]] = {}
+        configurations: dict[
+            ProcessPipelineId,
+            dict[ConfigurationHandlerId, TimeSeriesChokeConfiguration | TimeSeriesTemperatureSetterConfiguration],
+        ] = {}
 
         process_pipeline_reference_to_id_map: dict[str, ProcessPipelineId] = {}
         for yaml_compressor_train_item in yaml_process_simulation.targets:
@@ -294,15 +306,34 @@ def map_process_simulation(
             process_unit_map: dict[ProcessUnitId, ProcessUnit] = {}
             compressor_stages: list[list[ProcessUnitId]] = []
             compressor_ids: list[ProcessUnitId] = []
+            problem_configuration_handlers = []
+            problem_time_series_configurations: dict[
+                ConfigurationHandlerId, TimeSeriesChokeConfiguration | TimeSeriesTemperatureSetterConfiguration
+            ] = {}
             for yaml_serial_item in item.items:
                 yaml_compressor_stage = self._resolve_compressor_stage_reference(yaml_serial_item.target)
                 compressor = self._get_compressor(yaml_compressor_stage=yaml_compressor_stage)
                 compressor_ids.append(compressor.get_id())
+
                 temperature_setter = TemperatureSetter(
-                    required_temperature_kelvin=0,
                     fluid_service=self._fluid_service,
                 )
-                choke = Choke(fluid_service=self._fluid_service, pressure_change=0)
+                temperature_setter_configuration_handler = TemperatureSetterConfigurationHandler(
+                    temperature_setter=temperature_setter
+                )
+                problem_time_series_configurations[temperature_setter_configuration_handler.get_id()] = (
+                    TimeSeriesTemperatureSetterConfiguration(
+                        temperature=self._map_temperature(yaml_compressor_stage.inlet_temperature)
+                    )
+                )
+                problem_configuration_handlers.append(temperature_setter_configuration_handler)
+
+                choke, choke_configuration_handler = choke_factory(fluid_service=self._fluid_service)
+                problem_time_series_configurations[choke_configuration_handler.get_id()] = TimeSeriesChokeConfiguration(
+                    delta_pressure=self._map_pressure(yaml_compressor_stage.pressure_drop_ahead_of_stage)
+                )
+                problem_configuration_handlers.append(choke_configuration_handler)
+
                 liquid_remover = LiquidRemover(fluid_service=self._fluid_service)
                 process_unit_map[temperature_setter.get_id()] = temperature_setter
                 process_unit_map[choke.get_id()] = choke
@@ -323,32 +354,34 @@ def map_process_simulation(
             except KeyError as e:
                 raise EcalcValidationException(f"Missing pressure control for process system '{item.name}'") from e
 
-            configuration_handlers = []
-
             if pressure_control == "COMMON_ASV":
                 recirculation_loop, process_units = with_asv(units=list(process_unit_map.values()))
-                configuration_handlers.append(recirculation_loop)
+                problem_configuration_handlers.append(recirculation_loop)
             else:
                 process_units = []
-                configuration_handlers = []
+                problem_configuration_handlers = []
                 for compressor_stage_ids in compressor_stages:
                     stage_units = [process_unit_map[stage_unit_id] for stage_unit_id in compressor_stage_ids]
                     recirculation_loop, stage_process_units = with_asv(units=stage_units)
-                    configuration_handlers.append(recirculation_loop)
+                    problem_configuration_handlers.append(recirculation_loop)
                     process_units.extend(stage_process_units)
 
             if pressure_control == "DOWNSTREAM_CHOKE":
                 choke, choke_configuration_handler = choke_factory(fluid_service=self._fluid_service)
-                configuration_handlers.append(choke_configuration_handler)
+                problem_configuration_handlers.append(choke_configuration_handler)
                 process_units.append(choke)
             elif pressure_control == "UPSTREAM_CHOKE":
                 choke, choke_configuration_handler = choke_factory(fluid_service=self._fluid_service)
-                configuration_handlers.append(choke_configuration_handler)
+                problem_configuration_handlers.append(choke_configuration_handler)
                 process_units = [choke, *process_units]
+
             process_pipeline = ProcessPipeline(
                 stream_propagators=process_units,
             )
 
+            configuration_handlers[process_pipeline.get_id()] = problem_configuration_handlers
+            configurations[process_pipeline.get_id()] = problem_time_series_configurations
+
             pressure_control_configs[process_pipeline.get_id()] = PressureControlConfig(
                 type=pressure_control,
             )
@@ -452,6 +485,8 @@ def map_process_simulation(
                 constraint=constraints[process_pipeline.get_id()],
                 anti_surge_strategy=anti_surge_configs[process_pipeline.get_id()],
                 pressure_control_strategy=pressure_control_configs[process_pipeline.get_id()],
+                configuration_handlers=configuration_handlers[process_pipeline.get_id()],
+                configurations=configurations[process_pipeline.get_id()],
             )
             for process_pipeline in process_pipelines
         ]

src/libecalc/process/process_solver/configuration.py

@@ -39,6 +39,11 @@ class ChokeConfiguration:
     delta_pressure: float
 
 
+@dataclass
+class TemperatureSetterConfiguration:
+    temperature: float
+
+
 @dataclass
 class RecirculationConfiguration:
     recirculation_rate: float

src/libecalc/process/process_solver/temperature_setter_configuration_handler.py

@@ -0,0 +1,32 @@
+from typing import Final
+
+from libecalc.process.process_solver.configuration import (
+    Configuration,
+    ConfigurationHandlerId,
+    TemperatureSetterConfiguration,
+)
+from libecalc.process.process_solver.configuration_handler import ConfigurationHandler
+from libecalc.process.process_units.temperature_setter import TemperatureSetter
+
+
+class TemperatureSetterConfigurationHandler(ConfigurationHandler):
+    def __init__(
+        self, temperature_setter: TemperatureSetter, configuration_handler_id: ConfigurationHandlerId | None = None
+    ):
+        self._temperature_setter = temperature_setter
+        self._id: Final[ConfigurationHandlerId] = configuration_handler_id or ConfigurationHandler._create_id()
+
+    def get_id(self) -> ConfigurationHandlerId:
+        return self._id
+
+    def handle_configuration(self, configuration: Configuration) -> None:
+        assert configuration.configuration_handler_id == self._id, (
+            f"Configuration id '{configuration.configuration_handler_id}' does not match configuration handler id '{self._id}'"
+        )
+        assert isinstance(configuration.value, TemperatureSetterConfiguration), (
+            f"Expected configuration value to be of type '{TemperatureSetterConfiguration.__name__}', got '{type(configuration.value)}'"
+        )
+        self._temperature_setter.set_temperature(configuration.value.temperature)
+
+    def reset(self) -> None:
+        raise NotImplementedError("Calling reset on this should not happen, as it's shouldn't be manipulated by solver")

src/libecalc/process/process_units/temperature_setter.py

@@ -8,8 +8,8 @@
 class TemperatureSetter(ProcessUnit):
     def __init__(
         self,
-        required_temperature_kelvin: float,
         fluid_service: FluidService,
+        required_temperature_kelvin: float = 0,
         process_unit_id: ProcessUnitId | None = None,
     ):
         self._id: Final[ProcessUnitId] = process_unit_id or ProcessUnit._create_id()
@@ -19,6 +19,9 @@ def __init__(
     def get_id(self) -> ProcessUnitId:
         return self._id
 
+    def set_temperature(self, temperature_kelvin: float) -> None:
+        self._required_temperature_kelvin = temperature_kelvin
+
     @property
     def required_temperature_kelvin(self) -> float:
         return self._required_temperature_kelvin