def run(self): global omc del(omc) omc = OMCSession() omc.sendExpression("setModelicaPath(\""+omhome+"/lib/omlibrary\")") omc.sendExpression('cd("tmp")') return []
def __init__(self, rootPath): ''' Constructor starts omc and loads MSL ''' self.rootPath = rootPath self.omc = OMCSession() os.chdir(self.rootPath) self.omc.sendExpression("loadModel(Modelica)")
def __init__(self, modelName, modelFileName, config): SimulatorBase.Model.__init__(self, modelName, modelFileName, config) self.modelType = 'Modelica model in OpenModelica' self._omc = OMCSession() self.onlyResultFile = False self.integrationSettings.resultFileExtension = 'mat' self._availableIntegrationAlgorithms = ['Dassl', 'Euler', 'Rungekutta', 'Dopri5'] self.integrationSettings.algorithmName = self._availableIntegrationAlgorithms[0] self._IntegrationAlgorithmHasFixedStepSize = [False, True, True, False] self._IntegrationAlgorithmCanProvideStepSizeResults = [False, True, True, False] self.compileModel() if self.resFile != '""': self._initialResult = loadResultFileInit(os.path.join(os.getcwd(), self.name + "_init.xml")) else: print "The selected model could not be instantiated, check for any dependencies that the model might have" return # SocketServer setup to visualize the simulation progress bar HOST, PORT = "localhost", 0 self.server = SocketServer.TCPServer((HOST, PORT), ThreadedTCPRequestHandler) self.ip, self.port = self.server.server_address self.server_port = self.port self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.daemon = True self.server_thread.setDaemon(True) self.server_thread.start()
def __init__(self, parent= None, configResources= None, configSimulation= None): QtGui.QDialog.__init__(self, parent) self.setupUi(self) self.__simsource= configResources self.__simconfig= configSimulation self.load_configuration() self.btnModelBrowser.clicked.connect(self.browse_models) self.btnLibraryBrowser.clicked.connect(self.browse_libraries) self.cbxModelList.activated['QString'].connect(self.set_models) self.progressBar.setRange(0,1) # self.btnRunSimulation.setIcon(QIcon('./res/img/Play.ico')) self.btnRunSimulation.setIconSize(QSize(48,48)) self.btnRunSimulation.clicked.connect(self.onStartSimulation) self.btnPlot.setIcon(QIcon('./res/img/Presentation.ico')) self.btnPlot.setIconSize(QSize(48,48)) self.btnPlot.clicked.connect(self.browse_simulation) #debug self.__omcSession= OMCSession() if self.__simconfig.compiler== 'dymola': self.__simulationTask = TaskThreadDY(self, self.__simsource, self.__simconfig, self.__results) elif self.__simconfig.compiler== 'jmodelica': pass elif self.__simconfig.compiler== 'openmodelica': self.__simulationTask = TaskThreadOMC(self, self.__simsource, self.__simconfig, self.__omcSession, self.__results) self.__simulationTask.taskFinished.connect(self.onFinishSimulation)
def __init__(self, sources= None, experiment= None, results= None): ''' Loading simulations resources. Parameters related to models to be simulated and libraries''' self.__sources= sources ''' Loading configuration values for the simulator solver ''' self.__experiment= experiment self.__results= results self.__omcSession= OMCSession()
def __init__(self, modelName, modelFileName, config): Plugins.Simulator.SimulatorBase.Model.__init__(self, modelName, modelFileName, 'OpenModelica', config) self._omc = OMCSession() self.onlyResultFile = False self.integrationSettings.resultFileExtension = 'mat' self._availableIntegrationAlgorithms = [ 'Dassl', 'Euler', 'Rungekutta', 'Dopri5' ] self.integrationSettings.algorithmName = self._availableIntegrationAlgorithms[ 0] self._IntegrationAlgorithmHasFixedStepSize = [False, True, True, False] self._IntegrationAlgorithmCanProvideStepSizeResults = [ False, True, True, False ] self.compileModel() if self.resFile != '""': self._initialResult = loadResultFileInit( os.path.join(os.getcwd(), self.name + "_init.xml")) else: print "The selected model could not be instantiated, check for any dependencies that the model might have" return # SocketServer setup to visualize the simulation progress bar HOST, PORT = "localhost", 0 self.server = SocketServer.TCPServer((HOST, PORT), ThreadedTCPRequestHandler) self.ip, self.port = self.server.server_address self.server_port = self.port self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.daemon = True self.server_thread.setDaemon(True) self.server_thread.start()
def Select_Model(self): OMPython = OMCSession() command= CommandOMC() OMPython.execute(command.loadModelica()) OMPython.execute(command.loadFile(self.mfile)) #print self.mfile #print command.set_ModelName(self.mfile) self._MN=OMPython.execute(command.getClassNames(self.mfile)) self.filetouse=self.mfile.replace('.mo', '.') print self._MN['SET1']['Set1'] fle= open('dict1.properties','w') for x in range(len(self._MN['SET1']['Set1'])): self.lis.append(self.filetouse+self._MN['SET1']['Set1'][x]) fle.writelines(str(self.filetouse+self._MN['SET1']['Set1'][x]+'\n')) #_______________________________________________________ # self.tt=command.set_ModelName(self.mfile)+'.'+self._MN['SET1']['Set1'][0] # #print self.tt # self.success=OMPython.execute(command.getClassNames(self.tt)) # self.success['SET2']['Set1'] # fle= open('dict1.properties','w') # for x in range(len(self.success['SET1']['Set1'])): # for y in range(len(self.success['SET2']['Set1'])): # self.lis.append(self.mfile+self.success['SET1']['Set1'][x]+'.'+self.success['SET2']['Set1'][y]) # fle.writelines(str(self.mfile+self.success['SET1']['Set1'][x]+'.'+self.success['SET2']['Set1'][y]+'\n')) #____________________________________________________ self.comboBox_5.clear() self.comboBox_5.addItems(self.lis) #print self.lis """
def run(self): global omc del (omc) omc = OMCSession() omc.sendExpression("setModelicaPath(\"" + omhome + "/lib/omlibrary\")") omc.sendExpression('cd("tmp")') return []
def createsession(): ## Create a new omc session for the users and allot a seperate working directory for the session ## #print 'creating omc session' session['msg'] = [] session['mat'] = [] sid = request.form['sid'] session['tmpdir'] = tempfile.mkdtemp() #print session['tmpdir'] os.chdir(session['tmpdir']) sess = OMCSession() sessionobj[sid] = sess #print sessionobj #sys.stdout.flush() return "success"
class CITests(): ''' Python class used to run CI tests ''' def __init__(self, rootPath): ''' Constructor starts omc and loads MSL ''' self.rootPath = rootPath self.omc = OMCSession() os.chdir(self.rootPath) self.omc.sendExpression("loadModel(Modelica)") def loadLib(self, libPath): # Attempt to load the library if self.omc.sendExpression('loadFile("%s")' % (self.rootPath + libPath)): print "%s is successfully loaded." % libPath else: raise Exception( "%s was not loaded! Check the library path.") % libPath def runCheck(self, libName, libPath): # Load library self.loadLib(libPath) ''' Checks all of the models in the library and returns number of faild checks ''' # Get the list of all classes in OpenIPSL test_list = self.omc.sendExpression( 'getClassNames(%s,recursive=true)' % libName) nFailed = 0 nPassed = 0 # Run the check for all classes that are model and print result msgs for test in test_list: if self.omc.sendExpression("isModel(%s)" % (test)): # Check if a class is a model passMsg = self.omc.sendExpression("checkModel(%s)" % (test)) if "completed successfully." in passMsg: # print passMsg nPassed += 1 else: failMsg = self.omc.sendExpression("getErrorString()") print failMsg nFailed += 1 # Print a check summary print "==== Check Summary for %s ====" % libName print "Number of models that passed the check is: %s" % nPassed print "Number of models that failed the check is: %s" % nFailed return (nFailed == 0)
def Simulation(self): """ starting a new session """ OMPython = OMCSession() command= CommandOMC() OMPython.execute(command.loadModelica()) OMPython.execute(command.loadFile(self.mfile)) print self.mfile print command.set_ModelName(self.mfile) self._MN=OMPython.execute(command.getClassNames(self.mfile)) print self._MN['SET1']['Set1'] self.tt=command.set_ModelName(self.mfile)+'.'+self._MN['SET1']['Set1'][0] print self.tt self.success=OMPython.execute(command.getClassNames(self.tt)) print self.success['SET2']['Set1']
class CITests(): ''' Python class used to run CI tests ''' def __init__(self, rootPath): ''' Constructor starts omc and loads MSL ''' self.rootPath = rootPath self.omc = OMCSession() os.chdir(self.rootPath) self.omc.sendExpression("loadModel(Modelica)") def loadLib(self, libPath): # Attempt to load the library if self.omc.sendExpression('loadFile("%s")' % (self.rootPath + libPath)): print "%s is successfully loaded." % libPath else: raise Exception("%s was not loaded! Check the library path.") % libPath def runCheck(self, libName, libPath): # Load library self.loadLib(libPath) ''' Checks all of the models in the library and returns number of faild checks ''' # Get the list of all classes in OpenIPSL test_list = self.omc.sendExpression('getClassNames(%s,recursive=true)' % libName) nFailed = 0 nPassed = 0 # Run the check for all classes that are model and print result msgs for test in test_list: if self.omc.sendExpression("isModel(%s)" % (test)): # Check if a class is a model passMsg = self.omc.sendExpression("checkModel(%s)" % (test)) if "completed successfully." in passMsg: # print passMsg nPassed += 1 else: failMsg = self.omc.sendExpression("getErrorString()") print failMsg nFailed += 1 # Print a check summary print "==== Check Summary for %s ====" % libName print "Number of models that passed the check is: %s" % nPassed print "Number of models that failed the check is: %s" % nFailed return (nFailed == 0)
class EngineOMC(object): def __init__(self, sources= None, experiment= None, results= None): ''' Loading simulations resources. Parameters related to models to be simulated and libraries''' self.__sources= sources ''' Loading configuration values for the simulator solver ''' self.__experiment= experiment self.__results= results self.__omcSession= OMCSession() # ''' Loading output variables of the model, their values will be stored in h5 and plotted ''' # self.outputs= outvar.OutVariableStream(sys.argv[3]) @property def omcSession(self): return self.__omcSession @omcSession.setter def omcSession(self, valor): self.__omcSession= valor def simulate(self): objCOMC= CommandOMC() '''Load Modelica library''' self.__omcSession.execute("loadModel(Modelica)") command= objCOMC.loadFile(self.__sources.libraryFile) print '1) Command', command self.__omcSession.execute(command) '''loading the model we want to simulate''' command= objCOMC.loadFile(self.__sources.modelFile) print '2) Command', command # here, show the list of parameters we can modify, (variability= parameter) print self.__sources.modelName success= self.__omcSession.execute(command) result= None if (success): #command= objCOMC.simulate(self.moModel, self.simOptions, 'vf1=0.1,pm1=0.001') command= objCOMC.simulate(self.__experiment.modelName, self.__experiment, False) print '3) Command', command result= self.__omcSession.execute(command) print '4) Result', result # TODO: Handle when simulation fails, no result file # inMemoryResultFile= OMPython.get(result, 'SimulationResults.resultFile') # print '5) Result file ', inMemoryResultFile # resultfile= objCOMC.saveResult(inMemoryResultFile, self.outPath) print '5) Simulation Results', result['SimulationResults'] self.__results= result['SimulationResults'] print '6) Result file', self.__results['resultFile'] else: print ("Failed to load resources!")
class EngineOMC(ModelicaEngine): def __init__(self, resources= None, settings= None): super(EngineOMC, self).__init__(resources, settings) self._omcSession= OMCSession() self._simulationResult= None @property def omcSession(self): return self._omcSession @property def simulationResult(self): return self._simulationResult def simulate(self): objCOMC= CommandOMC() '''Load Modelica library''' self._omcSession.execute("loadModel(Modelica)") command= objCOMC.loadFile(self._resources.libraryFile) print '1) Command', command self._omcSession.execute(command) '''loading the model we want to simulate''' command= objCOMC.loadFile(self._resources.modelFile) print '2) Command', command # here, show the list of parameters we can modify, (variability= parameter) print self._resources.modelName success= self._omcSession.execute(command) if (success): #command= objCOMC.simulate(self.moModel, self.simOptions, 'vf1=0.1,pm1=0.001') command= objCOMC.simulate(self._configuration.modelName, self._configuration, False) print '3) Command', command omc_result= self._omcSession.execute(command) print '4) Result', omc_result # TODO: Handle when simulation fails, no result file # inMemoryResultFile= OMPython.get(result, 'SimulationResults.resultFile') # print '5) Result file ', inMemoryResultFile # resultfile= objCOMC.saveResult(inMemoryResultFile, self.outPath) print '5) Simulation Results', omc_result['SimulationResults'] self._simulationResult= omc_result['SimulationResults'] print '6) Result file', self._simulationResult['resultFile'] else: print ("Failed to load resources!") def linearize(self): pass
def __init__(self, resources= None, settings= None): super(EngineOMC, self).__init__(resources, settings) self._omcSession= OMCSession() self._simulationResult= None
# Apply Copyright in all .mo files of the library import sys import os from OMPython import OMCSession # Start OMC session and load MSL omc = OMCSession() omc.sendExpression("loadModel(Modelica)") # Load OpenIPSL and get all models omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\OpenIPSL\package.mo")') omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\_Tutorial\Tutorial\package.mo")' ) omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\AKD\package.mo")') omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\IEEE9\package.mo")' ) omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\IEEE14\package.mo")' ) omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\KundurSMIB\package.mo")' ) omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\N44\package.mo")') omc.sendExpression( 'loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\PSAT_Systems\package.mo")'
class Model(Plugins.Simulator.SimulatorBase.Model): def __init__(self, modelName, modelFileName, config): Plugins.Simulator.SimulatorBase.Model.__init__(self, modelName, modelFileName, 'OpenModelica', config) self._omc = OMCSession() self.onlyResultFile = False self.integrationSettings.resultFileExtension = 'mat' self._availableIntegrationAlgorithms = [ 'Dassl', 'Euler', 'Rungekutta', 'Dopri5' ] self.integrationSettings.algorithmName = self._availableIntegrationAlgorithms[ 0] self._IntegrationAlgorithmHasFixedStepSize = [False, True, True, False] self._IntegrationAlgorithmCanProvideStepSizeResults = [ False, True, True, False ] self.compileModel() if self.resFile != '""': self._initialResult = loadResultFileInit( os.path.join(os.getcwd(), self.name + "_init.xml")) else: print "The selected model could not be instantiated, check for any dependencies that the model might have" return # SocketServer setup to visualize the simulation progress bar HOST, PORT = "localhost", 0 self.server = SocketServer.TCPServer((HOST, PORT), ThreadedTCPRequestHandler) self.ip, self.port = self.server.server_address self.server_port = self.port self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.daemon = True self.server_thread.setDaemon(True) self.server_thread.start() def compileModel(self): """ This function is needed to load the data into the VariablesBrowser before simulating the model with parameters. """ if len(self.fileName) == 1: if self.fileName[0] <> "": # Load the Modelica Standard library only if there is a uses-annotation on the model (done automagically) if not (os.path.isfile(self.fileName[0]) and self._omc. sendExpression("loadFile(\"" + self.fileName[0].encode( sys.getfilesystemencoding()) + "\")")): print self._omc.sendExpression("getErrorString()") raise FileDoesNotExist("compileModel failed, file '" + self.fileName[0] + "' does not exist") else: pack = str(self.name.split(".", 1)[0]) if not self._omc.sendExpression("loadModel(" + pack + ")"): print self._omc.sendExpression("getErrorString()") raise FileDoesNotExist("compileModel failed, package " + pack + " does not exist") # set the working directory in OMC pwd = os.path.abspath('.').replace('\\', '/') workdir = self._omc.sendExpression("cd(\"" + pwd + "\")") # simulate the model simResult = self._omc.sendExpression( str("buildModel(" + self.name + ")")) if simResult[0] == "": raise BuildModelFail( self._omc.sendExpression("getErrorString()")) # call getErrorString() to get complete error. print self._omc.sendExpression("getErrorString()"), # read the result file self.resFile = os.path.join(workdir, self.name + "_res.mat") def getReachedSimulationTime(self): ''' Read the current simulation time during a simulation from the Model.exe file generated during loadFile() ''' t = ((simulationProgressData * self.integrationSettings.stopTime) / 100.0) return t def simulate(self): def precheck_for_set_sim_options(): s = self.integrationSettings settings = s.__dict__ # prepare the simulation options string for OpenModelica set_sim_options = [ 'startTime', 'stopTime', 'errorToleranceTol', 'resultFileFormat', 'fixedStepSize', 'algorithmName' ] om_sim_options = [ 'startTime', 'stopTime', 'tolerance', 'outputFormat', 'fixedStepSize', 'method' ] simulate_options = [] for k, v in settings.iteritems(): if k in set_sim_options: i = set_sim_options.index(k) if v != None and v != "": if k == "algorithmName": v = str(v).lower() simulate_options += [om_sim_options[i] + "=" + str(v)] return ",".join(simulate_options) def precheck_for_model(): self.sim_opts = precheck_for_set_sim_options() def readStatistics(): ''' Read statistics from the LOG_STATS.txt file ''' work_dir = os.getcwd() result_exe = os.path.join( work_dir, self.name + (".exe" if os.name == "nt" else "")) + " -lv LOG_STATS" + " -r=\"" + os.path.abspath( self.integrationSettings.resultFileName) + "\"" if self.sim_opts <> "": result_exe += " -override=" + self.sim_opts result_exe += " -port=%d" % self.server_port with open('LOG_STATS.txt', 'w') as output_f: p = subprocess.Popen(result_exe, stdout=output_f, shell=True) import time attempts = 0 while True: if not os.path.isfile('LOG_STATS.txt'): time.sleep(0.15) attempts += 1 if attempts == 10: return else: statistics = open('LOG_STATS.txt', 'r') break nTimeEvents = 0 nStateEvents = 0 currentGridPoints = 0 currentTime = self.integrationSettings.startTime if statistics != None: fact = [line.strip() for line in statistics] for i in fact: if "State Events" in i: nStateEvents = int(i.split(':', 1)[1]) if "Sample Events" in i: nTimeEvents = int(i.split(':', 1)[1]) if "simulation time" in i: currentTime = float(i.split(':', 1)[1]) statistics.close() currentTime = self.integrationSettings.stopTime # Wait for the process to finish; otherwise we cannot read the result-file p.wait() self.integrationStatistics.nTimeEvents = nTimeEvents self.integrationStatistics.nStateEvents = nStateEvents self.integrationStatistics.nGridPoints = currentGridPoints self.integrationStatistics.reachedTime = currentTime precheck_for_model() readStatistics() if not os.path.isfile(self.integrationSettings.resultFileName): raise FileDoesNotExist(self.integrationSettings.resultFileName) def setVariableTree(self): if self.resFile == '""': return for v in self._initialResult: value = None if v['variability'] == 'fixed' or v['valueEdit']: value = v['value'] else: value = None variableAttribute = '' if v['description'] != '': variableAttribute += 'Description:' + chr( 9) + v['description'] + '\n' variableAttribute += 'Causality:' + chr(9) + v['causality'] + '\n' variableAttribute += 'Variability:' + chr( 9) + v['variability'] + '\n' variableAttribute += 'Type:' + chr(9) + v['type'] self.variableTree.variable[v['name'].replace( '[', '.[')] = Plugins.Simulator.SimulatorBase.TreeVariable( self.structureVariableName(v['name'].replace('[', '.[')), value, v['valueEdit'], v['unit'], v['variability'], variableAttribute) def getAvailableIntegrationAlgorithms(self): return self._availableIntegrationAlgorithms def getIntegrationAlgorithmHasFixedStepSize(self, algorithmName): return self._IntegrationAlgorithmHasFixedStepSize[ self._availableIntegrationAlgorithms.index(algorithmName)] def getIntegrationAlgorithmCanProvideStepSizeResults(self, algorithmName): return self._IntegrationAlgorithmCanProvideStepSizeResults[ self._availableIntegrationAlgorithms.index(algorithmName)]
# Apply Copyright in all .mo files of the library import sys import os from OMPython import OMCSession # Start OMC session and load MSL omc = OMCSession() omc.sendExpression("loadModel(Modelica)") # Load OpenIPSL and get all models omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\OpenIPSL\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\_Tutorial\Tutorial\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\AKD\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\IEEE9\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\IEEE14\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\KundurSMIB\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\N44\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\PSAT_Systems\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\SevenBus\package.mo")') omc.sendExpression('loadFile("C:\dev\OSS\OpenIPSL_Repo\Application Examples\TwoAreas\package.mo")') list_models = omc.sendExpression('getClassNames(OpenIPSL,recursive=true)') list_models_1 = omc.sendExpression('getClassNames(Tutorial,recursive=true)') list_models_2 = omc.sendExpression('getClassNames(AKD,recursive=true)') list_models_3 = omc.sendExpression('getClassNames(IEEE9,recursive=true)') list_models_4 = omc.sendExpression('getClassNames(IEEE14,recursive=true)') list_models_5 = omc.sendExpression('getClassNames(KundurSMIB,recursive=true)') list_models_6 = omc.sendExpression('getClassNames(N44,recursive=true)') list_models_7 = omc.sendExpression('getClassNames(PSAT_Systems,recursive=true)')
if ompython_omhome != "": # Use a different OMC for running OMPython than for running the tests omhome = os.environ["OPENMODELICAHOME"] try: omc_version = subprocess.check_output( ["%s/bin/omc" % omhome, "--version"], stderr=subprocess.STDOUT).strip() except: omc_version = subprocess.check_output( ["%s/bin/omc" % omhome, "+version"], stderr=subprocess.STDOUT).strip() version_cmd = "+version" rmlStyle = True print("Work-around for RML-style command-line arguments (+version)") os.environ["OPENMODELICAHOME"] = ompython_omhome omc = OMCSession() ompython_omc_version = omc.sendExpression('getVersion()') os.environ["OPENMODELICAHOME"] = omhome else: omc = OMCSession() omhome = omc.sendExpression('getInstallationDirectoryPath()') omc_version = omc.sendExpression('getVersion()') ompython_omc_version = omc_version ompython_omc_version = ompython_omc_version.replace("OMCompiler", "").strip() def timeSeconds(f): return cgi.escape("%.2f" % f) omc.sendExpression('setModelicaPath("%s/lib/omlibrary")' % omhome)
import traceback from os.path import basename from StringIO import StringIO import subprocess from sphinx.util.compat import Directive from docutils import nodes from docutils.parsers.rst.directives.misc import Include as BaseInclude from sphinx import directives from docutils.parsers.rst import directives as rstdirectives import docutils.parsers.rst.directives.images from docutils.statemachine import ViewList from OMPython import OMCSession omc = OMCSession() omhome = omc.sendExpression("getInstallationDirectoryPath()") omc.sendExpression("setModelicaPath(\""+omhome+"/lib/omlibrary\")") omc.sendExpression('mkdir("tmp/source")') dochome = omc.sendExpression('cd("tmp")') class ExecDirective(Directive): """Execute the specified python code and insert the output into the document""" has_content = True def run(self): oldStdout, sys.stdout = sys.stdout, StringIO() try: exec '\n'.join(self.content) return [nodes.paragraph(text = sys.stdout.getvalue())] except Exception, e:
def __init__(self, **kwargs): Kernel.__init__(self, **kwargs) self.omc = OMCSession() self.matfile = None
with open(errFile, 'a+') as fp: fp.write( "C++ FMI runtime not supported in this installation (HelloWorld failed or did not respect fileNamePrefix)" ) writeResultAndExit(0) elif conf["simCodeTarget"] == "C" and not conf["haveFMI"]: with open(errFile, 'a+') as fp: fp.write( "C FMI runtime not supported in this installation (HelloWorld failed or did not respect fileNamePrefix)" ) writeResultAndExit(0) omhome = conf["omhome"] os.environ["OPENMODELICAHOME"] = omhome omc = OMCSession() if ompython_omhome != "": os.environ["OPENMODELICAHOME"] = ompython_omhome omc_new = OMCSession() else: omc_new = omc cmd = 'setCommandLineOptions("%s")' % conf["single_thread_cmd"] if not omc.sendExpression(cmd): raise Exception('Could not send %s' % cmd) try: os.unlink("%s.tmpfiles" % conf["fileName"]) except: pass #cmd = 'setCommandLineOptions("--running-testsuite=%s.tmpfiles")' % conf["fileName"]
import sys from OMPython import OMCSession # List of the test examples that will be checked omc = OMCSession() omc.sendExpression("loadModel(Modelica)") omc.sendExpression('loadFile("/OpenIPSL/OpenIPSL/package.mo")') omc.sendExpression("getClassNames()") ''' test_list = ["OpenIPSL.Examples.Machines.PSSE.GENSAL", "OpenIPSL.Examples.Machines.PSSE.GENSAE", "OpenIPSL.Examples.Machines.PSSE.GENROE", "OpenIPSL.Examples.Machines.PSSE.GENROU"] ''' # Get the list of all test cases in class DevelopmentExamples test_list = omc.sendExpression('getClassNames(OpenIPSL,recursive=true)') nFailed = 0 nPassed = 0 for test in test_list: if omc.sendExpression("isModel(%s)" % (test)): passMsg = omc.sendExpression("checkModel(%s)" % (test)) failMsg = omc.sendExpression("getErrorString()") if "completed successfully." in passMsg: # print passMsg nPassed += 1 else: print failMsg
def createOmcSession(): return OMCSession( docker=docker, dockerExtraArgs=dockerExtraArgs, timeout=5) if corbaStyle else OMCSessionZMQ( docker=docker, dockerExtraArgs=dockerExtraArgs, timeout=5)
$\frac{dx}{dt} = ax$. """ code='''model Simple Real x(start=1); parameter Real a=1; equation der(x)=a*x; end Simple;''' # модель мовою Modelica with open('Simple.mo', 'w') as f: f.write(code) # створити файл моделі import os, sys sys.path.insert(0, r"e:\OpenModelica\share\omc\scripts\PythonInterface") # шлях до модулів from OMPython import OMCSession, ModelicaSystem # перший спосіб - використання OMCSession: omc = OMCSession() omc.sendExpression('loadFile("Simple.mo")') omc.sendExpression('setParameterValue(Simple, a, 2)') omc.sendExpression('simulate(Simple)') omc.sendExpression('plot(x)') print omc.sendExpression('val(x , 1.0)') # результат x(time=1.0) # або більш зручний спосіб: mod=ModelicaSystem("Simple.mo","Simple") print mod.getParameters() mod.setParameters(a=2) mod.setSimulationOptions(stopTime=2.0) mod.simulate() print mod.getSolutions('time','x') # результати як масиви # або компілювати модель і симулювати без OMPython:
class Model(SimulatorBase.Model): def __init__(self, modelName, modelFileName, config): SimulatorBase.Model.__init__(self, modelName, modelFileName, config) self.modelType = 'Modelica model in OpenModelica' self._omc = OMCSession() self.onlyResultFile = False self.integrationSettings.resultFileExtension = 'mat' self._availableIntegrationAlgorithms = ['Dassl', 'Euler', 'Rungekutta', 'Dopri5'] self.integrationSettings.algorithmName = self._availableIntegrationAlgorithms[0] self._IntegrationAlgorithmHasFixedStepSize = [False, True, True, False] self._IntegrationAlgorithmCanProvideStepSizeResults = [False, True, True, False] self.compileModel() if self.resFile != '""': self._initialResult = loadResultFileInit(os.path.join(os.getcwd(), self.name + "_init.xml")) else: print "The selected model could not be instantiated, check for any dependencies that the model might have" return # SocketServer setup to visualize the simulation progress bar HOST, PORT = "localhost", 0 self.server = SocketServer.TCPServer((HOST, PORT), ThreadedTCPRequestHandler) self.ip, self.port = self.server.server_address self.server_port = self.port self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.daemon = True self.server_thread.setDaemon(True) self.server_thread.start() def compileModel(self): """ This function is needed to load the data into the VariablesBrowser before simulating the model with parameters. """ if len(self.fileName) == 1: if self.fileName[0] <> "": # Load the Modelica Standard library only if there is a uses-annotation on the model (done automagically) if not (os.path.isfile(self.fileName[0]) and self._omc.sendExpression("loadFile(\"" + self.fileName[0].encode(sys.getfilesystemencoding()) + "\")")): print self._omc.sendExpression("getErrorString()") raise FileDoesNotExist("compileModel failed, file '" + self.fileName[0] + "' does not exist") else: pack = str(self.name.split(".",1)[0]) if not self._omc.sendExpression("loadModel(" + pack + ")"): print self._omc.sendExpression("getErrorString()") raise FileDoesNotExist("compileModel failed, package " + pack + " does not exist") # set the working directory in OMC pwd = os.path.abspath('.').replace('\\', '/') workdir = self._omc.sendExpression("cd(\"" + pwd + "\")") # simulate the model simResult = self._omc.sendExpression(str("buildModel(" + self.name + ")")) if simResult[0] == "": raise BuildModelFail(self._omc.sendExpression("getErrorString()")) # call getErrorString() to get complete error. print self._omc.sendExpression("getErrorString()"), # read the result file self.resFile = os.path.join(workdir,self.name + "_res.mat") def getReachedSimulationTime(self): ''' Read the current simulation time during a simulation from the Model.exe file generated during loadFile() ''' t = ((simulationProgressData * self.integrationSettings.stopTime) / 100.0) return t def simulate(self): def precheck_for_set_sim_options(): s = self.integrationSettings settings = s.__dict__ # prepare the simulation options string for OpenModelica set_sim_options = ['startTime', 'stopTime', 'errorToleranceTol', 'resultFileFormat', 'fixedStepSize', 'algorithmName'] om_sim_options = ['startTime', 'stopTime', 'tolerance', 'outputFormat', 'fixedStepSize', 'method'] simulate_options = [] for k, v in settings.iteritems(): if k in set_sim_options: i = set_sim_options.index(k) if v != None and v != "": if k == "algorithmName": v = str(v).lower() simulate_options += [om_sim_options[i] + "=" + str(v)] return ",".join(simulate_options) def precheck_for_model(): self.sim_opts = precheck_for_set_sim_options() def readStatistics(): ''' Read statistics from the LOG_STATS.txt file ''' work_dir = os.getcwd() result_exe = os.path.join(work_dir, self.name + (".exe" if os.name == "nt" else "")) + " -lv LOG_STATS" + " -r=\"" + os.path.abspath(self.integrationSettings.resultFileName) + "\"" if self.sim_opts <> "": result_exe += " -override=" + self.sim_opts result_exe += " -port=%d" % self.server_port with open('LOG_STATS.txt', 'w') as output_f: p = subprocess.Popen(result_exe, stdout=output_f, shell=True) import time attempts = 0 while True: if not os.path.isfile('LOG_STATS.txt'): time.sleep(0.15) attempts += 1 if attempts == 10: return else: statistics = open('LOG_STATS.txt', 'r') break nTimeEvents = 0 nStateEvents = 0 currentGridPoints = 0 currentTime = self.integrationSettings.startTime if statistics != None: fact = [line.strip() for line in statistics] for i in fact: if "State Events" in i: nStateEvents = int(i.split(':', 1)[1]) if "Sample Events" in i: nTimeEvents = int(i.split(':', 1)[1]) if "simulation time" in i: currentTime = float(i.split(':', 1)[1]) statistics.close() currentTime = self.integrationSettings.stopTime # Wait for the process to finish; otherwise we cannot read the result-file p.wait() self.integrationStatistics.nTimeEvents = nTimeEvents self.integrationStatistics.nStateEvents = nStateEvents self.integrationStatistics.nGridPoints = currentGridPoints self.integrationStatistics.reachedTime = currentTime precheck_for_model() readStatistics() if not os.path.isfile(self.integrationSettings.resultFileName): raise FileDoesNotExist(self.integrationSettings.resultFileName) def setVariableTree(self): if self.resFile == '""': return for v in self._initialResult: value = None if v['variability'] == 'fixed' or v['valueEdit']: value = v['value'] else: value = None variableAttribute = '' if v['description'] != '' : variableAttribute += 'Description:' + chr(9) + v['description'] + '\n' variableAttribute += 'Causality:' + chr(9) + v['causality'] + '\n' variableAttribute += 'Variability:' + chr(9) + v['variability'] + '\n' variableAttribute += 'Type:' + chr(9) + v['type'] self.variableTree.variable[v['name'].replace('[', '.[')] = SimulatorBase.TreeVariable(self.structureVariableName(v['name'].replace('[', '.[')), value, v['valueEdit'], v['unit'], v['variability'], variableAttribute) def getAvailableIntegrationAlgorithms(self): return self._availableIntegrationAlgorithms def getIntegrationAlgorithmHasFixedStepSize(self, algorithmName): return self._IntegrationAlgorithmHasFixedStepSize[self._availableIntegrationAlgorithms.index(algorithmName)] def getIntegrationAlgorithmCanProvideStepSizeResults(self, algorithmName): return self._IntegrationAlgorithmCanProvideStepSizeResults[self._availableIntegrationAlgorithms.index(algorithmName)]
import traceback from os.path import basename from StringIO import StringIO import subprocess from sphinx.util.compat import Directive from docutils import nodes from docutils.parsers.rst.directives.misc import Include as BaseInclude from sphinx import directives from docutils.parsers.rst import directives as rstdirectives import docutils.parsers.rst.directives.images from docutils.statemachine import ViewList from OMPython import OMCSession omc = OMCSession() omhome = omc.sendExpression("getInstallationDirectoryPath()") omc.sendExpression("setModelicaPath(\"" + omhome + "/lib/omlibrary\")") omc.sendExpression('mkdir("tmp/source")') dochome = omc.sendExpression('cd("tmp")') class ExecDirective(Directive): """Execute the specified python code and insert the output into the document""" has_content = True def run(self): oldStdout, sys.stdout = sys.stdout, StringIO() try: exec '\n'.join(self.content) return [nodes.paragraph(text=sys.stdout.getvalue())]
class OpenModelicaKernel(Kernel): implementation = 'openmodelica_kernel' implementation_version = '1.0' language = 'openmodelica' language_version = '1.0' language_info = { 'name': "openmodelica", 'version': "1.0", 'mimetype': 'text/modelica', } banner = "openmodelicakernel - for evaluating modelica codes in jupyter notebook" def __init__(self, **kwargs): Kernel.__init__(self, **kwargs) self.omc = OMCSession() self.matfile = None def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=True): #print code z1 = filter(lambda x: not re.match(r'^\s*$', x), code) plotcommand = z1.replace(' ', '').startswith('plot(') and z1.replace( ' ', '').endswith(')') #print self.execution_count if (plotcommand == True): l1 = z1.replace(' ', '') l = l1[0:-1] plotvar = l[5:].replace('{', '').replace('}', '') plotdivid = str(self.execution_count) finaldata = plotgraph(plotvar, plotdivid, self.omc, self.matfile) if not silent: ''' stream_content = {'name': 'stdout','text':ouptut} self.send_response(self.iopub_socket, 'stream', stream_content) ''' display_content = { 'source': 'kernel', 'data': { 'text/html': finaldata } } self.send_response(self.iopub_socket, 'display_data', display_content) else: try: val = self.omc.sendExpression(code) try: self.matfile = val['resultFile'] except: pass except: val = self.omc.sendExpression(code, parsed=False) #print self.matfile if not silent: display_content = { 'source': 'kernel', 'data': { 'text/plain': str(val) } } self.send_response(self.iopub_socket, 'display_data', display_content) return { 'status': 'ok', # The base class increments the execution count 'execution_count': self.execution_count, 'payload': [], 'user_expressions': {}, } def do_shutdown(self, restart): try: self.omc.__del__() except: pass
class UI_Simulation(QtGui.QDialog, form_gui): ''' classdocs TODO: list of components and variables of the model ''' __engine= None __results= None def __init__(self, parent= None, configResources= None, configSimulation= None): QtGui.QDialog.__init__(self, parent) self.setupUi(self) self.__simsource= configResources self.__simconfig= configSimulation self.load_configuration() self.btnModelBrowser.clicked.connect(self.browse_models) self.btnLibraryBrowser.clicked.connect(self.browse_libraries) self.cbxModelList.activated['QString'].connect(self.set_models) self.progressBar.setRange(0,1) # self.btnRunSimulation.setIcon(QIcon('./res/img/Play.ico')) self.btnRunSimulation.setIconSize(QSize(48,48)) self.btnRunSimulation.clicked.connect(self.onStartSimulation) self.btnPlot.setIcon(QIcon('./res/img/Presentation.ico')) self.btnPlot.setIconSize(QSize(48,48)) self.btnPlot.clicked.connect(self.browse_simulation) #debug self.__omcSession= OMCSession() if self.__simconfig.compiler== 'dymola': self.__simulationTask = TaskThreadDY(self, self.__simsource, self.__simconfig, self.__results) elif self.__simconfig.compiler== 'jmodelica': pass elif self.__simconfig.compiler== 'openmodelica': self.__simulationTask = TaskThreadOMC(self, self.__simsource, self.__simconfig, self.__omcSession, self.__results) self.__simulationTask.taskFinished.connect(self.onFinishSimulation) ### save/load configuration def load_configuration(self): if self.__simconfig!= None: self.txtCompiler.setText(self.__simconfig.compiler) self.txtStartTime.setText(self.__simconfig.startTime) self.txtStopTime.setText(self.__simconfig.stopTime) if self.__simconfig.numberOfIntervals!= '-1': self.txtInterval.setText(self.__simconfig.numberOfIntervals) else: self.txtInterval.setText(self.__simconfig.fixStepSize) self.txtTolerance.setText(self.__simconfig.tolerance) self.txtSolver.setText(self.__simconfig.method) def browse_models(self): fileName = QtGui.QFileDialog.getOpenFileName(self, 'Open Model file', directory= self.__simsource.modelFolder+'/', filter='Modelica Models (*.mo)') self.txtModelFile.setText(fileName) self.__simsource.modelFile= str(fileName) self.__simsource.modelName= str(fileName) self.cbxModelList.clear() command= CommandOMC() success= self.__omcSession.execute(command.loadFile(self.__simsource.modelFile)) if (success): modelNames= self.__omcSession.execute(command.getClassNames(self.__simsource.modelName)) # print modelNames # print modelNames['SET1']['Set1'][0] # fle= open('dict1.properties','w') for x in range(len(modelNames['SET1']['Set1'])): # self.modellist.append(modelNames['SET1']['Set1'][x]) # fle.writelines(str(modelNames['SET1']['Set1'][x]+'\n')) # add modellist to combobox self.cbxModelList.addItem(modelNames['SET1']['Set1'][x]) else: print 'Something unexpected happened!' def set_models(self, text): self.__simconfig.modelName= str(text) def browse_libraries(self): fileName = QtGui.QFileDialog.getOpenFileName(self, 'Open Library file', directory= self.__simsource.libraryFolder+'/', filter='Modelica Models (*.mo)') self.txtLibraryFile.setText(fileName) self.__simsource.libraryFile= str(fileName) def browse_simulation(self): # simmodel = SimRes('./SevenBus.Network_res.mat') #debug ''' TODO change debug object, use simulation results ''' simmodel = SimRes('./res/dy/Two_Areas_PSSE_AVR_Noise_dassl_dsin.mat') # simmodel.browse() simbrowser = UI_Plot_MEE(self, simmodel) simbrowser.show() def onStartSimulation(self): self.progressBar.setRange(0,0) self.__simulationTask.start() def onFinishSimulation(self): # Stop the pulsation self.progressBar.setRange(0,100) def closeEvent(self, event): self.__omcSession.sendExpression('quit()') self.__omcSession= None event.accept() # let the window close