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 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 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 _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(): 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 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 simulate_flex(model_name, model_path, sim_duration, flex_var, param_dict): dymola = DymolaInterface() #Model muss noch geöffnet sein openModel = dymola.openModel(path=model_path) print(openModel) translateModel = dymola.translateModel(problem=model_name) print(translateModel) if flex_var == 1: #erste Ebene dymola.ExecuteCommand("konf_Bivalenz=true") dymola.ExecuteCommand("konf_HK=true") dymola.ExecuteCommand("konf_BHKW_stromgefuehrt=false") #zweite Ebene dymola.ExecuteCommand(str("konf_BHKW=" + param_dict["konf_BHKW"])) dymola.ExecuteCommand(str("konf_WRG=" + param_dict["konf_WRG"])) dymola.ExecuteCommand(str("konf_Puffer=" + param_dict["konf_Puffer"])) dymola.ExecuteCommand(str("Anzahl_HK=" + param_dict["Anzahl_HK"])) #die if-Bedingung ist nur zur Sicherheit if param_dict["konf_WRG"] == "true": dymola.ExecuteCommand(str("Anzahl_WRG=" + param_dict["Anzahl_WRG"])) else: dymola.ExecuteCommand("Anzahl_WRG=0") elif flex_var == 2: #erste Ebene dymola.ExecuteCommand("konf_BHKW=true") dymola.ExecuteCommand("konf_Bivalenz=false") dymola.ExecuteCommand("konf_BHKW_Puffer=true") dymola.ExecuteCommand("konf_BHKW_stromgefuehrt=true") #zweite Ebene dymola.ExecuteCommand(str("konf_HK=" + param_dict["konf_HK"])) dymola.ExecuteCommand(str("konf_WRG=" + param_dict["konf_WRG"])) #die if-Bedingung ist nur zur Sicherheit if param_dict["konf_HK"] == "true": dymola.ExecuteCommand(str("Anzahl_HK=" + param_dict["Anzahl_HK"])) else: dymola.ExecuteCommand("Anzahl_HK=0") #die if-Bedingung ist nur zur Sicherheit if param_dict["konf_WRG"] == "true": dymola.ExecuteCommand(str("Anzahl_WRG=" + param_dict["Anzahl_WRG"])) else: dymola.ExecuteCommand("Anzahl_WRG=0") else: print("Auswahl der Flexibilisierungsmaßnahme fehlerhaft") result = dymola.simulateExtendedModel(problem=model_name, stopTime=sim_duration, finalNames=[ "konf_Bivalenz", "konf_HK", "konf_BHKW_stromgefuehrt", "konf_BHKW", "konf_WRG", "konf_Puffer", "Anzahl_WRG", "Anzahl_HK" ]) if not result[0]: print("Simulation failed. Below is the translation log.") log = dymola.getLastError() print(log) print('ERGEBNIS_Inhalt:', "konf_Bivalenz", "konf_HK", "konf_BHKW_stromgefuehrt", "konf_BHKW", "konf_WRG", "konf_Puffer", "Anzahl_WRG", "Anzahl_HK") #saveModel=dymola.saveTotalModel('C:/Users/theisinger_l/waerme_save.mo', "waerme") #Achtung Dymola speichert mit saveTotalModel anscheinend nicht parameterwerte ab.. #print(saveModel) dymola.close() return result
class 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
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(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