def test_setBooleanParameterValues(self): """ Tests the :mod:`buildingspy.simulate.Dymola.addParameters` function for boolean parameters. """ from buildingspy.io.outputfile import Reader # Delete output file resultFile = os.path.join("BooleanParameters.mat") if os.path.exists(resultFile): os.remove(resultFile) s = Simulator("MyModelicaLibrary.Examples.BooleanParameters", packagePath=self._packagePath) s.addParameters({'p1': True}) s.addParameters({'p2': False}) s.simulate() r = Reader(resultFile, "dymola") (_, p) = r.values('p1') self.assertEqual(p[0], 1.0) (_, p) = r.values('p2') self.assertEqual(p[0], 0.0) # Delete output files s.deleteOutputFiles()
def test_setBooleanParameterValues(self): ''' Tests the :mod:`buildingspy.simulate.Simulator.addParameters` function for boolean parameters. ''' from buildingspy.io.outputfile import Reader # Delete output file resultFile = os.path.join("BooleanParameters.mat") if os.path.exists(resultFile): os.remove(resultFile) s = Simulator("MyModelicaLibrary.Examples.BooleanParameters", "dymola", packagePath=self._packagePath) s.addParameters({'p1' : True}) s.addParameters({'p2' : False}) s.simulate() r = Reader(resultFile, "dymola") (_, p) = r.values('p1') self.assertEqual(p[0], 1.0) (_, p) = r.values('p2') self.assertEqual(p[0], 0.0) # Delete output files s.deleteOutputFiles() s.deleteLogFiles()
def test_setResultFilterRegExp(self): """ Tests the :mod:`buildingspy.simulate.Optimica.setResultFilter` function. """ from buildingspy.io.outputfile import Reader model = "MyModelicaLibrary.Examples.MyStep" resultFile = f"{model.replace('.', '_')}_result.mat" # Delete output file if os.path.exists(resultFile): os.remove(resultFile) s = Simulator(model, packagePath=self._packagePath) s.setResultFilter(["*source.y"]) s.simulate() self.assertTrue( os.path.exists(resultFile), f"Expected file {resultFile} to exist in test_setResultFilterRegExp." ) r = Reader(resultFile, "dymola") (_, _) = r.values('myStep.source.y') # This output should not be stored with self.assertRaises(KeyError): r.values("y") # Delete output files s.deleteOutputFiles()
def run_cdl_simulation(self, model, output_folder, ip_list, op_list, sample_time): """function that runs the CDL simulation using OpenModelica; also converts the .mat output file to .csv Parameters ---------- model : str name of the modelica model output_folder : str name of the folder where the generated mat file with the results will be saved ip_list : list list of input variables for this model op_list : list list of output variables for this model sample_time : int sample time in seconds Returns ------- simulation_output : pd.DataFrame timeseries of input and output variable values from the CDL simulation """ print("in running cdl simulation") omc = OMCSessionZMQ() if not omc.sendExpression("loadModel(Modelica)"): err = omc.sendExpression("getErrorString()") print("error while loading Modelica Standard Library: {}".format( err)) if not omc.sendExpression("loadModel(Buildings)"): err = omc.sendExpression("getErrorString()") print("error while loading Modelica Buildings Library: {}".format( err)) shutil.move("{}_res.mat".format(model), output_folder + "/{}_res.mat".format(model)) for file in os.listdir('.'): if file.startswith(model): os.remove(file) r = Reader(output_folder + "/{}_res.mat".format(model), 'dymola') df_list = [] for ip in ip_list: values = r.values(ip) df = pd.DataFrame(index=values[0], data={ip: values[1]}) df_list.append(df) for op in op_list: values = r.values(op) df = pd.DataFrame(index=values[0], data={op: values[1]}) df_list.append(df) simulation_output = pd.concat(df_list, axis=1).fillna(method='ffill') simulation_output = simulation_output.loc[~simulation_output.index. duplicated(keep='first')] simulation_output.to_csv(output_folder + "/{}_res.csv".format(model)) simulation_output.index = simulation_output.index.astype(float) simulation_output.index.name = 'time' return simulation_output
def main(): """ Main method that plots the results """ import os import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from buildingspy.io.outputfile import Reader # Optionally, change fonts to use LaTeX fonts # from matplotlib import rc # rc('text', usetex=True) # rc('font', family='serif') # Read results ofr1 = Reader( os.path.join("buildingspy", "examples", "dymola", "case1", "PIDHysteresis.mat"), "dymola") ofr2 = Reader( os.path.join("buildingspy", "examples", "dymola", "case2", "PIDHysteresis.mat"), "dymola") (time1, T1) = ofr1.values("cap.T") (time1, y1) = ofr1.values("con.y") (time2, T2) = ofr2.values("cap.T") (time2, y2) = ofr2.values("con.y") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(time1 / 3600, T1 - 273.15, 'r', label='$T_1$') ax.plot(time2 / 3600, T2 - 273.15, 'b', label='$T_2$') ax.set_xlabel('time [h]') ax.set_ylabel(r'temperature [$^\circ$C]') ax.set_xticks(list(range(25))) ax.set_xlim([0, 24]) ax.legend() ax.grid(True) ax = fig.add_subplot(212) ax.plot(time1 / 3600, y1, 'r', label='$y_1$') ax.plot(time2 / 3600, y2, 'b', label='$y_2$') ax.set_xlabel('time [h]') ax.set_ylabel('y [-]') ax.set_xticks(list(range(25))) ax.set_xlim([0, 24]) ax.legend() ax.grid(True) # Save figure to file plt.savefig('plot.pdf') plt.savefig('plot.png')
def main(): """ Main method that plots the results """ import os import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from buildingspy.io.outputfile import Reader # Optionally, change fonts to use LaTeX fonts # from matplotlib import rc # rc('text', usetex=True) # rc('font', family='serif') # Read results ofr1 = Reader(os.path.join("buildingspy", "examples", "dymola", "case1", "PIDHysteresis.mat"), "dymola") ofr2 = Reader(os.path.join("buildingspy", "examples", "dymola", "case2", "PIDHysteresis.mat"), "dymola") (time1, T1) = ofr1.values("cap.T") (time1, y1) = ofr1.values("con.y") (time2, T2) = ofr2.values("cap.T") (time2, y2) = ofr2.values("con.y") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(time1 / 3600, T1 - 273.15, 'r', label='$T_1$') ax.plot(time2 / 3600, T2 - 273.15, 'b', label='$T_2$') ax.set_xlabel('time [h]') ax.set_ylabel(r'temperature [$^\circ$C]') ax.set_xticks(list(range(25))) ax.set_xlim([0, 24]) ax.legend() ax.grid(True) ax = fig.add_subplot(212) ax.plot(time1 / 3600, y1, 'r', label='$y_1$') ax.plot(time2 / 3600, y2, 'b', label='$y_2$') ax.set_xlabel('time [h]') ax.set_ylabel('y [-]') ax.set_xticks(list(range(25))) ax.set_xlim([0, 24]) ax.legend() ax.grid(True) # Save figure to file plt.savefig('plot.pdf') plt.savefig('plot.png')
def main(): jsonData = getCases() for (caseName, data) in jsonData.iteritems(): # plot totalPowerLoad for each subcase of each case params = data[0].iteritems() # simulate for each set of variables subCaseAmount = len(params.next()[1]) print("plotting " + str(subCaseAmount) + " subcases for case: " + caseName) plt.figure() for currentSubCase in range(subCaseAmount): print(str(currentSubCase + 1) + "/" + str(subCaseAmount)) matFile = caseName + "_" plotLabel = data[1] variables = [] for (varName, valueList) in data[0].iteritems(): value = valueList[currentSubCase] matFile += varName + "_" + str(value) plotLabel += "_" + str(value) variables.append(varName) fileReader = Reader( os.path.join("output_" + caseName, matFile.replace(".", "_") + ".mat"), "dymola") (t, y) = fileReader.values("totalPowerLoad") # seconds to days t = [x / 86400 for x in t] plt.plot(t, y, label=plotLabel) plt.xlabel("Time [d]") plt.ylabel("MWh") plt.legend() if not os.path.exists("plot_" + caseName): os.makedirs("plot_" + caseName) plt.savefig("plot_" + caseName + "/totalPowerLoad")
def split_plot_variable(var, s, e, x_label, file_name, var_modifier=0.0): mat_file = "case_" + case + ".mat" # PLOT r = Reader(os.path.join("output", mat_file), "dymola") (t, y) = r.values(var) t = t[s:e] y = y[s:e] quick_plot(t, [x + var_modifier for x in y], x_label, var, file_name)
def test_translate_simulate_exception_parameter(self): """ Tests the :mod:`buildingspy.simulate.Simulator.translate` and the :mod:`buildingspy.simulate.Simulator.simulate_translated` method. This tests whether an exception is thrown if one attempts to change a parameter that is fixed after compilation """ import numpy as np from buildingspy.io.outputfile import Reader s = Simulator("MyModelicaLibrary.Examples.ParameterEvaluation", "dymola", packagePath=self._packagePath) s.translate() s.setSolver("dassl") desired_value = 0.2 s.addParameters({'x': desired_value}) # Simulate the model with new parameter and check in the output file # whether the parameter is really set. # Dymola 2016 FD01 sets it correctly, but Dymola 2016 does not. try: s.simulate_translated() # No exception. Check results actual_res = Reader(os.path.join(".", 'ParameterEvaluation.mat'), 'dymola') (_, y) = actual_res.values('x') (_, n) = actual_res.values('n') np.testing.assert_allclose(y[0], desired_value) np.testing.assert_allclose(n[0], 5) except IOError as e: # An IOError was raised. Make sure it is raised by simulate_translated print(("Caught IOError with message '{}'".format(e))) self.assertRaises(IOError, s.simulate_translated) # clean up translate temporary dir s.deleteTranslateDirectory() # Delete output files s.deleteOutputFiles() s.deleteLogFiles() # This is called to clean up after an exception in simulate_translated(). s.deleteSimulateDirectory()
def test_translate_simulate_exception_parameter(self): ''' Tests the :mod:`buildingspy.simulate.Simulator.translate` and the :mod:`buildingspy.simulate.Simulator.simulate_translated` method. This tests whether an exception is thrown if one attempts to change a parameter that is fixed after compilation ''' import numpy as np from buildingspy.io.outputfile import Reader s = Simulator("MyModelicaLibrary.Examples.ParameterEvaluation", "dymola", packagePath=self._packagePath) s.translate() s.setSolver("dassl") desired_value = 0.2 s.addParameters({'x': desired_value}) # Simulate the model with new parameter and check in the output file # whether the parameter is really set. # Dymola 2016 FD01 sets it correctly, but Dymola 2016 does not. try: s.simulate_translated() # No exception. Check results actual_res = Reader(os.path.join(".", 'ParameterEvaluation.mat'), 'dymola') (_, y) = actual_res.values('x') (_, n) = actual_res.values('n') np.testing.assert_allclose(y[0], desired_value) np.testing.assert_allclose(n[0], 5) except IOError as e: # An IOError was raised. Make sure it is raised by simulate_translated print(("Caught IOError with message '{}'".format(e))) self.assertRaises(IOError, s.simulate_translated) # clean up translate temporary dir s.deleteTranslateDirectory() # Delete output files s.deleteOutputFiles() s.deleteLogFiles() # This is called to clean up after an exception in simulate_translated(). s.deleteSimulateDirectory()
def _extract_data(matFile, relVal): """ Extract time series data from mat file. :param matFile: modelica simulation result path :param relVal: list of variables that the data should be extracted """ from buildingspy.io.outputfile import Reader from buildingspy.io.postprocess import Plotter import re nPoi = 8761 try: r = Reader(matFile, TOOL) except IOError: raise ValueError("Failed to read {}.".format(matFile)) result = list() for var in relVal: time = [] val = [] try: var_mat = var # Matrix variables in JModelica are stored in mat file with no space e.g. [1,1]. var_mat = re.sub(' ', '', var_mat) (time, val) = r.values(var_mat) tMin = float(min(time)) tMax = float(max(time)) ti = _getTimeGrid(tMin, tMax, nPoi) except KeyError: raise ValueError("Result {} does not have variable {}.".format( matFile, var)) else: intVal = Plotter.interpolate(ti, time, val) temp = {'variable': var, 'time': ti, 'value': intVal} result.append(temp) return result
DNI = [] m_wf = [] T_amb = [] v_wind = [] DNIExp = [] T_suExp = [] T_exExp = [] m_wfExp = [] vector = [ 0, 1] for KKK in range(len(StartModTime)): resultFile=(ModResults+Days[KKK]+'/'+FileSimulation+".mat") r=Reader(resultFile, "dymola") DNI.append(r.values('DNI.y')) NN.append(r.values('EuroTrough.N')) T_su.append(r.values('SensTsu.fluidState.T')) T_ex.append(r.values('SensTex.fluidState.T')) #resultFile='/Users/adriano/Google Drive/GitHub/PSA_SFERAII/Modelling/ModelicaResults/20160629/PTTL_SF_.mat' #r=Reader(resultFile, "dymola") #DNI.append(r.values('DNI.y')) #NN.append(r.values('EuroTrough.N')) #T_su.append(r.values('SensTsu.fluidState.T')) #T_ex.append(r.values('SensTex.fluidState.T')) #TimeSim.append(T_ex[KKK][0]) ##T_ex_exp.append(r.values('t_htf_ex.y')) #Delta_T.append(r.values('DeltaT.Delta'))
legendsize = 10 N = 6 #gs = gridspec.GridSpec(4,1,height_ratios=[1,1,1,1]) ax0 = plt.subplot(1, 1, 1) # print(reader.values("EAnnHea600[1]")[1][-1]) # exit(0) plot_results(ax0, EHeacase600_Avg, EHeacase600_Min, EHeacase600_Max, EHeacase600_E_plus, np.array([ reader.values("EAnnHea600[" + str(i + 1) + "]")[1][-1] for i in range(N) ]), N, -0.3, marker=r'$\mathrm{E}_H$') plt.ylabel('Normalized errors $e_i$') plt.legend(frameon=False, prop={'size': legendsize}, loc=2, ncol=3, numpoints=1) plot_results(ax0, ECoocase600_Avg, ECoocase600_Min,
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt from pylab import * import numpy as np rcParams['legend.loc'] = 'best' r=Reader('HotelModel_annual.mat','dymola') (t1,y1)=r.values('Loa.Loa') (t2,y2)=r.values('GueRooDomWatDem.y[1]') (t3,y3)=r.values('KitHotWatDem.y[1]') y1=y1/1000 t1d=[] t2d=[] t3d=[] y1d=[] y2d=[] y3d=[] for i in range(len(y1)): if t1[i]>3715200 and t1[i]<3801600: t1d.append(t1[i]) y1d.append(y1[i]) for i in range(len(y2)): if t2[i]>3715200 and t2[i]<3801600: t2d.append(t2[i]) y2d.append(y2[i]) for i in range(len(y3)): if t3[i]>3715200 and t3[i]<3801600:
Delta_T = [] DNI = [] m_wf = [] T_amb = [] v_wind = [] DNIExp = [] T_suExp = [] T_exExp = [] m_wfExp = [] vector = [0, 1] for KKK in range(len(StartModTime)): resultFile = (ModResults + Days[KKK] + '/' + FileSimulation + ".mat") r = Reader(resultFile, "dymola") DNI.append(r.values('DNI.y')) NN.append(r.values('EuroTrough.N')) T_su.append(r.values('SensTsu.fluidState.T')) T_ex.append(r.values('SensTex.fluidState.T')) #resultFile='/Users/adriano/Google Drive/GitHub/PSA_SFERAII/Modelling/ModelicaResults/20160629/PTTL_SF_.mat' #r=Reader(resultFile, "dymola") #DNI.append(r.values('DNI.y')) #NN.append(r.values('EuroTrough.N')) #T_su.append(r.values('SensTsu.fluidState.T')) #T_ex.append(r.values('SensTex.fluidState.T')) #TimeSim.append(T_ex[KKK][0]) ##T_ex_exp.append(r.values('t_htf_ex.y')) #Delta_T.append(r.values('DeltaT.Delta')) #m_wf.append(r.values('m_dot_htf.y'))
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt from pylab import figure import os # Change fonts to use LaTeX fonts from matplotlib import rc rc('text', usetex=True) rc('font', family='serif') # Read results ofr=Reader("Temperature_u.mat", "dymola") (t, u) = ofr.values("u") u /= 1e6 (t, T) = ofr.values("T") (t, TMon) = ofr.values("TMonotone") (t, e) = ofr.values("errNonMonotone") (t, eMon) = ofr.values("errMonotone") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(u, T-273.15, 'r', label='$T$') ax.plot(u, TMon-273.15, '--b', markevery=5, label='$T_{monotone}$') ax.set_xlabel('u [MJ/kg]') ax.set_ylabel('temperature [$^\circ$C]') #ax.set_xticks(range(25)) #ax.set_xlim([0, 24]) ax.legend(loc='lower right') ax.grid(True)
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt import os # Optionally, change fonts to use LaTeX fonts #from matplotlib import rc #rc('text', usetex=True) #rc('font', family='serif') # Read results ofr1=Reader(os.path.join("buildingspy", "examples", "dymola", "case1", "PIDHysteresis.mat"), "dymola") ofr2=Reader(os.path.join("buildingspy", "examples", "dymola", "case2", "PIDHysteresis.mat"), "dymola") (time1, T1) = ofr1.values("cap.T") (time1, y1) = ofr1.values("con.y") (time2, T2) = ofr2.values("cap.T") (time2, y2) = ofr2.values("con.y") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(time1/3600, T1-273.15, 'r', label='$T_1$') ax.plot(time2/3600, T2-273.15, 'b', label='$T_2$') ax.set_xlabel('time [h]') ax.set_ylabel('temperature [$^\circ$C]') ax.set_xticks(range(25)) ax.set_xlim([0, 24]) ax.legend() ax.grid(True) ax = fig.add_subplot(212)
df['LIGHTS 1 ROOM 102_CHRIS:Lights Convective Heating Rate [W](TimeStep)'] + \ df['ELECEQ 1 ROOM 102:Electric Equipment Radiant Heating Rate [W](TimeStep)'] + \ df['ROOM 102:Zone Other Equipment Radiant Heating Rate [W](TimeStep)'] ep_int_rad= \ df['LIGHTS 1 ROOM 102:Lights Convective Heating Rate [W](TimeStep)'] + \ df['LIGHTS 1 ROOM 102_CHRIS:Lights Convective Heating Rate [W](TimeStep)'] + \ df['ELECEQ 1 ROOM 102:Electric Equipment Convective Heating Rate [W](TimeStep)'] + \ df['ROOM 102:Zone Other Equipment Convective Heating Rate [W](TimeStep)'] mo_fil_name="/home/thierry/vmWareLinux/proj/buildings_library/models/modelica/git/71_T/modelica-buildings/Buildings/ElectroChromicWindow.mat" mof=Reader(mo_fil_name, "dymola") #(mo_tim, mo_inf) = mof.values("inf.m_flow") # Heat gains in W/m2 (but they are zero anyway. (mo_par, mo_qConGai_flow) = mof.values("qConGai_flow.y") (mo_par, mo_qRadGai_flow) = mof.values("qRadGai_flow.y") ############################################################### # Absorbed solar radiation ep_AGla=8.71 # Glass area, from 71T_singleRoom_Geometry.txt ep_qAbs_sol1=df['GLASS:Surface Window Total Absorbed Shortwave Radiation Rate Layer 1 [W](TimeStep)']/ep_AGla ep_qAbs_sol2=df['GLASS:Surface Window Total Absorbed Shortwave Radiation Rate Layer 2 [W](TimeStep)']/ep_AGla ep_HTotInc=df['GLASS:Surface Outside Face Incident Solar Radiation Rate per Area [W/m2](TimeStep)'] ep_HBeaInc=df['GLASS:Surface Outside Face Incident Beam Solar Radiation Rate per Area [W/m2](TimeStep)'] (_, mo_AGla) = mof.values("roo.conExtWin[1].AGla") print "Modelica glass area: AGla = {}".format(mo_AGla[0]) (mo_tim, mo_qAbs_sol1) = mof.values("roo.conExtWin[1].QAbsUns_flow[1]")
Delta_T = [] DNI = [] m_wf = [] T_amb = [] v_wind = [] DNIExp = [] T_suExp = [] T_exExp = [] m_wfExp = [] for KKK in range(len(StartModTime)): resultFile=('/Users/adriano/Dropbox/GitHub/PSA_SFERAII/Modelling/ModelicaResults/'+Days[KKK]+'/'+FileSimulation+".mat") r=Reader(resultFile, "dymola") DNI.append(r.values('DNI.y')) NN.append(r.values('EuroTrough.N')) T_su.append(r.values('SensTsu.fluidState.T')) T_ex.append(r.values('SensTex.fluidState.T')) TimeSim.append(T_ex[KKK][0]) T_ex_exp.append(r.values('t_htf_ex.y')) Delta_T.append(r.values('DeltaT.Delta')) m_wf.append(r.values('m_dot_htf.y')) # Create a time vector which values every 10 seconds TimeExp.append(np.linspace(StartModTime[KKK],StopModTime[KKK],num=int((StopModTime[KKK]-StartModTime[KKK])/10))) # Interpolate the Modelica results over the Time vector DNIExp.append(Plotter.interpolate(TimeExp[KKK], DNI[KKK][0], DNI[KKK][1])) T_suExp.append(Plotter.interpolate(TimeExp[KKK],T_su[KKK][0],T_su[KKK][1]-273.15))
def _simulate(case): """ Simulate the idf file with name idf_name in Spawn, and return true if successfull, or false otherwise """ from buildingspy.io.outputfile import Reader import subprocess idf_name = case['idf'] tmp_dir = os.path.join(TMP_DIR, f"{idf_name.name}") idf_full_name = os.path.abspath(os.path.join(tmp_dir, idf_name.name)) # Create working directory if os.path.exists(tmp_dir): shutil.rmtree(tmp_dir) os.mkdir(tmp_dir) # Copy file shutil.copyfile(idf_name, idf_full_name) # print("*********************************************************************") # print(f"*** Running {idf_full_name}") # Add one more leading slash if it is an absolute path mo_name = "TestModel" modifier = f"""( building( idfName=Modelica.Utilities.Files.loadResource( \"file:///{idf_full_name}\")))""" model = f"Buildings.ThermalZones.EnergyPlus.Validation.OutputVariable.OneEnvironmentOutputVariable{modifier}" mo_text = f""" model {mo_name} extends {model}; annotation( experiment( StopTime=86400, Tolerance=1e-06)); end {mo_name}; """ with open(os.path.join(tmp_dir, f"{mo_name}.mo"), "w") as m: m.write(mo_text) cmd = [ "jm_ipython.sh", os.path.join("..", "..", "jmodelica.py"), f"{mo_name}.mo" ] #print(f"Executing {cmd}") def _run(cmd, timeout_sec, cwd, modelica_path): from subprocess import Popen, PIPE my_env = os.environ.copy() my_env["MODELICAPATH"] = modelica_path proc = Popen(cmd, stdout=PIPE, stderr=PIPE, cwd=cwd, env=my_env) try: proc.wait(timeout=timeout_sec) except: print(f"*** Killing process for {idf_name}") proc.kill() _run(cmd, timeout_sec=60, cwd=tmp_dir, modelica_path=os.getcwd()) resultFile = os.path.join(tmp_dir, f"{mo_name}_result.mat") logFile = os.path.join(tmp_dir, f"{mo_name}_log.txt") # Process output if os.path.isfile(logFile): #print(f"Reading {logFile}") with open(logFile, encoding='ISO-8859-1') as f: con = f.read() if 'Fatal from EnergyPlus' in con and 'ModelicaError' in con: case['result'] = 'Fatal from EnergyPlus' return case # No fatal error. Check if final time is reached. if os.path.isfile(resultFile): # Read result file try: res = Reader(resultFile, "dymola") #print(res.varNames()) (t, TEnePlu) = res.values('TEnePlu.y') tMax = max(t) #print(f"*** Final time = {tMax}") if abs(tMax - 86400.0) < 0.1: case['result'] = "Success" # In case of success, delete the temporary directory shutil.rmtree(tmp_dir) else: case['result'] = "Error: Did not reach final time" except ValueError as e: msg = f"Error: ValueError when reading {resultFile}: {e}" print(msg) case['result'] = msg else: msg = f"Error: Result file {resultFile} does not exist" print(f"*** {msg}") case['result'] = msg return case
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt from pylab import figure import os # Change fonts to use LaTeX fonts from matplotlib import rc rc('text', usetex=True) rc('font', family='serif') # Read results ofr1 = Reader(os.path.join("case1", "PIDHysteresis.mat"), "dymola") ofr2 = Reader(os.path.join("case2", "PIDHysteresis.mat"), "dymola") (time1, T1) = ofr1.values("cap.T") (time1, y1) = ofr1.values("con.y") (time2, T2) = ofr2.values("cap.T") (time2, y2) = ofr2.values("con.y") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(time1 / 3600, T1 - 273.15, 'r', label='$T_1$') ax.plot(time2 / 3600, T2 - 273.15, 'b', label='$T_2$') ax.set_xlabel('time [h]') ax.set_ylabel('temperature [$^\circ$C]') ax.set_xticks(range(25)) ax.set_xlim([0, 24]) ax.legend() ax.grid(True)
def test_district_heating_and_cooling_systems(self): # create cooling network and plant cooling_network = Network2Pipe(self.sys_params) cooling_plant = CoolingPlant(self.sys_params) # create heating network and plant heating_network = Network2Pipe(self.sys_params) heating_plant = HeatingPlantWithOptionalCHP(self.sys_params) # create our load/ets/stubs # store all couplings to construct the District system all_couplings = [ Coupling(cooling_network, cooling_plant), Coupling(heating_network, heating_plant), ] # keep track of separate loads and etses for testing purposes loads = [] heat_etses = [] cool_etses = [] for geojson_load in self.gj.buildings: time_series_load = TimeSeries(self.sys_params, geojson_load) loads.append(time_series_load) geojson_load_id = geojson_load.feature.properties["id"] cooling_indirect = CoolingIndirect(self.sys_params, geojson_load_id) cool_etses.append(cooling_indirect) all_couplings.append(Coupling(time_series_load, cooling_indirect)) all_couplings.append(Coupling(cooling_indirect, cooling_network)) heating_indirect = HeatingIndirect(self.sys_params, geojson_load_id) heat_etses.append(heating_indirect) all_couplings.append(Coupling(time_series_load, heating_indirect)) all_couplings.append(Coupling(heating_indirect, heating_network)) # create the couplings and graph graph = CouplingGraph(all_couplings) district = District( root_dir=self.output_dir, project_name=self.project_name, system_parameters=self.sys_params, coupling_graph=graph ) district.to_modelica() root_path = Path(district._scaffold.districts_path.files_dir).resolve() self.run_and_assert_in_docker(Path(root_path) / 'DistrictEnergySystem.mo', project_path=district._scaffold.project_path, project_name=district._scaffold.project_name) # # Validate model outputs # results_dir = f'{district._scaffold.project_path}_results' mat_file = f'{results_dir}/{self.project_name}_Districts_DistrictEnergySystem_result.mat' mat_results = Reader(mat_file, 'dymola') # check the mass flow rates of the first load are in the expected range load = loads[0] (_, heat_m_flow) = mat_results.values(f'{load.id}.ports_aHeaWat[1].m_flow') # NL: changed the line below to be aChiWat (not repeating aHeaWat). (_, cool_m_flow) = mat_results.values(f'{load.id}.ports_aChiWat[1].m_flow') self.assertTrue((heat_m_flow >= 0).all(), 'Heating mass flow rate must be greater than or equal to zero') self.assertTrue((cool_m_flow >= 0).all(), 'Cooling mass flow rate must be greater than or equal to zero') # this tolerance determines how much we allow the actual mass flow rate to exceed the nominal value M_FLOW_NOMINAL_TOLERANCE = 0.01 (_, heat_m_flow_nominal) = mat_results.values(f'{load.id}.mHeaWat_flow_nominal') heat_m_flow_nominal = heat_m_flow_nominal[0] (_, cool_m_flow_nominal) = mat_results.values(f'{load.id}.mChiWat_flow_nominal') cool_m_flow_nominal = cool_m_flow_nominal[0] self.assertTrue( (heat_m_flow <= heat_m_flow_nominal + (heat_m_flow_nominal * M_FLOW_NOMINAL_TOLERANCE)).all(), f'Heating mass flow rate must be less than nominal mass flow rate ({heat_m_flow_nominal}) ' f'plus a tolerance ({M_FLOW_NOMINAL_TOLERANCE * 100}%)' ) self.assertTrue( (cool_m_flow <= cool_m_flow_nominal + (cool_m_flow_nominal * M_FLOW_NOMINAL_TOLERANCE)).all(), f'Cooling mass flow rate must be less than nominal mass flow rate ({cool_m_flow_nominal}) ' f'plus a tolerance ({M_FLOW_NOMINAL_TOLERANCE * 100}%)' ) # check the thermal load (_, load_q_req_hea_flow) = mat_results.values(f'{load.id}.QReqHea_flow') (_, load_q_req_coo_flow) = mat_results.values(f'{load.id}.QReqCoo_flow') (_, load_q_heat_flow) = mat_results.values(f'{load.id}.QHea_flow') (_, load_q_cool_flow) = mat_results.values(f'{load.id}.QCoo_flow') # make sure the q flow is positive load_q_req_hea_flow, load_q_req_coo_flow = np.abs(load_q_req_hea_flow), np.abs(load_q_req_coo_flow) load_q_heat_flow, load_q_cool_flow = np.abs(load_q_heat_flow), np.abs(load_q_cool_flow) cool_cvrmsd = self.cvrmsd(load_q_cool_flow, load_q_req_coo_flow) heat_cvrmsd = self.cvrmsd(load_q_heat_flow, load_q_req_hea_flow) CVRMSD_MAX = 0.3 # TODO: fix q flows to meet the CVRMSD maximum, then make these assertions rather than warnings if cool_cvrmsd >= CVRMSD_MAX: print(f'WARNING: The difference between the thermal cooling load of the load and ETS is too large (CVRMSD={cool_cvrmsd}). ' 'TODO: make this warning an assertion.') if heat_cvrmsd >= CVRMSD_MAX: print(f'WARNING: The difference between the thermal heating load of the load and ETS is too large (CVRMSD={heat_cvrmsd}). ' 'TODO: make this warning an assertion.')
def test_teaser_district_heating_and_cooling_systems(self): # create cooling network and plant cooling_network = Network2Pipe(self.sys_params) cooling_plant = CoolingPlant(self.sys_params) # create heating network and plant heating_network = Network2Pipe(self.sys_params) heating_plant = HeatingPlantWithOptionalCHP(self.sys_params) # create our load/ets/stubs # store all couplings to construct the District system all_couplings = [ Coupling(cooling_network, cooling_plant), Coupling(heating_network, heating_plant), ] # keep track of separate loads and etses for testing purposes loads = [] heat_etses = [] cool_etses = [] for geojson_load in self.gj.buildings: teaser_load = Teaser(self.sys_params, geojson_load) loads.append(teaser_load) geojson_load_id = geojson_load.feature.properties["id"] cooling_indirect = CoolingIndirect(self.sys_params, geojson_load_id) cool_etses.append(cooling_indirect) all_couplings.append(Coupling(teaser_load, cooling_indirect)) all_couplings.append(Coupling(cooling_indirect, cooling_network)) heating_indirect = HeatingIndirect(self.sys_params, geojson_load_id) heat_etses.append(heating_indirect) all_couplings.append(Coupling(teaser_load, heating_indirect)) all_couplings.append(Coupling(heating_indirect, heating_network)) # create the couplings and graph graph = CouplingGraph(all_couplings) district = District(root_dir=self.output_dir, project_name=self.project_name, system_parameters=self.sys_params, coupling_graph=graph) district.to_modelica() root_path = Path(district._scaffold.districts_path.files_dir).resolve() self.run_and_assert_in_docker( Path(root_path) / 'DistrictEnergySystem.mo', project_path=district._scaffold.project_path, project_name=district._scaffold.project_name) # # Validate model outputs # results_dir = f'{district._scaffold.project_path}_results' mat_file = f'{results_dir}/{self.project_name}_Districts_DistrictEnergySystem_result.mat' mat_results = Reader(mat_file, 'dymola') # check the mass flow rates of the first load are in the expected range load = loads[0] (_, heat_m_flow ) = mat_results.values(f'{load.id}.ports_aHeaWat[1].m_flow') (_, cool_m_flow ) = mat_results.values(f'{load.id}.ports_aChiWat[1].m_flow') self.assertTrue( (heat_m_flow >= 0).all(), 'Heating mass flow rate must be greater than or equal to zero') self.assertTrue( (cool_m_flow >= 0).all(), 'Cooling mass flow rate must be greater than or equal to zero') # this tolerance determines how much we allow the actual mass flow rate to exceed the nominal value M_FLOW_NOMINAL_TOLERANCE = 0.01 (_, heat_m_flow_nominal ) = mat_results.values(f'{load.id}.terUni[1].mLoaHea_flow_nominal') heat_m_flow_nominal = heat_m_flow_nominal[0] (_, cool_m_flow_nominal ) = mat_results.values(f'{load.id}.terUni[1].mLoaCoo_flow_nominal') cool_m_flow_nominal = cool_m_flow_nominal[0] # TODO: remove try/except this is fixed try: self.assertTrue( (heat_m_flow <= heat_m_flow_nominal + (heat_m_flow_nominal * M_FLOW_NOMINAL_TOLERANCE)).all(), f'Heating mass flow rate must be less than nominal mass flow rate ({heat_m_flow_nominal}) ' f'plus a tolerance ({M_FLOW_NOMINAL_TOLERANCE * 100}%)') except Exception as e: print(f'WARNING: assertion failed: {e}') try: self.assertTrue( (cool_m_flow <= cool_m_flow_nominal + (cool_m_flow_nominal * M_FLOW_NOMINAL_TOLERANCE)).all(), f'Cooling mass flow rate must be less than nominal mass flow rate ({cool_m_flow_nominal}) ' f'plus a tolerance ({M_FLOW_NOMINAL_TOLERANCE * 100}%)') except Exception as e: print(f'WARNING: assertion failed: {e}')
table2[name] = y table2 = table2.drop_duplicates(['time']) table = table.merge(table2, how='left') return table baseline = '0' season = 'summer1' #ofr1=Reader('Airflow_Network_baseline'+baseline+ '_'+season, "dymola") ofr1 = Reader('AHU', "dymola") data_list = pd.read_csv('data_list_FDD.csv', header=None, names=['id', 'name']) print data_list index = 1 for i in range(len(data_list)): (time, temp) = ofr1.values(data_list['id'].iloc[i].replace('\n', '')) tab = sample(time, temp, data_list['name'].iloc[i]) if index == 1: table1 = tab else: table1 = table1.merge(tab, how='inner') index = index + 1 table1 = table1[24 * 60:] table1.dropna(how='any') table1.to_csv('FDD.csv')
def simulate(dpi=300, plotDirectory='plots'): # Set the comparison for dymola results dymolaComparisons = ['non-fmu-all', 'fmu-all', 'non-fmu', 'fmu'] # In[3]: # Create plot directory # plotDirectory = 'plots' plotPath = plotDirectory if os.path.exists(plotPath): shutil.rmtree(plotPath) os.makedirs(plotPath) for key in dymolaComparisons: os.makedirs(os.path.join(plotPath, key)) for dymolaComparison in dymolaComparisons: # # FMpy Library # In[4]: fmu_tests = ['Connectors', 'Inputs', 'Parameters'] for fmu_test in fmu_tests: # fmu_test = fmu_tests[0] fmu_path = '../FMUs/' + fmu_test + '/' fmu = fmu_path + 'FMIRaven_Models_LorenzSystem_' + fmu_test + '.fmu' # In[5]: fmpy.dump(fmu) # In[6]: model_description = fmpy.read_model_description(fmu) # In[7]: vrs = [] for variable in model_description.modelVariables: vrs.append(variable.name) # In[8]: vrs # In[9]: outputs = ['x', 'y', 'z', 'sigma', 'beta', 'rho'] start_values = {'sigma': 10, 'rho': 28, 'beta': 8 / 3} inputs = np.genfromtxt('input_test.txt', delimiter=',', names=True) result = fmpy.simulate_fmu( fmu, output=outputs, start_values=start_values ) #,input=inputs) # simulate the FMU # In[10]: from fmpy.util import plot_result # import the plot function # plot_result(result,names=outputs) fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): ax[i].plot(result['time'], result[v]) ax[i].set_ylabel(v, rotation=0, labelpad=20) fig.savefig(plotPath + '/{}/{}_fmpy.png'.format(dymolaComparison, fmu_test), dpi=dpi) # # pyFMI Library # In[11]: from pyfmi import load_fmu model = load_fmu(fmu) model.set('sigma', 10) model.set('beta', 8 / 3) model.set('rho', 28) res_pyfmi = model.simulate() # In[12]: fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): ax[i].plot(res_pyfmi['time'], res_pyfmi[v]) ax[i].set_ylabel(v, rotation=0, labelpad=20) fig.savefig(plotPath + '/{}/{}_pyfmi.png'.format(dymolaComparison, fmu_test), dpi=dpi) # # Dymola Result File # In[13]: from buildingspy.io.outputfile import Reader # In[14]: if dymolaComparison == 'non-fmu-all': dymResultPath = 'MATFiles/BasicTest.mat' modelName = fmu_test elif dymolaComparison == 'fmu-all': dymResultPath = 'MATFiles/FMU_BasicTest.mat' modelName = fmu_test elif dymolaComparison == 'non-fmu': dymResultPath = 'MATFiles/{}.mat'.format(fmu_test) modelName = 'fmu' elif dymolaComparison == 'fmu': dymResultPath = 'MATFiles/FMU_{}.mat'.format(fmu_test) modelName = 'fmu' else: raise ValueError('Unsported dymolaComparison') res = Reader(dymResultPath, simulator='dymola') # In[15]: res_dym = {} res_dym['time'], res_dym['x'] = res.values( '{}.x'.format(modelName)) _, res_dym['y'] = res.values('{}.y'.format(modelName)) _, res_dym['z'] = res.values('{}.z'.format(modelName)) _, res_dym['sigma'] = res.values('{}.sigma'.format(modelName)) _, res_dym['beta'] = res.values('{}.beta'.format(modelName)) _, res_dym['rho'] = res.values('{}.rho'.format(modelName)) # In[16]: fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): try: ax[i].plot(res_dym['time'], res_dym[v]) ax[i].set_ylabel(v, rotation=0, labelpad=20) except: pass fig.savefig(plotPath + '/{}/{}_dymola.png'.format(dymolaComparison, fmu_test), dpi=dpi) # # Result Comparison # In[17]: fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): ax[i].plot(result['time'], result[v], 'k-', label='FMpy') ax[i].plot(res_pyfmi['time'], res_pyfmi[v], 'b--', label='pyFMI') try: ax[i].plot(res_dym['time'], res_dym[v], 'r-.', label='Dymola') except: pass ax[i].legend() ax[i].set_ylabel(v, rotation=0, labelpad=20) fig.savefig( plotPath + '/{}/{}_comparison.png'.format(dymolaComparison, fmu_test), dpi=dpi) # # Diff between FMU and Dymola # In[18]: fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): try: ax[i].plot(result['time'], result[v] - res_dym[v], 'k-', label='FMpy - Dymola') ax[i].plot(result['time'], res_pyfmi[v] - res_dym[v], 'b--', label='pyFMI - Dymola') except: pass ax[i].legend() ax[i].set_ylabel(v, rotation=0, labelpad=20) fig.savefig(plotPath + '/{}/{}_diff_FMUtoDymola.png'.format( dymolaComparison, fmu_test), dpi=dpi) # # Diff between FMUs # In[19]: fig, ax = plt.subplots(len(outputs), 1, figsize=[12, 12]) for i, v in enumerate(outputs): try: ax[i].plot(result['time'], result[v] - res_pyfmi[v], 'k-', label='FMpy - pyFMI') except: pass ax[i].legend() ax[i].set_ylabel(v, rotation=0, labelpad=20) fig.savefig( plotPath + '/{}/{}_diff_FMUtoFMU.png'.format(dymolaComparison, fmu_test), dpi=dpi) plt.close('all')
def get_values(fpath, varname): r = Reader(fpath, 'dymola') return r.values(varname)
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt Path = "/Users/maggie/Documents/AREN5010-HVAC-Modeling-and-Control/Modeling/OpenModelica/Task1_scenarios/" resultFile = "LTM_full_excite/LTM-full_excite.mat" fname = "LTM" #resultFile = "LightWallTestScenario/LWT.mat" #fname = "LWT" r = Reader(Path + resultFile, "dymola") (time, Ts_ext) = r.values(fname + '.Ts_ext') (time, Ts_int) = r.values(fname + '.Ts_int') (time, T_ext) = r.values(fname + '.T_ext') (time, T_int) = r.values(fname + '.T_int') (time, qs_ext) = r.values(fname + '.qs_ext') (time, qs_int) = r.values(fname + '.qs_int') print(len(time), len(Ts_ext), len(Ts_int), len(T_ext), len(T_int), len(qs_ext), len(qs_int)) # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(time / 3600, Ts_ext - 273.15, 'r', label='$T_{s,ext}$') ax.plot(time / 3600, Ts_int - 273.15, 'b', label='$T_{s,int}$')
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt from pylab import * import numpy as np rcParams['legend.loc'] = 'best' r=Reader('HotelModel_Annual.mat','dymola') (t1,y1)=r.values('realExpression.y') (t2,y2)=r.values('supCon.y') y1=y1*100 xlabind=[] xlab=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Dec','Nov'] x=(t1[len(t1)-1]-t1[0])/12 for i in range(12): xlabind.append(t1[0]+x*(0.5+i)) xlab.append(str(i)) ax1 = plt.subplot(2,1,1) ax1.scatter(t2,y2,color='black',s=0.2) ax1.set_ylabel('Stage') ylim(0,8) xtic=[1] xticks(xtic,'') ax2 = plt.subplot(2,1,2) ax2.scatter(t1,y1,color='black',s=0.2) ax2.set_ylabel('Hot Energy saving ratio(%)') ylim(0,35) ax2.legend(fontsize='10')
from buildingspy.io.outputfile import Reader import matplotlib.pyplot as plt from pylab import figure import os # Change fonts to use LaTeX fonts from matplotlib import rc rc('text', usetex=True) rc('font', family='serif') # Read results ofr = Reader("Temperature_u.mat", "dymola") (t, u) = ofr.values("u") u /= 1e6 (t, T) = ofr.values("T") (t, TMon) = ofr.values("TMonotone") (t, e) = ofr.values("errNonMonotone") (t, eMon) = ofr.values("errMonotone") # Plot figure fig = plt.figure() ax = fig.add_subplot(211) ax.plot(u, T - 273.15, 'r', label='$T$') ax.plot(u, TMon - 273.15, '--b', markevery=5, label='$T_{monotone}$') ax.set_xlabel('u [MJ/kg]') ax.set_ylabel('temperature [$^\circ$C]') #ax.set_xticks(range(25)) #ax.set_xlim([0, 24]) ax.legend(loc='lower right')
m_wf = [] T_amb = [] v_wind = [] DNIExp = [] T_suExp = [] T_exExp = [] m_wfExp = [] vector = [0, 1] for KKK in range(len(StartModTime)): resultFile = ( '/Users/adriano/Google Drive/GitHub/PSA_SFERAII/Modelling/ModelicaResults/' + Days[KKK] + '/' + FileSimulation + ".mat") r = Reader(resultFile, "dymola") DNI.append(r.values('DNI.y')) NN.append(r.values('EuroTrough.N')) T_su.append(r.values('SensTsu.fluidState.T')) T_ex.append(r.values('SensTex.fluidState.T')) TimeSim.append(T_ex[KKK][0]) T_ex_exp.append(r.values('t_htf_ex.y')) Delta_T.append(r.values('DeltaT.Delta')) m_wf.append(r.values('m_dot_htf.y')) # Create a time vector which values every 5 seconds TimeExp.append( np.linspace(StartModTime[KKK], StopModTime[KKK], num=int((StopModTime[KKK] - StartModTime[KKK]) / 10)))
def test_mft_time_series_to_modelica_and_run(self): project_name = "time_series_massflow" self.data_dir, self.output_dir = self.set_up(os.path.dirname(__file__), project_name) # load in the example geojson with a single office building filename = os.path.join(self.data_dir, "time_series_ex1.json") self.gj = UrbanOptGeoJson(filename) # load system parameter data filename = os.path.join(self.data_dir, "time_series_system_params_massflow_ex1.json") sys_params = SystemParameters(filename) # create the load, ETSes and their couplings time_series_mft_load = TimeSeriesMFT(sys_params, self.gj.buildings[0]) geojson_load_id = self.gj.buildings[0].feature.properties["id"] heating_indirect_system = HeatingIndirect(sys_params, geojson_load_id) ts_hi_coupling = Coupling(time_series_mft_load, heating_indirect_system) cooling_indirect_system = CoolingIndirect(sys_params, geojson_load_id) ts_ci_coupling = Coupling(time_series_mft_load, cooling_indirect_system) # create network stubs for the ETSes heated_water_stub = NetworkHeatedWaterStub(sys_params) hi_hw_coupling = Coupling(heating_indirect_system, heated_water_stub) chilled_water_stub = NetworkChilledWaterStub(sys_params) ci_cw_coupling = Coupling(cooling_indirect_system, chilled_water_stub) # build the district system district = District(root_dir=self.output_dir, project_name=project_name, system_parameters=sys_params, coupling_graph=CouplingGraph([ ts_hi_coupling, ts_ci_coupling, hi_hw_coupling, ci_cw_coupling, ])) district.to_modelica() root_path = os.path.abspath( os.path.join(district._scaffold.districts_path.files_dir)) mo_file_name = os.path.join(root_path, 'DistrictEnergySystem.mo') # set the run time to 31536000 (full year in seconds) mofile = Model(mo_file_name) mofile.update_model_annotation({"experiment": {"StopTime": 31536000}}) mofile.save() self.run_and_assert_in_docker( mo_file_name, project_path=district._scaffold.project_path, project_name=district._scaffold.project_name) # Check the results results_dir = f'{district._scaffold.project_path}_results' mat_file = f'{results_dir}/time_series_massflow_Districts_DistrictEnergySystem_result.mat' mat_results = Reader(mat_file, 'dymola') # hack to get the name of the loads (rather the 8 character connector shas) timeseries_load_var = None coolflow_var = None heatflow_var = None for var in mat_results.varNames(): m = re.match("TimeSerMFTLoa_(.{8})", var) if m: timeseries_load_var = m[1] continue m = re.match("cooInd_(.{8})", var) if m: coolflow_var = m[1] continue m = re.match("heaInd_(.{8})", var) if m: heatflow_var = m[1] continue if None not in (timeseries_load_var, coolflow_var, heatflow_var): break (time1, ts_hea_load) = mat_results.values( f"TimeSerMFTLoa_{timeseries_load_var}.ports_aChiWat[1].m_flow") (_time1, ts_chi_load) = mat_results.values( f"TimeSerMFTLoa_{timeseries_load_var}.ports_aHeaWat[1].m_flow") (_time1, cool_q_flow) = mat_results.values(f"cooInd_{coolflow_var}.Q_flow") (_time1, heat_q_flow) = mat_results.values(f"heaInd_{heatflow_var}.Q_flow") # if any of these assertions fail, then it is likely that the change in the timeseries massflow model # has been updated and we need to revalidate the models. self.assertEqual(ts_hea_load.min(), 0) self.assertAlmostEqual(ts_hea_load.max(), 51, delta=1) self.assertAlmostEqual(ts_hea_load.mean(), 4, delta=1) self.assertEqual(ts_chi_load.min(), 0) self.assertAlmostEqual(ts_chi_load.max(), 61, delta=1) self.assertAlmostEqual(ts_chi_load.mean(), 4, delta=1) self.assertAlmostEqual(cool_q_flow.min(), -51750, delta=10) self.assertAlmostEqual(cool_q_flow.max(), 354100, delta=10) self.assertAlmostEqual(cool_q_flow.mean(), 3160, delta=10) self.assertAlmostEqual(heat_q_flow.min(), -343210, delta=10) self.assertAlmostEqual(heat_q_flow.max(), 39475, delta=10) self.assertAlmostEqual(heat_q_flow.mean(), -23270, delta=10)
reader =Reader("/tmp/BESTEST.mat", "dymola") fig=plt.figure(figsize=(10,3.5)) legendsize=10 N=6 #gs = gridspec.GridSpec(4,1,height_ratios=[1,1,1,1]) ax0 = plt.subplot(1,1,1) # print(reader.values("EAnnHea600[1]")[1][-1]) # exit(0) plot_results(ax0, EHeacase600_Avg, EHeacase600_Min, EHeacase600_Max, EHeacase600_E_plus, np.array([reader.values("EAnnHea600[" + str(i+1) + "]")[1][-1] for i in range(N)]), N, -0.3, marker=r'$\mathrm{E}_H$') plt.ylabel('Normalized errors $e_i$') plt.legend(frameon=False,prop={'size':legendsize},loc=2,ncol=3,numpoints=1) plot_results(ax0, ECoocase600_Avg, ECoocase600_Min, ECoocase600_Max, ECoocase600_E_plus, np.array([reader.values("EAnnCoo600[" + str(i+1) + "]")[1][-1] for i in range(N)]), N, -0.1, marker='$E_C$') plot_results(ax0, PHeacase600_Avg, PHeacase600_Min, PHeacase600_Max, PHeacase600_E_plus, np.array([reader.values("QPeaHea600[" + str(i+1) + "]")[1][-1] for i in range(N)]), N, 0.1, marker='$P_H$') plot_results(ax0, PCoocase600_Avg, PCoocase600_Min, PCoocase600_Max, PCoocase600_E_plus, np.array([reader.values("QPeaCoo600[" + str(i+1) + "]")[1][-1] for i in range(N)]), N, 0.3, marker='$P_C$') plot_results(ax0, EHeacase900_Avg, EHeacase900_Min, EHeacase900_Max, EHeacase900_E_plus, [reader.values("EAnnHea900[" + str(i+1) + "]")[1][-1] for i in range(N)], N, -0.3 + N, marker='$E_H$') plot_results(ax0, ECoocase900_Avg, ECoocase900_Min, ECoocase900_Max, ECoocase900_E_plus, [reader.values("EAnnCoo900[" + str(i+1) + "]")[1][-1] for i in range(N)], N, -0.1 + N, marker='$E_C$') plot_results(ax0, PHeacase900_Avg, PHeacase900_Min, PHeacase900_Max, PHeacase900_E_plus, [reader.values("QPeaHea900[" + str(i+1) + "]")[1][-1] for i in range(N)], N, 0.1 + N, marker='$P_H$') plot_results(ax0, PCoocase900_Avg, PCoocase900_Min, PCoocase900_Max, PCoocase900_E_plus, [reader.values("QPeaCoo900[" + str(i+1) + "]")[1][-1] for i in range(N)], N, 0.3 + N, marker='$P_C$') N2=4 plot_results(ax0, TMin_avg, TMin_min, TMin_max, TMin_E_plus, [reader.values("Tmin[" + str(i+1) + "]")[1][-1] for i in range(N2)], N2, -0.2 + 2*N, marker=r'$\downarrow$') plot_results(ax0, TAvg_avg, TAvg_min, TAvg_max, TAvg_E_plus, [reader.values("TAnnAvg[" + str(i+1) + "]")[1][-1] for i in range(N2)], N2, 2*N, marker=r'$\bar{T}$')
y = removeRepeats((time, yRaw), 0, True) yint, tint = uniformData(t, y, tstart, tstop, nt) data[val] = yint data['time'] = tint return data if __name__ == "__main__": r = Reader('dsres.mat', 'dymola') varNames_param_base = [] varNames_var_base = [] for i, val in enumerate(r.varNames()): if np.size(r.values(val)) == 4: varNames_param_base.append(val) else: varNames_var_base.append(val) varNames_param = varNames_param_base varNames_var = varNames_var_base params = cleanDataParam(r, varNames_param) data = cleanDataTime(r, varNames_var, 0, 1, 201) # Normalize data data_norm = {} for i, val in enumerate(data): data_norm[val] = data[val] / max(abs(data[val]))
def simulate_in_dymola(heaPum, data, tableName, tableFileName): """ Evaluate the heat pump performance from the model in Dymola. :param heaPum: Heat pump model (object). :param data: Reference performance data (object). :param tableName: Name of the combiTimeTable. :param tableFileName: Name of the text file containing the combiTimeTable. :return: Performance data of the modeled heat pump (object). .. note:: Performance data from the model is evaluated at the same operating conditions (inlet water temperatures and mass flow rates at the source and load sides) as in the reference data. """ import buildingspy.simulate.Simulator as si from buildingspy.io.outputfile import Reader from scipy.interpolate import interp1d from builtins import str import getpass import os import tempfile # Find absolute path to buildings library packagePath = os.path.normpath( os.path.join(os.path.normpath(os.path.dirname(__file__)), '..', '..', '..', '..', '..', '..')) # Create temporary directory for simulation files dirPrefix = tempfile.gettempprefix() tmpDir = tempfile.mkdtemp(prefix=dirPrefix + '-' + 'HeatPumpCalibration' + '-' + getpass.getuser() + '-') # Set parameters for simulation in Dymola calModelPath = heaPum.modelicaCalibrationModelPath() s = si.Simulator(calModelPath, 'dymola', outputDirectory=tmpDir, packagePath=packagePath) s = heaPum.set_ModelicaParameters(s) m1_flow_nominal = min(data.flowSource) m2_flow_nominal = min(data.flowLoad) tableFilePath = \ str(os.path.join(tmpDir, tableFileName).replace(os.sep, '/')) s.addParameters({ 'm1_flow_nominal': m1_flow_nominal, 'm2_flow_nominal': m2_flow_nominal, 'calDat.fileName': tableFilePath }) # Write CombiTimeTable for dymola data.write_modelica_combiTimeTable(tableName, tmpDir, tableFileName, heaPum.CoolingMode) # Simulation parameters s.setStopTime(len(data.EWT_Source)) s.setSolver('dassl') # Kill the process if it does not finish in 2 minutes s.setTimeOut(120) s.showProgressBar(False) s.printModelAndTime() # s.showGUI(show=True) # s.exitSimulator(exitAfterSimulation=False) s.simulate() # Read results modelName = heaPum.modelicaModelName() ofr = Reader(os.path.join(tmpDir, modelName), 'dymola') (time1, QCon) = ofr.values('heaPum.QCon_flow') (time1, QEva) = ofr.values('heaPum.QEva_flow') (time1, P) = ofr.values('heaPum.P') t = [float(i) + 0.5 for i in range(len(data.EWT_Source))] f_P = interp1d(time1, P) P = f_P(t) f_QCon = interp1d(time1, QCon) QCon = f_QCon(t) f_QEva = interp1d(time1, QEva) QEva = f_QEva(t) # # Clean up # shutil.rmtree('calibrationModel') if heaPum.CoolingMode: Capacity = -QEva HR = QCon else: Capacity = QCon HR = -QEva dymRes = SimulationResults(data.EWT_Source, data.EWT_Load, data.flowSource, data.flowLoad, Capacity, HR, P, 'Modelica') return dymRes
def simulate_in_dymola(heaPum, data, tableName, tableFileName): """ Evaluate the heat pump performance from the model in Dymola. :param heaPum: Heat pump model (object). :param data: Reference performance data (object). :param tableName: Name of the combiTimeTable. :param tableFileName: Name of the text file containing the combiTimeTable. :return: Performance data of the modeled heat pump (object). .. note:: Performance data from the model is evaluated at the same operating conditions (inlet water temperatures and mass flow rates at the source and load sides) as in the reference data. """ import buildingspy.simulate.Simulator as si from buildingspy.io.outputfile import Reader from scipy.interpolate import interp1d from builtins import str import getpass import os import tempfile # Find absolute path to buildings library packagePath = os.path.normpath( os.path.join(os.path.normpath(os.path.dirname(__file__)), '..', '..', '..', '..', '..', '..')) # Create temporary directory for simulation files dirPrefix = tempfile.gettempprefix() tmpDir = tempfile.mkdtemp(prefix=dirPrefix + '-' + 'HeatPumpCalibration' + '-' + getpass.getuser() + '-') # Set parameters for simulation in Dymola calModelPath = heaPum.modelicaCalibrationModelPath() s = si.Simulator(calModelPath, 'dymola', outputDirectory=tmpDir, packagePath=packagePath) s = heaPum.set_ModelicaParameters(s) m1_flow_nominal = min(data.flowSource) m2_flow_nominal = min(data.flowLoad) tableFilePath = \ str(os.path.join(tmpDir, tableFileName).replace(os.sep, '/')) s.addParameters({'m1_flow_nominal': m1_flow_nominal, 'm2_flow_nominal': m2_flow_nominal, 'calDat.fileName': tableFilePath}) # Write CombiTimeTable for dymola data.write_modelica_combiTimeTable(tableName, tmpDir, tableFileName, heaPum.CoolingMode) # Simulation parameters s.setStopTime(len(data.EWT_Source)) s.setSolver('dassl') # Kill the process if it does not finish in 2 minutes s.setTimeOut(120) s.showProgressBar(False) s.printModelAndTime() # s.showGUI(show=True) # s.exitSimulator(exitAfterSimulation=False) s.simulate() # Read results modelName = heaPum.modelicaModelName() ofr = Reader(os.path.join(tmpDir, modelName), 'dymola') (time1, QCon) = ofr.values('heaPum.QCon_flow') (time1, QEva) = ofr.values('heaPum.QEva_flow') (time1, P) = ofr.values('heaPum.P') t = [float(i) + 0.5 for i in range(len(data.EWT_Source))] f_P = interp1d(time1, P) P = f_P(t) f_QCon = interp1d(time1, QCon) QCon = f_QCon(t) f_QEva = interp1d(time1, QEva) QEva = f_QEva(t) # # Clean up # shutil.rmtree('calibrationModel') if heaPum.CoolingMode: Capacity = -QEva HR = QCon else: Capacity = QCon HR = -QEva dymRes = SimulationResults(data.EWT_Source, data.EWT_Load, data.flowSource, data.flowLoad, Capacity, HR, P, 'Modelica') return dymRes