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 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 __init__(self, library, wh_lib):
self.library = library
self.wh_lib = wh_lib
self.wh_lib_path = self.wh_lib + os.sep + self.wh_lib + os.sep + "package.mo"
sys.path.append('bin/CITests')
from _config import ch_file, wh_file, exit_file
self.ch_file = ch_file
self.wh_file = wh_file
self.exit_file = exit_file
self.CRED = '\033[91m' # Colors
self.CEND = '\033[0m'
self.green = '\033[0;32m'
from dymola.dymola_interface import DymolaInterface # Load modelica python interface
from dymola.dymola_exception import DymolaException
print(f'1: Starting Dymola instance')
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
self.dymola = dymola
self.dymola_exception = DymolaException()
self.dymola.ExecuteCommand(
"Advanced.TranslationInCommandLog:=true;"
) # ## Writes all information in the log file, not only the
def __init__(self, package, library, dymolaversion, changed_models):
self.package = package
self.library = library
self.dymolaversion = dymolaversion
self.changed_models = changed_models
sys.path.append('bin/CITests')
from _config import exit_file, html_wh_file, ch_file
self.exit_file = exit_file
self.html_wh_file = html_wh_file
self.ch_file = ch_file
self.CRED = '\033[91m' # Colors
self.CEND = '\033[0m'
self.green = "\033[0;32m"
from dymola.dymola_interface import DymolaInterface # Load modelica python interface
from dymola.dymola_exception import DymolaException
print(f'1: Starting Dymola instance')
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
self.dymola = dymola
self.dymola_exception = DymolaException()
self.dymola.ExecuteCommand(
"Advanced.TranslationInCommandLog:=true;") # Writes all information in the log file, not only the
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 __init__(self, package, n_pro, show_gui, simulate_examples, ch_models,
mo_library, wh_library, filter_wh):
self.package = package
self.mo_library = mo_library
self.lib_path = self.mo_library + os.sep + "package.mo"
self.root_package = self.mo_library + os.sep + self.package
self.n_pro = n_pro
self.show_gui = show_gui
self.simulate_ex = simulate_examples
self.ch_models = ch_models
self.wh_library = wh_library
self.filter_wh = filter_wh
sys.path.append('bin/CITests')
from _config import ch_file, wh_file
self.ch_file = ch_file
self.wh_file = wh_file
self.err_log = f'{self.mo_library}{os.sep}{self.mo_library}.{self.package}-errorlog.txt'
self.CRED = '\033[91m' # Colors
self.CEND = '\033[0m'
self.green = "\033[0;32m"
from dymola.dymola_interface import DymolaInterface # Load modelica python interface
from dymola.dymola_exception import DymolaException
print(f'1: Starting Dymola instance')
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
self.dymola = dymola
self.dymola_exception = DymolaException()
self.dymola.ExecuteCommand(
"Advanced.TranslationInCommandLog:=true;"
) # Writes all information in the log file, not only the
def _Advanced():
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
dymola = DymolaInterface()
dymola.Execute(
r"N:\Forschung\EBC0387_Vaillant_Low_GWP_HP_study_GES\Students\cve-shi\02_Hiwi\05_GIT\Dymola\GitLabCI\bin\CITests\UnitTests\CheckPackages\CheckModelTests.mos"
)
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 setUpClass(cls):
cls.project_dir, _ = os.path.split(__file__)
temp_dir = os.path.join(cls.project_dir, 'Temp')
# clean up
if os.path.isdir(temp_dir):
shutil.rmtree(temp_dir)
# extract the distribution file
with zipfile.ZipFile("Modelica-Arduino.zip", "r") as zip_ref:
zip_ref.extractall("Temp")
package_file = os.path.join(temp_dir, 'Arduino', 'package.mo')
print("Starting Dymola")
cls.dymola = DymolaInterface(showwindow=False)
cmd = 'openModel("{}")'.format(package_file)
print("Loading Arduino library")
cls.dymola.ExecuteCommand(cmd)
print("Setting Compiler")
cls.dymola.ExecuteCommand(
'SetDymolaCompiler("vs", {"CCompiler=MSVC","MSVCDir=C:/Program Files (x86)/Microsoft Visual Studio 14.0/Vc"});'
)
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 __init__(self, package, library, dymolaversion, path):
self.package = package
self.library = library
self.dymolaversion = dymolaversion
self.path = path
sys.path.append('../bin/CITests')
from _config import ch_file, resource_dir
self.changed_file = f'..{os.sep}{ch_file}'
self.resource_file_path = f'{resource_dir}{os.sep}{self.package.replace(self.library + ".", "")}'
self.package_path = f'{self.package}'
self.CRED = '\033[91m' # Color
self.CEND = '\033[0m'
self.green = "\033[0;32m"
if self.package is None:
print(
f'{self.CRED}Error:{self.CEND} Package is missing! (e.g. Airflow)'
)
exit(1)
if self.library is None:
print(
f'{self.CRED}Error:{self.CEND} Library is missing! (e.g. AixLib)'
)
exit(1)
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
print(f'1: Starting Dymola instance')
if platform.system() == "Windows":
dymola = DymolaInterface()
else:
dymola = DymolaInterface(dymolapath="/usr/local/bin/dymola")
self.dymola = dymola
self.dymola_exception = DymolaException()
self.dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
librarycheck = self.dymola.openModel(self.path)
if librarycheck == True:
print(f'Found {self.library} Library. Start regression test.')
elif librarycheck == False:
print(
f'Library Path is wrong. Please Check Path of {self.library} Library Path'
)
exit(1)
self.dymola.ExecuteCommand("Advanced.TranslationInCommandLog:=true;")
def _Test():
# Import dymola package
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
dymola = None
#dymola.dymola_interface.DymolaInterface(dymolapath="", port=-1, showwindow=True, debug=False, allowremote=False, nolibraryscripts=False)
try:
dymola = DymolaInterface(showwindow=True)
dymola.simulateModel(
"Modelica.Mechanics.Rotational.Examples.CoupledClutches")
print("Simulate")
except DymolaException as ex:
print("Error")
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 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 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 _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 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 __EnsureDymolaIsOpen(this):
if (not Dymola2.__dymolaIsOpen):
import sys
sys.path.append(
r'C:\Program Files\Dymola 2018 FD01\Modelica\Library\python_interface\dymola.egg'
)
from dymola.dymola_interface import DymolaInterface
from PySimLib import Platform
Dymola2.__interface = DymolaInterface()
print('Dymola-Interface opened')
Dymola2.__dymolaIsOpen = True
#Platform.Execute([GetConfigValue("Dymola2", "PathExe")], False)
Dymola2.__interface.ExecuteCommand("OutputCPUtime:=true;")
else:
print('Dymola is still open')
def make_dymola(cls):
import sys
import os
if cls.dymola == None:
# Work-around for the environment variable
sys.path.insert(0, os.path.join(cls.dym_path))
# Import Dymola Package
print(cls.dym_path)
global dymola
from dymola.dymola_interface import DymolaInterface
# Start the interface
cls.dymola = DymolaInterface()
for i, path in enumerate(cls.lib_paths):
print(path)
check = cls.dymola.openModel(os.path.join(path, 'package.mo'))
print('Opening successful ' + str(check))
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 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 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 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 __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 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
import pandas as pd
import numpy as np
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']}
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 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 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 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
import platform
from dymola.dymola_interface import DymolaInterface
from dymola.dymola_exception import DymolaException
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:
#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'],
)
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