def simulator(self):
try:
dymola = None
dymola = DymolaInterface("C:/Program Files/Dymola 2019 FD01/bin64/Dymola.exe")
openResult = dymola.openModel(self.packageName)
print(" openModel : ", openResult )
if not openResult:
print("openModel is failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
exit(1)
dymola.experimentSetupOutput(events=False)
result = dymola.simulateExtendedModel(self.modelName,0.0, self.simTime, 0, self.deltaTime, "Radau", 0.00001, self.deltaTime, self.resultName, initialNames=self.handleModelParamName, initialValues=self.handleModelParamVal)
print(" simulateExtendedModel : ", result[0])
if not result[0]:
print("Simulation is failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
exit(1)
except DymolaException as ex:
print(("Error: " + str(ex)))
finally:
if dymola is not None:
dymola.close()
dymola = None
return 0
def check_libraries(self):
"""Build Dymola model according to the settings"""
temporary_directory = self.generate_fs()
model_build_queue = ModelBuildQueue(self.model_name_list, self.__libraries_required,
__env_configuration__.build_dir, temporary_directory)
model_build_queue.initialize()
# dymola.ExecuteCommand(u"Advanced.TranslationInCommandLog=true;\n")
dymola = None
try:
dymola = DymolaInterface(__env_configuration__.dymola_path)
self.load_libraries_mos(dymola)
errorLog = ''
for library in self.__libraries_required:
dymola.checkModel(self.__get_modelica_lib_name(library["library"]))
errorLog += dymola.getLastError()
if errorLog != '':
raise Exception(errorLog)
except Exception as exception:
raise exception
finally:
if dymola is not None:
dymola.close()
dymola = None
def build_models(self):
"""Build Dymola model according to the settings"""
temporary_directory = self.generate_fs()
model_build_queue = ModelBuildQueue(self.model_name_list, self.__libraries_required,
__env_configuration__.build_dir, temporary_directory)
model_build_queue.initialize()
dymola = None
try:
dymola = DymolaInterface(__env_configuration__.dymola_path)
self.load_libraries_mos(dymola)
while not model_build_queue.is_empty():
model = model_build_queue.pop()
print(model)
result = model.execute_script(dymola) #True: build successfully, False: failed
if not result:
model_build_queue.push_failed_queue(model)
else:
model_build_queue.push_success_queue(model)
model_build_queue.log_output()
except Exception as exception:
raise exception
finally:
if dymola is not None:
dymola.close()
dymola = None
return model_build_queue.get_failed_queue()
def kennfeld_simulieren(mp, Root_simulationsergebnisse, model_kennfeld_path,
model_kennfeld_name):
dymola = None
try:
#erzeuge Instanz von Dymola
dymola = DymolaInterface()
print(model_kennfeld_path, model_kennfeld_name)
#öffne das Model
dymola.openModel(path=model_kennfeld_path)
dymola.translateModel(problem=model_kennfeld_name)
print('simulieren')
result = dymola.simulateExtendedModel(
problem=model_kennfeld_name,
stopTime=200000,
method='radau IIa',
resultFile=Root_simulationsergebnisse + '\simulationsergebnis_mp' +
str(mp))
print(result[0])
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastError()
print(log)
except DymolaException as ex:
print("Error: " + str(ex))
if dymola is not None:
dymola.close()
dymola = None
return
def simulate_optimal(ladephasen, entladephasen, simulationsdauer,
dir_laden_daten, dir_modell_sim, name_modell_sim,
Root_simulationsergebnisse):
ladephasen = clear_phasen(ladephasen)
entladephasen = clear_phasen(entladephasen)
input_laden = merge(ladephasen, dir_laden_daten)
input_entladen = merge(entladephasen, dir_laden_daten)
try:
#erzeuge Instanz von Dymola
dymola = DymolaInterface()
dymola.openModel(path=dir_modell_sim)
dymola.translateModel(problem=name_modell_sim)
dymola.ExecuteCommand("laden.table=" + input_laden)
dymola.ExecuteCommand("entladen.table=" + input_entladen)
result = dymola.simulateExtendedModel(problem=name_modell_sim,
stopTime=simulationsdauer * 3600,
method='radau IIa',
finalNames=['Stromkosten.y'],
resultFile=os.path.join(
Root_simulationsergebnisse,
'simulation_optimal'))
print(result[0])
Stromkosten = result[1]
print('optimale Stromkosten', Stromkosten[0])
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastError()
print(log)
dymola.plot(["elektrische_leistungsaufnahme.y"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse,
"Leistungsaufnahme_optimal.png"))
dymola.plot(["__ctt__strompreis.y[1]"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse, "Strompreis.png"))
dymola.plot(["cost_calculation1.out_kkm1_drehzahl_min_unterschritten"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse,
"Drehzahl_unterschritten.png"))
dymola.plot(["cost_calculation1.out_Investitionskosten_kkm1"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse, "Invest_KKM.png"))
dymola.plot(["cost_calculation1.out_Investitionskosten_Speicher"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse, "Invest_Speicher.png"))
except DymolaException as ex:
print("Error: " + str(ex))
if dymola is not None:
dymola.close()
dymola = None
return input_laden, input_entladen, ladephasen, entladephasen
def results_to_csv(res_path):
"""
This function loads the mat file and save it to csv.
It loads the dymola result mat file and saves the indoor air temp of
the two modelled zones and the total heating power in W.
"""
res_all = pd.DataFrame()
signals = [
'Time', 'multizone.PHeater[1]', 'multizone.PHeater[2]',
'multizone.TAir[1]', 'multizone.TAir[2]'
]
dymola = DymolaInterface()
print('Reading signals: ', signals)
dym_res = dymola.readTrajectory(
fileName=res_path,
signals=signals,
rows=dymola.readTrajectorySize(fileName=res_path))
results = pd.DataFrame().from_records(dym_res).T
results = results.rename(
columns=dict(zip(results.columns.values, signals)))
results.index = results['Time']
results["AixLib_Heating_Power_W"] = results["multizone.PHeater[1]"] +\
results["multizone.PHeater[1]"]
# drop Time and single zones columns
results = results.drop(
['Time', 'multizone.PHeater[1]', 'multizone.PHeater[2]'], axis=1)
results = results.rename(index=str,
columns={
"multizone.TAir[1]": "AixLib_T_dayzone",
"multizone.TAir[2]": "AixLib_T_nightzone"
})
# results = results.drop(index_to_drop)
# results = results.groupby(level=0).first()
# results.to_csv(path=res_path, delimiter=';')
dymola.close()
res_csv = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"AixLib_SingleBuilding.csv")
results.to_csv(res_csv)
return results
def simulation(paths, models, times, A, t, htc, modelon, lcl, dir_save):
modelon = modelon
lcl = lcl
A = A
t = t
htc = htc
dir_save = dir_save
for pat, model, time in zip(paths, models, times):
dymola = None
try:
# Instantiate the Dymola interface and start Dymola
dymola = DymolaInterface()
# Loading libs
dymola.openModel(path=modelon)
dymola.openModel(path=lcl)
# Load model
dymola.openModel(path=pat)
dymola.translateModel(model)
# Call a function in Dymola and check its return value
result = dymola.simulateExtendedModel(
problem=model,
startTime=0,
stopTime=time,
outputInterval=0.5,
method="Esdirk45a",
initialNames=["A", "T", "htc"],
initialValues=[A, t, htc],
resultFile=dir_save + "\\" + model)
# result = dymola.simulateModel("C_Two_M_and_I", startTime=0, stopTime=t_stop, resultFile=dir_path + "_result")
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
# dymola.plot(["MotorStator.T", "Inverter_Al.T"], legends=['T_motor', 'T_inverter'])
# dymola.ExportPlotAsImage(r'C:\Users\sanjio.durasevic\Desktop\C2\12_11_2018_Motor_Inverter_script\plots\slika.png')
except DymolaException as ex:
print("Error: " + str(ex))
finally:
if dymola is not None:
dymola.close()
dymola = None
def dym_check_lic():
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
dym_sta_lic_available = dymola.ExecuteCommand('RequestOption("Standard");')
if not dym_sta_lic_available:
dymola.ExecuteCommand(
'DymolaCommands.System.savelog("Log_NO_DYM_STANDARD_LIC_AVAILABLE.txt");'
)
print("No Dymola License is available")
dymola.close()
else:
print("Dymola License is available")
def simple_fmu_build(model_name, script, component_path):
building_info = {'name': model_name, 'value': script}
dymola_interface = DymolaInterface(__conf__['buildSetting']['dymolaPath'])
model_generator = ModelGenerator(building_info, dymola_interface,
component_path,
__conf__['edrisComponentsPath'],
__conf__['libraryPath'],
translate_fmu=True, fmu_type='cs', temp_dir=__conf__['tempdir'],
fmu_name=FMUBuilder.__fmu_name('cs', component_path))
cs_finish, cs_log = model_generator.build_model()
model_generator = ModelGenerator(building_info, dymola_interface,
component_path,
__conf__['edrisComponentsPath'],
__conf__['libraryPath'],
translate_fmu=True, fmu_type='me', temp_dir=__conf__['tempdir'],
fmu_name=FMUBuilder.__fmu_name('me', component_path))
me_finish, me_log = model_generator.build_model()
dymola_interface.close()
return cs_finish, me_finish, cs_log, me_log
def createDymosimExe(modelPath, stopTime):
dymola = None
try:
dymola = DymolaInterface()
result = dymola.simulateExtendedModel(modelPath, 0.0, stopTime, 0, 0.0,
"Dassl", 0.0001, 0.0, None, None,
None, ["Result"], True)
print(result)
if not result[0]:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
except DymolaException as ex:
print(("Error: " + str(ex)))
finally:
if dymola is not None:
dymola.close()
dymola = None
def simulate_compare(simulationsdauer, dir_modell_sim, name_modell_sim,
Root_simulationsergebnisse):
try:
#erzeuge Instanz von Dymola
dymola = DymolaInterface()
dymola.openModel(path=dir_modell_sim)
dymola.translateModel(problem=name_modell_sim)
result = dymola.simulateExtendedModel(problem=name_modell_sim,
stopTime=simulationsdauer * 3600,
method='radau IIa',
finalNames=['Stromkosten.y'],
resultFile=os.path.join(
Root_simulationsergebnisse,
'simulation_optimal'))
print(result[0])
Stromkosten = result[1]
#ergebnis[step-1,1]=Stromkosten[0]☺
print('Vergleichs-Stromkosten', Stromkosten[0])
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastError()
print(log)
dymola.plot(["elektrische_leistungsaufnahme.y"])
dymola.ExportPlotAsImage(
os.path.join(Root_simulationsergebnisse,
"vergleichs_ergebnis.png"))
except DymolaException as ex:
print("Error: " + str(ex))
if dymola is not None:
dymola.close()
dymola = None
return Stromkosten
def _python_Interface():
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
dymola = DymolaInterface(showwindow=True)
dymola.openModel("D:/Gitlab/GitLabCI/AixLib/package.mo")
result = dymola.checkModel(
"AixLib.Fluid.Actuators.Valves.ExpansionValves.SimpleExpansionValves.IsenthalpicExpansionValve"
)
print(result)
Log = dymola.getLastError()
print(Log)
#Errorlog = dymola.getLastErrorLog()
#print(Errorlog)
dymola.savelog("Fluid-log.txt")
dymola.close()
if result == True:
print('\n Check was Successful! \n')
exit(0)
if result == False:
print('\n Error: Look in Savelog \n')
exit(1)
def translate(self):
try:
dymola = None
dymola = DymolaInterface("C:/Program Files/Dymola 2019 FD01/bin64/Dymola.exe")
openResult = dymola.openModel(self.packageName)
print(" openModel : ", openResult )
if not openResult:
print("Model open failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
exit(1)
transResult = dymola.translateModelExport(self.modelName)
print(" translateModel : ", transResult)
except DymolaException as ex:
print(("Error: " + str(ex)))
finally:
if dymola is not None:
dymola.close()
dymola = None
return 0
def _CreateIBPSALog(self):
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
import buildingspy.development.regressiontest as u
""" Check the IBPSA Model Automatical """
cmd = "git clone https://github.com/ibpsa/modelica-ibpsa.git"
returned_value = os.system(cmd) # returns the exit code in unix
print('returned value:', returned_value)
cmd = "cd modelica-ibpsa-master"
os.system(cmd)
Library = IBPSA/package.mo
ut = u.Tester(tool = self.tool)
### Set Number of Threads
ut.setNumberOfThreads(self.n_pro)
### Set GUI Show
ut.showGUI(self.show_gui)
### Set in Batch Mode
ut.batchMode(self.batch)
### Sets the Dymola path to activate the GUI
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
### Writes all information in the log file, not only the last entries
dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
dym_sta_lic_available = dymola.ExecuteCommand('RequestOption("Standard");')
if not dym_sta_lic_available:
dymola.ExecuteCommand('DymolaCommands.System.savelog("Log_NO_DYM_STANDARD_LIC_AVAILABLE.txt");')
print("No Dymola License is available")
dymola.close()
exit(1)
else:
print("Dymola License is available")
PackageCheck = dymola.openModel(Library)
if PackageCheck == True:
print("Found AixLib Library and start Checkmodel Tests \n Check Package " + self.Package+" \n")
elif PackageCheck == None:
print("Library Path is wrong. Please Check Path of AixLib Library Path")
exit(1)
result=dymola.checkModel(self.Package)
dymola.savelog(self.Package+"-log.txt")
Log = dymola.getLastError()
if result == True:
print('\n Check of Package '+self.Package+' was Successful! \n')
dymola.close()
#exit(0)
if result == False:
print('\n ModelCheck Failed in Package ' + self.Package+ ' Show Savelog \n')
print(Log)
dymola.clearlog()
dymola.close()
def _WriteWhiteList(self):
#_listAllModel
#rootdir = r"D:\Gitlab\modelica-ibpsa\IBPSA"
Package = self.Package.replace("AixLib","IBPSA")
Package = Package.split(".")[0]
Package = Package.replace(".",os.sep)
rootdir = "IBPSA"+os.sep+Package
ModelList = []
for subdir, dirs, files in os.walk(rootdir):
for file in files:
filepath = subdir + os.sep + file
if filepath.endswith(".mo") and file != "package.mo":
model = filepath
model = model.replace(os.sep,".")
model = model[model.rfind("IBPSA"):model.rfind(".mo")]
ModelList.append(model)
#_CheckModel
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
import buildingspy.development.regressiontest as u
ut = u.Tester(tool = self.tool)
### Set Number of Threads
ut.setNumberOfThreads(self.n_pro)
### Set GUI Show
ut.showGUI(self.show_gui)
### Set in Batch Mode
ut.batchMode(self.batch)
### Sets the Dymola path to activate the GUI
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
### Writes all information in the log file, not only the last entries
#dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
Library = "IBPSA"+os.sep+"IBPSA"+os.sep+"package.mo"
dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
dym_sta_lic_available = dymola.ExecuteCommand('RequestOption("Standard");')
if not dym_sta_lic_available:
dymola.ExecuteCommand('DymolaCommands.System.savelog("Log_NO_DYM_STANDARD_LIC_AVAILABLE.txt");')
print("No Dymola License is available")
dymola.close()
exit(1)
else:
print("Dymola License is available")
PackageCheck = dymola.openModel(Library)
if PackageCheck == True:
print("Found IBPSA Library and start Checkmodel Tests \n Check Package " + self.Package+" \n")
elif PackageCheck == False:
print("Library Path is wrong. Please Check Path of IBPSA Library Path")
exit(1)
## Check the Package
if len(ModelList) == 0:
print("Wrong path")
exit(1)
ErrorList = []
for i in ModelList:
result=dymola.checkModel(i)
if result == True:
print('\n Successful: '+i+'\n')
if result == False:
print('\ Error: '+i+'\n')
Log = dymola.getLastError()
print(Log)
ErrorList.append(i)
dymola.savelog("IBPSA-log.txt")
dymola.close()
IBPSA_PackageName = []
### Write the Package Names of IBPSA
for i in ModelList:
i = i.split(".")
i = i[1]
if i not in IBPSA_PackageName:
IBPSA_PackageName.append(i)
filename= "bin"+os.sep+"03_WhiteLists"+os.sep+"WhiteList_CheckModel.txt"
file = open(filename,"w")
for i in IBPSA_PackageName:
List = []
for l in ErrorList:
Package = l.split(".")[1]
if Package == i:
List.append(l)
file.write(i+"\n"+str(List)+"\n"+"\n")
file.close()
print("Write Whitelist")
def list_regression_tests(self):
### List all models, that have changed before
changed_model_list = Extended_model.list_changed_models(self)
## List and compare all regression examples that have changed, but no changes in the used classes
regression_model_list = Extended_model.list_changed_examples(
self, changed_model_list)
models_test_regression = []
if platform.system() == "Windows":
_setEnvironmentVariables(
"PATH",
os.path.join(os.path.abspath('.'), "Resources", "Library",
"win32"))
sys.path.insert(
0,
os.path.join('C:\\', 'Program Files',
'Dymola ' + self.DymolaVersion, 'Modelica',
'Library', 'python_interface', 'dymola.egg'))
print("operating system Windows")
else:
print("operating system Linux")
_setEnvironmentVariables(
"LD_LIBRARY_PATH",
os.path.join(os.path.abspath('.'), "Resources", "Library",
"linux32") + ":" +
os.path.join(os.path.abspath('.'), "Resources", "Library",
"linux64"))
sys.path.insert(
0,
os.path.join('opt', 'dymola-' + self.DymolaVersion + '-x86_64',
'Modelica', 'Library', 'python_interface',
'dymola.egg'))
sys.path.append(
os.path.join(os.path.abspath('.'), "..", "..", "BuildingsPy"))
if len(regression_model_list) == 0:
print("No modified regression models")
exit(0)
else:
## Load AixLib Library
DymolaVersion = self.DymolaVersion
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
if platform.system() == "Windows":
dymola = DymolaInterface(showwindow=True)
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
# Load AixLib
LibraryCheck = dymola.openModel(self.library)
if LibraryCheck == True:
print("Found AixLib Library and regression test starts")
elif LibraryCheck == False:
print(
"Library Path is wrong. Please Check Path of AixLib Library Path"
)
exit(1)
# Load ModelManagement
if platform.system() == "Windows":
dymola.ExecuteCommand(
'cd("C:\Program Files\Dymola ' + self.DymolaVersion +
'\Modelica\Library\ModelManagement 1.1.8\package.moe");')
else:
dymola.ExecuteCommand(
'cd("/opt/dymola-' + self.DymolaVersion +
'-x86_64/Modelica/Library/ModelManagement 1.1.8/package.moe");'
)
### Modified regression examples
for l in regression_model_list:
## Search for all used classes in the example
## Start CheckLibrary in ModelManagement
usedmodels = dymola.ExecuteCommand(
'ModelManagement.Structure.Instantiated.UsedModels("' + l +
'");')
#extendedmodels = dymola.ExecuteCommand('ModelManagement.Structure.AST.ExtendsInClass("'+l+'");')
regression_model = Extended_model.compare_change_used_models(
self, usedmodels, l, changed_model_list)
if regression_model is None:
continue
elif len(regression_model) > 0:
models_test_regression.append(regression_model)
dymola.close()
if len(models_test_regression) > 0:
print(
"These models have been changed and a regression test is started"
)
for l in models_test_regression:
print('Check Example "' + l + '"')
return models_test_regression
def optimierung(liste_minima, liste_maxima, liste_ladephasen, array_names,
simulationsdauer, dir_laden_daten, dir_modell_sim,
name_modell_sim, Root_simulationsergebnisse, ergebnis_compare):
Zyklenanzahl = len(liste_ladephasen)
Zyklus = 1
liste_entladephasen = np.zeros(np.shape(liste_ladephasen))
#ein Zyklus bedeutet die Zeitdauer von Anfang eines Minimum bis zum Ende des darauffolgenden Maximums
while Zyklus < Zyklenanzahl + 1:
print('Aktueller Strompreiszyklus in dem Optimiert wird:', Zyklus)
SOC = get_SOC(array_names, liste_ladephasen, Zyklus)
entladedauer = get_entladedauer(array_names, SOC, Zyklus)
ladedauer = reverse_ladedauer(array_names, SOC, Zyklus)
print('SOC', SOC)
print('entladedauer', entladedauer)
print('ladedauer', ladedauer)
liste_ladephasen[Zyklus - 1,
0] = liste_minima[Zyklus - 1] - (ladedauer /
(2 * 3600))
liste_ladephasen[Zyklus - 1,
1] = liste_minima[Zyklus - 1] + (ladedauer /
(2 * 3600))
print('liste_ladephasen', liste_ladephasen)
liste_entladephasen[Zyklus - 1,
0] = liste_maxima[Zyklus - 1] - (entladedauer /
(3 * 3600)) # &&&
liste_entladephasen[Zyklus - 1,
1] = liste_maxima[Zyklus - 1] + (2 * entladedauer /
(3 * 3600)) # &&&
print('liste_entladephasen', liste_entladephasen)
correct_left_result = correct_left(liste_ladephasen,
liste_entladephasen, Zyklus,
liste_minima)
liste_ladephasen[Zyklus - 1, :] = correct_left_result[0][Zyklus - 1, :]
liste_entladephasen[Zyklus - 1, :] = correct_left_result[1][Zyklus -
1, :]
print('liste_phasen nach correct left', liste_ladephasen,
liste_entladephasen)
correct_right_result = correct_right(liste_ladephasen,
liste_entladephasen, Zyklus,
liste_maxima, liste_minima,
array_names)
liste_ladephasen[Zyklus - 1, :] = correct_right_result[0][Zyklus -
1, :]
liste_entladephasen[Zyklus - 1, :] = correct_right_result[1][Zyklus -
1, :]
print('liste_phasen nach correct right', liste_ladephasen,
liste_entladephasen)
ergebnis = np.array([[0, 0]])
ladedauer_neu = liste_ladephasen[Zyklus - 1,
1] - liste_ladephasen[Zyklus - 1, 0]
print('ladedauer_neu_check', ladedauer_neu)
better = True
opt = 1 #Nummer des Optimierungsdurchgangs in dem jeweiligen Strompreiszyklus
while better == True: #solange sich die Stromkosten verkleinern werden die Phasen verkürzt
if liste_ladephasen[Zyklus - 1,
0] == 0 and liste_ladephasen[Zyklus - 1,
1] == 0:
break
ladephase_neu = np.array([[
liste_minima[Zyklus - 1] - (ladedauer_neu / (2)),
liste_minima[Zyklus - 1] + (ladedauer_neu / (2))
]])
SOC_neu = get_SOC(array_names, ladephase_neu, Zyklus)
entladedauer_neu = get_entladedauer(array_names, SOC_neu, Zyklus)
print('SOC:', SOC_neu)
print('entladedauer:', entladedauer_neu)
entladephase_neu = np.array([[
liste_maxima[Zyklus - 1] - (entladedauer_neu / (3 * 3600)),
liste_maxima[Zyklus - 1] + (2 * entladedauer_neu / (3 * 3600))
]]) # &&&
print('ladephase die getestet wird:', ladephase_neu)
print('entladephase die getestet wird:', entladephase_neu)
input_laden = merge(ladephase_neu, dir_laden_daten)
input_entladen = merge(entladephase_neu, dir_laden_daten)
try:
#erzeuge Instanz von Dymola
dymola = DymolaInterface()
dymola.openModel(path=dir_modell_sim)
dymola.translateModel(problem=name_modell_sim)
dymola.ExecuteCommand("laden.table=" + input_laden)
dymola.ExecuteCommand("entladen.table=" + input_entladen)
result = dymola.simulateExtendedModel(
problem=name_modell_sim,
stopTime=simulationsdauer * 3600,
method='radau IIa',
finalNames=['Stromkosten.y'],
resultFile=os.path.join(Root_simulationsergebnisse,
'optimization_test'))
Stromkosten = result[1]
column = np.array([ladedauer_neu, Stromkosten[0]])
ergebnis = np.vstack((ergebnis, column))
print('aktuelle Stromkosten', Stromkosten[0])
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastError()
print(log)
dymola.plot(["elektrische_leistungsaufnahme.y"])
dymola.ExportPlotAsImage(
os.path.join(
Root_simulationsergebnisse,
"Ergebnis_von" + str(Zyklus) + str(opt) + ".png"))
except DymolaException as ex:
print("Error: " + str(ex))
if dymola is not None:
dymola.close()
dymola = None
print(
'Optimierungsdurchgang der in dem Entsprechenden Strompreiszyklus durchgeführt wurde',
opt)
if opt > 1:
if ergebnis[opt, 1] < ergebnis[opt - 1, 1]:
better = True
else:
better = False
else:
better = True
print('better:', better)
if better == True:
liste_ladephasen[Zyklus - 1, :] = ladephase_neu
liste_entladephasen[Zyklus - 1, :] = entladephase_neu
ladedauer_neu = ladedauer_neu * 0.9 #ladedauer wird um 10% verkürzt
opt = opt + 1
if ergebnis[opt - 2, 1] > ergebnis_compare:
print('hier_ergebnis', ergebnis)
print('hier_ladeph', liste_ladephasen)
print('hier_opt', opt)
liste_ladephasen[Zyklus - 1, :] = np.zeros((1, 2))
liste_entladephasen[Zyklus - 1, :] = np.zeros((1, 2))
print('hier_ladeph', liste_ladephasen)
Zyklus = Zyklus + 1
print('ergebnis_tabelle des Zyklusses', ergebnis)
#&&& hier einfügen, dass eine Lade/und Entladephase nur verwendet wird, wenn das ergebnis besser als das vergleichsergebnis ist
return liste_ladephasen, liste_entladephasen
def _CheckStyle(self):
DymolaVersion = self.DymolaVersion
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
import buildingspy.development.regressiontest as u
ut = u.Tester(tool=self.tool)
if platform.system() == "Windows":
dymola = DymolaInterface(showwindow=True)
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
# Load AixLib
LibraryCheck = dymola.openModel(self.Library)
if LibraryCheck == True:
print("Found AixLib Library and start style check")
elif LibraryCheck == False:
print(
"Library Path is wrong. Please Check Path of AixLib Library Path"
)
exit(1)
# Load ModelManagement
if platform.system() == "Windows":
dymola.ExecuteCommand(
'cd("C:\Program Files\Dymola ' + DymolaVersion +
'\Modelica\Library\ModelManagement 1.1.8\package.moe");')
else:
dymola.ExecuteCommand(
'cd("/opt/dymola-' + DymolaVersion +
'-x86_64/Modelica/Library/ModelManagement 1.1.8/package.moe");'
)
# Start CheckLibrary in ModelManagement
print("Start Style Check")
if self.Changedmodels == False:
print("Check package or model " + self.Package)
dymola.ExecuteCommand(
'ModelManagement.Check.checkLibrary(false, false, false, true, "'
+ self.Package + '", translationStructure=false);')
Logfile = self.Library.replace(
"package.mo", self.Package + "_StyleCheckLog.html")
else:
changed_model_list = []
list_mo_models = git_models(".mo", self.Package)
model_list = list_mo_models.sort_mo_models()
for l in model_list:
print("Check package or model " + l)
path = self.Library.replace("package.mo", "")
dymola.ExecuteCommand(
'ModelManagement.Check.checkLibrary(false, false, false, true, "'
+ l + '", translationStructure=false);')
inputfile = path + l + "_StyleCheckLog.html"
log = codecs.open(inputfile, "r", encoding='utf8')
for line in log:
changed_model_list.append(line)
log.close()
os.remove(inputfile)
path_outfile = "ChangedModels_StyleCheckLog.html"
all_logs = codecs.open(path + path_outfile, "w", encoding='utf8')
for i in changed_model_list:
all_logs.write(i)
all_logs.close()
Logfile = path + path_outfile
dymola.close()
print("Style Check Complete")
return Logfile, model_list
def _WriteWhiteList():
#_listAllModel
rootdir = r"D:\Gitlab\modelica-ibpsa\IBPSA"
#rootdir = self.Package
ModelList = []
for subdir, dirs, files in os.walk(rootdir):
for file in files:
filepath = subdir + os.sep + file
if filepath.endswith(".mo") and file != "package.mo":
model = filepath
if platform.system() == "Windows":
model = model.replace("\\", ".")
else:
model = model.replace("//", ".")
model = model[model.rfind("IBPSA"):model.rfind(".mo")]
ModelList.append(model)
#_CheckModel
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
import buildingspy.development.regressiontest as u
#ut = u.Tester(tool = self.tool)
### Set Number of Threads
#ut.setNumberOfThreads(self.n_pro)
### Set GUI Show
#ut.showGUI(self.show_gui)
### Set in Batch Mode
#ut.batchMode(self.batch)
### Sets the Dymola path to activate the GUI
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
### Writes all information in the log file, not only the last entries
dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
Library = "IBPSA/package.mo"
PackageCheck = dymola.openModel(Library)
if PackageCheck == True:
print(
"Found AixLib Library and start Checkmodel Tests \n Check Package "
+ self.Package + " \n")
elif PackageCheck == None:
print(
"Library Path is wrong. Please Check Path of AixLib Library Path")
exit(1)
## Check the Package
ErrorList = []
for i in ModelList:
result = dymola.checkModel(i)
if result == True:
print('\n Check of Package ' + i + ' was Successful! \n')
#dymola.close()
#return 0
#exit(0)
if result == False:
#print('\n ModelCheck Failed in Package ' + i + ' Show Savelog \n')
ErrorList.append(i)
#print(Log)
#dymola.clearlog()
#dymola.close()
#return 1
#exit(1)"""
dymola.close()
IBPSA_PackageName = []
### Write the Package Names of IBPSA
for i in ModelList:
i = i.split(".")
i = i[1]
if i not in IBPSA_PackageName:
IBPSA_PackageName.append(i)
filename = r"D:\Gitlab\GitLabCI\WhiteLists\CheckModel\WhiteList_CheckModel.txt"
file = open(filename, "w")
for i in IBPSA_PackageName:
List = []
for l in ModelList:
Package = l.split(".")[1]
if Package == i:
List.append(l)
file.write(i + "\n" + str(List) + "\n" + "\n")
file.close()
print("Write Whitelist")
def _SimulateModel(self):
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
import buildingspy.development.regressiontest as u
ut = u.Tester(tool = self.tool)
### Set Number of Threads
ut.setNumberOfThreads(self.n_pro)
### Set GUI Show
ut.showGUI(self.show_gui)
### Set in Batch Mode
ut.batchMode(self.batch)
### Sets the Dymola path to activate the GUI
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
### Writes all information in the log file, not only the last entries
dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
dym_sta_lic_available = dymola.ExecuteCommand('RequestOption("Standard");')
if not dym_sta_lic_available:
dymola.ExecuteCommand('DymolaCommands.System.savelog("Log_NO_DYM_STANDARD_LIC_AVAILABLE.txt");')
print("No Dymola License is available")
dymola.close()
exit(1)
else:
print("Dymola License is available")
PackageCheck = dymola.openModel(self.Library)
if PackageCheck == True:
print("Found AixLib Library and start Checkmodel Tests \n Check Package " + self.Package+" \n")
elif PackageCheck == None:
print("Library Path is wrong. Please Check Path of AixLib Library Path")
exit(1)
ErrorList = []
if self.Changedmodels == False:
ModelList = ValidateTest._listAllExamples(self)
if len(ModelList) == 0:
print("Wrong Path")
exit(0)
for i in ModelList:
result=dymola.checkModel(i,simulate=True)
if result == True:
print('\n Successful: '+i+'\n')
if result == False:
print("Second Check Test")
result=dymola.checkModel(i,simulate=True)
if result == True:
print('\n Successful: '+i+'\n')
if result == False:
ErrorList.append(i)
Log = dymola.getLastError()
print('\n Error: '+i+'\n')
print(Log)
if self.Changedmodels == True:
list_path = 'bin'+os.sep+'03_WhiteLists'+os.sep+'changedmodels.txt'
list_mo_models = git_models(".mo",self.Package, list_path)
model_list= list_mo_models.sort_mo_models()
ErrorList = []
for i in model_list:
result=dymola.checkModel(i,simulate=True)
if result == True:
print('\n Successful: '+i+'\n')
if result == False:
print("Second Check Test")
result=dymola.checkModel(i,simulate=True)
if result == True:
print('\n Successful: '+i+'\n')
if result == False:
ErrorList.append(i)
Log = dymola.getLastError()
print('\n Error: '+i+'\n')
print(Log)
dymola.savelog(self.Package+"-log.txt")
dymola.close()
logfile = self.Package+"-log.txt"
ValidateTest._WriteErrorlog(self,logfile)
return ErrorList
osString = platform.system()
isWindows = osString.startswith("Win")
dymola = None
try:
# Instantiate the Dymola interface and start Dymola
dymola = DymolaInterface()
# Call a function in Dymola and check its return value
result = dymola.simulateModel("Modelica.Mechanics.Rotational.Examples.CoupledClutches")
if not result:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastErrorLog()
print(log)
exit(1)
dymola.plot(["J1.w", "J2.w", "J3.w", "J4.w"])
if (isWindows):
plotPath = "C:/temp/plot.png"
else:
plotPath = "/tmp/plot.png";
dymola.ExportPlotAsImage(plotPath)
print("OK")
except DymolaException as ex:
print(("Error: " + str(ex)))
finally:
if dymola is not None:
dymola.close()
dymola = None
def dymola_simulation(model_info, path_dymola, solver, printInfo=True):
'''
'''
# Retrieving model information
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']
dymola = None
try:
if printInfo:
print("Creating and starting Dymola instance")
# Creating dymola instance
dymola = DymolaInterface(dymolapath=path_dymola)
if printInfo:
print(f"Using Dymola port:" + str(dymola._portnumber))
print(f"Changing working directory to: {output_path}")
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 THE PATH TO OPENING THE LIBRARY AND THE MODEL
result = dymola.cd(root_path)
if not result:
print("1: Failed to change working directory")
# Opening OpenIPSL library
dymola.openModel(library_path)
if result and printInfo:
print("Library opened")
# Opening model
dymola.openModel(model_path)
if result and printInfo:
print("Model opened")
# CHANGING THE PATH FOR THE WORKING DIRECTORY
# Note that the model is already opened
result = dymola.cd(output_path)
if not result:
print("1: Failed to change working directory")
# Simulating the model
if solver == 'dassl':
dymola.Execute("Advanced.Define.DAEsolver = true")
print("DAE setting changed for dassl")
if solver in ["Rkfix2", "Rkfix4", "Euler"]:
print("Running simulation...")
result = dymola.simulateModel(model_name,
method=solver,
stopTime=120,
numberOfIntervals=240000,
tolerance=1e-06,
resultFile=model_name +
"_{}".format(solver))
else:
# Settings for dassl
print("Running simulation...")
result = dymola.simulateModel(model_name,
method=solver,
stopTime=120,
numberOfIntervals=5000,
tolerance=1e-06,
resultFile=model_name +
"_{}".format(solver))
if not result:
print("Simulation failed. Below is the error log:")
log = dymola.getLastErrorLog()
print(log)
else:
print("Simulation OK")
# Close Dymola
dymola.close()
except DymolaException as ex:
if printInfo:
print(("Error: " + str(ex)))
else:
pass
finally:
if dymola is not None:
dymola.close()
dymola = None
def simulate(simSettings,
showWindow=False,
closeWindow=True,
simID='',
seed=0,
singleTranslate=True):
'''
simSettings => dictionary of setting parameters (see below for details)
showWindow => =True to launch Dymola GUI
closeWindow => =False to prevent auto-closing of the Dymola GUI when done
simID => simulation ID to differentiate output files (e.g., simID_dsres0.mat vs. dsres0.mat)
seed => starting seed value for output file naming (e.g., seed+0, ..., seed+len(experiments))
singleTranslate => =True to only translate the model once
- !!! If variables needed to be changed require retranslation then add them to problem name.
i.e., simSettings['problem']=['Example.Test(var1=1,var2=5)'] or try to set 'annotation(Evaluate=false)' in the model
simSettings details:
- All settings, besides `=None`, must be enclosed in brackets []
- !!! 'initialNames' and 'initialValues' are set different than others.
Specify each variable indepenently. The script will generate the tests
and collapse all 'non-standard' keys.
- 'problem', 'resultFile', and 'autoLoad' only support 1 or None entries
- Only specify 'numberOfIntervals' or 'outputInterval', not both
- 'fixedstepsize' is only for fixed step size solvers
- showWindow=True and closeWindow=False only a specified number of simulations
are retained in memory according, not all simulations.
- The experiments generated are a list of dictionaries which are saved
as experiments.pickle in the working directory of the Modelica simulation (cwdMOD).
To open the pickle in python:
with open(os.path.join('PATHTOPICKLE,'experiments.pickle'), 'rb') as handle:
experiments = pickle.load(handle)
- !!! Settings not specified assume Dymola default settings.
Any simulation settings (tolerance, solver, etc.) located in the model
are ignored.
Default Settings:
'problem' = '' => Modelica file (.mo) to be run (e.g., ['TRANSFORM.Fluid.Examples.RankineCycl'] )
'startTime' = 0 => Start time of simulation
'stopTime' = 1 => Stop time of simulation
'numberOfIntervals' = 500 => Number of intervals to be saved to result file
'outputInterval' = 0 => Time (seconds) between intervals to be saved to result file
'method' = 'dassl' => Solver
'tolerance' = 0.0001 => Solver tolerance
'fixedstepsize' = 0 => Step size for solver (certain solvers only, e.g., Euler)
'resultFile' = 'dsres.mat' => Name of the result file
'initialNames' = '' => Names of variables in model
'initialValues' = '' => Value of variables in model (len(initialNames) = len(initialValues))
'finalNames' = '' => Variable for Dymola to print to screen when simulation is finished
'autoLoad' = true => Automatically load (true) the result file into the Dymola plot window
Possible Methods:
'methods' = Lsodar, dassl, Euler, Rkfix2, Rkfix3, Rkfix4,
Esdirk23a, Esdirk34a, Esdirk45a, Dopri45, Dopri853,
Sdirk34hw, Cerk23, Cerk34, Cerk34, Cvode
For the current supported solvers and their use see Dymola
'''
# Check User Input
checkInput(simSettings)
try:
if int(seed) >= 0:
seed = int(seed)
else:
raise NameError("seedNum must be a positive integer")
except:
raise NameError("seedNum must be a positive integer")
# Modify simID for naminc conventions
if simID != '':
simID = simID + '_'
# Generate all experiment permutations
experimentsRaw = genExperimentsRaw(simSettings)
# Filter experiments to generate key/value pairs for 'initialNames' and 'initialValues'
experiments = genExperiments(experimentsRaw)
# Instantiate the Dymola interface and start Dymola
dymola = None
result_tran = False
try:
# Open Dymola
dymola = DymolaInterface(showwindow=showWindow)
# Get working directory
cwdMod = dymola.ExecuteCommand(
'Modelica.Utilities.System.getWorkDirectory();')
# Translate the model
if singleTranslate:
result_tran = dymola.translateModel(experiments[0]['problem'])
if not result_tran:
raise Exception(
"Translation failed. Aborting parametric simulation. Investigate model in IDE for details."
)
# Run all experiments
saveResult = []
j = seed
print('Total experiments = {} for simID = "{}"'.format(
len(experiments), simID))
print('Experiment numbering started at seed = {}'.format(seed))
for i, value in enumerate(experiments):
j = seed + i
print('Experiment {} (= {}/{})'.format(j, i + 1, len(experiments)))
print(value)
# ModelTranslate = "Dymola.Path.To.Your.Model(Dymola.Path.to.Variable=1000)"
if not singleTranslate:
result_tran = False
result_tran = dymola.translateModel(value['problem'])
if not result_tran:
print(
"Translation failed. Aborting parametric simulation. Investigate model in IDE for details."
)
break
# Simulate the model
result = dymola.simulateExtendedModel(**value)[0]
# Save the result (success/fail)
saveResult.append(result)
# Rename the log files and return new log file for debugging ref.
dslogNew = renameFiles(simID, j, value, cwdMod, result)
# Print last line of error
if not result:
print(
"Simulation failed. Below is the translation log. For more details see: {}"
.format(dslogNew))
log = dymola.getLastErrorLog()
print('### Log Start ###\n' + log + '### Log End ###')
except DymolaException as ex:
print(("Error: " + str(ex)))
except Exception as inst:
print('{}'.format(inst.message))
finally:
if dymola is not None:
if showWindow == True and closeWindow == False:
pass
else:
dymola.close()
if result_tran:
# Save experiment dictionary as pickle in cwdMod
with open(
os.path.join(
cwdMod,
'{}experiments_{}to{}.pickle'.format(simID, seed, j)),
'wb') as handle:
pickle.dump(experiments, handle, protocol=pickle.HIGHEST_PROTOCOL)
# Save summary off success/fail (true/false) of simulations
with open(
os.path.join(cwdMod,
'{}summary_{}to{}.txt'.format(simID, seed, j)),
'w') as fil:
fil.write('Summary of success/fail (true/false) of experiments\n')
for i, val in enumerate(saveResult):
fil.write('\t'.join(
['Experiment', '{}'.format(i), '{}'.format(val)]) + '\n')
def simulate_flex(model_name, model_path, sim_duration, flex_var, param_dict):
dymola = DymolaInterface()
#Model muss noch geöffnet sein
openModel = dymola.openModel(path=model_path)
print(openModel)
translateModel = dymola.translateModel(problem=model_name)
print(translateModel)
if flex_var == 1:
#erste Ebene
dymola.ExecuteCommand("konf_Bivalenz=true")
dymola.ExecuteCommand("konf_HK=true")
dymola.ExecuteCommand("konf_BHKW_stromgefuehrt=false")
#zweite Ebene
dymola.ExecuteCommand(str("konf_BHKW=" + param_dict["konf_BHKW"]))
dymola.ExecuteCommand(str("konf_WRG=" + param_dict["konf_WRG"]))
dymola.ExecuteCommand(str("konf_Puffer=" + param_dict["konf_Puffer"]))
dymola.ExecuteCommand(str("Anzahl_HK=" + param_dict["Anzahl_HK"]))
#die if-Bedingung ist nur zur Sicherheit
if param_dict["konf_WRG"] == "true":
dymola.ExecuteCommand(str("Anzahl_WRG=" +
param_dict["Anzahl_WRG"]))
else:
dymola.ExecuteCommand("Anzahl_WRG=0")
elif flex_var == 2:
#erste Ebene
dymola.ExecuteCommand("konf_BHKW=true")
dymola.ExecuteCommand("konf_Bivalenz=false")
dymola.ExecuteCommand("konf_BHKW_Puffer=true")
dymola.ExecuteCommand("konf_BHKW_stromgefuehrt=true")
#zweite Ebene
dymola.ExecuteCommand(str("konf_HK=" + param_dict["konf_HK"]))
dymola.ExecuteCommand(str("konf_WRG=" + param_dict["konf_WRG"]))
#die if-Bedingung ist nur zur Sicherheit
if param_dict["konf_HK"] == "true":
dymola.ExecuteCommand(str("Anzahl_HK=" + param_dict["Anzahl_HK"]))
else:
dymola.ExecuteCommand("Anzahl_HK=0")
#die if-Bedingung ist nur zur Sicherheit
if param_dict["konf_WRG"] == "true":
dymola.ExecuteCommand(str("Anzahl_WRG=" +
param_dict["Anzahl_WRG"]))
else:
dymola.ExecuteCommand("Anzahl_WRG=0")
else:
print("Auswahl der Flexibilisierungsmaßnahme fehlerhaft")
result = dymola.simulateExtendedModel(problem=model_name,
stopTime=sim_duration,
finalNames=[
"konf_Bivalenz", "konf_HK",
"konf_BHKW_stromgefuehrt",
"konf_BHKW", "konf_WRG",
"konf_Puffer", "Anzahl_WRG",
"Anzahl_HK"
])
if not result[0]:
print("Simulation failed. Below is the translation log.")
log = dymola.getLastError()
print(log)
print('ERGEBNIS_Inhalt:', "konf_Bivalenz", "konf_HK",
"konf_BHKW_stromgefuehrt", "konf_BHKW", "konf_WRG", "konf_Puffer",
"Anzahl_WRG", "Anzahl_HK")
#saveModel=dymola.saveTotalModel('C:/Users/theisinger_l/waerme_save.mo', "waerme")
#Achtung Dymola speichert mit saveTotalModel anscheinend nicht parameterwerte ab..
#print(saveModel)
dymola.close()
return result
class DymolaLauncher(object):
"""
Dymola Launcher
"""
def __init__(self, **kwargs):
"""
This class is aimed to launch Dymola jobs
via the python interface
@ In, kwargs, dict, the dictionary of options
"""
from dymola.dymola_interface import DymolaInterface
# intialize dymola
cwd = os.getcwd()
if sys.platform.startswith("win"):
print("trying to find dymola executable")
found = None
for item in sys.path:
if item.endswith("dymola.egg"):
found = item
if found is not None:
print("dymola found in: ", found)
dymola_exe = os.path.join(
os.path.dirname(
os.path.dirname(os.path.dirname(
os.path.dirname(found)))), "bin64", "dymola.exe")
print("dymola exe: ", dymola_exe)
self.dymola = DymolaInterface(dymolapath=dymola_exe)
else:
print("dymola not found in", sys.path)
self.dymola = DymolaInterface()
else:
self.dymola = DymolaInterface()
self.workDir = kwargs.get("workingDir")
if not os.path.isabs(self.workDir):
self.workDir = os.path.join(cwd, self.workDir)
print("swd", self.workDir, "cwd", cwd, "MODELICAPATH",
os.environ.get("MODELICAPATH", ""))
self.silent = kwargs.get("silent")
self.dymola.cd(self.workDir)
self.dymola.experimentSetupOutput(events=False)
def run(self, input):
"""
Run the input file
@ In, input, str, the input file to run
@ Out, None
"""
self.returnOut = self.dymola.RunScript(input, silent=self.silent)
def getResultOutput(self):
"""
Return the result
@ In, None
@ Out, outcome, tuple, outcome (result, returnCode, log)
"""
if not self.returnOut:
outcome = (None, -1, self.dymola.getLastErrorLog())
else:
outcome = (self.returnOut, 0, self.dymola.getLastErrorLog())
print("result", outcome)
return outcome
def close(self):
"""
Finalize dymola
@ In, None
@ Out, None
"""
self.dymola.close()