Kalibrierung_Testo_174H
Kalibrierung der 4 Desto Datenlogger und Effizienzberechnung während des Testmonats
- Eingelesen werden drei csv Dateien, je eine pro Zeitabschnitt
- werden mit dem großen Datensatz zusammengefügt und gespeichert: Testo_Arbeitsdaten_15s.csv
Bibliotheken importieren
# Name des aktuellen Notebooks für die exportierten Datein
file_name = "Kalibrierung_Testo_174H"
# Ordner auf dem Server (nach files/)
ftp_folder = 'Notebooks/Aufbereitung'
## Bibliotheken, Module und Text- bzw- Grafikformatierungen aus zentraler Datei laden
%run ../Template/libraries_and_styles.ipynb ## Warum auch immer muss rcParams.update() in eine eigene Zelle...
mpl.rcParams.update(params)Daten Import
zusammenfügen
# wrg = pd.read_csv("MA_WGR_Daten_Testo.csv",sep=";",decimal=",",encoding="cp1252")
# wrg['Datum'] = pd.to_datetime(wrg["Datum"],dayfirst=True,)
# wrg.set_index(["Datum"], inplace=True)
# wrgF = pd.read_csv("MA_WGR_Daten_Testo_Feb.csv",sep=";",decimal=",",encoding="cp1252")
# wrgF['Datum'] = pd.to_datetime(wrgF["Datum"],dayfirst=True,)
# wrgF.set_index(["Datum"], inplace=True)
# wrgF2 = pd.read_csv("MA_WGR_Daten_Testo_Feb2.csv",sep=";",decimal=",",encoding="cp1252")
# wrgF2['Datum'] = pd.to_datetime(wrgF2["Datum"],dayfirst=True,)
# wrgF2.set_index(["Datum"], inplace=True)
# wrg = wrg.resample('15s').interpolate(method='linear')
# wrgF = wrgF.resample('15s').interpolate(method='linear')
# wrgF2 = wrgF2.resample('15s').interpolate(method='linear')
# daten = pd.read_csv('../1_Daten/Arbeitsdaten/Daten_15s.csv')
# daten["Zeit"] = pd.to_datetime(daten["Zeit"],dayfirst=True)
# daten["Zeit1"] = daten["Zeit"]
# daten.set_index(['Zeit1'], inplace=True)
# daten = daten.loc['2017-12-05 10:00:00':'2018-02-23 14:38:00']
# daten['L_Zuluft_VPunkt'] = daten['L_Zuluft_1_VPunkt'] + daten['L_Zuluft_2_VPunkt'] + daten['L_Zuluft_3_VPunkt']
# # concat wrg`s
# frames = [wrg, wrgF, wrgF2]
# testo = pd.concat(frames)
# testo.columns = ['Außenluft_C', 'Außenluft_rF', 'Zuluft_C', 'Zuluft_rF', 'Abluft_C','Abluft_rF', 'Fortluft_C', 'Fortluft_rF']
# testo['Zeit'] = testo.index
# testo.to_csv('Testo_174H.csv')
# ## GET the data, just for saving, not use
# # Testo_174H = pd.read_csv("Testo_174H.csv")
# # Testo_174H['Datum'] = pd.to_datetime(Testo_174H["Datum"],dayfirst=True,)
# # Testo_174H.set_index(["Datum"], inplace=True)
# # Testo_174H.head()
# # merge mit testo
# testo = testo.merge(daten , left_on=['Zeit'], right_on=['Zeit'], how='outer')
# testo["Zeit"] = pd.to_datetime(testo["Zeit"],dayfirst=True)
# testo.set_index(['Zeit'], inplace=True)
# testo.to_csv('Testo_Arbeitsdaten_15s.csv')
# # testo.head()
# print(wrg.head())# 2017-12-05 10:00:00
# print(wrg.tail())# 2017-12-12 10:18:00
# print(wrgF.head())# 2018-01-30 11:11:00
# print(wrgF.tail())# 2018-02-12 12:36:00
# print(wrgF2.head())# 2018-02-15 16:40:00
# print(wrgF2.tail())# 2018-02-23 14:38:00
## 1. Zeitraum
# von = '2017-12-05 10:00:00'
# bis = '2017-12-12 10:18:00 '
# ## 2. Zeitraum
# von = '2018-01-30 11:00:00'
# bis = '2018-02-12 11:00:00'
# ## 3. Zeitraum
# von = '2018-02-15 16:40:00'
# bis = '2018-02-21 10:00:00 '
## gesamter Zeitraum
von = '2017-12-05 10:00:00'
bis = '2018-02-21 10:00:00'
daten = pd.read_csv("Testo_Arbeitsdaten_15s.csv")
daten['Zeit'] = pd.to_datetime(daten["Zeit"],dayfirst=True,)
daten.set_index(["Zeit"], inplace=True)
# daten.head()Plot Einzelmessungen
# # 2017-12-05 10:00:00 2017-12-12 10:18:00
# fig, ax = plt.subplots()
# wrg.plot(ax=ax, linewidth=0.5)
# daten['L_Aussenlufttemperatur_1'].plot(ax=ax,color=colo('grün',1.2), linewidth=0.8)
# # Achsen
# # ax.set_ylabel(r'\textbf{Energie} ($kWh$)')
# # ax.set(ylim=[0,0.04])
# ax.set_xlabel('')
# # Legende
# h0, l0 = ax.get_legend_handles_labels()
# legend = plt.legend(h0, l0, ncol=4, loc=1)
# set_legend_linewidth(legend)
# ax.set(xlim=[pd.to_datetime("2017-12-05 10:00:00"),pd.to_datetime("2017-12-12 10:18:00 ")])
# # 2018-01-30 11:11:00 2018-02-12 12:36:00
# fig, ax = plt.subplots()
# wrgF.plot(ax=ax, linewidth=0.5)
# daten['L_Aussenlufttemperatur_1'].plot(ax=ax,color=colo('grün',1.2), linewidth=0.8)
# # Achsen
# # ax.set_ylabel(r'\textbf{Energie} ($kWh$)')
# # ax.set(ylim=[0,0.04])
# ax.set_xlabel('')
# # Legende
# h0, l0 = ax.get_legend_handles_labels()
# legend = plt.legend(h0, l0, ncol=4, loc=1)
# set_legend_linewidth(legend)
# ax.set(xlim=[pd.to_datetime("2018-01-30 11:11:00"),pd.to_datetime("2018-02-12 12:36:00")])
# # 2018-02-15 16:40:00 2018-02-23 14:38:00
# fig, ax = plt.subplots()
# wrgF2.plot(ax=ax, linewidth=0.5)
# daten['L_Aussenlufttemperatur_1'].plot(ax=ax,color=colo('grün',1.2), linewidth=0.8)
# # Achsen
# # ax.set_ylabel(r'\textbf{Energie} ($kWh$)')
# # ax.set(ylim=[0,0.04])
# ax.set_xlabel('')
# # Legende
# h0, l0 = ax.get_legend_handles_labels()
# legend = plt.legend(h0, l0, ncol=4, loc=1)
# set_legend_linewidth(legend)
# ax.set(xlim=[pd.to_datetime("2018-02-15 16:40:00"),pd.to_datetime("2018-02-23 14:38:00")])
Plot gesamt bax
# https://pydoc.net/brokenaxes/0.4.2/brokenaxes/
eins = pd.to_datetime("2017-12-05 10:00", infer_datetime_format=True).to_pydatetime()
zwei = pd.to_datetime("2017-12-12 10:18", infer_datetime_format=True).to_pydatetime()
drei = pd.to_datetime("2018-01-30 11:11", infer_datetime_format=True).to_pydatetime()
vier = pd.to_datetime("2018-02-12 12:36", infer_datetime_format=True).to_pydatetime()
fünf = pd.to_datetime("2018-02-15 16:40", infer_datetime_format=True).to_pydatetime()
sechs = pd.to_datetime("2018-02-23 14:38", infer_datetime_format=True).to_pydatetime()
fig = plt.figure(constrained_layout=False, figsize=(10,3))
bax = brokenaxes(xlims=((eins, zwei), (drei, vier), (fünf,sechs)), hspace=1.2)
bax.plot(daten.index, daten['Außenluft_C'], color=colo('blau',1), linewidth=0.5, label = r'Außenluft')
bax.plot(daten.index, daten['Außenluft_rF'], color=colo('blau',1.4), linewidth=0.5, label = r'__nolable__')
bax.plot(daten.index, daten['Zuluft_C'], color=colo('rot',1), linewidth=0.5, label = r'Zuluft')
bax.plot(daten.index, daten['Zuluft_rF'], color=colo('rot',1.4), linewidth=0.5, label = r'__nolable__')
bax.plot(daten.index, daten['Abluft_C'], color=colo('orange',1), linewidth=0.5, label = r'Abluft')
bax.plot(daten.index, daten['Abluft_rF'], color=colo('orange',1.4), linewidth=0.5, label = r'__nolable__')
bax.plot(daten.index, daten['Fortluft_C'], color=colo('violet',1), linewidth=0.5, label = r'Fortluft')
bax.plot(daten.index, daten['Fortluft_rF'], color=colo('violet',1.4), linewidth=0.5, label = r'__nolable__')
fig.axes[0].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
fig.axes[1].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
fig.axes[2].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
bax.legend(loc=1, ncol=4)
bax.set_ylabel('Temp. / rel. LF')
Text(0, 0.5, 'Temp. / rel. LF')
Kalibrierung
## Funktion kalibriert und gib Strings für copy&paste aus
def kalibrieren(X,Y):
polyfit = np.polyfit(X,Y,deg=1)
schaetzer = np.poly1d(polyfit)
# print(schaetzer)
# print('daten_kal_sub[\''+X.name+'\'] = pow(daten_kal_sub[\''+X.name+'\'],3) * ' +str(schaetzer[3]) + ' + pow(daten_kal_sub[\''+X.name+'\'],2) * ' +str(schaetzer[2]) + ' + daten_kal_sub[\''+X.name+'\'] * ' +str(schaetzer[1]) + ' + ' +str(schaetzer[0]) )
print('daten_kal_sub[\''+X.name+'\'] = daten_kal_sub[\''+X.name+'\'] * ' +str(schaetzer[1]) + ' + ' +str(schaetzer[0]) )
return schaetzer(X)
## DataFrame für den Zeitraum der Kalibrierung
kal = daten.loc['2018-02-22 16:40:00':'2018-02-23 14:38:00']
## Referenzen definieren
# kal['ref_rF'] = (kal.Abluft_rF + kal.Fortluft_rF + kal.Zuluft_rF + kal.Außenluft_rF) / 4
# kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C + kal.Außenluft_C) / 4
# kal['ref_rF'] = (kal.Abluft_rF + kal.Fortluft_rF ) / 2
# kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C) / 3
# kal['ref_rF'] = kal.Zuluft_rF
# kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C) / 3
# kal['ref_rF'] = kal.Außenluft_rF
# kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C) / 3
# kal['ref_rF'] = kal.Außenluft_rF
# kal['ref_C'] = kal.Außenluft_C
kal['ref_rF'] = (kal.Abluft_rF + kal.Fortluft_rF + kal.Zuluft_rF + kal.Außenluft_rF) / 4
kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C + kal.Außenluft_C) / 4
kal['Abluft_rF'] = kalibrieren(kal['Abluft_rF'], kal['ref_rF'])
kal['Fortluft_rF'] = kalibrieren(kal['Fortluft_rF'], kal['ref_rF'])
kal['Außenluft_rF'] = kalibrieren(kal['Außenluft_rF'],kal['ref_rF'])
kal['Zuluft_rF'] = kalibrieren(kal['Zuluft_rF'], kal['ref_rF'])
kal['Abluft_C'] = kalibrieren(kal['Abluft_C'], kal['ref_C'])
kal['Fortluft_C'] = kalibrieren(kal['Fortluft_C'], kal['ref_C'])
kal['Außenluft_C'] = kalibrieren(kal['Außenluft_C'], kal['ref_C'])
kal['Zuluft_C'] = kalibrieren(kal['Zuluft_C'], kal['ref_C'])
daten_kal_sub['Abluft_rF'] = daten_kal_sub['Abluft_rF'] * 0.8305882666625446 + 8.055745638372443
daten_kal_sub['Fortluft_rF'] = daten_kal_sub['Fortluft_rF'] * 1.062370224215799 + -1.121169045293179
daten_kal_sub['Außenluft_rF'] = daten_kal_sub['Außenluft_rF'] * 0.8354930285393901 + 5.015519047999741
daten_kal_sub['Zuluft_rF'] = daten_kal_sub['Zuluft_rF'] * 0.9236537106550828 + 2.6983173712048316
daten_kal_sub['Abluft_C'] = daten_kal_sub['Abluft_C'] * 0.9596161144526612 + 0.6980052676578619
daten_kal_sub['Fortluft_C'] = daten_kal_sub['Fortluft_C'] * 0.9053512255469426 + 1.7706350319492505
daten_kal_sub['Außenluft_C'] = daten_kal_sub['Außenluft_C'] * 1.0931527544943642 + -1.5660310943041458
daten_kal_sub['Zuluft_C'] = daten_kal_sub['Zuluft_C'] * 0.9264435014124848 + 1.3362432683236858a = 3
b = 5
c = 4
d = 4
arr_mitte = (a+b+c+d)/4
mitte = ( a*a + b*b + c*c + d*d)**(1./4)
print(arr_mitte)
print(mitte)4.0
2.8502698827717983Plot Kalibrierung
## DataFrame für den Zeitraum der Kalibrierung
daten_sub = daten.loc['2018-02-22 16:40:00':'2018-02-23 14:38:00']
fig, ax = plt.subplots()
daten_sub['Außenluft_C'].plot(ax=ax,color=colo('blau',1), linewidth=0.5, label = 'Außenluft')
daten_sub['Zuluft_C'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
daten_sub['Abluft_C'].plot(ax=ax,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
daten_sub['Fortluft_C'].plot(ax=ax,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
ax2 = ax.twinx()
daten_sub['Außenluft_rF'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = '__nolable__')
daten_sub['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
daten_sub['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
daten_sub['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[18,23])
ax.set_yticks([18.5,19,19.5])
ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
ax2.set(ylim=[27,48])
ax2.set_yticks([39,41,43])
ax2.set_ylabel(r'\textbf{rel Luftfeuchte} (\%)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Testo174H vor Kalibrierung')
# ax.set(xlim=[pd.to_datetime("2018-02-22 16:40:00"),pd.to_datetime("2018-02-23 14:38:00")])
## DataFrame für den Zeitraum der Kalibrierung
# df ist bei der Kalibreirung schon erstellt worden
fig, ax = plt.subplots()
kal['Außenluft_C'].plot(ax=ax,color=colo('blau',1), linewidth=0.5, label = 'Außenluft')
kal['Zuluft_C'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
kal['Abluft_C'].plot(ax=ax,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
kal['Fortluft_C'].plot(ax=ax,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
ax2 = ax.twinx()
kal['Außenluft_rF'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = '__nolable__')
kal['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
kal['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
kal['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[18,23])
ax.set_yticks([18.5,19,19.5])
ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
ax2.set(ylim=[27,48])
ax2.set_yticks([39,41,43])
ax2.set_ylabel(r'\textbf{rel Luftfeuchte} (\%)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Testo174H nach Kalibrierung')
# ax.set(xlim=[pd.to_datetime("2018-02-22 16:40:00"),pd.to_datetime("2018-02-23 14:38:00")])
## Aus der Kalibrierung vom 25.03.2019 gegen das Testo480
## Excel MA_Testo_174_Kalibrierung
kal1 = daten.loc['2018-02-22 16:40:00':'2018-02-23 14:38:00']
kal1['Abluft_rF'] = kal1['Abluft_rF'] * 1.0386 - 0.0826
kal1['Fortluft_rF'] = kal1['Fortluft_rF'] * 0.9522 + 2.5642
kal1['Außenluft_rF'] = kal1['Außenluft_rF'] * 1.0568 + 3.1864
kal1['Zuluft_rF'] = kal1['Zuluft_rF'] * 1.0489 + 2.9552
kal1['Abluft_C'] = kal1['Abluft_C'] * 1.0447 - 0.5989
kal1['Fortluft_C'] = kal1['Fortluft_C'] * 1.0002 + 0.2829
kal1['Außenluft_C'] = kal1['Außenluft_C'] * 1.0191 - 0.809
kal1['Zuluft_C'] = kal1['Zuluft_C'] * 1.0059 - 0.3276
## DataFrame für den Zeitraum der Kalibrierung
# df ist bei der Kalibreirung schon erstellt worden
fig, ax = plt.subplots()
kal1['Außenluft_C'].plot(ax=ax,color=colo('blau',1), linewidth=0.5, label = 'Außenluft')
kal1['Zuluft_C'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
kal1['Abluft_C'].plot(ax=ax,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
kal1['Fortluft_C'].plot(ax=ax,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
ax2 = ax.twinx()
kal1['Außenluft_rF'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = '__nolable__')
kal1['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
kal1['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
kal1['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[18,23])
ax.set_yticks([18.5,19,19.5])
ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
ax2.set(ylim=[27,48])
ax2.set_yticks([39,41,43])
ax2.set_ylabel(r'\textbf{rel Luftfeuchte} (\%)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Kalibrierung gegen Testo480')
# ax.set(xlim=[pd.to_datetime("2018-02-22 16:40:00"),pd.to_datetime("2018-02-23 14:38:00")])Text(0.5, 1.0, 'Kalibrierung gegen Testo480')
WRG
kalibrieren
## löschen
## ungenaue Enden abschneiden
datena = daten.loc['2017-12-05 11:00:00':'2017-12-12 09:00:00']
datenb = daten.loc['2018-01-30 12:00:00':'2018-02-12 11:00:00']
datenc = daten.loc['2018-02-15 18:00:00':'2018-02-21 10:00:00']
daten = pd.concat([datena, datenb, datenc])
daten.dropna(inplace=True)
## wurde da noch mal kalibriert?
datena = daten.loc['2017-12-05 10:00:00':'2018-02-05 08:00:00']
datenb = daten.loc['2018-02-05 18:00:00':'2018-02-21 10:00:00']
daten = pd.concat([datena, datenb])
daten.dropna(inplace=True)
print(f'daten: {round(daten.Abluft_rF.mean(),2)}') daten: 28.19## df zur Kontrolle
daten_sub = daten.copy()
## df für Kalibrierung
daten_kal_sub = daten.copy()
print(f'daten: {round(daten.Abluft_rF.mean(),2)}')
print(f'daten_sub: {round(daten_sub.Abluft_rF.mean(),2)}')
print(f'daten_kal_sub: {round(daten_kal_sub.Abluft_rF.mean(),2)}')daten: 28.19
daten_sub: 28.19
daten_kal_sub: 28.19## Aus der Kalibrierung vom 25.03.2019 gegen das Testo480 Excel MA_Testo_174_Kalibrierung
# daten_kal_sub['Abluft_rF'] = daten['Abluft_rF'] * 1.0386 - 0.0826
# daten_kal_sub['Fortluft_rF'] = daten['Fortluft_rF'] * 0.9522 + 2.5642
# daten_kal_sub['Außenluft_rF'] = daten['Außenluft_rF'] * 1.0568 + 3.1864
# daten_kal_sub['Zuluft_rF'] = daten['Zuluft_rF'] * 1.0489 + 2.9552
# daten_kal_sub['Abluft_C'] = daten['Abluft_C'] * 1.0447 - 0.5989
# daten_kal_sub['Fortluft_C'] = daten['Fortluft_C'] * 1.0002 + 0.2829
# daten_kal_sub['Außenluft_C'] = daten['Außenluft_C'] * 1.0191 - 0.809
# daten_kal_sub['Zuluft_C'] = daten['Zuluft_C'] * 1.0059 - 0.3276
## kal['ref_rF'] = (kal.Abluft_rF + kal.Fortluft_rF ) / 2
## kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C) / 3
daten_kal_sub['Abluft_rF'] = daten_kal_sub['Abluft_rF'] * 0.828993573070746 + 6.801455317349444
daten_kal_sub['Fortluft_rF'] = daten_kal_sub['Fortluft_rF'] * 1.0674200418092923 + -2.6412934624410167
daten_kal_sub['Außenluft_rF'] = daten_kal_sub['Außenluft_rF'] * 0.8002161817773167 + 5.231630936999777
daten_kal_sub['Zuluft_rF'] = daten_kal_sub['Zuluft_rF'] * 0.9223667924445846 + 1.4339541677129877
daten_kal_sub['Abluft_C'] = daten_kal_sub['Abluft_C'] * 1.0209706144779265 + -0.4144120307172744
daten_kal_sub['Fortluft_C'] = daten_kal_sub['Fortluft_C'] * 0.9647290370199838 + 0.6981836985112495
daten_kal_sub['Außenluft_C'] = daten_kal_sub['Außenluft_C'] * 1.1242036726591484 + -2.0880414590720107
daten_kal_sub['Zuluft_C'] = daten_kal_sub['Zuluft_C'] * 0.9913301797188931 + 0.1560904830431007
# daten.info()
print(f'daten: {round(daten.Abluft_rF.mean(),2)}')
print(f'daten_sub: {round(daten_sub.Abluft_rF.mean(),2)}')
print(f'daten_kal_sub: {round(daten_kal_sub.Abluft_rF.mean(),2)}')
daten_kal_sub.to_csv('Testo_Arbeitsdaten_15s_WRG_Eff.csv')daten: 28.19
daten_sub: 28.19
daten_kal_sub: 30.17
#################################### INSERT HERE ####################################
## Referenz:
## kal['ref_rF'] = (kal.Abluft_rF + kal.Fortluft_rF ) / 2
## kal['ref_C'] = (kal.Abluft_C + kal.Fortluft_C + kal.Zuluft_C) / 3
# daten_kal_sub['Abluft_rF'] = daten_kal_sub['Abluft_rF'] * 0.828993573070746 + 6.801455317349444
# daten_kal_sub['Fortluft_rF'] = daten_kal_sub['Fortluft_rF'] * 1.0674200418092923 + -2.6412934624410167
# daten_kal_sub['Außenluft_rF'] = daten_kal_sub['Außenluft_rF'] * 0.8002161817773167 + 5.231630936999777
# daten_kal_sub['Zuluft_rF'] = daten_kal_sub['Zuluft_rF'] * 0.9223667924445846 + 1.4339541677129877
# daten_kal_sub['Abluft_C'] = daten_kal_sub['Abluft_C'] * 1.0209706144779265 + -0.4144120307172744
# daten_kal_sub['Fortluft_C'] = daten_kal_sub['Fortluft_C'] * 0.9647290370199838 + 0.6981836985112495
# daten_kal_sub['Außenluft_C'] = daten_kal_sub['Außenluft_C'] * 1.1242036726591484 + -2.0880414590720107
# daten_kal_sub['Zuluft_C'] = daten_kal_sub['Zuluft_C'] * 0.9913301797188931 + 0.1560904830431007
#################################### INSERT HERE ####################################b
# display(daten_sub[['Abluft_rF','Fortluft_rF','Außenluft_rF','Zuluft_rF','Abluft_C','Fortluft_C','Außenluft_C','Zuluft_C',]].mean())
# display(daten_kal_sub[['Abluft_rF','Fortluft_rF','Außenluft_rF','Zuluft_rF','Abluft_C','Fortluft_C','Außenluft_C','Zuluft_C',]].mean())
# display(daten.tail(10))
# display(daten_sub.tail(10))
# display(daten_kal_sub.tail(10))
# daten_kal_sub['W_Luftdruck']Effizienz berechnen
############## VORHER ##############
daten_sub['W_Luftdruck'] = 101.325 ## 101,3 kPa = 1,013 bar
daten_sub['L_Zuluft_VPunkt'] = daten_sub['L_Zuluft_1_VPunkt'] + daten_sub['L_Zuluft_2_VPunkt'] + daten_sub['L_Zuluft_3_VPunkt']
## Wassergehalte (WG) in den Luftströmen daten_sub
daten_sub['Außenluft_WG'] = psy.Hum_rat2(daten_sub['Außenluft_C'], daten_sub['Außenluft_rF']/100, daten_sub['W_Luftdruck'])
daten_sub['Zuluft_WG'] = psy.Hum_rat2(daten_sub['Zuluft_C'], daten_sub['Zuluft_rF']/100, daten_sub['W_Luftdruck'])
daten_sub['Abluft_WG'] = psy.Hum_rat2(daten_sub['Abluft_C'], daten_sub['Abluft_rF']/100, daten_sub['W_Luftdruck'])
daten_sub['Fortluft_WG'] = psy.Hum_rat2(daten_sub['Fortluft_C'], daten_sub['Fortluft_rF']/100, daten_sub['W_Luftdruck'])
## Enthalpien in den Luftströmen daten_sub
daten_sub['h21_Außenluft'] = psy.Enthalpy_Air_H2O(daten_sub['Außenluft_C'], daten_sub['Außenluft_WG'])
daten_sub['h22_Zuluft'] = psy.Enthalpy_Air_H2O(daten_sub['Zuluft_C'], daten_sub['Zuluft_WG'])
daten_sub['h11_Abluft'] = psy.Enthalpy_Air_H2O(daten_sub['Abluft_C'], daten_sub['Abluft_WG'])
daten_sub['h12_Fortluft'] = psy.Enthalpy_Air_H2O(daten_sub['Fortluft_C'], daten_sub['Fortluft_WG'])
## Effizienz der Wärmerückgewinnung
daten_sub['EÜG_Fortluft'] = (daten_sub['h11_Abluft'] - daten_sub['h12_Fortluft']) / (daten_sub['h11_Abluft'] - daten_sub['h21_Außenluft']) * 100
daten_sub['EÜG_Außenluft'] = (daten_sub['h22_Zuluft'] - daten_sub['h21_Außenluft']) / (daten_sub['h11_Abluft'] - daten_sub['h21_Außenluft']) * 100
## Rückwärmezahl
daten_sub['RWZ_Außenluft'] = (daten_sub['Abluft_C'] - daten_sub['Fortluft_C']) / (daten_sub['Abluft_C'] - daten_sub['Außenluft_C']) * 100
## Gewicht der feuchten Luft
daten_sub['Außenluft_Masse'] = psy.Dry_Air_Density(daten_sub['W_Luftdruck'], daten_sub['Außenluft_C'], daten_sub['Außenluft_WG']) * (1 + daten_sub['Außenluft_WG'])
daten_sub['Fortluft_Masse'] = psy.Dry_Air_Density(daten_sub['W_Luftdruck'], daten_sub['Fortluft_C'], daten_sub['Fortluft_WG']) * (1 + daten_sub['Fortluft_WG'])
## Energie der Luftmassenströme
daten_sub['Außenluft_Energie'] = daten_sub['h21_Außenluft'] * daten_sub['Außenluft_Masse'] * daten_sub['L_Zuluft_VPunkt'] * (1/3600) ## kJ in kWh
daten_sub['Fortluftluft_Energie'] = daten_sub['h12_Fortluft'] * daten_sub['Fortluft_Masse'] * daten_sub['L_Zuluft_VPunkt'] * (1/3600) ## kJ in kWh
daten_sub['verlorene_Energie'] = daten_sub['Fortluftluft_Energie'] - daten_sub['Außenluft_Energie']
daten_sub['Zuluft_Druck_Schwelle_unten'] = 80
daten_sub['Zuluft_Druck_Schwelle_oben'] = 93
daten_sub['EÜG_Fortluft_bereinigt_unten'] = np.where(daten_sub['L_Zuluft_Druck'] < daten_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_sub['EÜG_Fortluft'])
daten_sub['EÜG_Außenluft_bereinigt_unten'] = np.where(daten_sub['L_Zuluft_Druck'] < daten_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_sub['EÜG_Außenluft'])
daten_sub['RWZ_Außenluft_bereinigt_unten'] = np.where(daten_sub['L_Zuluft_Druck'] < daten_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_sub['RWZ_Außenluft'])
daten_sub['EÜG_Fortluft_bereinigt'] = np.where(daten_sub['L_Zuluft_Druck'] > daten_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_sub['EÜG_Fortluft_bereinigt_unten'])
daten_sub['EÜG_Außenluft_bereinigt'] = np.where(daten_sub['L_Zuluft_Druck'] > daten_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_sub['EÜG_Außenluft_bereinigt_unten'])
daten_sub['RWZ_Außenluft_bereinigt'] = np.where(daten_sub['L_Zuluft_Druck'] > daten_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_sub['RWZ_Außenluft_bereinigt_unten'])
daten_sub['EÜG_Fortluft_mean'] = daten_sub['EÜG_Fortluft_bereinigt'].mean()
daten_sub['EÜG_Außenluft_mean'] = daten_sub['EÜG_Außenluft_bereinigt'].mean()
daten_sub['RWZ_Außenluft_mean'] = daten_sub['RWZ_Außenluft_bereinigt'].mean()
daten_sub['RWZ_Außenluft_für_Effizienz'] = 0
daten_sub.loc[ daten_sub['RWZ_Außenluft'].rolling(2000, center=True).std() < 1 , 'RWZ_Außenluft_plateau'] = 1
daten_sub.loc[ daten_sub['RWZ_Außenluft_bereinigt'] > 1 , 'RWZ_Außenluft_Bypass_zu'] = 1
daten_sub['RWZ_Außenluft_für_Effizienz'] = np.where( (daten_sub['RWZ_Außenluft_plateau'] == 1) & (daten_sub['RWZ_Außenluft_Bypass_zu'] == 1) , 1, 0)
############## NACHHER ##############
daten_kal_sub['L_Zuluft_VPunkt'] = daten_kal_sub['L_Zuluft_1_VPunkt'] + daten_kal_sub['L_Zuluft_2_VPunkt'] + daten_kal_sub['L_Zuluft_3_VPunkt']
daten_kal_sub['W_Luftdruck'] = 101.325 ## 101,3 kPa = 1,013 bar
## Wassergehalte (WG) in den Luftströmen daten_kal_sub
daten_kal_sub['Außenluft_WG'] = psy.Hum_rat2(daten_kal_sub['Außenluft_C'], daten_kal_sub['Außenluft_rF']/100, daten_kal_sub['W_Luftdruck'])
daten_kal_sub['Zuluft_WG'] = psy.Hum_rat2(daten_kal_sub['Zuluft_C'], daten_kal_sub['Zuluft_rF']/100, daten_kal_sub['W_Luftdruck'])
daten_kal_sub['Abluft_WG'] = psy.Hum_rat2(daten_kal_sub['Abluft_C'], daten_kal_sub['Abluft_rF']/100, daten_kal_sub['W_Luftdruck'])
daten_kal_sub['Fortluft_WG'] = psy.Hum_rat2(daten_kal_sub['Fortluft_C'], daten_kal_sub['Fortluft_rF']/100, daten_kal_sub['W_Luftdruck'])
## Enthalpien in den Luftströmen daten_kal_sub
daten_kal_sub['h21_Außenluft'] = psy.Enthalpy_Air_H2O(daten_kal_sub['Außenluft_C'], daten_kal_sub['Außenluft_WG'])
daten_kal_sub['h22_Zuluft'] = psy.Enthalpy_Air_H2O(daten_kal_sub['Zuluft_C'], daten_kal_sub['Zuluft_WG'])
daten_kal_sub['h11_Abluft'] = psy.Enthalpy_Air_H2O(daten_kal_sub['Abluft_C'], daten_kal_sub['Abluft_WG'])
daten_kal_sub['h12_Fortluft'] = psy.Enthalpy_Air_H2O(daten_kal_sub['Fortluft_C'], daten_kal_sub['Fortluft_WG'])
## Effizienz der Wärmerückgewinnung
daten_kal_sub['EÜG_Fortluft'] = (daten_kal_sub['h11_Abluft'] - daten_kal_sub['h12_Fortluft']) / (daten_kal_sub['h11_Abluft'] - daten_kal_sub['h21_Außenluft']) * 100
daten_kal_sub['EÜG_Außenluft'] = (daten_kal_sub['h22_Zuluft'] - daten_kal_sub['h21_Außenluft']) / (daten_kal_sub['h11_Abluft'] - daten_kal_sub['h21_Außenluft']) * 100
## Rückwärmezahl
daten_kal_sub['RWZ_Außenluft'] = (daten_kal_sub['Abluft_C'] - daten_kal_sub['Fortluft_C']) / (daten_kal_sub['Abluft_C'] - daten_kal_sub['Außenluft_C']) * 100
## Gewicht der feuchten Luft
daten_kal_sub['Außenluft_Masse'] = psy.Dry_Air_Density(daten_kal_sub['W_Luftdruck'], daten_kal_sub['Außenluft_C'], daten_kal_sub['Außenluft_WG']) * (1 + daten_kal_sub['Außenluft_WG'])
daten_kal_sub['Fortluft_Masse'] = psy.Dry_Air_Density(daten_kal_sub['W_Luftdruck'], daten_kal_sub['Fortluft_C'], daten_kal_sub['Fortluft_WG']) * (1 + daten_kal_sub['Fortluft_WG'])
## Energie der Luftmassenströme
daten_kal_sub['Außenluft_Energie'] = daten_kal_sub['h21_Außenluft'] * daten_kal_sub['Außenluft_Masse'] * daten_kal_sub['L_Zuluft_VPunkt'] * (1/3600) ## kJ in kWh
daten_kal_sub['Fortluftluft_Energie'] = daten_kal_sub['h12_Fortluft'] * daten_kal_sub['Fortluft_Masse'] * daten_kal_sub['L_Zuluft_VPunkt'] * (1/3600) ## kJ in kWh
daten_kal_sub['verlorene_Energie'] = daten_kal_sub['Fortluftluft_Energie'] - daten_kal_sub['Außenluft_Energie']
daten_kal_sub['Zuluft_Druck_Schwelle_unten'] = 80
daten_kal_sub['Zuluft_Druck_Schwelle_oben'] = 93
daten_kal_sub['EÜG_Fortluft_bereinigt_unten'] = np.where(daten_kal_sub['L_Zuluft_Druck'] < daten_kal_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_kal_sub['EÜG_Fortluft'])
daten_kal_sub['EÜG_Außenluft_bereinigt_unten'] = np.where(daten_kal_sub['L_Zuluft_Druck'] < daten_kal_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_kal_sub['EÜG_Außenluft'])
daten_kal_sub['RWZ_Außenluft_bereinigt_unten'] = np.where(daten_kal_sub['L_Zuluft_Druck'] < daten_kal_sub['Zuluft_Druck_Schwelle_unten'], np.NaN,daten_kal_sub['RWZ_Außenluft'])
daten_kal_sub['EÜG_Fortluft_bereinigt'] = np.where(daten_kal_sub['L_Zuluft_Druck'] > daten_kal_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_kal_sub['EÜG_Fortluft_bereinigt_unten'])
daten_kal_sub['EÜG_Außenluft_bereinigt'] = np.where(daten_kal_sub['L_Zuluft_Druck'] > daten_kal_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_kal_sub['EÜG_Außenluft_bereinigt_unten'])
daten_kal_sub['RWZ_Außenluft_bereinigt'] = np.where(daten_kal_sub['L_Zuluft_Druck'] > daten_kal_sub['Zuluft_Druck_Schwelle_oben'], np.NaN,daten_kal_sub['RWZ_Außenluft_bereinigt_unten'])
daten_kal_sub['EÜG_Fortluft_mean'] = daten_kal_sub['EÜG_Fortluft_bereinigt'].mean()
daten_kal_sub['EÜG_Außenluft_mean'] = daten_kal_sub['EÜG_Außenluft_bereinigt'].mean()
daten_kal_sub['RWZ_Außenluft_mean'] = daten_kal_sub['RWZ_Außenluft_bereinigt'].mean()
daten_kal_sub['RWZ_Außenluft_für_Effizienz'] = 0
daten_kal_sub.loc[ daten_kal_sub['RWZ_Außenluft'].rolling(2000, center=True).std() < 1 , 'RWZ_Außenluft_plateau'] = 1
daten_kal_sub.loc[ daten_kal_sub['RWZ_Außenluft_bereinigt'] > 1 , 'RWZ_Außenluft_Bypass_zu'] = 1
daten_kal_sub['RWZ_Außenluft_für_Effizienz'] = np.where( (daten_kal_sub['RWZ_Außenluft_plateau'] == 1) & (daten_kal_sub['RWZ_Außenluft_Bypass_zu'] == 1) , 1, 0)
# daten_sub['RWZ_Außenluft_bereinigt'].head(500)# daten_kal_sub['W_Luftdruck']
WRG Plot vor und nach Kalibrierung
## Plot
fig, ax = plt.subplots()
ax.fill_between(daten_sub.index, 0, 1, where=daten_sub['RWZ_Außenluft_für_Effizienz']==1, color=colo('grau',1), alpha=1, transform=ax.get_xaxis_transform())
# EÜG, EÜG fett, EÜG Durchschnitt
daten_sub['EÜG_Außenluft'].plot(ax=ax,color=colo('grün',1), linewidth=0.5, label = 'EÜG_Außenluft')
daten_sub['EÜG_Fortluft'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'EÜG_Fortluft')
daten_sub['RWZ_Außenluft'].plot(ax=ax,color=colo('black',1), linewidth=0.5, label = 'RWZ_Außenluft')
# EÜG in Druckintervall
daten_sub['EÜG_Außenluft_bereinigt'].plot(ax=ax,color=colo('grün',1), linewidth=1, label = '__nolable__')
daten_sub['EÜG_Fortluft_bereinigt'].plot(ax=ax,color=colo('rot',1), linewidth=1, label = '__nolable__')
daten_sub['RWZ_Außenluft_bereinigt'].plot(ax=ax,color=colo('black',1), linewidth=1, label = '__nolable__')
# EÜG Durchschnitt
daten_sub['EÜG_Fortluft_mean'].plot(ax=ax,color=colo('rot',1.5), linewidth=0.5, label = '__nolable__')
daten_sub['EÜG_Außenluft_mean'].plot(ax=ax,color=colo('grün',1.5), linewidth=0.5, label = '__nolable__')
daten_sub['RWZ_Außenluft_mean'].plot(ax=ax,color=colo('black',1.5), linewidth=0.5, label = '__nolable__')
ax.text(0.1, 0.05, 'EÜG_Außenluft: '+str(int(daten_sub['EÜG_Außenluft_bereinigt'].mean()))+' \%', color=colo('grün',.8), transform=ax.transAxes, fontsize=10)
ax.text(0.4, 0.05, 'EÜG_Fortluft: '+str(int(daten_sub['EÜG_Fortluft_bereinigt'].mean()))+' \%', color=colo('rot',.8), transform=ax.transAxes, fontsize=10)
ax.text(0.7, 0.05, 'RWZ_Außenluft: '+str(int(daten_sub['RWZ_Außenluft_bereinigt'].mean()))+' \%', color=colo('black',.8), transform=ax.transAxes, fontsize=10)
ax.set(xlim=[pd.to_datetime("2018-01-30 11:00:00"),pd.to_datetime("2018-02-12 11:00:00")])
ax.set(ylabel="Energie(kWh)", xlabel="Zeit",ylim=[20,100])
ax.set_xlabel('')
h0, l0 = ax.get_legend_handles_labels()
legend = plt.legend(h0, l0, ncol=3, loc=1)
set_legend_linewidth(legend)
plt.title('WRG vor Kalibrierung')
# plt.savefig(output_folder + '/' + file_name + 'WRG_vor_Kalibrierung.pdf')
plt.show()
## Plot
fig, ax = plt.subplots()
ax.fill_between(daten_kal_sub.index, 0, 1, where=daten_kal_sub['RWZ_Außenluft_für_Effizienz']==1, alpha=1, color=colo('grau',1), transform=ax.get_xaxis_transform())
# EÜG, EÜG fett, EÜG Durchschnitt
daten_kal_sub['EÜG_Außenluft'].plot(ax=ax,color=colo('grün',1), linewidth=0.5, label = 'EÜG_Außenluft')
daten_kal_sub['EÜG_Fortluft'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'EÜG_Fortluft')
daten_kal_sub['RWZ_Außenluft'].plot(ax=ax,color=colo('black',1), linewidth=0.5, label = 'RWZ_Außenluft')
# EÜG in Druckintervall
daten_kal_sub['EÜG_Außenluft_bereinigt'].plot(ax=ax,color=colo('grün',1), linewidth=1, label = '__nolable__')
daten_kal_sub['EÜG_Fortluft_bereinigt'].plot(ax=ax,color=colo('rot',1), linewidth=1, label = '__nolable__')
daten_kal_sub['RWZ_Außenluft_bereinigt'].plot(ax=ax,color=colo('black',1), linewidth=1, label = '__nolable__')
# EÜG Durchschnitt
daten_kal_sub['EÜG_Fortluft_mean'].plot(ax=ax,color=colo('rot',1.5), linewidth=0.5, label = '__nolable__')
daten_kal_sub['EÜG_Außenluft_mean'].plot(ax=ax,color=colo('grün',1.5), linewidth=0.5, label = '__nolable__')
daten_kal_sub['RWZ_Außenluft_mean'].plot(ax=ax,color=colo('black',1.5), linewidth=0.5, label = '__nolable__')
ax.text(0.1, 0.05, 'EÜG_Außenluft: '+str(int(daten_kal_sub['EÜG_Außenluft_bereinigt'].mean()))+' \%', color=colo('grün',.8), transform=ax.transAxes, fontsize=10)
ax.text(0.4, 0.05, 'EÜG_Fortluft: '+str(int(daten_kal_sub['EÜG_Fortluft_bereinigt'].mean()))+' \%', color=colo('rot',.8), transform=ax.transAxes, fontsize=10)
ax.text(0.7, 0.05, 'RWZ_Außenluft: '+str(int(daten_kal_sub['RWZ_Außenluft_bereinigt'].mean()))+' \%', color=colo('black',.8), transform=ax.transAxes, fontsize=10)
ax.set(xlim=[pd.to_datetime("2018-01-30 11:00:00"),pd.to_datetime("2018-02-12 11:00:00")])
ax.set(ylabel="Energie(kWh)", xlabel="Zeit",ylim=[20,100])
ax.set_xlabel('')
h0, l0 = ax.get_legend_handles_labels()
legend = plt.legend(h0, l0, ncol=3, loc=1)
set_legend_linewidth(legend)
plt.title('WRG nach Kalibrierung')
# plt.savefig(output_folder + '/' + file_name + 'WRG_nach_Kalibrierung.pdf')
plt.show()
Plateau finden
# RWZ_Außenluft EÜG_Außenluft
daten_kal_sub['RWZ_Außenluft_für_Effizienz'] = 0
daten_kal_sub.loc[ daten_kal_sub['RWZ_Außenluft'].rolling(2000, center=True).std() < 1 , 'RWZ_Außenluft_plateau'] = 1
daten_kal_sub.loc[ daten_kal_sub['RWZ_Außenluft_bereinigt'] > 1 , 'RWZ_Außenluft_Bypass_zu'] = 1
daten_kal_sub['RWZ_Außenluft_für_Effizienz'] = np.where( (daten_kal_sub['RWZ_Außenluft_plateau'] == 1) & (daten_kal_sub['RWZ_Außenluft_Bypass_zu'] == 1) , 1, 0)
daten_kal_sub['RWZ_Außenluft_für_Effizienz_plot'] = np.where( (daten_kal_sub['RWZ_Außenluft_für_Effizienz'] == 1) , daten_kal_sub['RWZ_Außenluft_bereinigt'] , np.nan)
daten_kal_sub['EÜG_Außenluft_bereinigt'] = np.where( (daten_kal_sub['RWZ_Außenluft_für_Effizienz'] == 1) , daten_kal_sub['EÜG_Außenluft_bereinigt'] , np.nan)
fig, ax = plt.subplots()
daten_kal_sub['RWZ_Außenluft_bereinigt'].plot(ax=ax,color=colo('red',1), linewidth=0.3, label = 'RWZ_Außenluft')
daten_kal_sub['RWZ_Außenluft_für_Effizienz_plot'].plot(ax=ax,color=colo('black',1), linewidth=0.5, label = 'RWZ_Außenluft_für_Effizienz')
ax.fill_between(daten_kal_sub.index, 0, 1, where=daten_kal_sub['RWZ_Außenluft_für_Effizienz']==1, alpha=1, color=colo('grau',1), transform=ax.get_xaxis_transform())
# ax.fill_between(daten_kal_sub.index, 0, 1, where=daten_kal_sub['RWZ_Außenluft_plateau'] == 1, alpha=1, color=colo('grau',1), transform=ax.get_xaxis_transform())
ax2 = ax.twinx()
daten_kal_sub['Außenluft_C'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = 'Außenluft')
daten_kal_sub['Zuluft_C'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
daten_kal_sub['Abluft_C'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
daten_kal_sub['Fortluft_C'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
# kal['Außenluft_rF'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = '__nolable__')
# kal['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
# kal['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
# kal['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[50,70])
# ax.set_yticks([18.5,19,19.5])
# ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
ax2.set(ylim=[-5,30])
# ax2.set_yticks([39,41,43])
# ax2.set_ylabel(r'\textbf{rel Luftfeuchte} (\%)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Plateau finden')
ax.set(xlim=[pd.to_datetime("2018-01-30 11:00:00"),pd.to_datetime("2018-02-12 11:00:00")])[(736724.4583333334, 736737.4583333334)]
bax Plot
eins = pd.to_datetime("2017-12-05 10:00", infer_datetime_format=True).to_pydatetime()
zwei = pd.to_datetime("2017-12-12 10:18", infer_datetime_format=True).to_pydatetime()
drei = pd.to_datetime("2018-01-30 11:11", infer_datetime_format=True).to_pydatetime()
vier = pd.to_datetime("2018-02-12 12:36", infer_datetime_format=True).to_pydatetime()
fünf = pd.to_datetime("2018-02-15 16:40", infer_datetime_format=True).to_pydatetime()
sechs = pd.to_datetime("2018-02-23 14:38", infer_datetime_format=True).to_pydatetime()
fig = plt.figure(constrained_layout=False, figsize=(10,3))
bax = brokenaxes(xlims=((eins, zwei), (drei, vier), (fünf,sechs)), hspace=1.2)
bax.plot(daten_kal_sub.index, daten_kal_sub['Außenluft_C'], color=colo('grün',1), linewidth=0.5, label = r'Außenluft_C')
bax.plot(daten_kal_sub.index, daten_kal_sub['Außenluft_rF'], color=colo('orange',1), linewidth=0.5, label = r'Außenluft_rF')
bax.plot(daten_kal_sub.index, daten_kal_sub['RWZ_Außenluft_für_Effizienz_plot'], color=colo('blau',1), linewidth=0.8, label = r'RWZ_Außenluft_für_Effizienz_plot')
bax.plot(daten_kal_sub.index, daten_kal_sub['EÜG_Außenluft_bereinigt'], color=colo('rot',1), linewidth=0.8, label = r'EÜG_Außenluft_bereinigt')
fig.axes[0].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
fig.axes[1].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
fig.axes[2].get_xaxis().set_major_formatter(mdates.DateFormatter("%d.%m."))
# bax.set_xlabel('')
bax.set(ylim=[-10,110])
# bax.set_yticks([18.5,19,19.5])
# bax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
bax.legend(loc=1, ncol=4) <matplotlib.legend.Legend at 0x1ec93552608>
save to file
daten_kal_sub.to_csv('Testo_Arbeitsdaten_15s_WRG_Eff.csv')Zusammenhang Außenluft & RWZ
## alle daten nur wenn RWZ gültig ist
eff_ber = daten_kal_sub.where(daten_kal_sub['RWZ_Außenluft_für_Effizienz']==1)
## alle daten nur wenn RWZ gültig ist
eff_ber = daten_kal_sub.where(daten_kal_sub['RWZ_Außenluft_für_Effizienz']==1)
from numpy.polynomial.polynomial import polyfit
# eff_ber['RWZ_Außenluft_für_Effizienz_plot'] = np.where( (eff_ber['RWZ_Außenluft_für_Effizienz_plot'] < 59) , eff_ber['RWZ_Außenluft_für_Effizienz_plot'] , np.nan)
y = eff_ber['RWZ_Außenluft_für_Effizienz_plot']
y2 = eff_ber['EÜG_Fortluft_bereinigt']
x = eff_ber['Außenluft_C']
# w = np.polyfit(x,y,3)
# p = np.poly1d(w)
X = np.arange(-4,12)
Y = .6*X + 56
plt.scatter(x, y2, s=1, color=colo('rot',1), label="EÜG")
plt.scatter(x, y, s=1, color=colo('blau',1), label="RWZ")
# plt.plot(X,.33*X + 55,color=colo('blau',1.5),label = 'Regressionsgerade RWZ')
plt.ylabel("RWZ")
plt.xlabel("Außenluft")
plt.legend(loc='upper right')
plt.show()
Luftwerte während der Kalibrierung der WRG
fig, ax = plt.subplots()
daten_kal_sub['Außenluft_C'].plot(ax=ax,color=colo('blau',1), linewidth=0.5, label = 'Außenluft')
daten_kal_sub['Zuluft_C'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
daten_kal_sub['Abluft_C'].plot(ax=ax,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
daten_kal_sub['Fortluft_C'].plot(ax=ax,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
ax2 = ax.twinx()
daten_kal_sub['Außenluft_rF'].plot(ax=ax2,color=colo('blau',1), linewidth=0.5, label = '__nolable__')
daten_kal_sub['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
daten_kal_sub['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
daten_kal_sub['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[-10,80])
ax.set_yticks([-5,5,15,25])
ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)')
ax2.set(ylim=[-40,100])
ax2.set_yticks([30,60,90])
ax2.set_ylabel(r'\textbf{rel Luftfeuchte} (\%)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Während der WGR Effizienzmessung')
ax.set(xlim=[pd.to_datetime("2018-01-30 11:00:00"),pd.to_datetime("2018-02-12 11:00:00")])
print('EÜG_Außenluft:\t '+str(int(daten_kal_sub['EÜG_Außenluft_bereinigt'].mean()))+' %')
print('EÜG_Fortluft:\t '+str(int(daten_kal_sub['EÜG_Fortluft_bereinigt'].mean()))+' %')
print('RWZ_Außenluft:\t '+str(int(daten_kal_sub['RWZ_Außenluft_bereinigt'].mean()))+' %')
print('Außenluft_C:\t '+str(round(daten_kal_sub['Außenluft_C'].mean(),2))+' °C')
print('Zuluft_C:\t '+str(round(daten_kal_sub['Zuluft_C'].mean(),2))+' °C')
print('Abluft_C:\t '+str(round(daten_kal_sub['Abluft_C'].mean(),2))+' °C')
print('Fortluft_C:\t '+str(round(daten_kal_sub['Fortluft_C'].mean(),2))+' °C')
print('Außenluft_rF:\t '+str(round(daten_kal_sub['Außenluft_rF'].mean(),2))+' %')
print('Zuluft_rF:\t '+str(round(daten_kal_sub['Zuluft_rF'].mean(),2))+' %')
print('Abluft_rF:\t '+str(round(daten_kal_sub['Abluft_rF'].mean(),2))+' %')
print('Fortluft_rF:\t '+str(round(daten_kal_sub['Fortluft_rF'].mean(),2))+' %')
print('Luftstrom:\t '+str(round(daten_kal_sub['L_Zuluft_VPunkt'].mean(),2))+' m³/h')
EÜG_Außenluft: 69 %
EÜG_Fortluft: 49 %
RWZ_Außenluft: 55 %
Außenluft_C: 2.14 °C
Zuluft_C: 14.86 °C
Abluft_C: 19.22 °C
Fortluft_C: 10.05 °C
Außenluft_rF: 63.74 %
Zuluft_rF: 35.75 %
Abluft_rF: 30.17 %
Fortluft_rF: 52.17 %
Luftstrom: 1327.74 m³/h
fig, ax = plt.subplots()
daten_sub['L_Zuluft_VPunkt'].plot(ax=ax,color=colo('blau',1), linewidth=0.5, label = 'L_Zuluft_VPunkt')
# daten_sub['Zuluft_C'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'Zuluft')
# daten_sub['Abluft_C'].plot(ax=ax,color=colo('orange',1), linewidth=0.5, label = 'Abluft')
# daten_sub['Fortluft_C'].plot(ax=ax,color=colo('violet',1), linewidth=0.5, label = 'Fortluft')
ax2 = ax.twinx()
daten_sub['L_Zuluft_Druck'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = 'L_Zuluft_Druck')
# daten_sub['Zuluft_rF'].plot(ax=ax2,color=colo('rot',1), linewidth=0.5, label = '__nolable__')
# daten_sub['Abluft_rF'].plot(ax=ax2,color=colo('orange',1), linewidth=0.5, label = '__nolable__')
# daten_sub['Fortluft_rF'].plot(ax=ax2,color=colo('violet',1), linewidth=0.5, label = '__nolable__')
ax.set_xlabel('')
ax.set(ylim=[1480,1490])
ax.set_yticks([1480,1485,1490])
ax.set_ylabel(r'\textbf{Volumenstrom} (m\textsuperscript{3}/h)')
ax2.set(ylim=[80,100])
ax2.set_yticks([80,87,94])
ax2.set_ylabel(r'\textbf{Druck} (Pa)')
# Legende
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
legend = plt.legend(h0+h2, l0+l2, ncol=4, loc=1)
set_legend_linewidth(legend)
plt.title('Weitere Werte während der WGR Effizienzmessung')
ax.set(xlim=[pd.to_datetime("2018-01-30 11:00:00"),pd.to_datetime("2018-02-12 11:00:00")])[(736724.4583333334, 736737.4583333334)]
Save & Upload
## Skriptlaufzeit Ende (Funktion in: libraries_and_styles.ipynb)
hours, minutes, seconds = laufzeit()
## Notebook speichern vor dem Upload (Funktion in: libraries_and_styles.ipynb)
save_notebook()
## Notebook als Markdown Datei mit eingebetten Grafiken speichern und auf den Server laden
%run ../Template/save_and_upload.ipynb 
