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 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")
dymola.ExecuteCommand("Advanced.TranslationInCommandLog = true")
# Simulating the model
if solver == 'dassl':
dymola.ExecuteCommand("Advanced.Define.DAEsolver = true")
print("DAE setting changed for dassl")
if solver in ["Rkfix2", "Rkfix4", "Euler"]:
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 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 Initialize_Simulation(Path, Show=False):
"""
Initializes the simulation via dymola.
Inputs:
Path : String, relative path to model
Show : Boolean, Optional. Shows Dymola Window if True.
Default is False
Returns:
Model_Instance : Instance of the model in the dymola interface.
"""
Model_Instance = DymolaInterface(use64bit=True, showwindow=Show)
Model_Instance.openModel(path=Path)
return Model_Instance
def simulate():
dir_aixlib = r"D:\Sciebo\Programmierung\GIT\_Standard\AixLib\AixLib"
dir_result = r"D:\Sciebo\Programmierung\Tests\Dymola"
dymola = DymolaInterface()
try:
dymola.openModel(path=os.path.join(dir_aixlib, 'package.mo'))
# dymola.openModel(r"D:\Sciebo\Programmierung\Tests\Dymola\Test_BUDO.mo")
dymola.translateModel(
'AixLib.Fluid.BoilerCHP.Examples.Test_BUDO.CompleteModel')
output = dymola.simulateExtendedModel(
problem='AixLib.Fluid.BoilerCHP.Examples.Test_BUDO.CompleteModel',
startTime=0.0,
stopTime=86400,
outputInterval=500,
method="Dassl",
tolerance=0.0001,
resultFile=os.path.join(dir_result, 'demo_results'),
finalNames=['boiler_system.temperature_sensor_2.T'],
)
print(output[1])
error = dymola.getLastError()
print(error)
# dymola.plot(
# ["boiler_system.temperature_sensor_2.T", "combiTimeTable.y[3]"])
# dymola.ExportPlotAsImage(os.path.join(dir_result, "plot.png"))
# list_var = dymola.list(
# r"D:\Sciebo\Programmierung\Tests\Dymola\Test_BUDO.txt", variables='*"H02.1"*')
# print(list_var)
# list_var = dymola.variables(
# r"D:\Sciebo\Programmierung\Tests\Dymola\Test_BUDO.txt")
# print(list_var)
# list_var = dymola.getExperiment()
# print(list_var)
# list_var = dymola.listfunctions(filter="*")
# print(list_var)
dymola.exit()
except:
print("Unexpected error:", sys.exc_info())
dymola.exit()
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 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 TranslateModel(model_path, name, position):
"""
Function to handle the Compilation of Modelica models
inputs
model_path: path of the model
name: name of the subsystems
position: position number of the subsystems
returns:
None
"""
global gl_model_compiled
if gl_model_compiled[position - 1] == False:
import os
import sys
global dymola
""" Dymola configurations"""
if dymola is None:
# Work-around for the environment variable
sys.path.insert(
0,
os.path.join(
r'C:\Program Files\Dymola 2018 FD01\Modelica\Library\python_interface\dymola.egg'
))
# Import Dymola Package
from dymola.dymola_interface import DymolaInterface
# Start the interface
dymola = DymolaInterface()
""" Compilation """
# Open dymola library
for lib in Init.path_lib:
check1 = dymola.openModel(os.path.join(lib, 'package.mo'))
print("Opening successful " + str(check1))
# Force Dymola to use 64 bit compiler
dymola.ExecuteCommand("Advanced.CompileWith64=2")
dymola.cd(Init.path_res + '\\' + Init.name_wkdir + '\\' + name)
# Translate the model
check2 = dymola.translateModel(model_path)
print("Translation successful " + str(check2))
if check2 is True:
gl_model_compiled[position - 1] = True
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 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
import os
# In[198]:
#This is intended to be used in the manuelnvro Dell using Dymola 2020
# In[3]:
#Setting Dymola Interface
dymola = DymolaInterface("/opt/dymola-2020-x86_64/bin64/dymola.sh")
#Setting OpenIPSL library
dymola.openModel("/home/manuelnvro/dev/Gitted/PythonTesting/OpenIPSL-master/OpenIPSL/package.mo")
print("Dymola Machines Simulation Start...\n")
# In[4]:
#Creation of matrix with names, paths and variables
machines = { 'names' : ["GENROU","GENSAL", "GENCLS", "GENROE", "GENSAE", "CSVGN1"],
'path' : ["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.Machines.PSSE.CSVGN1"],
'delta' : ['gENROU.delta', 'gENSAL.delta', 'gENCLS.delta', 'gENROE.delta', 'gENSAE.delta', 'cSVGN1.delta'],
'pelec' : ['gENROU.PELEC', 'gENSAL.PELEC', 'gENCLS.PELEC', 'gENROE.PELEC', 'gENSAE.PELEC', 'cSVGN1.PELEC'],
'speed' : ['gENROU.SPEED', 'gENSAL.SPEED', 'gENCLS.SPEED', 'gENROE.SPEED', 'gENSAE.SPEED', 'cSVGN1.SPEED']}
# In[5]:
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
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 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
class DymolaBaseEnv(gym.Env):
"""
A variation of the ModelicaGym FMU interface that uses the Dymola API.
To install dymola API add dymola.exe to the system PATH variable.
"""
def __init__(self):
"""
:param model_path: path to the model FMU. Absolute path is advised.
:param mode: FMU exporting mode "CS" or "ME"
:param config: dictionary with model specifications:
model_input_names - names of parameters to be used as action.
model_output_names - names of parameters to be used as state descriptors.
model_parameters - dictionary of initial parameters of the model
time_step - time difference between simulation steps
positive_reward - (optional) positive reward for default reward policy. Is returned when episode goes on.
negative_reward - (optional) negative reward for default reward policy. Is returned when episode is ended
:param log_level: level of logging to be used
"""
with open(self.conf_file) as f:
config = json.load(f)
logger.setLevel(config['log_level'])
self.model_name = config['mo_name']
self.dymola = None
self.libs = config['libs']
self.reset_dymola()
# Parameters required by this implementation
self.tau = config['time_step']
self.model_input_names = []
for i in range(len(config['action_names'])):
if config['action_len'][i] <= 1:
self.model_input_names += [config['action_names'][i]]
else:
self.model_input_names += [
f"{config['action_names'][i]}[{x}]"
for x in range(1, 1 + config['action_len'][i])
]
self.model_output_names = config['state_names']
self.model_parameters = config['model_parameters']
self.default_action = config['default_action']
self.add_names = config['additional_debug_states']
self.method = config['method']
self.negative_reward = config['negative_reward']
self.positive_reward = config['positive_reward']
if not len(self.model_input_names) == len(self.default_action):
raise Exception(
"The number of action names and the default action values should be the same length."
)
# initialize the model time and state
self.start = 0
self.stop = self.tau
self.done = False
self.state = self.reset()
# OpenAI Gym requirements
self.action_space = self._get_action_space()
self.observation_space = self._get_observation_space()
self.debug_data = {name: [] for name in self.model_output_names}
self.rbc_action_names = []
for i in range(len(config['rbc_action_names'])):
if config['rbc_action_len'][i] <= 1:
self.rbc_action_names += [config['rbc_action_names'][i]]
else:
foo = config['rbc_action_names'][i]
bar = config['rbc_action_len'][i]
self.rbc_action_names += [
f"{foo}[{x}]" for x in range(1, 1 + bar)
]
self.rbc_action = []
self.data = None
self.tracker = 0
self.exception_flag = False
# OpenAI Gym API
def render(self, **kwargs):
"""
OpenAI Gym API. Determines how current environment state should be rendered.
:param kwargs:
:return: implementation should return rendering result
"""
pass
def reset(self):
"""
OpenAI Gym API. Determines restart procedure of the environment
:return: environment state after restart
"""
logger.info(
"Resetting the environment and deleting old results files.")
if os.path.isdir('temp_dir'):
# print("Removing old files...")
for file in os.listdir('temp_dir'):
try:
os.remove(os.path.join(os.getcwd(), 'temp_dir', file))
except:
pass
self.action = self.default_action
self.start = 0
self.stop = self.tau
logger.info("The model is being reset")
res = self.dymola.simulateExtendedModel(
self.model_name,
startTime=self.start,
stopTime=self.stop,
initialNames=self.model_input_names,
initialValues=self.action,
finalNames=self.model_output_names)
self.state = res[1]
self.cached_values = None
self.cached_state = None
self.debug_data = {
name: []
for name in self.model_output_names + self.add_names
}
self.state = self.postprocess_state(self.state)
self.done = not (res[0])
if self.done:
logger.error(
f"Model failed to reset. Dymola simulation from time {self.start} to {self.stop} failed with error message: {self.dymola.getLastError()}"
)
return flatten(self.state)
def reset_dymola(self):
if self.dymola: # this doesn't really seem to be working. It hangs
self.dymola.close()
self.dymola = DymolaInterface()
self.dymola.ExecuteCommand("Advanced.Define.DAEsolver = true")
# load libraries
loaded = []
#self.dymola.eraseClasses('Modelica')
for lib in self.libs: # all paths relative to the cwd
loaded += [self.dymola.openModel(lib, changeDirectory=False)]
if not loaded[-1]:
logger.error(f"Could not find library {lib}")
if not False in loaded:
logger.debug("Successfully loaded all libraries.")
if not os.path.isdir('temp_dir'):
os.mkdir('temp_dir')
self.temp_dir = os.path.join(os.getcwd(), "temp_dir")
self.dymola.cd('temp_dir')
logger.debug("Dymola has been reset")
return
def step(self, action):
"""
OpenAI Gym API. Determines how one simulation step is performed for the environment.
Simulation step is execution of the given action in a current state of the environment.
:param action: action to be executed.
:return: resulting state
"""
logger.debug("Experiment next step was called.")
if self.done:
logger.warning(
"""You are calling 'step()' even though this environment has already returned done = True.
You should always call 'reset' once you receive 'done = True' -- any further steps are
undefined behavior.""")
return np.array(self.state), self.negative_reward, self.done, {}
# check if action is a list. If not - create list of length 1
try:
iter(action)
except TypeError:
action = [action]
logger.warning(
"Model input values (action) should be passed as a list")
# Check if number of model inputs equals number of values passed
if len(action) != len(list(self.model_input_names)):
message = "List of values for model inputs should be of the length {}," \
"equal to the number of model inputs. Actual length {}".format(
len(list(self.model_input_names)), len(action))
logger.error(message)
raise ValueError(message)
# Set input values of the model
logger.debug("model input: {}, values: {}".format(
self.model_input_names, action))
try:
self.done, state = self.do_simulation()
self.state = state
self.start += self.tau
self.stop += self.tau
except:
print("exception")
self.reset()
self.exception_flag = True
return flatten(self.state), self._reward_policy(), self.done, {}
# logging
def get_log_file_name(self):
log_date = datetime.datetime.utcnow()
log_file_name = "{}-{}-{}_{}.txt".format(log_date.year, log_date.month,
log_date.day, self.model_name)
return log_file_name
# internal logic
def _get_action_space(self):
"""
Returns action space according to OpenAI Gym API requirements.
:return: one of gym.spaces classes that describes action space according to environment specifications.
"""
low = -1 * np.ones(len(self.model_input_names))
high = 1 * np.ones(len(self.model_input_names))
return spaces.Box(low, high)
def _get_observation_space(self):
"""
Returns state space according to OpenAI Gym API requirements.
:return: one of gym.spaces classes that describes state space according to environment specifications.
"""
low = -1 * np.ones(len(self.model_output_names))
high = 1 * np.ones(len(self.model_output_names))
return spaces.Box(low, high)
def _is_done(self, results):
"""
Determines logic when experiment is considered to be done.
:return: boolean flag if current state of the environment indicates that experiment has ended.
"""
return not results[0]
def do_simulation(self):
"""
Executes simulation by FMU in the time interval [start_time; stop_time]
currently saved in the environment.
:return: resulting state of the environment.
"""
#print("============================")
logger.debug("Simulation started for time interval {}-{}".format(
self.start, self.stop))
self.act = self.action + self.rbc_action #self.debug_points[-1*self.n_points:]
found = self.dymola.importInitialResult('dsres.mat', atTime=self.start)
print(found)
x = self.dymola.simulateExtendedModel(
self.model_name,
startTime=self.start,
stopTime=self.stop,
initialNames=self.model_input_names + self.rbc_action_names,
initialValues=self.act,
finalNames=self.model_output_names)
finished, state = x
if finished == False:
print('finished = False')
print(self.dymola.getLastError())
state = self.reset()
finished = True
self.get_state_values()
logger.debug("Simulation results: {}".format(state))
return not finished, state
def _reward_policy(self):
"""
Determines reward based on the current environment state.
By default, implements simple logic of penalizing for experiment end and rewarding each step.
:return: reward associated with the current state
"""
if self.exception_flag:
self.exception_flag = False
if self.done:
reward = self.negative_reward
else:
reward = self.positive_reward
return reward
def get_state_values(self):
"""
Extracts the values of model outputs at the end of modeling time interval from simulation result
:return: Values of model outputs as tuple in order specified in `model_outputs` attribute
"""
self.data = DyMat.DyMatFile('temp_dir/dsres.mat')
for name in self.debug_data:
self.debug_data[name] += self.data[name].tolist()
for name in self.add_names + self.model_input_names + self.rbc_action_names:
if not name in self.debug_data:
self.debug_data.update({name: []})
self.debug_data[name] += self.data[name].tolist()
return
def _set_init_parameter(self):
"""
Sets initial parameters of a model.
:return: environment
"""
if self.model_parameters is not None:
self.model.set(list(self.model_parameters),
list(self.model_parameters.values()))
return self
#file:///C:/Program%20Files/Dymola%202019/Modelica/Library/python_interface/doc/index.html
import os
# Import dymola package
from dymola.dymola_interface import DymolaInterface
# Start the interface
dymola = DymolaInterface()
# Location of your local AixLib clone
dir_aixlib = r"C:\Users\hinack\Dropbox\09_Modelica_Library\AixLib"
# Location where to store the results
dir_result = r"C:\Users\hinack\Dropbox\18_ModelManagement"
# Open AixLib
dymola.openModel(path=os.path.join(dir_aixlib, 'package.mo'))
# Translate any model you'd like to simulate
dymola.translateModel('AixLib.ThermalZones.ReducedOrder.Examples.ThermalZone')
# Simulate the model
output = dymola.simulateExtendedModel(
problem='AixLib.ThermalZones.ReducedOrder.Examples.ThermalZone',
startTime=0.0,
stopTime=3.1536e+07,
outputInterval=3600,
method="Dassl",
tolerance=0.0001,
resultFile=os.path.join(dir_result, 'demo_results'),
finalNames=['thermalZone.TAir'],
)
#Setting Dymola Interface
dymola = DymolaInterface("/opt/dymola-2019FD01-x86_64/bin64/dymola.sh")
# In[19]:
#Deleting old OpenIPSL library version
try:
shutil.rmtree(f"" + OpenIPSL + "")
except:
pass
#Pulling latest OpenIPSL library version
print('Pulling latest OpenIPSL library version...\n')
git.Git("" + Dymola + "").clone("" + GitHubOpenIPSL + "")
#Setting OpenIPSL library
dymola.openModel("" + OpenIPSLPackage + "")
print("Fault Dymola Machines Simulation Start...\n")
# In[20]:
#Creation of matrix with names, paths and variables
machines = {
'names': ["GENROU", "GENSAL", "GENCLS", "GENROE", "GENSAE", "CSVGN1"],
'path': [
"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"
],
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 _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 main():
"""Create a system and multiple subsystems"""
AHU = System.System()
subsystems = AHU.GenerateSubSys()
"""Prepare the working Directory"""
os.chdir(Init.path_res)
os.mkdir(str(Init.name_wkdir))
os.chdir(str(Init.name_wkdir))
"""Create one directory for each of the subsystems and one for the inputs"""
for s in subsystems:
os.mkdir(s._name)
os.mkdir("Inputs")
"""Load the FMU model, set the experiment and initialize the inputs"""
global dymola
dymola = None
# Work-around for the environment variable
sys.path.insert(0, os.path.join(str(Init.path_dymola)))
# Import Dymola Package
from dymola.dymola_interface import DymolaInterface
# Start the interface
dymola = DymolaInterface()
""" Simulation """
# Open dymola library
for lib in Init.path_lib:
check1 = dymola.openModel(os.path.join(lib, 'package.mo'))
print('Opening successful ' + str(check1))
dymola.cd(Init.path_res + '\\' + Init.name_wkdir)
# Translate the model to FMU
if Init.create_FMU:
dymola.ExecuteCommand('translateModelFMU("' + Init.path_fmu +
'", true, "' + Init.name_fmu +
'", "1", "cs", false, 0)')
else:
shutil.copyfile(
Init.path_res + "\\" + Init.name_fmu + ".fmu", Init.path_res +
'\\' + Init.name_wkdir + '\\' + Init.name_fmu + '.fmu')
model = load_fmu(Init.path_res + '\\' + Init.name_wkdir + '\\' +
Init.name_fmu + '.fmu')
model.set('humidifierWSP1', 0)
model.set('valveHRS', 0)
model.set('valvePreHeater', 0)
model.set('valveHeater', 0)
model.set('valveCooler', 0)
model.initialize()
model.do_step(0, Init.sync_rate)
"""Variables storing (time) steps"""
time_step = Init.sync_rate
time_storage = 0
start = time.time()
counter = 0
"""Variables storing commands"""
storage_commands = np.zeros([5, 1])
supplyTemps = []
"""There are currently three different options:
1. NC-OPT algorithm
2. NC-OPT algorithm using parallel computing
3. BExMoC algorithm
"""
"""The algorithms work with a discrete *time_step*. In each step, the current measurements are taken using the :func:`GetMeasurements' method. """
while time_step <= Init.sync_rate * Init.stop_time:
# Variable for the final commands of all subsystems
command_all = []
if Init.algorithm == 'NC_DMPC':
if time_step - time_storage >= Init.optimization_interval or time_step == Init.sync_rate:
""" Consider the subsystems in multiple iterations, either in parallel or in sequential order """
for k in range(4):
command_all = []
if Init.parallelization:
def f(s):
commands = s.CalcDVvalues(time_step, time_storage,
k, model)
return commands
p = Pool(4)
commands = p.map(f, [
subsystems[0], subsystems[1], subsystems[2],
subsystems[3], subsystems[4]
])
command_all = commands
else:
for s in subsystems:
commands = s.CalcDVvalues(time_step, time_storage,
k, model)
print(k, s._name, commands)
command_all.append(commands)
elif Init.algorithm == 'BExMoC':
#Consider each subsystem sequentially
for s in subsystems:
print(s._name)
"""The main calculations are carried out by invoking the :func:'CalcDVvalues' method. The BExMoC algorithm exchanges tables between the subsystems in a .mat format"""
commands = (s.CalcDVvalues(time_step, time_storage, 0, model))
command_all.append(commands)
#Save the look-up tables in .mat files
(sio.savemat(
(Init.path_res + '\\' + Init.name_wkdir + '\\' + s._name +
'\\' + 'DV_lookUpTable' + str(counter) + '.mat'),
{'DV_lookUpTable': s.lookUpTables[1]}))
(sio.savemat(
(Init.path_res + '\\' + Init.name_wkdir + '\\' + s._name +
'\\' + 'Costs_lookUpTable' + str(counter) + '.mat'),
{'Cost_lookUpTable': s.lookUpTables[0]}))
(sio.savemat(
(Init.path_res + '\\' + Init.name_wkdir + '\\' + s._name +
'\\' + 'Output_Table' + str(counter) + '.mat'),
{'Output_Table': s.lookUpTables[2]}))
(sio.savemat(
(Init.path_res + '\\' + Init.name_wkdir + '\\' + s._name +
'\\' + 'command' + str(counter) + '.mat'),
{'Output_Table': commands}))
#For real time experiments, the excecution needs to be paused
if Init.realtime:
if time_step > 0:
time.sleep(max(Init.sync_rate - time.time() + start, 0))
start = time.time()
else:
length = len(Init.name)
for l, val in enumerate(command_all):
if Init.names_DVs[length - l - 1] != None:
model.set(Init.names_DVs[length - l - 1], val)
print(val)
model.do_step(time_step, Init.sync_rate)
print('Proceding')
if time_step - time_storage >= Init.optimization_interval:
time_storage = time_step
time_step += Init.sync_rate
counter += 1
Objective_Function.CloseDymola()
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(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 _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