chore: add process service for registration

frodehk · frodehk · commit 62daf8c08d46 · 2025-11-14T11:15:22.000+01:00
diff --git a/src/libecalc/domain/ecalc_component.py b/src/libecalc/domain/ecalc_component.py
@@ -0,0 +1,8 @@
+from uuid import UUID
+
+
+class EcalcComponent:
+    def __init__(self, id: UUID, name: str, type: str):
+        self.id = id
+        self.name = name
+        self.type = type
diff --git a/src/libecalc/domain/process/process_service.py b/src/libecalc/domain/process/process_service.py
@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from uuid import UUID
+
+from libecalc.common.time_utils import Period
+from libecalc.domain.ecalc_component import EcalcComponent
+from libecalc.domain.process.compressor.core.base import CompressorModel, CompressorWithTurbineModel
+from libecalc.domain.process.compressor.core.sampled import CompressorModelSampled
+from libecalc.domain.process.evaluation_input import CompressorEvaluationInput, PumpEvaluationInput
+from libecalc.domain.process.pump.pump import PumpModel
+from libecalc.presentation.yaml.domain.ecalc_components import ProcessSystemComponent, SimplifiedProcessUnitComponent
+
+
+class ProcessService(ABC):
+    @abstractmethod
+    def register_process_system(
+        self,
+        ecalc_component: EcalcComponent,
+        process_system: CompressorModel,
+        evaluation_input: CompressorEvaluationInput,
+    ): ...
+
+    @abstractmethod
+    def register_simplified_process_unit(
+        self,
+        ecalc_component: EcalcComponent,
+        simplified_process_unit: CompressorModelSampled | PumpModel | CompressorWithTurbineModel,
+        evaluation_input: CompressorEvaluationInput | PumpEvaluationInput,
+    ): ...
+
+    @abstractmethod
+    def map_model_to_consumer(
+        self,
+        consumer_id: UUID,
+        period: Period,
+        ecalc_component: ProcessSystemComponent | SimplifiedProcessUnitComponent,
+    ): ...
+
+    @abstractmethod
+    def get_evaluation_input(self, process_system_id: UUID) -> CompressorEvaluationInput | PumpEvaluationInput: ...
diff --git a/src/libecalc/presentation/yaml/domain/default_process_service.py b/src/libecalc/presentation/yaml/domain/default_process_service.py
@@ -0,0 +1,71 @@
+from uuid import UUID
+
+from libecalc.common.time_utils import Period
+from libecalc.domain.ecalc_component import EcalcComponent
+from libecalc.domain.process.compressor.core.base import CompressorModel, CompressorWithTurbineModel
+from libecalc.domain.process.compressor.core.sampled import CompressorModelSampled
+from libecalc.domain.process.compressor.core.train.base import CompressorTrainModel
+from libecalc.domain.process.evaluation_input import CompressorEvaluationInput, PumpEvaluationInput
+from libecalc.domain.process.process_service import ProcessService
+from libecalc.domain.process.pump.pump import PumpModel
+from libecalc.presentation.yaml.domain.ecalc_components import ProcessSystemComponent, SimplifiedProcessUnitComponent
+
+
+class DefaultProcessService(ProcessService):
+    def __init__(self):
+        self._process_systems: dict[UUID, CompressorTrainModel] = {}
+        self._simplified_process_units: dict[UUID, CompressorModelSampled | PumpModel | CompressorWithTurbineModel] = {}
+        self._evaluation_inputs: dict[UUID, CompressorEvaluationInput | PumpEvaluationInput] = {}
+        self._consumer_to_model_map: dict[tuple[UUID, Period], UUID] = {}
+        self._ecalc_components: dict[UUID, EcalcComponent] = {}
+
+    @property
+    def evaluation_inputs(self) -> dict[UUID, CompressorEvaluationInput | PumpEvaluationInput]:
+        return self._evaluation_inputs
+
+    @property
+    def process_systems(self) -> dict[UUID, CompressorTrainModel]:
+        return self._process_systems
+
+    @property
+    def simplified_process_units(self) -> dict[UUID, CompressorModelSampled | PumpModel | CompressorWithTurbineModel]:
+        return self._simplified_process_units
+
+    @property
+    def ecalc_components(self) -> dict[UUID, EcalcComponent]:
+        return self._ecalc_components
+
+    @property
+    def consumer_to_model_map(self) -> dict[tuple[UUID, Period], UUID]:
+        return self._consumer_to_model_map
+
+    def register_process_system(
+        self,
+        ecalc_component: EcalcComponent,
+        process_system: CompressorModel,
+        evaluation_input: CompressorEvaluationInput,
+    ):
+        self._ecalc_components[ecalc_component.id] = ecalc_component
+        self.process_systems[ecalc_component.id] = process_system
+        self.evaluation_inputs[ecalc_component.id] = evaluation_input
+
+    def register_simplified_process_unit(
+        self,
+        ecalc_component: EcalcComponent,
+        simplified_process_unit: CompressorModelSampled | PumpModel | CompressorWithTurbineModel,
+        evaluation_input: CompressorEvaluationInput | PumpEvaluationInput,
+    ):
+        self._ecalc_components[ecalc_component.id] = ecalc_component
+        self.simplified_process_units[ecalc_component.id] = simplified_process_unit
+        self.evaluation_inputs[ecalc_component.id] = evaluation_input
+
+    def map_model_to_consumer(
+        self,
+        consumer_id: UUID,
+        period: Period,
+        ecalc_component: ProcessSystemComponent | SimplifiedProcessUnitComponent,
+    ):
+        self.consumer_to_model_map[(consumer_id, period)] = ecalc_component.id
+
+    def get_evaluation_input(self, model_id: UUID) -> CompressorEvaluationInput | PumpEvaluationInput:
+        return self.evaluation_inputs.get(model_id)
diff --git a/src/libecalc/presentation/yaml/domain/ecalc_components.py b/src/libecalc/presentation/yaml/domain/ecalc_components.py
@@ -0,0 +1,13 @@
+from uuid import UUID
+
+from libecalc.domain.ecalc_component import EcalcComponent
+
+
+class ProcessSystemComponent(EcalcComponent):
+    def __init__(self, id: UUID, name: str, type: str):
+        super().__init__(id=id, name=name, type=type)
+
+
+class SimplifiedProcessUnitComponent(EcalcComponent):
+    def __init__(self, id: UUID, name: str, type: str):
+        super().__init__(id=id, name=name, type=type)
diff --git a/src/libecalc/presentation/yaml/mappers/consumer_function_mapper.py b/src/libecalc/presentation/yaml/mappers/consumer_function_mapper.py
@@ -61,6 +61,7 @@
 from libecalc.expression import Expression
 from libecalc.expression.expression import InvalidExpressionError
 from libecalc.infrastructure.neqsim_fluid_provider.neqsim_fluid_factory import NeqSimFluidFactory
+from libecalc.presentation.yaml.domain.ecalc_components import ProcessSystemComponent, SimplifiedProcessUnitComponent
 from libecalc.presentation.yaml.domain.expression_time_series_flow_rate import ExpressionTimeSeriesFlowRate
 from libecalc.presentation.yaml.domain.expression_time_series_fluid_density import ExpressionTimeSeriesFluidDensity
 from libecalc.presentation.yaml.domain.expression_time_series_power import ExpressionTimeSeriesPower
@@ -940,6 +941,7 @@ def __init__(
         self._period_subsets = {}
         self._time_adjusted_model = define_time_model_for_period(energy_usage_model, target_period=target_period)
         self._mapping_context = mapping_context
+        self._process_service = mapping_context._process_service
         self._consumer_id = consumer_id
         for period in self._time_adjusted_model:
             start_index, end_index = period.get_period_indices(expression_evaluator.get_periods())
@@ -1105,10 +1107,11 @@ def _map_pump(
         )
         # Register the pump model and its evaluation input in the mapping context
         model_id = uuid4()
-        self._mapping_context.register_simplified_process_unit(id=model_id, simplified_process_unit=pump_model)
-        self._mapping_context.register_evaluation_input(id=model_id, evaluation_input=evaluation_input)
-        # Ensure that the process system ID is associated with the correct consumer ID and period
-        self._mapping_context.map_model_to_consumer(consumer_id=consumer_id, period=period, model_id=model_id)
+        component = SimplifiedProcessUnitComponent(id=model_id, name=model.energy_function, type=model.type)
+        self._process_service.register_simplified_process_unit(
+            ecalc_component=component, simplified_process_unit=pump_model, evaluation_input=evaluation_input
+        )
+        self._process_service.map_model_to_consumer(consumer_id=consumer_id, period=period, ecalc_component=component)
 
         return pump_model
 
@@ -1195,11 +1198,11 @@ def _map_multiple_streams_compressor(
         )
 
         # Register the compressor model and its evaluation input in the mapping context
-        self._mapping_context.register_process_system(id=process_system_id, process_system=compressor_train_model)
-        self._mapping_context.register_evaluation_input(id=process_system_id, evaluation_input=evaluation_input)
-
-        # Ensure that the process system ID is associated with the correct consumer ID and period
-        self._mapping_context.map_model_to_consumer(consumer_id=consumer_id, period=period, model_id=process_system_id)
+        component = ProcessSystemComponent(id=process_system_id, name=model.compressor_train_model, type=model.type)
+        self._process_service.register_process_system(
+            ecalc_component=component, process_system=compressor_train_model, evaluation_input=evaluation_input
+        )
+        self._process_service.map_model_to_consumer(consumer_id=consumer_id, period=period, ecalc_component=component)
 
         return compressor_train_model
 
@@ -1286,27 +1289,36 @@ def _map_compressor(
         )
 
         model_id = uuid4()
-        # Register the compressor model and its evaluation input in the mapping context
+        # Register the compressor model and its evaluation input in the process service
         # - If it is a sampled model, or a turbine model wrapping a sampled model, treat as non-process.
         # - Otherwise, treat as a process model.
         if isinstance(compressor_model, CompressorModelSampled):
-            self._mapping_context.register_simplified_process_unit(
-                id=model_id, simplified_process_unit=compressor_model
+            component = SimplifiedProcessUnitComponent(id=model_id, name=model.energy_function, type=model.type)
+            self._process_service.register_simplified_process_unit(
+                ecalc_component=component, simplified_process_unit=compressor_model, evaluation_input=evaluation_input
             )
         elif isinstance(compressor_model, CompressorWithTurbineModel):
             if isinstance(compressor_model.compressor_model, CompressorModelSampled):
-                self._mapping_context.register_simplified_process_unit(
-                    id=model_id, simplified_process_unit=compressor_model
+                component = SimplifiedProcessUnitComponent(id=model_id, name=model.energy_function, type=model.type)
+                self._process_service.register_simplified_process_unit(
+                    ecalc_component=component,
+                    simplified_process_unit=compressor_model,
+                    evaluation_input=evaluation_input,
                 )
             else:
-                self._mapping_context.register_process_system(id=model_id, process_system=compressor_model)
-        else:
-            self._mapping_context.register_process_system(id=model_id, process_system=compressor_model)
+                component = ProcessSystemComponent(id=model_id, name=model.energy_function, type=model.type)
+                self._process_service.register_process_system(
+                    ecalc_component=component, process_system=compressor_model, evaluation_input=evaluation_input
+                )
 
-        self._mapping_context.register_evaluation_input(id=model_id, evaluation_input=evaluation_input)
+        else:
+            component = ProcessSystemComponent(id=model_id, name=model.energy_function, type=model.type)
+            self._process_service.register_process_system(
+                ecalc_component=component, process_system=compressor_model, evaluation_input=evaluation_input
+            )
 
         # Ensure that the process system ID is associated with the correct consumer ID and period
-        self._mapping_context.map_model_to_consumer(consumer_id=consumer_id, period=period, model_id=model_id)
+        self._process_service.map_model_to_consumer(consumer_id=consumer_id, period=period, ecalc_component=component)
 
         return compressor_model
 
diff --git a/src/libecalc/presentation/yaml/mappers/yaml_mapping_context.py b/src/libecalc/presentation/yaml/mappers/yaml_mapping_context.py
@@ -2,21 +2,8 @@
 
 from libecalc.common.temporal_model import TemporalModel
 from libecalc.common.time_utils import Period
-from libecalc.domain.infrastructure.energy_components.legacy_consumer.consumer_function import ConsumerFunction
-from libecalc.domain.process.compressor.core import CompressorModel
-from libecalc.domain.process.compressor.core.base import CompressorWithTurbineModel
-from libecalc.domain.process.compressor.core.sampled import CompressorModelSampled
-from libecalc.domain.process.entities.process_units.compressor.compressor import Compressor
-from libecalc.domain.process.entities.process_units.liquid_remover.liquid_remover import LiquidRemover
-from libecalc.domain.process.entities.process_units.pressure_modifier.pressure_modifier import (
-    DifferentialPressureModifier,
-)
-from libecalc.domain.process.entities.process_units.rate_modifier.rate_modifier import RateModifier
-from libecalc.domain.process.entities.process_units.temperature_setter.temperature_setter import TemperatureSetter
-from libecalc.domain.process.entities.shaft import Shaft
-from libecalc.domain.process.evaluation_input import CompressorEvaluationInput, PumpEvaluationInput
-from libecalc.domain.process.pump.pump import PumpModel
 from libecalc.presentation.yaml.domain.category_service import CategoryService
+from libecalc.presentation.yaml.domain.default_process_service import DefaultProcessService
 from libecalc.presentation.yaml.domain.yaml_component import YamlComponent
 from libecalc.presentation.yaml.mappers.yaml_path import YamlPath
 
@@ -25,49 +12,14 @@ class MappingContext(CategoryService):
     def __init__(self, target_period: Period):
         self._yaml_path_map: dict[YamlPath, YamlComponent] = {}
         self._yaml_component_map: dict[UUID, YamlComponent] = {}
-        self._process_systems: dict[UUID, CompressorModel] = {}
-        self._process_units: dict[
-            UUID, Compressor | Shaft | LiquidRemover | DifferentialPressureModifier | RateModifier | TemperatureSetter
-        ] = {}
-        self._simplified_process_units: dict[UUID, PumpModel | CompressorModelSampled | CompressorWithTurbineModel] = {}
-        self._consumer_functions: dict[UUID, ConsumerFunction] = {}
-        self._evaluation_input: dict[UUID, CompressorEvaluationInput] = {}
-        self._consumer_to_model_map: dict[tuple[UUID, Period], UUID] = {}
+
         self._target_period = target_period
+        self._process_service = DefaultProcessService()
 
     def register_yaml_component(self, yaml_path: YamlPath, yaml_component: YamlComponent):
         self._yaml_path_map[yaml_path] = yaml_component
         self._yaml_component_map[yaml_component.id] = yaml_component
 
-    def register_process_system(self, id: UUID, process_system: CompressorModel):
-        self._process_systems[id] = process_system
-
-    def register_process_unit(
-        self,
-        id: UUID,
-        process_unit: Compressor
-        | Shaft
-        | LiquidRemover
-        | DifferentialPressureModifier
-        | RateModifier
-        | TemperatureSetter,
-    ):
-        self._process_units[id] = process_unit
-
-    def register_simplified_process_unit(
-        self, id: UUID, simplified_process_unit: PumpModel | CompressorModelSampled | CompressorWithTurbineModel
-    ):
-        self._simplified_process_units[id] = simplified_process_unit
-
-    def register_consumer_function(self, id: UUID, consumer_function: ConsumerFunction):
-        self._consumer_functions[id] = consumer_function
-
-    def register_evaluation_input(self, id: UUID, evaluation_input: CompressorEvaluationInput | PumpEvaluationInput):
-        self._evaluation_input[id] = evaluation_input
-
-    def map_model_to_consumer(self, consumer_id: UUID, period: Period, model_id: UUID):
-        self._consumer_to_model_map[(consumer_id, period)] = model_id
-
     def get_component_name_from_yaml_path(self, yaml_path: YamlPath) -> str | None:
         component_context = self._yaml_path_map.get(yaml_path)
         if component_context is None:
diff --git a/src/libecalc/presentation/yaml/model.py b/src/libecalc/presentation/yaml/model.py
@@ -28,6 +28,7 @@
 from libecalc.dto import ResultOptions
 from libecalc.dto.component_graph import ComponentGraph
 from libecalc.presentation.yaml.domain.category_service import CategoryService
+from libecalc.presentation.yaml.domain.default_process_service import DefaultProcessService
 from libecalc.presentation.yaml.domain.reference_service import ReferenceService
 from libecalc.presentation.yaml.domain.time_series_collections import TimeSeriesCollections
 from libecalc.presentation.yaml.domain.time_series_resource import TimeSeriesResource
@@ -314,16 +315,17 @@ def _get_context(self, component_id: str) -> ComponentEnergyContext:
 
     def evaluate_energy_usage(self) -> dict[str, ComponentResult]:
         energy_components = self.get_energy_components()
+        process_service = self.get_process_service()
 
         # Evaluate process systems.
         process_system_results = self.evaluate_domain_models(
-            models=self._mapping_context._process_systems,
-            evaluation_inputs=self._mapping_context._evaluation_input,
+            models=process_service.process_systems,
+            evaluation_inputs=process_service.evaluation_inputs,
         )
         # Evaluate simplified process units (e.g. CompressorModelSampled and PumpModel).
         simplified_process_unit_results = self.evaluate_domain_models(
-            models=self._mapping_context._simplified_process_units,
-            evaluation_inputs=self._mapping_context._evaluation_input,
+            models=process_service.simplified_process_units,
+            evaluation_inputs=process_service.evaluation_inputs,
         )
 
         all_model_results = {**process_system_results, **simplified_process_unit_results}
@@ -382,11 +384,14 @@ def get_installations(self) -> list[Installation]:
     def get_category_service(self) -> CategoryService:
         return self._mapping_context
 
+    def get_process_service(self) -> DefaultProcessService:
+        return self._mapping_context._process_service
+
+    @staticmethod
     def evaluate_domain_models(
-        self,
         models: dict[UUID, Any],
-        evaluation_inputs: dict[UUID, Any],
-    ) -> dict[UUID, CompressorTrainResult]:
+        evaluation_inputs: dict[UUID, CompressorEvaluationInput | PumpEvaluationInput],
+    ) -> dict[UUID, CompressorTrainResult | PumpModelResult]:
         """
         Evaluates domain models and returns a mapping: model_id -> evaluated_result.
 
@@ -432,21 +437,21 @@ def get_consumer_energy_results_from_domain_models(
             Dictionary mapping consumer UUID to consumer result, containing energy results
             for all periods.
         """
-
+        process_service = self.get_process_service()
         allowed_model_result_types = (CompressorTrainResult, PumpModelResult)
         assert all(
             isinstance(model_result, allowed_model_result_types) for model_result in model_results.values()
         ), "All models must be of allowed types"
 
         # Map from UUID to id for all energy components
-        uuid_to_id = {component._uuid: component.id for component in self.get_energy_components()}
+        uuid_to_id = {component.get_id(): component.id for component in self.get_energy_components()}
 
         # Construct ConsumerFunctionResult objects for each consumer
         consumer_function_results: dict[UUID, list[ConsumerFunctionResult]] = {}
-        for (consumer_id, _period), model_id in self._mapping_context._consumer_to_model_map.items():
+        for (consumer_id, _period), model_id in process_service.consumer_to_model_map.items():
             model_result = model_results.get(model_id)
             if model_result is not None:
-                evaluation_input = self._mapping_context._evaluation_input.get(model_id)
+                evaluation_input = process_service.evaluation_inputs.get(model_id)
                 power_loss_factor = evaluation_input.power_loss_factor if evaluation_input else None
                 consumer_function_results.setdefault(consumer_id, []).append(
                     ConsumerFunctionResult(
