fmu-manipulation-toolbox 1.8__py3-none-any.whl → 1.8.2__py3-none-any.whl

fmu_manipulation_toolbox/fmu_container.py

@@ -74,9 +74,12 @@ class EmbeddedFMU(OperationAbstract):
     def __init__(self, filename):
         self.fmu = FMU(filename)
         self.name = Path(filename).name
+        self.id = Path(filename).stem
 
         self.fmi_version = None
         self.step_size = None
+        self.start_time = None
+        self.stop_time = None
         self.model_identifier = None
         self.guid = None
         self.ports: Dict[str, FMUPort] = {}
@@ -103,15 +106,18 @@ class EmbeddedFMU(OperationAbstract):
         for capability in self.capability_list:
             self.capabilities[capability] = attrs.get(capability, "false")
 
-    def experiment_attrs(self, attrs):
+    def experiment_attrs(self, attrs: Dict[str, str]):
         try:
             self.step_size = float(attrs['stepSize'])
         except KeyError:
             logger.warning(f"FMU '{self.name}' does not specify preferred step size")
-            pass
+        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
 
@@ -148,7 +154,7 @@ class ContainerPort:
 
 class Local:
     def __init__(self, cport_from: ContainerPort):
-        self.name = cport_from.fmu.name[:-4] + "." + cport_from.port.name  # strip .fmu suffix
+        self.name = cport_from.fmu.id + "." + cport_from.port.name  # strip .fmu suffix
         self.cport_from = cport_from
         self.cport_to_list: List[ContainerPort] = []
         self.vr = None
@@ -195,6 +201,9 @@ class FMUContainer:
 
         self.description_pathname = description_pathname
 
+        self.start_time = None
+        self.stop_time = None
+
         # Rules
         self.inputs: Dict[str, ContainerPort] = {}
         self.outputs: Dict[str, ContainerPort] = {}
@@ -291,7 +300,7 @@ class FMUContainer:
 
         self.start_values[cport] = value
 
-    def find_input(self, port_to_connect: FMUPort) -> Union[ContainerPort, None]:
+    def find_input(self, port_to_connect: FMUPort) -> Optional[ContainerPort]:
         for fmu in self.execution_order:
             for port in fmu.ports.values():
                 if (port.causality == 'input' and port.name == port_to_connect.name
@@ -299,13 +308,19 @@ class FMUContainer:
                     return ContainerPort(fmu, port.name)
         return None
 
-    def add_implicit_rule(self, auto_input: bool = True, auto_output: bool = True, auto_link: bool = True):
+    def add_implicit_rule(self, auto_input=True, auto_output=True, auto_link=True, auto_parameter=False,
+                          auto_local=False):
         # Auto Link outputs
         for fmu in self.execution_order:
             for port_name in fmu.ports:
                 cport = ContainerPort(fmu, port_name)
                 if cport not in self.rules:
-                    if cport.port.causality == 'output':
+                    if cport.port.causality == 'parameter' and auto_parameter:
+                        parameter_name = cport.fmu.model_identifier+"."+cport.port.name
+                        logger.info(f"AUTO PARAMETER: {cport} as {parameter_name}")
+                        self.inputs[parameter_name] = cport
+                        self.mark_ruled(cport, 'PARAMETER')
+                    elif cport.port.causality == 'output':
                         candidate_cport = self.find_input(cport.port)
                         if auto_link and candidate_cport:
                             local = Local(cport)
@@ -314,11 +329,21 @@ class FMUContainer:
                             self.mark_ruled(cport, 'LINK')
                             self.mark_ruled(candidate_cport, 'LINK')
                             self.locals[cport] = local
-                        else:
-                            if auto_output:
-                                self.mark_ruled(cport, 'OUTPUT')
-                                self.outputs[port_name] = cport
-                                logger.info(f"AUTO OUTPUT: Expose {cport}")
+                        elif auto_output:
+                            self.mark_ruled(cport, 'OUTPUT')
+                            self.outputs[port_name] = cport
+                            logger.info(f"AUTO OUTPUT: Expose {cport}")
+                    elif cport.port.causality == 'local':
+                        local_portname = None
+                        if port_name.startswith("container."):
+                            local_portname = "container." + cport.fmu.id + "." + port_name[10:]
+                            logger.info(f"PROFILING: Expose {cport}")
+                        elif auto_local:
+                            local_portname = cport.fmu.id + "." + port_name
+                            logger.info(f"AUTO LOCAL: Expose {cport}")
+                        if local_portname:
+                            self.mark_ruled(cport, 'OUTPUT')
+                            self.outputs[local_portname] = cport
 
         if auto_input:
             # Auto link inputs
@@ -346,31 +371,26 @@ class FMUContainer:
 
         return step_size
 
-    def sanity_check(self, step_size: Union[float, None]):
-        nb_error = 0
+    def sanity_check(self, step_size: Optional[float]):
         for fmu in self.execution_order:
             if not fmu.step_size:
                 continue
             ts_ratio = step_size / fmu.step_size
             if ts_ratio < 1.0:
-                logger.error(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
-                             f"step_size={fmu.step_size}s")
+                logger.warning(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
+                               f"step_size={fmu.step_size}s.")
             if ts_ratio != int(ts_ratio):
-                logger.error(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
-                             f"step_size={fmu.step_size}s")
+                logger.warning(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
+                               f"step_size={fmu.step_size}s.")
             for port_name in fmu.ports:
                 cport = ContainerPort(fmu, port_name)
                 if cport not in self.rules:
                     if cport.port.causality == 'input':
                         logger.error(f"{cport} is not connected")
-                        nb_error += 1
                     if cport.port.causality == 'output':
                         logger.warning(f"{cport} is not connected")
 
-        if nb_error:
-            raise FMUContainerError(f"Some ports are not connected.")
-
-    def make_fmu(self, fmu_filename: Union[str, Path], step_size: Union[float, None] = None, debug=False, mt=False,
+    def make_fmu(self, fmu_filename: Union[str, Path], step_size: Optional[float] = None, debug=False, mt=False,
                  profiling=False):
         if isinstance(fmu_filename, str):
             fmu_filename = Path(fmu_filename)
@@ -411,6 +431,18 @@ class FMUContainer:
                 if fmu.capabilities[capability] == "true":
                     capabilities[capability] = "true"
 
+        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}')")
+        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}')")
+        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"
@@ -439,14 +471,14 @@ class FMUContainer:
     <Category name="fmucontainer"/>
   </LogCategories>
 
-  <DefaultExperiment stepSize="{step_size}"/>
+  <DefaultExperiment stepSize="{step_size}" startTime="{self.start_time}" stopTime="{self.stop_time}"/>
 
   <ModelVariables>
 """)
         if profiling:
             for fmu in self.execution_order:
                 vr = vr_table.add_vr("Real")
-                name = f"container.{fmu.model_identifier}.rt_ratio"
+                name = f"container.{fmu.id}.rt_ratio"
                 print(f'<ScalarVariable valueReference="{vr}" name="{name}" causality="local">'
                       f'<Real /></ScalarVariable>', file=xml_file)
 
@@ -596,6 +628,14 @@ class FMUContainer:
                 for cport, vr in outputs_fmu_per_type[type_name][fmu.name].items():
                     print(f"{vr} {cport.port.vr}", file=txt_file)
 
+    @staticmethod
+    def long_path(path: Union[str, Path]) -> str:
+        # https://stackoverflow.com/questions/14075465/copy-a-file-with-a-too-long-path-to-another-directory-in-python
+        if os.name == 'nt':
+            return "\\\\?\\" + os.path.abspath(str(path))
+        else:
+            return path
+
     def make_fmu_skeleton(self, base_directory: Path) -> Path:
         logger.debug(f"Initialize directory '{base_directory}'")
 
@@ -622,8 +662,8 @@ class FMUContainer:
                 shutil.copy(library_filename, binary_directory / f"{self.identifier}.dll")
 
         for fmu in self.involved_fmu.values():
-            shutil.copytree(fmu.fmu.tmp_directory, resources_directory / fmu.name, dirs_exist_ok=True)
-
+            shutil.copytree(self.long_path(fmu.fmu.tmp_directory),
+                            self.long_path(resources_directory / fmu.name), dirs_exist_ok=True)
         return resources_directory
 
     def make_fmu_package(self, base_directory: Path, fmu_filename: Path):
@@ -631,11 +671,10 @@ class FMUContainer:
         with zipfile.ZipFile(self.fmu_directory / fmu_filename, "w", zipfile.ZIP_DEFLATED) as zip_file:
             for root, dirs, files in os.walk(base_directory):
                 for file in files:
-                    zip_file.write(os.path.join(root, file),
+                    zip_file.write(self.long_path(os.path.join(root, file)),
                                    os.path.relpath(os.path.join(root, file), base_directory))
         logger.info(f"'{fmu_filename}' is available.")
 
-    @staticmethod
-    def make_fmu_cleanup(base_directory: Path):
+    def make_fmu_cleanup(self, base_directory: Path):
         logger.debug(f"Delete directory '{base_directory}'")
-        shutil.rmtree(base_directory)
+        shutil.rmtree(self.long_path(base_directory))

fmu_manipulation_toolbox/fmu_operations.py

@@ -89,9 +89,8 @@ class Manipulation:
                         self.remove_port(attrs['name'])
                     else:
                         self.keep_port(attrs['name'])
-                else:
+                else:  # Keep ScalarVariable as it is.
                     self.keep_port(attrs['name'])
-                    self.skip_until = name   # do not read inner tags
             elif name == 'CoSimulation':
                 self.operation.cosimulation_attrs(attrs)
             elif name == 'DefaultExperiment':
@@ -100,7 +99,7 @@ class Manipulation:
                 self.operation.fmi_attrs(attrs)
             elif name == 'Unknown':
                 self.unknown_attrs(attrs)
-            elif name in ('Real', 'Integer', 'String', 'Boolean'):
+            elif name in ('Real', 'Integer', 'String', 'Boolean', 'Enumeration'):
                 self.operation.scalar_type(name, attrs)
 
         except ManipulationSkipTag: