refactor: separate process definitions from instance references

Author: frodehk

src/libecalc/presentation/yaml/mappers/process/build_sections.py

@@ -3,7 +3,7 @@
     MappedSection,
     ProcessPartitioner,
 )
-from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessUnitReference
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessUnitInstanceName
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_simulation import YamlProcessConstraint
 from libecalc.process.fluid_stream.fluid_service import FluidService
 from libecalc.process.process_pipeline.process_unit import ProcessUnit, ProcessUnitId
@@ -25,7 +25,7 @@ def __init__(self):
     def partition_and_validate(
         self,
         process_unit_map: dict[ProcessUnitId, ProcessUnit],
-        unit_name_to_id: dict[ProcessUnitReference, ProcessUnitId],
+        unit_name_to_id: dict[ProcessUnitInstanceName, ProcessUnitId],
         pipeline_constraints: list[YamlProcessConstraint],
     ) -> list[MappedSection]:
         sections = self._partitioner.partition(

src/libecalc/presentation/yaml/mappers/process/process_partitioner.py

@@ -1,6 +1,6 @@
 from libecalc.common.ddd import value_object
 from libecalc.common.errors.ecalc_validation_error import EcalcValidationException
-from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessUnitReference
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessUnitInstanceName
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_simulation import YamlProcessConstraint
 from libecalc.process.process_pipeline.process_unit import ProcessUnit, ProcessUnitId
 from libecalc.process.process_units.compressor import Compressor
@@ -27,7 +27,7 @@ class ProcessPartitioner:
     @staticmethod
     def partition(
         process_unit_map: dict[ProcessUnitId, ProcessUnit],
-        unit_name_to_id: dict[ProcessUnitReference, ProcessUnitId],
+        unit_name_to_id: dict[ProcessUnitInstanceName, ProcessUnitId],
         pipeline_constraints: list[YamlProcessConstraint],
     ) -> list[MappedSection]:
         process_units = list(process_unit_map.values())
@@ -40,7 +40,7 @@ def partition(
                     raise EcalcValidationException("Only one constraint can target the process pipeline outlet.")
                 terminal_constraint = constraint
                 continue
-            unit_id = unit_name_to_id.get(constraint.process_unit)
+            unit_id = unit_name_to_id.get(ProcessUnitInstanceName(constraint.process_unit))
             if unit_id is None:
                 raise EcalcValidationException(f"Constraint references unknown unit '{constraint.process_unit}'.")
 

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

@@ -39,13 +39,16 @@
 )
 from libecalc.presentation.yaml.mappers.model import InvalidChartResourceException
 from libecalc.presentation.yaml.mappers.process.build_sections import ProcessSectionBuilder
+from libecalc.presentation.yaml.resolvers.process_unit_resolver import ProcessUnitResolver
 from libecalc.presentation.yaml.yaml_types.components.yaml_expression_type import YamlExpressionType
 from libecalc.presentation.yaml.yaml_types.models import YamlFluidModel
 from libecalc.presentation.yaml.yaml_types.models.yaml_compressor_stages import YamlControlMarginUnits
 from libecalc.presentation.yaml.yaml_types.models.yaml_fluid import YamlCompositionFluidModel, YamlPredefinedFluidModel
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_pipeline import YamlProcessPipeline
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import (
-    ProcessUnitReference,
+    ProcessPipelineInstanceName,
+    ProcessPipelineInstanceReference,
+    ProcessUnitInstanceName,
 )
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_simulation import (
     YamlProcessSimulation,
@@ -131,6 +134,7 @@ def __init__(
         self._reference_service = reference_service
         self._resources = resources
         self._ecalc_event_service = ecalc_event_service
+        self._process_unit_resolver = ProcessUnitResolver(reference_service)
 
     def _resolve_train_reference(self, ref: str | YamlProcessPipeline) -> YamlProcessPipeline:
         if isinstance(ref, str):
@@ -247,7 +251,7 @@ def _map_fluid_model(self, yaml_fluid_model: YamlFluidModel) -> FluidModel:
     def _validate_and_map_pipeline_events(
         self,
         yaml_pipeline: YamlProcessPipeline,
-        unit_name_to_id: dict[ProcessUnitReference, ProcessUnitId],
+        unit_name_to_id: dict[ProcessUnitInstanceName, ProcessUnitId],
     ) -> list[PipelineEvent]:
         """Validate pipeline event references and map to domain objects."""
         events: list[PipelineEvent] = []
@@ -275,7 +279,7 @@ def _validate_and_map_pipeline_events(
             events.append(
                 PipelineEvent(
                     action=PipelineEventAction(yaml_event.type.value),
-                    change_target=unit_name_to_id[yaml_event.change_target],
+                    change_target=unit_name_to_id[ProcessUnitInstanceName(yaml_event.change_target)],
                     change_to=change_to_unit,
                     change_type=PipelineEventChangeType(yaml_event.change_type.value),
                     change_time=ecalc_event.start,
@@ -308,9 +312,10 @@ def map_process_simulation(
             problem_configuration_handlers = []
             shaft = VariableSpeedShaft()
             item = self._resolve_train_reference(yaml_compressor_train_item.target)
+            pipeline_instance_name = yaml_compressor_train_item.name or ProcessPipelineInstanceName(item.name)
             process_unit_map: dict[ProcessUnitId, ProcessUnit] = {}
             compressor_ids: list[ProcessUnitId] = []
-            unit_name_to_id: dict[ProcessUnitReference, ProcessUnitId] = {}
+            unit_name_to_id: dict[ProcessUnitInstanceName, ProcessUnitId] = {}
             problem_time_series_configurations: dict[
                 ProcessUnitId,
                 TimeSeriesTemperatureSetterConfiguration
@@ -320,10 +325,9 @@ def map_process_simulation(
             ] = {}
 
             for yaml_pipeline_item in item.items:
-                yaml_process_unit = yaml_pipeline_item.target
-                process_unit_name = yaml_pipeline_item.name
-                if isinstance(yaml_process_unit, str):
-                    yaml_process_unit = self._reference_service.get_process_unit(yaml_process_unit)
+                resolved_process_unit = self._process_unit_resolver.resolve(yaml_pipeline_item)
+                process_unit_name = resolved_process_unit.name
+                yaml_process_unit = resolved_process_unit.specification
 
                 match yaml_process_unit:
                     case YamlCompressor():
@@ -394,10 +398,11 @@ def map_process_simulation(
             # from section, and keep track of them at pipeline level
             process_pipeline_sections: list[ProcessPipelineSection] = []
             process_problem_sections: list[ProcessProblemSection] = []
-            pipeline_constraints = yaml_process_simulation.constraints.get(item.name)
-
+            pipeline_constraints = yaml_process_simulation.constraints.get(
+                ProcessPipelineInstanceReference(pipeline_instance_name)
+            )
             if not pipeline_constraints:
-                raise EcalcValidationException(f"Missing constraint for process system '{item.name}'")
+                raise EcalcValidationException(f"Missing constraint for process system '{pipeline_instance_name}'")
 
             mapped_sections = section_builder.partition_and_validate(
                 process_unit_map=process_unit_map,
@@ -426,7 +431,7 @@ def map_process_simulation(
             # TODO: We should move this class to this module/layer
             # in particular because it creates necessary connections, which means that they will get new IDs
             process_pipeline = ProcessPipeline(
-                name=item.name,
+                name=pipeline_instance_name,
                 process_pipeline_sections=process_pipeline_sections,
                 events=pipeline_events,
                 process_periods=process_periods,
@@ -476,7 +481,7 @@ def map_process_simulation(
 
             predefined_configurations[process_pipeline.get_id()] = problem_time_series_configurations
 
-            process_pipeline_reference_to_id_map[item.name] = process_pipeline.get_id()
+            process_pipeline_reference_to_id_map[pipeline_instance_name] = process_pipeline.get_id()
             process_pipelines.append(process_pipeline)
             process_problems.append(
                 ProcessProblem(

src/libecalc/presentation/yaml/resolvers/__init__.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+from libecalc.presentation.yaml.domain.reference_service import ReferenceService
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_pipeline import YamlProcessUnitItem
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessUnitInstanceName
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_units import YamlProcessUnit
+
+
+@dataclass(frozen=True)
+class ResolvedProcessUnitItem:
+    name: ProcessUnitInstanceName | None
+    specification: YamlProcessUnit
+
+
+class ProcessUnitResolver:
+    def __init__(self, references: ReferenceService):
+        self._references = references
+
+    def resolve(self, item: YamlProcessUnitItem) -> ResolvedProcessUnitItem:
+        specification = self._references.get_process_unit(item.target) if isinstance(item.target, str) else item.target
+        return ResolvedProcessUnitItem(
+            name=item.name,
+            specification=specification,
+        )

src/libecalc/presentation/yaml/resolvers/process_unit_resolver.py

@@ -6,6 +6,9 @@
 from libecalc.presentation.yaml.yaml_types import YamlBase
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import (
     ProcessEventReference,
+    ProcessUnitDefinitionReference,
+    ProcessUnitInstanceName,
+    ProcessUnitInstanceReference,
     ProcessUnitReference,
 )
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_units import (
@@ -20,6 +23,11 @@ class YamlItem[TTarget](YamlBase):
     name: str | None = None
 
 
+class YamlProcessUnitItem(YamlBase):
+    name: ProcessUnitInstanceName | None = None
+    target: YamlProcessUnit | ProcessUnitDefinitionReference
+
+
 class PipelineEventAction(StrEnum):
     CHANGE = "CHANGE"
     ADD = "ADD"
@@ -39,21 +47,21 @@ class YamlPipelineEvent(YamlBase):
         ),
     ]
     change_target: Annotated[
-        ProcessUnitReference,
+        ProcessUnitInstanceReference,
         Field(
             title="CHANGE_TARGET",
             description="Name of the process unit in the pipeline to change.",
         ),
     ]
     change_from: Annotated[
-        ProcessUnitReference,
+        ProcessUnitDefinitionReference,
         Field(
             title="CHANGE_FROM",
             description="Reference to the existing process unit template being replaced.",
         ),
     ]
     change_to: Annotated[
-        ProcessUnitReference,
+        ProcessUnitDefinitionReference,
         Field(
             title="CHANGE_TO",
             description="Reference to the new process unit template to use.",
@@ -78,7 +86,7 @@ class YamlPipelineEvent(YamlBase):
 class YamlProcessPipeline(YamlBase):
     type: Literal["SERIAL"]
     name: str
-    items: list[YamlItem[YamlProcessUnit]]
+    items: list[YamlProcessUnitItem]
     events: Annotated[
         list[YamlPipelineEvent],
         Field(

src/libecalc/presentation/yaml/yaml_types/process/yaml_process_pipeline.py

@@ -2,9 +2,19 @@
 Shared reference type aliases for YAML process types.
 """
 
+from typing import NewType
+
 type StreamRef = str
 type ProcessPipelineReference = str  # TODO: validate correct reference
 type ProcessUnitReference = str
 type EcalcEventReference = str
 type ProcessEventReference = str
 type PumpChartReference = str
+
+ProcessUnitInstanceName = NewType("ProcessUnitInstanceName", str)
+ProcessUnitInstanceReference = NewType("ProcessUnitInstanceReference", str)
+ProcessUnitDefinitionReference = NewType("ProcessUnitDefinitionReference", str)
+
+ProcessPipelineInstanceName = NewType("ProcessPipelineInstanceName", str)
+ProcessPipelineInstanceReference = NewType("ProcessPipelineInstanceReference", str)
+ProcessPipelineDefinitionReference = NewType("ProcessPipelineDefinitionReference", str)

src/libecalc/presentation/yaml/yaml_types/process/yaml_process_references.py

@@ -5,14 +5,13 @@
 from libecalc.ecalc_model.ecalc_event import EcalcEventType, ProcessEventType
 from libecalc.presentation.yaml.yaml_types import YamlBase
 from libecalc.presentation.yaml.yaml_types.components.yaml_expression_type import YamlExpressionType
-from libecalc.presentation.yaml.yaml_types.process.yaml_process_pipeline import (
-    YamlItem,
-    YamlProcessPipeline,
-)
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_pipeline import YamlProcessPipeline
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import (
     EcalcEventReference,
-    ProcessPipelineReference,
-    ProcessUnitReference,
+    ProcessPipelineDefinitionReference,
+    ProcessPipelineInstanceName,
+    ProcessPipelineInstanceReference,
+    ProcessUnitInstanceReference,
     PumpChartReference,
 )
 from libecalc.presentation.yaml.yaml_types.process.yaml_stream_distribution import YamlStreamDistribution
@@ -83,9 +82,14 @@ class YamlProcessEvent(YamlBase):
     ]
 
 
+class YamlProcessPipelineTarget(YamlBase):
+    name: ProcessPipelineInstanceName | None = None
+    target: YamlProcessPipeline | ProcessPipelineDefinitionReference
+
+
 class YamlProcessConstraint(YamlBase):
     process_unit: Annotated[
-        ProcessUnitReference | None,
+        ProcessUnitInstanceReference | None,
         Field(
             title="PROCESS_UNIT",
             description="Reference to a named unit within the pipeline. If omitted, the constraint applies to the last process unit in the pipeline section.",
@@ -117,12 +121,12 @@ class YamlProcessConstraint(YamlBase):
 class YamlProcessSimulation(YamlBase):
     name: str
     targets: Annotated[
-        list[YamlItem[YamlProcessPipeline]],
+        list[YamlProcessPipelineTarget],
         Field(title="TARGETS"),
     ]
     stream_distribution: YamlStreamDistribution
     constraints: Annotated[
-        dict[ProcessPipelineReference, list[YamlProcessConstraint]],
+        dict[ProcessPipelineInstanceReference, list[YamlProcessConstraint]],
         Field(
             title="CONSTRAINTS",
             description="Constraints per target. Key is pipeline name, value is list of constraints.",

src/libecalc/presentation/yaml/yaml_types/process/yaml_process_simulation.py

@@ -3,14 +3,14 @@
 
 from libecalc.presentation.yaml.yaml_types import YamlBase
 from libecalc.presentation.yaml.yaml_types.components.yaml_expression_type import YamlExpressionType
-from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessPipelineReference
+from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import ProcessPipelineInstanceReference
 from libecalc.presentation.yaml.yaml_types.streams.yaml_inlet_stream import YamlInletStream
 from libecalc.presentation.yaml.yaml_types.process.yaml_process_references import StreamRef
 
 
 class YamlOverflow(YamlBase):
-    from_reference: ProcessPipelineReference
-    to_reference: ProcessPipelineReference
+    from_reference: ProcessPipelineInstanceReference
+    to_reference: ProcessPipelineInstanceReference
 
 
 class YamlCommonStreamSetting(YamlBase):