def run_OpenModelica_CLI(model=None):
"""Run simulations with calls to the OpenModelica command line."""
# Create a subdirectory for the simulation
sim_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'sim_' + sys.platform # separate windows and linux
)
if os.path.exists(sim_dir) is False:
os.mkdir(sim_dir)
omc = OMCSessionZMQ()
base_path = omc.sendExpression('getInstallationDirectoryPath()')
file = os.path.join(base_path, r'lib/omlibrary/AixLib 0.9.1/package.mo')
model = "AixLib.FastHVAC.Examples.{}".format(model)
cmds = [
'setCommandLineOptions("-d=newInst")',
'loadFile("{}")'.format(file),
'cd("{}")'.format(sim_dir),
'isPackage({})'.format(model),
'isModel({})'.format(model),
'checkModel({})'.format(model),
'simulate({})'.format(model),
# 'plot(temperatureSensor_after.T)',
# 'plot(innerCycle.QCon)',
]
for cmd in cmds:
print(cmd)
answer = omc.sendExpression(cmd)
pprint.pprint(answer)
print()
def run_ModelicaSystem():
'''Create a ``ModelicaSystem`` object which provides functions to
load, configure and simulate a model. Plotting is done with Python.
For this example, we run the simulations for different heights 'h' from
where the bouncing ball is dropped.
'''
# Setup the Modelica session and load the module
omc = OMCSessionZMQ()
model_path = (omc.sendExpression('getInstallationDirectoryPath()')
+ '/share/doc/omc/testmodels/')
mod = ModelicaSystem(model_path + 'BouncingBall.mo', 'BouncingBall')
# Set some simulation options
mod.setSimulationOptions(stepSize=.05, stopTime=2.0)
# Print some useful information
quant = pd.DataFrame(mod.getQuantities())
print(quant)
# Modify and run simulations
for h_start in [1, 2, 3]:
mod.setContinuous(h=h_start) # `h` is a `continuous` variable
mod.simulate()
time, h = mod.getSolutions('time', 'h')
plt.plot(time, h, label='h_start = {0} m'.format(h_start))
plt.legend()
plt.xlabel(r'time $t$ in [s]')
plt.ylabel(r'height $h$ in [m]')
plt.show(block=False)
def run(self):
global omc
del(omc)
omc = OMCSessionZMQ()
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 = OMCSessionZMQ()
os.chdir(self.rootPath)
self.omc.sendExpression("loadModel(Modelica)")
def make_fmu():
'''Create an FMU from the Modelica model to use for testing
'''
# Setup the Modelica session and load the module
omc = OMCSessionZMQ()
model_path = (omc.sendExpression('getInstallationDirectoryPath()')
+ '/share/doc/omc/testmodels/')
mod = ModelicaSystem(model_path + 'BouncingBall.mo', 'BouncingBall')
# Convert model to FMU 'BouncingBall.fmu'
mod.convertMo2Fmu()
def run_OpenModelica_CLI():
'''Use calls to the OpenModelica command line interface to load,
simulate and plot a model.
'''
omc = OMCSessionZMQ()
cmds = [
('loadFile(getInstallationDirectoryPath()'
+ ' + "/share/doc/omc/testmodels/BouncingBall.mo")'),
'simulate(BouncingBall)',
'plot(h)',
]
for cmd in cmds:
answer = omc.sendExpression(cmd)
print('\n{}:\n{}'.format(cmd, answer))
def simulate(self, ds_test: TestDataSet):
omc = OMCSessionZMQ()
# path = inspect.getfile(omc.__class__)
mod = ModelicaSystem(sep.join([self.path_model, "package.mo"]),
"Steps.Test.TestPCHXMeshram", ["Modelica 3.2.1"])
# options for simulation - steady state simulation, no iteration required, so set numberOfIntervals = 2
mod.setSimulationOptions('stepSize = 0.2')
for test in ds_test:
cfg = test.cfg
print('prepare to simulate:' + cfg.full_name)
mod.setParameters(test.gen_sim_param())
mod.simulate()
print('simulation {0} done, retrieving result'.format(
cfg.full_name))
result = test.result
# collect data in solutions
for sol_key in result:
sol = mod.getSolutions(sol_key)
if not sol is None:
result.set_result(sol_key, sol)
else:
print("solution with key = {0} not exsits".format(sol_key))
# result.update_cal_columns()
print('all simulation(s) done, save result next')
self.save_results(ds_test)
def __init__(self, rootPath):
'''
Constructor starts omc and loads MSL
'''
self.rootPath = rootPath
self.omc = OMCSessionZMQ()
os.chdir(self.rootPath)
self.omc.sendExpression("loadModel(Modelica)")
def run_ModelicaSystem():
"""Create a ``ModelicaSystem`` object and run a simulation.
For this example, we run the simulations for different heights 'h' from
where the bouncing ball is dropped. Plotting is done with Python.
"""
# Setup the Modelica session and load the module
omc = OMCSessionZMQ()
model_path = (omc.sendExpression('getInstallationDirectoryPath()') +
'/share/doc/omc/testmodels/')
mod = ModelicaSystem(model_path + 'BouncingBall.mo',
'BouncingBall',
commandLineOptions='-d=newInst')
# Set some simulation options
stepSize = 0.05
stopTime = 2.0
text = ["stepSize={}".format(stepSize), "stopTime={}".format(stopTime)]
mod.setSimulationOptions(text)
# Print some useful information
quantities = pd.DataFrame(mod.getQuantities())
print(quantities)
# Modify and run simulations
for h_start in [1, 2, 3]:
# `h` is a `continuous` variable
mod.setContinuous("h={}".format(h_start))
mod.simulate() # Run the actual simulation
solution_list = ['time', 'h']
solution_data = mod.getSolutions(solution_list) # read solutions
df = pd.DataFrame(data=solution_data.T, columns=solution_list)
plt.plot(df.time, df.h, label='h_start = {0} m'.format(h_start))
plt.legend()
plt.xlabel(r'time $t$ in [s]')
plt.ylabel(r'height $h$ in [m]')
plt.show(block=False)
def linearize_model(
model_info: ModelicaModelInfo,
initial_parameters: ModelVariables = dict(),
control_df: t.Optional[pd.DataFrame] = None) -> fmi.FMUModelCS2:
omc = OMCSessionZMQ()
is_loaded: bool = omc.sendExpression(f'loadFile("{model_info.location}")')
if not is_loaded:
raise RuntimeError("Could not load model: ")
stopTime = 100
path_to_csv = None
if control_df is not None:
path_to_csv = _generate_control_csv(control_df.reset_index())
stopTime = control_df.index[-1]
initial_parameters_flags = "".join(
[f'-override {var}={val}' for var, val in initial_parameters.items()])
input_file_flags = f"-csvInput {path_to_csv}" if path_to_csv is not None else ""
linearization_result = omc.sendExpression(
f'linearize({model_info.name}, startTime=0, stopTime={stopTime}, stepSize=10, simflags="{initial_parameters_flags} {input_file_flags}", outputFormat="csv")'
)
if path_to_csv is not None:
os.remove(path_to_csv)
if linearization_result is None or not len(
linearization_result['resultFile']):
print(linearization_result)
raise RuntimeError("Could not linearize a model: ")
fmu_path = FmuSource.from_modelica(
ModelicaModelInfo(Path("linearized_model.mo"),
"linearized_model")).fmu_path
model = load_fmu(str(fmu_path))
# FMU exported from OpenModelica doesn't estimate from time 0,
# so simulation from 0 to 0 helps
opts = model.simulate_options()
opts['silent_mode'] = True
model.simulate(0, 0, options=opts)
return model
class CITests():
'''
Python class used to run CI tests
'''
def __init__(self, rootPath):
'''
Constructor starts omc and loads MSL
'''
self.rootPath = rootPath
self.omc = OMCSessionZMQ()
os.chdir(self.rootPath)
self.omc.sendExpression("loadModel(Modelica)")
def loadLib(self, libName, libPath):
# Attempt to load the library
if self.omc.sendExpression('loadFile("%s")' %
(self.rootPath + libPath)):
print("Load success: %s" % libName)
else:
errmsg = libName + " was not loaded! Check the library path:\n" + libPath
raise Exception(errmsg)
def runSyntaxCheck(self, libName, libPath):
# Load library
self.loadLib(libName, 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:
nPassed += 1
else:
failMsg = self.omc.sendExpression("getErrorString()")
print(failMsg)
nFailed += 1
# Print a check summary
if nFailed == 0:
str1 = "== %s ----------------------" % libName
print("%s OK! == Models checked: %s" % (str1[:22], nPassed))
else:
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 test result
return (nFailed == 0)
def run(self):
global omc
del (omc)
omc = OMCSessionZMQ()
omc.sendExpression("setModelicaPath(\"" + omhome + "/lib/omlibrary\")")
omc.sendExpression('cd("tmp")')
return []
class CITests():
'''
Python class used to run CI tests
'''
def __init__(self, rootPath):
'''
Constructor starts omc and loads MSL
'''
self.rootPath = rootPath
self.omc = OMCSessionZMQ()
os.chdir(self.rootPath)
self.omc.sendExpression("loadModel(Modelica)")
def loadLib(self, libName, libPath):
# Attempt to load the library
if self.omc.sendExpression('loadFile("%s")' % (self.rootPath + libPath)):
print "Load success: %s" % libName
else:
errmsg = libName + " was not loaded! Check the library path:\n" + libPath
raise Exception(errmsg)
def runSyntaxCheck(self, libName, libPath):
# Load library
self.loadLib(libName,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:
nPassed += 1
else:
failMsg = self.omc.sendExpression("getErrorString()")
print failMsg
nFailed += 1
# Print a check summary
if nFailed == 0:
str1 = "== %s ----------------------" % libName
print "%s OK! == Models checked: %s" % (str1[:22], nPassed)
else:
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 test result
return (nFailed == 0)
def run_cdl_simulation(self, model, output_folder, ip_list, op_list,
sample_time):
"""function that runs the CDL simulation using OpenModelica; also converts the .mat output file to .csv
Parameters
----------
model : str
name of the modelica model
output_folder : str
name of the folder where the generated mat file with the results will be saved
ip_list : list
list of input variables for this model
op_list : list
list of output variables for this model
sample_time : int
sample time in seconds
Returns
-------
simulation_output : pd.DataFrame
timeseries of input and output variable values from the CDL simulation
"""
print("in running cdl simulation")
omc = OMCSessionZMQ()
if not omc.sendExpression("loadModel(Modelica)"):
err = omc.sendExpression("getErrorString()")
print("error while loading Modelica Standard Library: {}".format(
err))
if not omc.sendExpression("loadModel(Buildings)"):
err = omc.sendExpression("getErrorString()")
print("error while loading Modelica Buildings Library: {}".format(
err))
shutil.move("{}_res.mat".format(model),
output_folder + "/{}_res.mat".format(model))
for file in os.listdir('.'):
if file.startswith(model):
os.remove(file)
r = Reader(output_folder + "/{}_res.mat".format(model), 'dymola')
df_list = []
for ip in ip_list:
values = r.values(ip)
df = pd.DataFrame(index=values[0], data={ip: values[1]})
df_list.append(df)
for op in op_list:
values = r.values(op)
df = pd.DataFrame(index=values[0], data={op: values[1]})
df_list.append(df)
simulation_output = pd.concat(df_list, axis=1).fillna(method='ffill')
simulation_output = simulation_output.loc[~simulation_output.index.
duplicated(keep='first')]
simulation_output.to_csv(output_folder + "/{}_res.csv".format(model))
simulation_output.index = simulation_output.index.astype(float)
simulation_output.index.name = 'time'
return simulation_output
def __init__(self, path_file, name, display_errors):
self.path_file = os.path.abspath(path_file)
self.path = os.path.dirname(self.path_file)
self.name = name
self.display_errors = display_errors
# os.chdir(self.path)
# os.chdir("../")
print("Working directory is " + os.getcwd() + "\n")
self.stop_time = 0
self.omc = OMCSessionZMQ()
print self.omc.sendExpression("getVersion()")
self.print_err()
print self.omc.sendExpression(
"setCommandLineOptions(\"+g=PDEModelica --demoMode=true\")")
self.print_err()
print self.omc.sendExpression("loadModel(Modelica)")
self.print_err()
print self.omc.sendExpression("loadFile(\"" + path_file + "\")")
self.print_err()
#create empty init file for case no parameters will be changed:
#init_file = open("./WorkingDir/init_file.txt", "w")
init_file = open("init_file.txt", "w")
init_file.write("\n")
init_file.close()
#!/usr/bin/env python
# coding: utf-8
from OMPython import OMCSessionZMQ
omc = OMCSessionZMQ()
from modelicares import SimRes
import pandas as pd
import numpy as np
import os
import shutil
# get current directory and set it to the beginning of the repository
RepoDir = os.getcwd()
#This is intended to be used in the manuelnvro Dell using Dymola 2020
ReferenceStep = RepoDir + "/ReferenceStep/"
#Run Exciters
print('---------------------------------------------------------- Reference Step Open Modelica Exciters Testing ----------------------------------------------------------')
try:
os.chdir(f""+ReferenceStep+"")
exec(open("ReferenceStepExcitersOpenModelica.py").read())
print('Reference Step Open Modelica Exciters Testing OK...')
except:
print('Error in Reference Step Open Modelica Exciters Testing...')
#Run Machines
print('---------------------------------------------------------- Reference Step Open Modelica Machines Testing ----------------------------------------------------------')
print('No Reference Step Open Modelica in Machines Testing...')
#Run Turbine Governors
print('---------------------------------------------------------- Reference Step Open Modelica Turbine Governors Testing ----------------------------------------------------------')
* False to stop
</inp>
RETURN:
----------
<out>
output : output from commands
</out>
"""
#For example
#cmds = ['loadFile(getInstallationDirectoryPath() + "/share/doc/omc/testmodels/BouncingBall.mo")',
#"simulate(BouncingBall)",
#"plot(h)"]
#Run = True
from OMPython import OMCSessionZMQ
if Run:
omc = OMCSessionZMQ()
output = []
for command in CMDs:
#change parentheses
command = command.replace("[", "{").replace("]", "}")
answer = omc.sendExpression(command)
#print(cmd)
output.append("\n{}:\n{}".format(command, answer))
else:
output = "False"
import os
import sys
import math
import numpy as np
import time
import os.path
from OMPython import OMCSessionZMQ
os.system("rm -f ./System") # .... to be on the safe side
omc = OMCSessionZMQ()
omc.sendExpression("getVersion()")
omc.sendExpression("cd()")
omc.sendExpression("loadModel(Modelica)")
omc.sendExpression("getErrorString()")
omc.sendExpression("loadFile(\"randomGenerator.mo\")")
omc.sendExpression("getErrorString()")
omc.sendExpression("loadFile(\"connectors.mo\")")
omc.sendExpression("getErrorString()")
omc.sendExpression("loadFile(\"aule.mo\")")
omc.sendExpression("getErrorString()")
omc.sendExpression("loadFile(\"studenti.mo\")")
omc.sendExpression("getErrorString()")
def generateOverviewHTML(crossCheckDir, platform, omsVersion, omsVersionShort, timeStart, totalTime, sysInfo):
# Remove html directory
shutil.rmtree(htmlResultDir, ignore_errors=True)
# Generate data frame
result_df = constructDF(crossCheckDir, platform, omsVersionShort)
# Create directories for HTML files
for dirs in [htmlResultDir, os.path.join(htmlResultDir,filesDir)]:
if not os.path.exists(dirs):
os.mkdir(dirs)
# Read result data frame
numFmus = len(result_df["OMS can import FMU"])
fmusSimulated = list(result_df["OMS can import FMU"]).count(True)
fmusVerified = list(result_df["Results Correct"]).count(True)
# Generate result table
resultsTable = ""
for index, row in result_df.iterrows():
fmiVersion = row["FMI Version"]
fmiType = row["FMI Type"]
exportingToolID = row["Exporting Tool"]
exportingToolVersion = row["Exporting Tool Version"]
modelName = row["Model Name"]
testFMUDir = os.path.join(crossCheckDir, "fmus", fmiVersion, fmiType, platform, \
exportingToolID, exportingToolVersion, modelName)
resultDir = os.path.join(crossCheckDir, "results", fmiVersion, fmiType, \
platform, "OMSimulator", omsVersionShort, \
exportingToolID, exportingToolVersion, modelName)
fileName = row["FMI Version"].replace(".", "") + "." \
+ row["FMI Type"] + "." \
+ row["Exporting Tool"].replace(".", "_") + "." \
+ row["Exporting Tool Version"].replace(".", "_") + "." \
+ row["Model Name"]
# Create directory for model
modelDir = os.path.join(htmlResultDir, filesDir, fileName)
if not os.path.exists(modelDir):
os.mkdir(modelDir)
modelLog = generateSimLogHTML(row, testFMUDir ,resultDir, modelDir, fileName)
if row["OMS can import FMU"]:
simulated = "<td bgcolor=\"#SimulationColor#\">Yes</td>"
else:
simulated = "<td bgcolor=\"#FFCC66\">No</td>"
if not row["OMS can import FMU"]:
verified = "<td bgcolor=\"#FFCC66\"></td>"
elif row["Results Correct"]:
verified = "<td bgcolor=\"#VerificationColor#\">Yes</td>"
else:
linkTarget = generateFailedVerificationHTML(row, testFMUDir, resultDir, modelDir, fileName)
vailedVars = str(len(row["Failed Variables"]))
totalVars = str(int(row["Toal Variables"]))
verified = "<td bgcolor=\"#FFCC66\">" \
+ "<a href=\"" + linkTarget + "\">" \
+ vailedVars+"/"+totalVars+" failed</td>" \
+ "</a>" \
+ "</td>\n"
# TODO Add verivifaction time
simTime = str(round(row["Simulation Time"],2))
row = " <tr>\n" \
+ " <td>" + fmiVersion + "</td>\n" \
+ " <td>" + fmiType + "</td>\n" \
+ " <td>" + exportingToolID + "</td>\n" \
+ " <td>" + exportingToolVersion + "</td>\n" \
+ " <td>" + modelLog + "</td>\n" \
+ " " + verified + "\n" \
+ " " + simulated + "\n" \
+ " <td>" + simTime + "</td>\n" \
+ " </tr>\n"
resultsTable = resultsTable + row
commitshort = subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], cwd=crossCheckDir).decode('utf-8')
commitfull = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=crossCheckDir).decode('utf-8')
if re.search(r"-g.+-",omsVersion):
omscommitshort = re.search(r"-g.+-",omsVersion).group()[2:9]
else:
omscommitshort = "unknown"
htmltpl=open("fmi-cross-check.html.tpl").read()
# Replace keywords from HTML template
htmltpl = htmltpl.replace("#Total#", str(numFmus))
htmltpl = htmltpl.replace("#Simulation#", str(fmusSimulated))
htmltpl = htmltpl.replace("#Verification#", str(fmusVerified))
htmltpl = htmltpl.replace("#commitshort#", str(commitshort))
htmltpl = htmltpl.replace("#commitfull#", str(commitfull))
htmltpl = htmltpl.replace("#omscommitshort#", str(omscommitshort))
htmltpl = htmltpl.replace("#totalTime#", time.strftime("%M:%S", time.gmtime(totalTime)))
htmltpl = htmltpl.replace("#sysInfo#", sysInfo)
htmltpl = htmltpl.replace("#omsVersion#", omsVersion)
htmltpl = htmltpl.replace("#timeStart#", str(timeStart))
htmltpl = htmltpl.replace("#ulimitOMSimulator#", str(ulimitOMSimulator))
htmltpl = htmltpl.replace("#default_tolerance#", str(default_tolerance))
omc = OMCSessionZMQ()
omcVersion = omc.sendExpression("getVersion()")
htmltpl = htmltpl.replace("#referenceTool#", omcVersion + " with function diffSimulationResults")
htmltpl = htmltpl.replace(" #testsHTML#", resultsTable)
resultHTML = os.path.join(htmlResultDir,"fmi-cross-check.html")
open(resultHTML, "w").write(htmltpl)
# Copy dygraph.js into html/
shutil.copyfile("dygraph.js", os.path.join(htmlResultDir,"dygraph.js"))
return resultHTML
class OpenModelicaKernel(Kernel):
implementation = 'openmodelica_kernel'
implementation_version = '1.0'
language = 'openmodelica'
language_version = '1.0'
language_info = {
'name': "modelica",
'version': "1.0",
'mimetype': 'text/x-modelica',
}
banner = "openmodelicakernel - for evaluating modelica codes in jupyter notebook"
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.omc = OMCSessionZMQ()
self.matfile = None
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=True):
# print code
z1 = "".join(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):
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)
# f = open("demofile.html", "w")
# f.write(finaldata)
# f.close()
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
},
'metadata': {}
}
self.send_response(self.iopub_socket, 'display_data',
display_content)
else:
try:
val = self.omc.sendExpression(code)
try:
self.matfile = val['resultFile']
except BaseException:
pass
except BaseException:
val = self.omc.sendExpression(code, parsed=False)
# print self.matfile
if not silent:
display_content = {
'source': 'kernel',
'data': {
'text/plain': str(val)
},
'metadata': {}
}
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 BaseException:
pass
except ImportError:
from io import StringIO
import subprocess
#from sphinx.util.compat import Directive
from docutils.parsers.rst 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 OMCSessionZMQ
omc = OMCSessionZMQ()
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 as e:
def __init__(self, rootPath):
self.rootPath = rootPath
self.omc = OMCSessionZMQ()
os.chdir(rootPath)
self.omc.sendExpression("loadModel(Modelica)")
class unitTests():
def __init__(self, rootPath):
self.rootPath = rootPath
self.omc = OMCSessionZMQ()
os.chdir(rootPath)
self.omc.sendExpression("loadModel(Modelica)")
def loadLibrary(self, libraryName, libraryPath):
# Attempt to load the library
if self.omc.sendExpression('loadFile("%s")' % (libraryPath)):
print("Load success: %s" % libraryName)
else:
errorMessage = libraryName + " was not loaded! Check the library path:\n" + libraryPath
print(errorMessage)
raise Exception(errorMessage)
def runModelCheck(self, libraryName, libraryPath):
# Load library
self.loadLibrary(libraryName, libraryPath)
print("Model Check Start...")
totalFailed = 0
#testList = self.omc.sendExpression('getClassNames(%s,recursive=true)' % libraryName)
testList = {
'exciters': [
"OpenIPSL.Examples.Controls.PSSE.ES.ESAC1A",
"OpenIPSL.Examples.Controls.PSSE.ES.ESAC2A",
"OpenIPSL.Examples.Controls.PSSE.ES.ESDC1A",
"OpenIPSL.Examples.Controls.PSSE.ES.ESST1A",
"OpenIPSL.Examples.Controls.PSSE.ES.ESST4B",
"OpenIPSL.Examples.Controls.PSSE.ES.EXAC1",
"OpenIPSL.Examples.Controls.PSSE.ES.EXAC2",
"OpenIPSL.Examples.Controls.PSSE.ES.EXST1",
"OpenIPSL.Examples.Controls.PSSE.ES.IEEET1",
"OpenIPSL.Examples.Controls.PSSE.ES.IEEET2",
"OpenIPSL.Examples.Controls.PSSE.ES.SCRX",
"OpenIPSL.Examples.Controls.PSSE.ES.SEXS"
],
'machines': [
"OpenIPSL.Examples.Machines.PSSE.GENROU",
"OpenIPSL.Examples.Machines.PSSE.GENSAL",
"OpenIPSL.Examples.Machines.PSSE.GENCLS",
"OpenIPSL.Examples.Machines.PSSE.GENROE",
"OpenIPSL.Examples.Machines.PSSE.GENSAE",
"OpenIPSL.Examples.Banks.PSSE.CSVGN1"
],
'turbinegovernors': [
"OpenIPSL.Examples.Controls.PSSE.TG.GAST",
"OpenIPSL.Examples.Controls.PSSE.TG.HYGOV",
"OpenIPSL.Examples.Controls.PSSE.TG.IEEEG1",
"OpenIPSL.Examples.Controls.PSSE.TG.IEESGO",
"OpenIPSL.Examples.Controls.PSSE.TG.TGOV1"
],
'powersystemstabilizers': [
"OpenIPSL.Examples.Controls.PSSE.PSS.PSS2A",
"OpenIPSL.Examples.Controls.PSSE.PSS.PSS2B"
],
'windturbines': [
"OpenIPSL.Examples.Wind.PSSE.WT4G.WT4G1",
"OpenIPSL.Examples.Wind.PSSE.WT4G.WT4E1"
]
}
#Exciter check
print("Exciter Model Check Start...")
totalModels = 0
testsFailed = 0
testsPassed = 0
for test in testList['exciters']:
totalModels += 1
if self.omc.sendExpression("isModel(%s)" % (test)):
passMessage = self.omc.sendExpression("checkModel(%s)" %
(test))
if "completed successfully." in passMessage:
testsPassed += 1
else:
testFailed += 1
totalFailed += 1
print(
str(testsPassed) + " have passed out of " + str(totalModels) +
" Exciter Models.")
#Machine check
print("Machine Model Check Start...")
totalModels = 0
testsFailed = 0
testsPassed = 0
for test in testList['machines']:
totalModels += 1
if self.omc.sendExpression("isModel(%s)" % (test)):
passMessage = self.omc.sendExpression("checkModel(%s)" %
(test))
if "completed successfully." in passMessage:
testsPassed += 1
else:
testFailed += 1
totalFailed += 1
print(
str(testsPassed) + " have passed out of " + str(totalModels) +
" Machine Models.")
#Turbine Governor check
print("Turbine Governor Model Check Start...")
totalModels = 0
testsFailed = 0
testsPassed = 0
for test in testList['turbinegovernors']:
totalModels += 1
if self.omc.sendExpression("isModel(%s)" % (test)):
passMessage = self.omc.sendExpression("checkModel(%s)" %
(test))
if "completed successfully." in passMessage:
testsPassed += 1
else:
testFailed += 1
totalFailed += 1
print(
str(testsPassed) + " have passed out of " + str(totalModels) +
" Turbine Governor Models.")
#Power System Stabilizer check
print("Power System Stabilizer Model Check Start...")
totalModels = 0
testsFailed = 0
testsPassed = 0
for test in testList['powersystemstabilizers']:
totalModels += 1
if self.omc.sendExpression("isModel(%s)" % (test)):
passMessage = self.omc.sendExpression("checkModel(%s)" %
(test))
if "completed successfully." in passMessage:
testsPassed += 1
else:
testFailed += 1
totalFailed += 1
print(
str(testsPassed) + " have passed out of " + str(totalModels) +
" Power System Stabilizer Models.")
#Wind Turbine check
print("Wind Turbine Model Check Start...")
totalModels = 0
testsFailed = 0
testsPassed = 0
for test in testList['windturbines']:
totalModels += 1
if self.omc.sendExpression("isModel(%s)" % (test)):
passMessage = self.omc.sendExpression("checkModel(%s)" %
(test))
if "completed successfully." in passMessage:
testsPassed += 1
else:
testFailed += 1
totalFailed += 1
print(
str(testsPassed) + " have passed out of " + str(totalModels) +
" Wind Turbine Models.")
return (testsFailed)
except ImportError:
from io import StringIO
import subprocess
#from sphinx.util.compat import Directive
from docutils.parsers.rst 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 OMCSessionZMQ
omc = OMCSessionZMQ()
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())]
def om_simulation(model_info, solver):
root_path = model_info['root_path']
library_path = model_info['library_path']
model_path = model_info['model_path']
model_name = model_info['model_name']
output_path = model_info['output_path']
omc = OMCSessionZMQ()
print(omc.sendExpression("getVersion()"))
try:
if not os.path.exists(output_path):
os.makedirs(output_path)
print("Working directory created")
except OSError as ex:
print("1: Failed to create folder for working directory")
# Changing working directory
omc.sendExpression(f"cd(\"{output_path}\")")
# Opening library
omc.sendExpression(f"parseFile(\"{library_path}\", \"UTF-8\")")
omc.sendExpression(f"loadFile(\"{library_path}\", \"UTF-8\", true)")
omc.sendExpression("instantiateModel(OpenIPSL)")
if solver == "dassl":
omc.sendExpression("setCommandLineOptions(\"daeMode=true\")")
print("DAE setting changed for dassl")
# Setting the number of cores for computation to 1
omc.sendExpression("setCommandLineOptions(\"-n=1\")")
if solver in ["euler", "trapezoid", "rungekutta"]:
print("Running simulation...")
flag = omc.sendExpression(
f"simulate({model_name},stopTime=120,method=\"{solver}\",numberOfIntervals=240000,tolerance=1e-06)"
)
print(flag)
else:
print("Running simulation...")
flag = omc.sendExpression(
f"simulate({model_name},stopTime=120,method=\"{solver}\",numberOfIntervals=5000,tolerance=1e-06)"
)
print(flag)
omc.sendExpression("quit()")
if omc is not None:
omc = None
rmlStyle=False
# Try to make the processes a bit nicer...
os.environ["GC_MARKERS"]="1"
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 = OMCSessionZMQ()
ompython_omc_version=omc.sendExpression('getVersion()')
os.environ["OPENMODELICAHOME"] = omhome
else:
omc = FindBestOMCSession()
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)
omc_exe=os.path.join(omhome,"bin","omc")
dygraphs=os.path.join(ompython_omhome or omhome,"share","doc","omc","testmodels","dygraph-combined.js")
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.omc = OMCSessionZMQ()
self.matfile = None
#!/usr/bin/env python3
import os
import sys
import xmltodict
from OMPython import OMCSessionZMQ
omc = OMCSessionZMQ()
omc.execute('loadModel(Modelica)')
for file in os.listdir('.'): #elenco elementi in directory
if os.path.isfile(file): #controllo se elemento e' file
if file.endswith('.mo'): #prendo solo i .mo
omc.execute('loadFile("' + file + '")')
if (len(sys.argv) > 2):
className = sys.argv[2] + '.' + sys.argv[1]
else:
className = sys.argv[1]
omc.execute('dumpXMLDAE(' + className +
', translationLevel="backEnd", addMathMLCode=true)')
with open(className + '.xml') as fd:
doc = xmltodict.parse(fd.read())
print(doc)
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.omc = OMCSessionZMQ()
self.matfile = None
def createOmcSession():
return OMCSession(
docker=docker, dockerExtraArgs=dockerExtraArgs,
timeout=5) if corbaStyle else OMCSessionZMQ(
docker=docker, dockerExtraArgs=dockerExtraArgs, timeout=5)
class OpenModelicaKernel(Kernel):
implementation = 'openmodelica_kernel'
implementation_version = '1.0'
language = 'openmodelica'
language_version = '1.0'
language_info = {
'name': "modelica",
'version': "1.0",
'mimetype': 'text/x-modelica',
}
banner = "openmodelicakernel - for evaluating modelica codes in jupyter notebook"
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.omc = OMCSessionZMQ()
self.matfile = None
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=True):
# print code
z1 = "".join(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):
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)
# f = open("demofile.html", "w")
# f.write(finaldata)
# f.close()
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 BaseException:
pass
except BaseException:
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 BaseException:
pass
def createOmcSessionNew():
if ompython_omhome != "":
os.environ["OPENMODELICAHOME"] = ompython_omhome
return OMCSessionZMQ()
else:
return createOmcSession()
if conf["simCodeTarget"]=="Cpp" and not conf["haveFMICpp"]:
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 = FindBestOMCSession()
if ompython_omhome != "":
os.environ["OPENMODELICAHOME"] = ompython_omhome
omc_new = OMCSessionZMQ()
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"]
runningTestsuiteFiles = False
#if omc.sendExpression(cmd):
# runningTestsuiteFiles = True
import os
import sys
import traceback
import pandas as pd
from OMPython import OMCSessionZMQ
# Start omc
omc = OMCSessionZMQ()
omc.sendExpression('getVersion()')
# Global vars
ignoreNotCompliantWithLatestRules = True
default_tolerance = 1e-8
reltolDiffMinMax = 1e-4
rangeDelta = 0.002
def filterResultFile(resultFile, referenceFile, resultDir):
"""Filter result file from OMSimulator to contain same variables as reference file.
Remove prefixes from varaible names.
"""
# Only save columns from fmu and remove ".fmu" and "\"" from variable names
csv_res = pd.read_csv(resultFile)
fmu_vars = [
s for s in list(csv_res.columns.values)
if (s.startswith(" \"fmu.") or s == "time")
]
csv_res = csv_res[fmu_vars]
#!/usr/bin/env python # coding: utf-8 from OMPython import OMCSessionZMQ omc = OMCSessionZMQ() from modelicares import SimRes import pandas as pd import numpy as np import os import shutil # get current directory and set it to the beginning of the repository RepoDir = os.getcwd() RepoDir = os.path.abspath(os.path.join(RepoDir, os.pardir)) RepoDir = os.path.abspath(os.path.join(RepoDir, os.pardir)) #OpenIPSL Location OpenIPSL = RepoDir + "/OpenIPSL/" OpenIPSLPackage = RepoDir + "/OpenIPSL/OpenIPSL/package.mo" #Working Directory LVExcitersWorkingDir = RepoDir + "/WorkingDir/LoadVariation/Exciters/" #Load Variation Folder Locations LoadVariationSource = RepoDir + "/CI/LoadVariation/AuxiliaryModels/Load_variation.mo" LoadVariationDestinationPath = RepoDir + "/OpenIPSL/OpenIPSL/Electrical/Loads/PSSE/Load_variation.mo" # Power Fault Folder Locations PowerFaultSource = RepoDir + "/CI/LoadVariation/AuxiliaryModels/PwFault.mo" PowerFaultDestinationPath = RepoDir + "/OpenIPSL/OpenIPSL/Electrical/Events/" PowerFaultDestination = RepoDir + "/OpenIPSL/OpenIPSL/Electrical/Events/PwFault.mo" # SMIB Partial Folder Location SMIBPartialSource = RepoDir + "/CI/LoadVariation/AuxiliaryModels/SMIBpartial.mo"
class ModelicaModel:
def __init__(self, path_file, name, display_errors):
self.path_file = os.path.abspath(path_file)
self.path = os.path.dirname(self.path_file)
self.name = name
self.display_errors = display_errors
# os.chdir(self.path)
# os.chdir("../")
print("Working directory is " + os.getcwd() + "\n")
self.stop_time = 0
self.omc = OMCSessionZMQ()
print self.omc.sendExpression("getVersion()")
self.print_err()
print self.omc.sendExpression(
"setCommandLineOptions(\"+g=PDEModelica --demoMode=true\")")
self.print_err()
print self.omc.sendExpression("loadModel(Modelica)")
self.print_err()
print self.omc.sendExpression("loadFile(\"" + path_file + "\")")
self.print_err()
#create empty init file for case no parameters will be changed:
#init_file = open("./WorkingDir/init_file.txt", "w")
init_file = open("init_file.txt", "w")
init_file.write("\n")
init_file.close()
def print_err(self):
if self.display_errors:
print self.omc.sendExpression("getErrorString()")
def set_stop_time(self, stop_time):
self.stop_time = stop_time
def set_parameters(self, param_dict):
#init_file = open("./WorkingDir/init_file.txt", "w")
init_file = open("init_file.txt", "w")
for key in param_dict:
init_file.write(key + "=" + str(param_dict[key]) + "\n")
init_file.close()
def simulate(self):
#os.chdir("./WorkingDir/")
simul_str = "simulate(" + self.name + ", stopTime=" + str(
self.stop_time) + ", simflags = \"-overrideFile=init_file.txt\")"
print self.omc.sendExpression(simul_str)
self.print_err()
#os.chdir("../")
def get_var(self, var, t):
valStr = "val(" + var + " , " + str(t) + ")"
val = self.omc.sendExpression(valStr)
self.print_err()
return val
def get_var_final(self, var):
return self.get_var(var, self.stop_time)
