flexCommunicator 0.1.0__py3-none-any.whl

flexCommunicator/clientLibraries/flcpy/fmi/fmuNode.py

@@ -0,0 +1,166 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+from flexCommunicator.clientLibraries.flcpy.fmi.node import *
+
+
+class FMUNode(Node):
+    def __init__(self, name='tbd', description='tbd',stepsize=0.05, inports=None, outports=None, fmuPath=None, verbose=False):
+        super().__init__(name=name, description=description, inports=inports, outports=outports,stepSize=stepsize, verbose=verbose)
+        """Initialize a FMU node component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the node components
+
+                description : string
+                    description of the node components
+
+                inports : list
+                    inport list of the node components
+
+                outports : list
+                    inport list of the node components
+
+                fmuPath : string
+                    path to the FMU
+
+
+                verbose : bool
+                    component verbose execution
+
+        See Also
+        --------
+        ..
+
+        Examples
+        --------
+        >> node = FMUNode(name="DUMMY_NODE_1", description='tbd', inports=[IN1_1], outports=[OUT1_1],fmuPath = "path/to/fmu", verbose=False)
+
+        """
+        self._inputList=[]
+        self._outputList = []
+        self._parameterList = []
+        # -- Functional mock-up unit (FMU) --
+        if fmuPath != None:
+            self._instantiateFMU(fmuPath)
+            x=1
+            # self._exposeFMUIO()
+        else:
+            self.model_description = None
+            self._fmu = None
+
+    @property
+    def FMU(self):
+        """The name property (read-only)."""
+        return self._fmu
+
+    # ------------------------------------------------------------------------------------------------------------------
+    # -------------------------------------------FMI INTEGRATION functions----------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
+    def get_port_update(self,port):
+        try:
+            port.value = self._fmu.getReal([port.valueReference])[0]
+            return port
+        except:
+            return False
+
+
+
+    # ------------------------------------------------------------------------------------------------------------------
+    # --------------------------------------------FMU functions---------------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
+    def _instantiateFMU(self, path, startTime=0.0):
+        try:
+            from fmpy import read_model_description, extract
+            from fmpy.fmi2 import FMU2Slave
+            self.model_description = read_model_description(path)
+            # instantiate FMU
+            unzipdir = extract(path)
+            fmu = FMU2Slave(guid=self.model_description.guid, unzipDirectory=unzipdir,
+                            modelIdentifier=self.model_description.coSimulation.modelIdentifier)
+            fmu.instantiate()
+            fmu.setupExperiment(startTime=startTime)
+            fmu.enterInitializationMode()
+            fmu.exitInitializationMode()
+            self._fmu = fmu
+            #determine the interface variables
+            for variable in self.model_description.modelVariables:
+                if variable.causality == 'input':
+                    self._inputList.append([variable.name,variable.valueReference,variable.type,variable.start])
+                    for input in self.inports:
+                        if input.name == variable.name:
+                            input.valueReference = variable.valueReference
+                elif variable.causality == 'output':
+                    self._outputList.append([variable.name,variable.valueReference,variable.type,variable.start])
+                    for output in self.outports:
+                        if output.name == variable.name:
+                            output.valueReference = variable.valueReference
+                elif variable.causality == 'parameter':
+                    self._parameterList.append([variable.name,variable.valueReference,variable.type,variable.start])
+                    #TODO: add the parameter components to be set!
+
+        except:
+            if self._verbose: print("FMU instantiation failed - No valid FMU found on path")
+            self._fmu = None
+
+    def getOutput(self, port):
+        if self._verbose:print("GetReal function - " + port.name)
+        port.value = self._fmu.getReal([port.valueReference])[0]
+
+    def setInput(self, port, value):
+        if self._verbose:print("SetReal function - " + port.name)
+        self._fmu.setReal([port.valueReference], [value])
+
+    def doStep(self, executionPattern=ExecutionPatterns.TRIGGERED):
+        if self._verbose:print("DoStep function - " + self.name)
+        self._fmu.doStep(currentCommunicationPoint=self._simTime, communicationStepSize=self._stepSize)
+        self._updateSimTime()
+
+
+    def info(self):
+        _info = self._compose_fmi_info()
+        return _info
+
+    def getInputs(self):
+        return self._inputList
+
+    def getOutputs(self):
+        return self._outputList
+
+    def getParameters(self):
+        return self._parameterList
+
+    def _compose_fmi_info(self):
+        # Collect general FMI info
+        _fmi_info = {
+            "model_Info": {
+                "FMI Version": self.model_description.fmiVersion,
+                "Model Name": self.model_description.coSimulation.modelIdentifier,
+                "Description": str(self.model_description.description),
+                "Continuous_States": str(self.model_description.numberOfContinuousStates),
+                "Event_Indicators": str(self.model_description.numberOfEventIndicators),
+                "Variables": str(len(self.model_description.modelVariables)),
+                "Generation Tool": self.model_description.generationTool,
+                "Generation Date": self.model_description.generationDateAndTime
+            },
+            "Variables": []
+        }
+
+        # Collect variables (only input/output)
+        for variable in self.model_description.modelVariables:
+            if variable.causality in ["output", "input"]:
+                _fmi_info["Variables"].append({
+                    "Name": variable.name,
+                    "Causality": variable.causality,
+                    "StartValue": str(variable.start) if variable.start is not None else "-",
+                    "Unit": variable.unit if variable.unit is not None else "-",
+                    "Description": variable.description if variable.description is not None else "-"
+                })
+        return _fmi_info

flexCommunicator/clientLibraries/flcpy/fmi/node.py

@@ -0,0 +1,360 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+from flexCommunicator.clientLibraries.flcpy.utils.constants import *
+class Node(object):
+
+    def __init__(self, name='tbd',description='tbd',stepSize=0.05,inports=None,outports=None,doStepFunction = None,inputUpdateFunction = None,outputUpdateFunction = None,verbose=False):
+        """Initialize a generic node component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the node components
+
+                description : string
+                    description of the node components
+
+                stepSize : double
+                    stepsize of the node component
+
+                inports : list
+                    inport list of the node components
+
+                outports : list
+                    inport list of the node components
+
+                doStepFunction : function
+                    doStepFuntion to overload standard function
+
+                inputUpdateFunction : function
+                    inputUpdateFunction to overload standard function
+
+                outputUpdateFunction : function
+                    outputUpdateFunction to overload standard function
+
+                verbose : bool
+                    component verbose execution
+
+        See Also
+        --------
+        ..
+
+        Examples
+        --------
+        >> node = Node(name="DUMMY_NODE_1", description='tbd', inports=[IN1_1], outports=[OUT1_1], verbose=False)
+
+        """
+
+        self._name = name
+        self._description = description
+        if inports!=None:
+            self._inports=inports
+        else:
+            self._inports=[]
+        if outports != None:
+            self._outports = outports
+        else:
+            self._outports = []
+        self._verbose = verbose
+
+
+        #internal relations
+        self._internalRelations=[]
+
+        # -- function overloading --
+        if doStepFunction != None:
+            self._doStep = doStepFunction
+        if inputUpdateFunction != None:
+            self._inputUpdate = inputUpdateFunction
+        if outputUpdateFunction != None:
+            self._outputUpdate = outputUpdateFunction
+
+        # -- simulation node initialization
+        self._simTime = self._setSimTime(simConstants.startTime_Default)
+        self._stepSize = stepSize
+
+    @property
+    def name(self):
+        """The name property (read-only)."""
+        return self._name
+
+    @property
+    def description(self):
+        """The description property (read-only)."""
+        return self._description
+
+    @property
+    def inports(self):
+        """The inports list property (read)."""
+        return self._inports
+
+    @property
+    def outports(self):
+        """The outports list property (read)."""
+        return self._outports
+
+    @property
+    def internalRelations(self):
+        """The internal relations list property (read)."""
+        return self._internalRelations
+
+    @property
+    def simTime(self):
+        """The simtime property (read)."""
+        return self._simTime
+
+    def add_Port(self,port_for_adding):
+        """Add a single port `port_for_adding`
+
+                        Parameters
+                        ----------
+                        relation_for_adding : Port
+                            port node to be added
+
+
+                        See Also
+                        --------
+                        ..
+
+                        Examples
+                        --------
+                        >> todo:add example
+
+                        """
+        if port_for_adding not in self._inports and port_for_adding not in self._outports:
+            if port_for_adding is None:
+                raise ValueError("Port cannot be added")
+            else:
+                if type(port_for_adding)=='Inport':
+                    self._inports.append(port_for_adding)
+                elif type(port_for_adding)=='Outport':
+                    self._outports.append(port_for_adding)
+                else:
+                    raise ValueError("Port cannot be added")
+
+    def add_Relation(self,relation_for_adding):
+        """Add a single relation `relation_for_adding`
+
+                        Parameters
+                        ----------
+                        relation_for_adding : Relation
+                            Relation node to be added
+
+
+                        See Also
+                        --------
+                        ..
+
+                        Examples
+                        --------
+                        >> todo:add example
+
+                        """
+        if relation_for_adding not in self._internalRelations:
+            if relation_for_adding is None:
+                raise ValueError("Internal relation cannot be added")
+            else:
+                self._internalRelations.append(relation_for_adding)
+
+
+    # ------------------------------------------------------------------------------------------------------------------
+    # ---------------------------------------LOCAL INTERFACE functions--------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
+    def inputUpdate(self):
+        if self._verbose:print("Input update for node: "+self.name)
+        # external function execution
+        self._inputUpdate()
+
+    def outputUpdate(self):
+        if self._verbose:print("Output update for node: "+self.name)
+        # external function execution
+        self._outputUpdate()
+
+
+
+    def doStep(self, executionPattern=ExecutionPatterns.TRIGGERED):
+        if executionPattern == ExecutionPatterns.TRIGGERED:
+            if self._verbose:print("doStep for node: "+self.name)
+            # external function execution
+            self._doStep()
+        elif executionPattern == ExecutionPatterns.IPO:
+            # (I)input
+            self.inputUpdate()
+            # (P)processing
+            if self._verbose:print("doStep for node: "+self.name)
+            # external function execution
+            self._doStep()
+            # (O)output
+            self.outputUpdate()
+        # update simulation time after execution
+        self._updateSimTime()
+
+    def _updateSimTime(self):
+        self._simTime += float(self._stepSize)
+
+    def _setSimTime(self, simTime):
+        self._simTime = simTime
+        return simTime
+
+    # ------------------------------------------------------------------------------------------------------------------
+    # -----------------------------------------EXECUTION functions------------------------------------------------------
+    # ------------------------------------------------------------------------------------------------------------------
+    def _inputUpdate(self):
+        if self._verbose: print("No user-defined function call provided for inputUpdate()")
+
+
+    def _outputUpdate(self):
+        if self._verbose: print("No user-defined function call provided for outputUpdate() - IN1 -> OUT1 for testing purposes")
+        #  --- DUMMY BEHAVIOR FOR TESTING PURPOSE ---
+        self.outports[0].value = self.inports[0].value
+
+    def _doStep(self):
+        if self._verbose: print("No user-defined function call provided for doStep(), node behavior missing.")
+
+class Port(object):
+
+    def __init__(self, name='tbd',description='tbd',initialValue = 1.0,valueReference=1,verbose=False):
+        """Initialize a port component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the port components
+
+                description : string
+                    description of the port components
+
+                valueReference : int
+                    valueReference of the port components (FMU-specific)
+
+                initialValue : string
+                    initialValue of the port components
+
+
+                verbose : bool
+                    component verbose execution
+
+        See Also
+        --------
+        ..
+
+        Examples
+        --------
+        >> port = Port(name="P1",description="description for P1",verbose=False)
+
+        """
+
+        self._name = name
+        self._description = description
+        self._value = initialValue
+        self._valueReference = valueReference
+        self._verbose = verbose
+
+
+
+    @property
+    def name(self):
+        """The name property (read-only)."""
+        return self._name
+
+    @property
+    def description(self):
+        """The description property (read-only)."""
+        return self._description
+
+    @property
+    def value(self):
+        """The value property (read)."""
+        return self._value
+
+    @value.setter
+    def value(self,value):
+        """The value property (write)."""
+        self._value = value
+
+    @property
+    def valueReference(self):
+        """The valueReference property (read)."""
+        return self._valueReference
+
+    @valueReference.setter
+    def valueReference(self, value):
+        """The valueReference property (write)."""
+        self._valueReference = value
+
+class Inport(Port):
+
+    def __init__(self, name='tbd',description='tbd',reactive=False,verbose=False):
+        super().__init__(name=name, description=description, verbose=verbose)
+        """Initialize a port component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the port components
+
+                description : string
+                    description of the port components
+
+                reactive : bool
+                    reactive property of the inport
+
+                verbose : bool
+                    component verbose execution
+
+        See Also
+        --------
+        ..
+
+        Examples
+        --------
+        >> port = Inport(name="P1",description="description for P1",reactive=False,verbose=False)
+
+        """
+
+        self._name = name
+        self._description = description
+        self._reactive=reactive
+        self._verbose = verbose
+
+    @property
+    def reactive(self):
+        """The reactive property (read-only)."""
+        return self._reactive
+
+class Outport(Port):
+
+    def __init__(self, name='tbd', description='tbd', verbose=False):
+        super().__init__(name=name, description=description, verbose=verbose)
+        """Initialize a port component.
+
+                Parameters
+                ----------
+                name : string
+                    name of the port components
+
+                description : string
+                    description of the port components
+
+                verbose : bool
+                    component verbose execution
+
+        See Also
+        --------
+        ..
+
+        Examples
+        --------
+        >> port = Outport(name="P1",description="description for P1",verbose=False)
+
+        """
+
+        self._name = name
+        self._description = description
+        self._verbose = verbose