fmu-manipulation-toolbox 1.9rc0__py3-none-any.whl → 1.9rc1__py3-none-any.whl

fmu_manipulation_toolbox/container.py

@@ -1,7 +1,9 @@
 import logging
+import getpass
 import os
 import shutil
 import uuid
+import platform
 import zipfile
 from datetime import datetime
 from pathlib import Path
@@ -14,22 +16,101 @@ from .version import __version__ as tool_version
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
 
-class FMUPort:
-    def __init__(self, attrs: Dict[str, str]):
+class EmbeddedFMUPort:
+    FMI_TO_CONTAINER = {
+        2: {
+            'Real': 'real64',
+            'Integer': 'integer32',
+            'String': 'string',
+            'Boolean': 'boolean'
+        },
+        3: {
+            'Float64': 'real64',
+            'Float32': 'real32',
+            'Int8': 'integer8',
+            'UInt8': 'uinteger8',
+            'Int16': 'integer16',
+            'UInt16': 'uinteger16',
+            'Int32': 'integer32',
+            'UInt32': 'uinteger32',
+            'Int64': 'integer64',
+            'UInt64': 'uinteger64',
+            'String': 'string',
+            'Boolean': 'boolean1'
+        }
+    }
+
+    FMI_TO_CONTAINER = {
+        2: {
+            'Real': 'real64',
+            'Integer': 'integer32',
+            'String': 'string',
+            'Boolean': 'boolean'
+        },
+        3: {
+            'Float64': 'real64',
+            'Float32': 'real32',
+            'Int8': 'integer8',
+            'UInt8': 'uinteger8',
+            'Int16': 'integer16',
+            'UInt16': 'uinteger16',
+            'Int32': 'integer32',
+            'UInt32': 'uinteger32',
+            'Int64': 'integer64',
+            'UInt64': 'uinteger64',
+            'String': 'string',
+            'Boolean': 'boolean1'
+        }
+    }
+
+    CONTAINER_TO_FMI = {
+        2: {
+            'real64': 'Real',
+            'integer32': 'Integer',
+            'string': 'String',
+            'boolean': 'Boolean'
+        },
+        3: {
+            'real64': 'Float64' ,
+            'real32': 'Float32' ,
+            'integer8': 'Int8' ,
+            'uinteger8': 'UInt8' ,
+            'integer16': 'Int16' ,
+            'uinteger16': 'UInt16' ,
+            'integer32': 'Int32' ,
+            'uinteger32': 'UInt32' ,
+            'integer64': 'Int64' ,
+            'uinteger64': 'UInt64' ,
+            'string': 'String' ,
+            'boolean1': 'Boolean'
+        }
+    }
+
+    ALL_TYPES = (
+        "real64", "real32",
+        "integer8", "uinteger8", "integer16", "uinteger16", "integer32", "uinteger32", "integer64", "uinteger64",
+        "boolean", "boolean1",
+        "strings"
+    )
+
+
+
+    def __init__(self, fmi_type, attrs: Dict[str, str], fmi_version=0):
         self.causality = attrs.get("causality", "local")
         self.variability = attrs.get("variability", "continuous")
-        self.name = attrs.get("name")
-        self.vr = int(attrs.get("valueReference"))
+        self.name = attrs["name"]
+        self.vr = int(attrs["valueReference"])
         self.description = attrs.get("description", None)
 
-        self.type_name = attrs.get("type_name", None)
+        if fmi_version > 0:
+            self.type_name = self.FMI_TO_CONTAINER[fmi_version][fmi_type]
+        else:
+            self.type_name = fmi_type
+
         self.start_value = attrs.get("start", None)
         self.initial = attrs.get("initial", None)
 
-    def set_port_type(self, type_name: str, attrs: Dict[str, str]):
-        self.type_name = type_name
-        self.start_value = attrs.pop("start", None)
-        self.initial = attrs.pop("initial", None)
+
 
     def xml(self, vr: int, name=None, causality=None, start=None, fmi_version=2):
         if name is None:
@@ -39,23 +120,18 @@ class FMUPort:
         if start is None:
             start = self.start_value
         if self.variability is None:
-            self.variability = "continuous" if self.type_name == "Real" else "discrete"
+            self.variability = "continuous" if "real" in self.type_name else "discrete"
 
+        fmi_type = self.CONTAINER_TO_FMI[fmi_version][self.type_name]
 
         if fmi_version == 2:
-            child_dict =  {
+            child_attrs =  {
                 "start": start,
             }
-            if "Float" in self.type_name:
-                type_name = "Real"
-            elif "Int" in self.type_name:
-                type_name = "Integer"
-            else:
-                type_name = self.type_name
 
-            child_str = (f"<{type_name} " +
-                         " ".join([f'{key}="{value}"' if value is not None else ""
-                                   for (key, value) in child_dict.items()]) +
+            filtered_child_attrs = {key: value for key, value in child_attrs.items() if value is not None}
+            child_str = (f"<{fmi_type} " +
+                         " ".join([f'{key}="{value}"' for (key, value) in filtered_child_attrs.items()]) +
                          "/>")
 
             scalar_attrs = {
@@ -66,11 +142,23 @@ class FMUPort:
                 "initial": self.initial,
                 "description": self.description,
             }
-            scalar_attrs_str = " ".join([f'{key}="{value}"' if value is not None else ""
-                                         for (key, value) in scalar_attrs.items()])
+            filtered_attrs = {key: value for key, value in scalar_attrs.items() if value is not None}
+            scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
             return f'<ScalarVariable {scalar_attrs_str}>{child_str}</ScalarVariable>'
         else:
-            return f'FIX ME'
+            scalar_attrs = {
+                "name": name,
+                "valueReference": vr,
+                "causality": causality,
+                "variability": self.variability,
+                "initial": self.initial,
+                "description": self.description,
+                "start": start
+            }
+            filtered_attrs = {key: value for key, value in scalar_attrs.items() if value is not None}
+            scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
+
+            return f'<{fmi_type} {scalar_attrs_str}/>'
 
 
 class EmbeddedFMU(OperationAbstract):
@@ -80,14 +168,15 @@ class EmbeddedFMU(OperationAbstract):
     def __init__(self, filename):
         self.fmu = FMU(filename)
         self.name = Path(filename).name
-        self.id = Path(filename).stem
+        self.id = Path(filename).stem.lower()
 
         self.step_size = None
         self.start_time = None
         self.stop_time = None
         self.model_identifier = None
         self.guid = None
-        self.ports: Dict[str, FMUPort] = {}
+        self.fmi_version = None
+        self.ports: Dict[str, EmbeddedFMUPort] = {}
 
         self.capabilities: Dict[str, str] = {}
         self.current_port = None  # used during apply_operation()
@@ -100,21 +189,10 @@ class EmbeddedFMU(OperationAbstract):
         fmi_version = attrs['fmiVersion']
         if fmi_version == "2.0":
             self.guid = attrs['guid']
+            self.fmi_version = 2
         if fmi_version == "3.0":
             self.guid = attrs['instantiationToken']
-
-
-    def scalar_attrs(self, attrs) -> int:
-        if 'type_name' in attrs:  # FMI 3.0
-            type_name = attrs.pop('type_name')
-            port = FMUPort(attrs)
-            port.type_name = type_name
-            self.ports[port.name] = port
-        else: # FMI 2.0
-            self.current_port = FMUPort(attrs)
-            self.ports[self.current_port.name] = self.current_port
-
-        return 0
+            self.fmi_version = 3
 
     def cosimulation_attrs(self, attrs: Dict[str, str]):
         self.model_identifier = attrs['modelIdentifier']
@@ -129,12 +207,9 @@ class EmbeddedFMU(OperationAbstract):
         self.start_time = float(attrs.get("startTime", 0.0))
         self.stop_time = float(attrs.get("stopTime", self.start_time + 1.0))
 
-    def scalar_type(self, type_name, attrs):
-        if self.current_port:
-            if type_name == "Enumeration":
-                type_name = "Integer"
-            self.current_port.set_port_type(type_name, attrs)
-        self.current_port = None
+    def port_attrs(self, fmu_port):
+        port = EmbeddedFMUPort(fmu_port.fmi_type, fmu_port, fmi_version=self.fmi_version)
+        self.ports[port.name] = port
 
     def __repr__(self):
         return f"FMU '{self.name}' ({len(self.ports)} variables)"
@@ -212,21 +287,23 @@ class Local:
 
 class ValueReferenceTable:
     def __init__(self):
-        self.vr_table: Dict[str, int] = {
-            "Real": 0,
-            "Float64": 0,
-            "Integer": 0,
-            "Boolean": 0,
-            "String": 0,
-        }
+        self.vr_table = {}
+        self.masks = {}
+        for i, type_name in enumerate(EmbeddedFMUPort.ALL_TYPES):
+            self.vr_table[type_name] = 0
+            self.masks[type_name] = i << 24
+
 
-    def get_vr(self, cport: ContainerPort) -> int:
-        return self.add_vr(cport.port.type_name)
+    def add_vr(self, port_or_type_name: Union[ContainerPort, str]) -> int:
+        if isinstance(port_or_type_name, ContainerPort):
+            type_name = port_or_type_name.port.type_name
+        else:
+            type_name = port_or_type_name
 
-    def add_vr(self, type_name: str) -> int:
         vr = self.vr_table[type_name]
         self.vr_table[type_name] += 1
-        return vr
+
+        return vr | self.masks[type_name]
 
 
 class AutoWired:
@@ -255,15 +332,83 @@ class AutoWired:
 
 
 class FMUContainer:
-    def __init__(self, identifier: str, fmu_directory: Union[str, Path], description_pathname=None):
+    HEADER_XML_2 = """<?xml version="1.0" encoding="ISO-8859-1"?>
+<fmiModelDescription
+  fmiVersion="2.0"
+  modelName="{identifier}"
+  generationTool="FMUContainer-{tool_version}"
+  generationDateAndTime="{timestamp}"
+  guid="{guid}"
+  description="FMUContainer with {embedded_fmu}"
+  author="{author}"
+  license="Proprietary"
+  copyright="See Embedded FMU's copyrights."
+  variableNamingConvention="structured">
+
+  <CoSimulation
+    modelIdentifier="{identifier}"
+    canHandleVariableCommunicationStepSize="true"
+    canBeInstantiatedOnlyOncePerProcess="{only_once}"
+    canNotUseMemoryManagementFunctions="true"
+    canGetAndSetFMUstate="false"
+    canSerializeFMUstate="false"
+    providesDirectionalDerivative="false"
+    needsExecutionTool="{execution_tool}">
+  </CoSimulation>
+
+  <LogCategories>
+    <Category name="fmucontainer"/>
+  </LogCategories>
+
+  <DefaultExperiment stepSize="{step_size}" startTime="{start_time}" stopTime="{stop_time}"/>
+
+  <ModelVariables>
+    <ScalarVariable valueReference="0" name="time" causality="independent"><Real /></ScalarVariable>
+"""
+
+    HEADER_XML_3 = """<?xml version="1.0" encoding="ISO-8859-1"?>
+<fmiModelDescription
+  fmiVersion="3.0"
+  modelName="{identifier}"
+  generationTool="FMUContainer-{tool_version}"
+  generationDateAndTime="{timestamp}"
+  instantiationToken="{guid}"
+  description="FMUContainer with {embedded_fmu}"
+  author="{author}"
+  license="Proprietary"
+  copyright="See Embedded FMU's copyrights."
+  variableNamingConvention="structured">
+
+  <CoSimulation
+    modelIdentifier="{identifier}"
+    canHandleVariableCommunicationStepSize="true"
+    canBeInstantiatedOnlyOncePerProcess="{only_once}"
+    canNotUseMemoryManagementFunctions="true"
+    canGetAndSetFMUstate="false"
+    canSerializeFMUstate="false"
+    providesDirectionalDerivative="false"
+    needsExecutionTool="{execution_tool}">
+  </CoSimulation>
+
+  <LogCategories>
+    <Category name="fmucontainer"/>
+  </LogCategories>
+
+  <DefaultExperiment stepSize="{step_size}" startTime="{start_time}" stopTime="{stop_time}"/>
+
+  <ModelVariables>
+    <Float64 valueReference="0" name="time" causality="independent"/>
+"""
+
+    def __init__(self, identifier: str, fmu_directory: Union[str, Path], description_pathname=None, fmi_version=2):
         self.fmu_directory = Path(fmu_directory)
         self.identifier = identifier
         if not self.fmu_directory.is_dir():
             raise FMUContainerError(f"{self.fmu_directory} is not a valid directory")
-        self.involved_fmu: Dict[str, EmbeddedFMU] = {}
-        self.execution_order: List[EmbeddedFMU] = []
+        self.involved_fmu: OrderedDict[str, EmbeddedFMU] = OrderedDict()
 
         self.description_pathname = description_pathname
+        self.fmi_version = fmi_version
 
         self.start_time = None
         self.stop_time = None
@@ -276,15 +421,31 @@ class FMUContainer:
         self.rules: Dict[ContainerPort, str] = {}
         self.start_values: Dict[ContainerPort, str] = {}
 
+
+    def convert_type_name(self, type_name: str) -> str:
+        if self.fmi_version == 2:
+            table = {}
+        elif self.fmi_version == 3:
+            table = {}
+        else:
+            table = {}
+
+        try:
+            return table[type_name]
+        except KeyError:
+            return type_name
+
     def get_fmu(self, fmu_filename: str) -> EmbeddedFMU:
         if fmu_filename in self.involved_fmu:
             return self.involved_fmu[fmu_filename]
 
         try:
             fmu = EmbeddedFMU(self.fmu_directory / fmu_filename)
+            if fmu.fmi_version > self.fmi_version:
+                logger.fatal(f"Try to embed FMU-{fmu.fmi_version} into container FMI-{self.fmi_version}")
             self.involved_fmu[fmu.name] = fmu
-            self.execution_order.append(fmu)
-            logger.debug(f"Adding FMU #{len(self.execution_order)}: {fmu}")
+
+            logger.debug(f"Adding FMU #{len(self.involved_fmu)}: {fmu}")
         except (FMUContainerError, FMUError) as e:
             raise FMUContainerError(f"Cannot load '{fmu_filename}': {e}")
 
@@ -299,7 +460,7 @@ class FMUContainer:
         self.rules[cport] = rule
 
     def get_all_cports(self):
-        return [ContainerPort(fmu, port_name) for fmu in self.execution_order for port_name in fmu.ports]
+        return [ContainerPort(fmu, port_name) for fmu in self.involved_fmu.values() for port_name in fmu.ports]
 
     def add_input(self, container_port_name: str, to_fmu_filename: str, to_port_name: str):
         if not container_port_name:
@@ -373,7 +534,7 @@ class FMUContainer:
 
         self.start_values[cport] = value
 
-    def find_inputs(self, port_to_connect: FMUPort) -> List[ContainerPort]:
+    def find_inputs(self, port_to_connect: EmbeddedFMUPort) -> List[ContainerPort]:
         candidates = []
         for cport in self.get_all_cports():
             if (cport.port.causality == 'input' and cport not in self.rules and cport.port.name == port_to_connect.name
@@ -432,7 +593,7 @@ class FMUContainer:
 
     def minimum_step_size(self) -> float:
         step_size = None
-        for fmu in self.execution_order:
+        for fmu in self.involved_fmu.values():
             if step_size:
                 if fmu.step_size and fmu.step_size < step_size:
                     step_size = fmu.step_size
@@ -446,7 +607,7 @@ class FMUContainer:
         return step_size
 
     def sanity_check(self, step_size: Optional[float]):
-        for fmu in self.execution_order:
+        for fmu in self.involved_fmu.values():
             if not fmu.step_size:
                 continue
             ts_ratio = step_size / fmu.step_size
@@ -494,7 +655,7 @@ class FMUContainer:
         guid = str(uuid.uuid4())
         embedded_fmu = ", ".join([fmu_name for fmu_name in self.involved_fmu])
         try:
-            author = os.getlogin()
+            author = getpass.getuser()
         except OSError:
             author = "Unspecified"
 
@@ -505,94 +666,91 @@ class FMUContainer:
                 if fmu.capabilities[capability] == "true":
                     capabilities[capability] = "true"
 
+        first_fmu = next(iter(self.involved_fmu.values()))
         if self.start_time is None:
-            self.start_time = self.execution_order[0].start_time
-            logger.info(f"start_time={self.start_time} (deduced from '{self.execution_order[0].name}')")
+            self.start_time = first_fmu.start_time
+            logger.info(f"start_time={self.start_time} (deduced from '{first_fmu.name}')")
         else:
             logger.info(f"start_time={self.start_time}")
 
         if self.stop_time is None:
-            self.stop_time = self.execution_order[0].stop_time
-            logger.info(f"stop_time={self.stop_time} (deduced from '{self.execution_order[0].name}')")
+            self.stop_time = first_fmu.stop_time
+            logger.info(f"stop_time={self.stop_time} (deduced from '{first_fmu.name}')")
         else:
             logger.info(f"stop_time={self.stop_time}")
 
-        xml_file.write(f"""<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="2.0"
-  modelName="{self.identifier}"
-  generationTool="FMUContainer-{tool_version}"
-  generationDateAndTime="{timestamp}"
-  guid="{guid}"
-  description="FMUContainer with {embedded_fmu}"
-  author="{author}"
-  license="Proprietary"
-  copyright="See Embedded FMU's copyrights."
-  variableNamingConvention="structured">
-
-  <CoSimulation
-    modelIdentifier="{self.identifier}"
-    canHandleVariableCommunicationStepSize="true"
-    canBeInstantiatedOnlyOncePerProcess="{capabilities['canBeInstantiatedOnlyOncePerProcess']}"
-    canNotUseMemoryManagementFunctions="true"
-    canGetAndSetFMUstate="false"
-    canSerializeFMUstate="false"
-    providesDirectionalDerivative="false"
-    needsExecutionTool="{capabilities['needsExecutionTool']}">
-  </CoSimulation>
-
-  <LogCategories>
-    <Category name="fmucontainer"/>
-  </LogCategories>
-
-  <DefaultExperiment stepSize="{step_size}" startTime="{self.start_time}" stopTime="{self.stop_time}"/>
-
-  <ModelVariables>
-""")
+        if self.fmi_version == 2:
+            xml_file.write(self.HEADER_XML_2.format(identifier=self.identifier, tool_version=tool_version,
+                                                    timestamp=timestamp, guid=guid, embedded_fmu=embedded_fmu,
+                                                    author=author,
+                                                    only_once=capabilities['canBeInstantiatedOnlyOncePerProcess'],
+                                                    execution_tool=capabilities['needsExecutionTool'],
+                                                    start_time=self.start_time, stop_time=self.stop_time,
+                                                    step_size=step_size))
+        elif self.fmi_version == 3:
+            xml_file.write(self.HEADER_XML_3.format(identifier=self.identifier, tool_version=tool_version,
+                                                    timestamp=timestamp, guid=guid, embedded_fmu=embedded_fmu,
+                                                    author=author,
+                                                    only_once=capabilities['canBeInstantiatedOnlyOncePerProcess'],
+                                                    execution_tool=capabilities['needsExecutionTool'],
+                                                    start_time=self.start_time, stop_time=self.stop_time,
+                                                    step_size=step_size))
+
+        vr_time = vr_table.add_vr("real64")
+        logger.debug(f"Time vr = {vr_time}")
         if profiling:
-            for fmu in self.execution_order:
-                vr = vr_table.add_vr("Real")
-                name = f"container.{fmu.id}.rt_ratio"
-                print(f'<ScalarVariable valueReference="{vr}" name="{name}" causality="local">'
-                      f'<Real /></ScalarVariable>', file=xml_file)
+            for fmu in self.involved_fmu.values():
+                vr = vr_table.add_vr("real64")
+                port = EmbeddedFMUPort("real64", {"valueReference": vr,
+                                        "name": f"container.{fmu.id}.rt_ratio",
+                                        "description": f"RT ratio for embedded FMU '{fmu.name}'"})
+                print(f"    {port.xml(vr, fmi_version=self.fmi_version)}", file=xml_file)
 
         # Local variable should be first to ensure to attribute them the lowest VR.
         for local in self.locals.values():
-            vr = vr_table.get_vr(local.cport_from)
-            print(f'    {local.cport_from.port.xml(vr, name=local.name, causality="local")}', file=xml_file)
+            vr = vr_table.add_vr(local.cport_from)
+            try:
+                print(f"    {local.cport_from.port.xml(vr, name=local.name, causality='local', fmi_version=self.fmi_version)}", file=xml_file)
+            except KeyError:
+                logger.error(f"Cannot expose '{local.name}' because type '{local.cport_from.port.type_name}' is not compatible with FMI-{self.fmi_version}.0")
             local.vr = vr
 
         for input_port_name, input_port in self.inputs.items():
             vr = vr_table.add_vr(input_port.type_name)
             # Get Start and XML from first connected input
             start = self.start_values.get(input_port.cport_list[0], None)
-            print(f"    {input_port.cport_list[0].port.xml(vr, name=input_port_name, start=start)}", file=xml_file)
+            print(f"    {input_port.cport_list[0].port.xml(vr, name=input_port_name, start=start, fmi_version=self.fmi_version)}", file=xml_file)
             input_port.vr = vr
 
         for output_port_name, cport in self.outputs.items():
-            vr = vr_table.get_vr(cport)
-            print(f"    {cport.port.xml(vr, name=output_port_name)}", file=xml_file)
+            vr = vr_table.add_vr(cport)
+            print(f"    {cport.port.xml(vr, name=output_port_name, fmi_version=self.fmi_version)}", file=xml_file)
             cport.vr = vr
 
-        xml_file.write("""  </ModelVariables>
-
-  <ModelStructure>
-    <Outputs>
-""")
+        if self.fmi_version == 2:
+            self.make_fmu_xml_epilog_2(xml_file)
+        elif self.fmi_version == 3:
+            self.make_fmu_xml_epilog_3(xml_file)
 
+    def make_fmu_xml_epilog_2(self, xml_file):
+        xml_file.write(f"  </ModelVariables>\n\n  <ModelStructure>\n    <Outputs>\n")
         index_offset = len(self.locals) + len(self.inputs) + 1
         for i, _ in enumerate(self.outputs.keys()):
             print(f'      <Unknown index="{index_offset+i}"/>', file=xml_file)
-        xml_file.write("""    </Outputs>
-    <InitialUnknowns>
-""")
+
+        xml_file.write("    </Outputs>\n    <InitialUnknowns>\n")
+
         for i, _ in enumerate(self.outputs.keys()):
             print(f'      <Unknown index="{index_offset+i}"/>', file=xml_file)
-        xml_file.write("""    </InitialUnknowns>
-  </ModelStructure>
 
-</fmiModelDescription>
-""")
+        xml_file.write("    </InitialUnknowns>\n  </ModelStructure>\n\n</fmiModelDescription>")
+
+    def make_fmu_xml_epilog_3(self, xml_file):
+        xml_file.write(f"  </ModelVariables>\n\n  <ModelStructure>\n")
+        for output in self.outputs.values():
+            print(f'      <Output valueReference="{output.vr}"/>', file=xml_file)
+
+        xml_file.write("  </ModelStructure>\n\n</fmiModelDescription>\n""")
 
     def make_fmu_txt(self, txt_file, step_size: float, mt: bool, profiling: bool, sequential: bool):
         print("# Container flags <MT> <Profiling> <Sequential>", file=txt_file)
@@ -604,15 +762,14 @@ class FMUContainer:
         print(f"# NB of embedded FMU's", file=txt_file)
         print(f"{len(self.involved_fmu)}", file=txt_file)
         fmu_rank: Dict[str, int] = {}
-        for i, fmu in enumerate(self.execution_order):
-            print(f"{fmu.name}", file=txt_file)
+        for i, fmu in enumerate(self.involved_fmu.values()):
+            print(f"{fmu.name} {fmu.fmi_version}", file=txt_file)
             print(f"{fmu.model_identifier}", file=txt_file)
             print(f"{fmu.guid}", file=txt_file)
             fmu_rank[fmu.name] = i
 
         # Prepare data structure
-        type_names_list = ("Real", "Integer", "Boolean", "String")  # Ordered list
-        inputs_per_type: Dict[str, List[ContainerInput]] = {}        # Container's INPUT
+        inputs_per_type: Dict[str, List[ContainerInput]] = {}       # Container's INPUT
         outputs_per_type: Dict[str, List[ContainerPort]] = {}       # Container's OUTPUT
 
         inputs_fmu_per_type: Dict[str, Dict[str, Dict[ContainerPort, int]]] = {}      # [type][fmu]
@@ -620,7 +777,7 @@ class FMUContainer:
         outputs_fmu_per_type = {}
         locals_per_type: Dict[str, List[Local]] = {}
 
-        for type_name in type_names_list:
+        for type_name in EmbeddedFMUPort.ALL_TYPES:
             inputs_per_type[type_name] = []
             outputs_per_type[type_name] = []
             locals_per_type[type_name] = []
@@ -629,7 +786,7 @@ class FMUContainer:
             start_values_fmu_per_type[type_name] = {}
             outputs_fmu_per_type[type_name] = {}
 
-            for fmu in self.execution_order:
+            for fmu in self.involved_fmu.values():
                 inputs_fmu_per_type[type_name][fmu.name] = {}
                 start_values_fmu_per_type[type_name][fmu.name] = {}
                 outputs_fmu_per_type[type_name][fmu.name] = {}
@@ -651,27 +808,35 @@ class FMUContainer:
             for cport_to in local.cport_to_list:
                 inputs_fmu_per_type[cport_to.port.type_name][cport_to.fmu.name][cport_to] = vr
 
-        print(f"# NB local variables Real, Integer, Boolean, String", file=txt_file)
-        for type_name in type_names_list:
+        print(f"# NB local variables:", ", ".join(EmbeddedFMUPort.ALL_TYPES), file=txt_file)
+        nb_local = []
+        for type_name in EmbeddedFMUPort.ALL_TYPES:
             nb = len(locals_per_type[type_name])
-            if profiling and type_name == "Real":
-                nb += len(self.execution_order)
-            print(f"{nb} ", file=txt_file, end='')
+            if type_name == "real64":
+                nb += 1  # reserver a slot for "time"
+                if profiling:
+                    nb += len(self.involved_fmu)
+            nb_local.append(str(nb))
+        print(" ".join(nb_local), file=txt_file, end='')
         print("", file=txt_file)
 
         print("# CONTAINER I/O: <VR> <NB> <FMU_INDEX> <FMU_VR> [<FMU_INDEX> <FMU_VR>]", file=txt_file)
-        for type_name in type_names_list:
+        for type_name in EmbeddedFMUPort.ALL_TYPES:
             print(f"# {type_name}", file=txt_file)
             nb = len(inputs_per_type[type_name]) + len(outputs_per_type[type_name]) + len(locals_per_type[type_name])
             nb_input_link = 0
             for input_port in inputs_per_type[type_name]:
                 nb_input_link += len(input_port.cport_list) - 1
 
-            if profiling and type_name == "Real":
-                nb += len(self.execution_order)
-                print(f"{nb} {nb+nb_input_link}", file=txt_file)
-                for profiling_port, _ in enumerate(self.execution_order):
-                    print(f"{profiling_port} 1 -2 {profiling_port}", file=txt_file)
+            if type_name == "real64":
+                nb += 1  # reserver a slot for "time"
+                if profiling:
+                    nb += len(self.involved_fmu)
+                print(f"{nb} {nb + nb_input_link}", file=txt_file)
+                print(f"0 1 -1 0", file=txt_file)  # Time slot
+                if profiling:
+                    for profiling_port, _ in enumerate(self.involved_fmu.values()):
+                        print(f"{profiling_port+1} 1 -2 {profiling_port+1}", file=txt_file)
             else:
                 print(f"{nb} {nb+nb_input_link}", file=txt_file)
             for input_port in inputs_per_type[type_name]:
@@ -680,24 +845,24 @@ class FMUContainer:
             for cport in outputs_per_type[type_name]:
                 print(f"{cport.vr} 1 {fmu_rank[cport.fmu.name]} {cport.port.vr}", file=txt_file)
             for local in locals_per_type[type_name]:
-                print(f"{local.vr} 1 -1 {local.vr}", file=txt_file)
+                print(f"{local.vr} 1 -1 {local.vr & 0xFFFFFF}", file=txt_file)
 
         # LINKS
-        for fmu in self.execution_order:
-            for type_name in type_names_list:
+        for fmu in self.involved_fmu.values():
+            for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Inputs of {fmu.name} - {type_name}: <VR> <FMU_VR>", file=txt_file)
                 print(len(inputs_fmu_per_type[type_name][fmu.name]), file=txt_file)
                 for cport, vr in inputs_fmu_per_type[type_name][fmu.name].items():
                     print(f"{vr} {cport.port.vr}", file=txt_file)
 
-            for type_name in type_names_list:
+            for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Start values of {fmu.name} - {type_name}: <FMU_VR> <RESET> <VALUE>", file=txt_file)
                 print(len(start_values_fmu_per_type[type_name][fmu.name]), file=txt_file)
                 for cport, value in start_values_fmu_per_type[type_name][fmu.name].items():
                     reset = 1 if cport.port.causality == "input" else 0
                     print(f"{cport.port.vr} {reset} {value}", file=txt_file)
 
-            for type_name in type_names_list:
+            for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Outputs of {fmu.name} - {type_name}: <VR> <FMU_VR>", file=txt_file)
                 print(len(outputs_fmu_per_type[type_name][fmu.name]), file=txt_file)
                 for cport, vr in outputs_fmu_per_type[type_name][fmu.name].items():
@@ -711,6 +876,39 @@ class FMUContainer:
         else:
             return path
 
+    @staticmethod
+    def copyfile(origin, destination):
+        logger.debug(f"Copying {origin} in {destination}")
+        shutil.copy(origin, destination)
+
+    def get_bindir_and_suffixe(self) -> (str, str, str):
+        suffixes = {
+            "Windows": "dll",
+            "Linux": "so",
+            "Darwin": "dylib"
+        }
+
+        origin_bindirs = {
+            "Windows": "win64",
+            "Linux": "linux64",
+            "Darwin": "darwin64"
+        }
+
+        if self.fmi_version == 3:
+            target_bindirs = {
+                "Windows": "x86_64-windows",
+                "Linux": "x86_64-linux",
+                "Darwin": "aarch64-darwin"
+            }
+        else:
+            target_bindirs = origin_bindirs
+
+        os_name = platform.system()
+        try:
+            return origin_bindirs[os_name], suffixes[os_name], target_bindirs[os_name]
+        except KeyError:
+            raise FMUContainerError(f"OS '{os_name}' is not supported.")
+
     def make_fmu_skeleton(self, base_directory: Path) -> Path:
         logger.debug(f"Initialize directory '{base_directory}'")
 
@@ -725,20 +923,23 @@ class FMUContainer:
         documentation_directory.mkdir(exist_ok=True)
 
         if self.description_pathname:
-            logger.debug(f"Copying {self.description_pathname}")
-            shutil.copy(self.description_pathname, documentation_directory)
+            self.copyfile(self.description_pathname, documentation_directory)
+
+        self.copyfile(origin / "model.png", base_directory)
 
-        shutil.copy(origin / "model.png", base_directory)
-        for bitness in ('win32', 'win64'):
-            library_filename = origin / bitness / "container.dll"
-            if library_filename.is_file():
-                binary_directory = binaries_directory / bitness
-                binary_directory.mkdir(exist_ok=True)
-                shutil.copy(library_filename, binary_directory / f"{self.identifier}.dll")
+        origin_bindir, suffixe, target_bindir = self.get_bindir_and_suffixe()
+
+        library_filename = origin / origin_bindir / f"container.{suffixe}"
+        if not library_filename.is_file():
+            raise FMUContainerError(f"File {library_filename} not found")
+        binary_directory = binaries_directory / target_bindir
+        binary_directory.mkdir(exist_ok=True)
+        self.copyfile(library_filename, binary_directory / f"{self.identifier}.{suffixe}")
 
         for i, fmu in enumerate(self.involved_fmu.values()):
             shutil.copytree(self.long_path(fmu.fmu.tmp_directory),
                             self.long_path(resources_directory / f"{i:02x}"), dirs_exist_ok=True)
+
         return resources_directory
 
     def make_fmu_package(self, base_directory: Path, fmu_filename: Path):