MCA Bilanz

Bibliotheken importieren

# Name des aktuellen Notebooks für die exportierten Datein
file_name = "Bilanz" 
# Ordner auf dem Server (nach files/)
ftp_folder = 'Notebooks/Auswertung'

## 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['figure.figsize']
mpl.use('WebAgg')
mpl.use("pgf")
mpl.rcParams.update(params)  

Daten importieren

## Auflösung der Messdaten in Sekunden / Stunde in Sekunden    

# res         = 3600/3600
# daten       = pd.read_csv('../1_Daten/Arbeitsdaten/Daten_1H.csv')

res         = 60/3600
daten       = pd.read_csv('../1_Daten/Arbeitsdaten/Daten_60s.csv')

daten.set_index(['Zeit'], inplace=True)
daten.index = pd.to_datetime(daten.index) 

## dfs erstellen um sie füllen zu können
Energie_Tag   = pd.DataFrame().astype(np.float32)
Energie_Monat = pd.DataFrame().astype(np.float32)
Energie_Jahr  = pd.DataFrame(index=['1']).astype(np.float32)

## print columns
#print_md(str(daten.columns).replace("dtype='object')", "").replace("',", "\n").replace("\n\n", "\n").replace("Index(['", "").replace("'", "").replace("\"", "").replace("\n", "\n\n").replace("       ", "").replace("],", ""))

Funktionen

# Gauß`sche Addition
####################
def unc_2sign(u1=1.,u2=1.):
    uges = np.sqrt((u1*u1) + (u2*u2))
    return uges


# Berechnung der stochastischen und systematischen Messfehler
#############################################################
def unc_Q_combined(name, Th,uth,usysh, Tc,utc,usysc, md,u_md,usysmd, cp, dt, dist,nr,f_sigma,plot):

    ## Notwendig, um den moving_average aus der Funktion zu bekommen
    movemean = pd.DataFrame().astype(np.float32)
    DF_MEAN = pd.DataFrame().astype(np.float32)

    # Berechnung der stochastischen Unsicherheiten:
    Qt,u_Qt, Qday,u_Qday, Qmonth,u_Qmonth, Qyear,u_Qyear = unc_Q_stochastisch(T1=Th,ut1=uth,T2=Tc,ut2=utc,md=md,u_md=u_md,cp=cp,dt=dt, dist=dist)

    # Berechnung der systematischen Unsicherheiten
    u_Qday_sys,u_Qmonth_sys,u_Qyear_sys,qsys_mean,movemean = unc_Q_systematisch (T1=Th,usys1=usysh, T2=Tc,usys2=usysc, md=md,usysmd=usysmd, cp=cp, dt=dt, dist=dist,nr=nr,f_sigma=f_sigma,plot=plot)

    # Kombinieren der stochastischen und systematischen Messfehler
    u_Qday_comb   = unc_2sign(u_Qday,   u_Qday_sys)
    u_Qmonth_comb = unc_2sign(u_Qmonth, u_Qmonth_sys)
    u_Qyear_comb  = unc_2sign(u_Qyear,  u_Qyear_sys)

    Energie_Tag  [name + '_Wert']   = Qday
    Energie_Tag  [name + '_Fehler'] = u_Qday_comb
    Energie_Monat[name+'_Wert']   = Qmonth
    Energie_Monat[name+'_Fehler'] = u_Qmonth_comb
    Energie_Jahr[name+'_Wert']    = Qyear
    Energie_Jahr[name+'_Fehler']  = u_Qyear_comb

    return np.round(Qyear,3), np.round(u_Qyear_comb,3),np.round(u_Qyear,3), np.round(u_Qyear_sys,3), np.round(qsys_mean,5), movemean 



# Berechnung der stochastischen Messfehler
##########################################
def unc_Q_stochastisch(T1,ut1, T2,ut2, md,u_md, cp, dt, dist):

    ## maximaler stochsastischer Fehler
    if dist == 'max_error':
        dT       = np.maximum(T1-T2,0)
        #dT       = T1-T2
        Qt       = md*cp*dT*dt

        dT_max   = dT + ut1 + ut2
        md_max   = md + u_md
        Qt_max   = md_max*cp*dT_max*dt
        u_Qt     = Qt_max - Qt

        Qday     = Qt.resample('D').sum()
        u_Qday   = u_Qt.resample('D').sum()
        Qmonth   = Qt.resample('M').sum()
        u_Qmonth = u_Qt.resample('M').sum()
        Qyear    = Qt.resample('Y').sum().sum()               # angepasst um jahresübergreifen zu summieren
        u_Qyear  = u_Qt.resample('Y').sum().sum()           # angepasst um jahresübergreifen zu summieren 

    else: ## Normal oder Gleichverteilung
        ## Berechnung nur mit positiven Temperaturdifferenzen, damit der Vergleich stimmt.   
        dT      = np.maximum(T1-T2,0)
        #dT       = T1-T2
        u_dT     = unc_2sign(u1=ut1,u2=ut2)
        Qt       = md*cp*dT*dt 
        u_Qt     = np.sqrt((((md>0)*cp*dt*dT*u_md)**2+(cp*dt*md*u_dT)**2))
        u_Qt2    = u_Qt*u_Qt

        Qday     = Qt.resample('D').sum()
        u_Qday   = np.sqrt(u_Qt2.resample('D').sum())
        Qmonth   = Qt.resample('M').sum()
        u_Qmonth = np.sqrt(u_Qt2.resample('M').sum())
        Qyear    = Qt.resample('Y').sum().sum()               # angepasst um jahresübergreifen zu summieren
        u_Qyear  = np.sqrt(u_Qt2.resample('Y').sum().sum())   # angepasst um jahresübergreifen zu summieren 

    return (np.round(Qt,decimals=3),     np.round(u_Qt,decimals=3), 
            np.round(Qday,decimals=3),   np.round(u_Qday,decimals=3), 
            np.round(Qmonth,decimals=3), np.round(u_Qmonth,decimals=3),
            np.round(Qyear,decimals=3),  np.round(u_Qyear,decimals=3))




# Berechnung der systematischen Messfehler
##########################################
def unc_Q_systematisch(T1,usys1,T2,usys2,md,usysmd,cp,dt,dist,nr,f_sigma,plot):
    ## Vergleichsberechnung
    #Q_single = (md*cp*np.maximum(T1-T2,0)*dt).resample('Y').sum().sum()

    ## maximaler systematischer Fehler   
    if dist == 'max_error':
        dT          = T1 - T2 
        Qt          = md*cp*dT*dt
        dT_max      = dT + usys1 + usys2
        md_max      = md + usysmd
        Qt_max      = md_max*cp*dT_max*dt
        uQsys_max   = Qt_max - Qt

        Qday        = Qt.resample('D').sum()
        uQday_sys   = uQsys_max.resample('D').sum()
        Qmonth      = Qt.resample('M').sum()
        uQmonth_sys = uQsys_max.resample('M').sum()
        Qyear       = Qt.resample('Y').sum().sum()                    # angepasst um jahresübergreifend zu summieren
        uQyear_sys  = uQsys_max.resample('Y').sum().sum()           # angepasst um jahresübergreifend zu summieren

        # werden bei MAX nicht berechnet, müssen aber zurückgegeben werden
        qsys_mean = uQyear_sys 
        movmean   = 0 
        sigma_mov = 0
        movemean  = movmean
    else:


        ## Zufallszahlen generieren
        rand1 = np.random.RandomState(seed = 456)
        rand2 = np.random.RandomState(seed = 8822)
        rand3 = np.random.RandomState(seed = 42)
        rand4 = np.random.RandomState(seed = 4432)

        if dist == 'uniform': ## gleichverteilt
            uTh = rand1.uniform(-usys1,  usys1,  nr)
            uTc = rand2.uniform(-usys2,  usys2 , nr)
            umd = rand3.uniform(-usysmd, usysmd, nr)

        else:                 ## normalverteilt
            udT = rand4.normal(0, (usys1  / f_sigma), nr)
            uTh = rand1.normal(0, (usys1  / f_sigma), nr)
            uTc = rand2.normal(0, (usys2  / f_sigma), nr)
            umd = rand3.normal(0, (usysmd / f_sigma), nr) 


        Th  = 0 
        Tc  = 0
        dT0 = 0 

        for i in range(0,nr,1):           
            if dist == 'getrennt':            
                # beide Temperaturen bekommen eine systematiche Unsicherheit
                Th       =  T1 + uTh[i] 
                Tc       =  T2 + uTc[i] 
                dT       = np.maximum(Th-Tc,0)
            else:
                ## nur die Temperaturdifferenz bekommt eine systematische Unsicherheit
                dT0      = np.maximum(T1-T2,0)
                dT       = dT0 + udT[i]
                dT       = np.maximum(dT,0)

            md_manip = (md * (1+(umd[i]/100.)))## wenn dT + udT negaviv wird, wieder auf 0 setzen            
            ## Berechne Q
            Q_tmp    = md_manip*cp*dT*dt



            i_neg = np.where(Q_tmp<0)[0]      
            if len(i_neg)>1:
                print('Negative Energien vorhanden! '+str(i))
                Q_tmp[i_neg]=0

            tmp_str = "Q_{0}".format(i)
            if  i == 0:
                Q          = pd.DataFrame(Q_tmp, index=dT.index).astype(np.float32)#MemoryError:
                Q.columns  = [tmp_str]
            else:
                Q[tmp_str] = Q_tmp.values.astype(np.float32) #MemoryError: Unable to allocate array with shape (892, 2088412) and data type float64


        del [[Q_tmp, Th, Tc, md_manip, dT, dT0, tmp_str ]]; gc.collect()

        Qday        = Q.resample('D').sum().astype(np.float32) 
        uQday_sys   = Qday.std(axis=1) 
        Qmonth      = Q.resample('M').sum().astype(np.float32) 
        uQmonth_sys = Qmonth.std(axis=1) 
        Qyear       = Q.resample('Y').sum().sum().astype(np.float32) # angepasst um jahresübergreifend zu summieren
        uQyear_sys  = Qyear.std(axis=0)          # angepasst um jahresübergreifend zu summieren

        list_qsys = []
        for element in Q.columns:
            list_qsys.append(np.sum(Q[element]))
        #display(list_qsys)

        # display(Q.info())   
        del Q;  gc.collect()
        #display('Q.: '+str(round(process.memory_info().rss/1024/1024/1024,4))+' GB')

        qsys_mean = np.mean(list_qsys)
        movmean   = []
        sigma_mov = []

        for i in range(0,nr,1):
            movmean.append(np.mean(list_qsys[0:(i+1)]))
            sigma_mov.append(np.std(list_qsys[0:(i+1)]))

        movemean = movmean # for return 

        del list_qsys; gc.collect() 

        if plot==1: 
            # plot 
            fig, ax  = plt.subplots()  
            ax.ticklabel_format(useLocale=True) ## dot as thousand separator
            # moving lines
            plt.plot(np.arange(0,nr,1),movmean,             color=colo('blau',1), linestyle='--', linewidth=0.8, label = r'gleitender Mittelwert: $Q$')
            plt.plot(np.arange(0,nr,1),qsys_mean+sigma_mov, color=colo('rot',1),  linestyle='--', linewidth=0.8, label = r'gleitender Mittelwert: $u_{Q, sys}$')
            plt.plot(np.arange(0,nr,1),qsys_mean-sigma_mov, color=colo('rot',1),  linestyle='--', linewidth=0.8, label = '')
            # result of moving lines
            plt.axhline(y=int(round(qsys_mean,1)),                        color=colo('blau',1), linestyle='-', linewidth=0.8, label = r'Mittelwert: $Q$')
            plt.axhline(y=int(round(qsys_mean,1) + round(uQyear_sys,1)),  color=colo('rot',1),  linestyle='-', linewidth=0.8, label = r'Mittelwert: $u_{Q, sys}$')
            plt.axhline(y=int(round(qsys_mean,1) - round(uQyear_sys,1)),  color=colo('rot',1),  linestyle='-', linewidth=0.8, label = '')
            # Text for result of moving lines right side
#             ax.text(1.02, qsys_mean,            str(int(qsys_mean))           +' kWh', va='center', ha="left", transform=ax.get_yaxis_transform())
#             ax.text(1.02, qsys_mean+uQyear_sys, str(int(qsys_mean+uQyear_sys))+' kWh', va='center', ha="left", transform=ax.get_yaxis_transform())
#             ax.text(1.02, qsys_mean-uQyear_sys, str(int(qsys_mean-uQyear_sys))+' kWh', va='center', ha="left", transform=ax.get_yaxis_transform())


            ax.text(1.02, qsys_mean+uQyear_sys/2, '+'+str(int(round(uQyear_sys,1)))+' kWh \n+'+str(round(uQyear_sys/qsys_mean*100,1))+'\%' , va='center', ha="left", fontsize=6, color='black', transform=ax.get_yaxis_transform())
            ax.text(1.02, qsys_mean-uQyear_sys/2, '-'+str(int(round(uQyear_sys,1)))+' kWh \n-'+str(round(uQyear_sys/qsys_mean*100,1))+'\%' , va='center', ha="left", fontsize=6, color='black', transform=ax.get_yaxis_transform())

#             ax.set_title(name)
            ax.set_ylabel(r'\textbf{Wärmemenge} (kWh)')
            ax.set_xlabel(r'\textbf{Wiederholungen} (n)')
            ax.get_yaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, loc: locale.format_string('%d', x, 1))) ## dot as thousand separator for Y
            ax.get_xaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, loc: locale.format_string('%d', x, 1))) ## dot as thousand separator for X

#             ax.xaxis.set_tick_params(width=0.5)
#             ax.yaxis.set_tick_params(width=0.5) 

            ## Beschriftung der Y Achse nur mit den Ergebniswerten 
            ax.get_yaxis().set_ticks([int(qsys_mean),int(qsys_mean+uQyear_sys),int(qsys_mean-uQyear_sys)])

            ax.set_xlim(0, nr)

            h0, l0 = ax.get_legend_handles_labels() 

            legend = plt.legend(h0, l0, loc=1, ncol=2)   
            set_legend_linewidth(legend) 
            plt.savefig(output_folder + '/' + file_name + '_' + name +'_MCA.pdf') 
            display(fig)
            close_all()

    #del [[movmean, sigma_mov ]]; gc.collect()

    return uQday_sys,uQmonth_sys,uQyear_sys,qsys_mean, movemean

Energieberechnung

## Faktor für die systematischen Unsicherheiten
kalibriert = .5
cp         = (4.2/3.6) / 1000.0 
dt         = res
dist       = "normal"
f_sigma    = 2.0
nr         = 2000
plot       = 1

Solar

name   = 'Solar'
Th     = daten.S_Solar_VL
uth    = 1.0 * kalibriert
usysh  = 0.8 * kalibriert
Tc     = daten.S_Solar_RL
utc    = 1.0 * kalibriert
usysc  = 0.8 * kalibriert
md     = daten.S_Solar_Vpunkt * 0.998
u_md   = 5.0 * kalibriert
usysmd = 3.0 * kalibriert

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

Solar
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 3210 kWh ± 167 kWh
deterministische Unsicherheit: ± 167.793 kWh
stochastische Unsicherheit: ± 2.214 kWh
Verhältnis von Referenz zu Q: 1.00024
Variationskoeffizient letztes 1/3:0.000233

Kessel

name   = 'Kessel'
Th     = daten.S_Kessel_VL
uth    = 1.0 * kalibriert
usysh  = 0.8 * kalibriert
Tc     = daten.S_Kessel_RL
utc    = 1.0 * kalibriert
usysc  = 0.8 * kalibriert
md     = daten.S_Kessel_Vpunkt * 0.998
u_md   = 5.0 * kalibriert
usysmd = 3.0 * kalibriert

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

Kessel
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 20831 kWh ± 306 kWh
deterministische Unsicherheit: ± 306.32 kWh
stochastische Unsicherheit: ± 2.129 kWh
Verhältnis von Referenz zu Q: 0.99981
Variationskoeffizient letztes 1/3:6.7e-05

Heizung

name   = 'Heizung'
Th     = daten.S_Heizung_VL
uth    = 1.0 * kalibriert
usysh  = 0.8 * kalibriert
Tc     = daten.S_Heizung_RL
utc    = 1.0 * kalibriert
usysc  = 0.8 * kalibriert
md     = daten.S_Heizung_Vpunkt * 0.998
u_md   = 5.0 * kalibriert
usysmd = 3.0 * kalibriert

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

Heizung
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 20087 kWh ± 1095 kWh
deterministische Unsicherheit: ± 1095.474 kWh
stochastische Unsicherheit: ± 7.357 kWh
Verhältnis von Referenz zu Q: 1.00006
Variationskoeffizient letztes 1/3:0.000243

FriWa sek

name   = 'FriWa_Sek'
Th     = daten.S_FriWa_VL_Sek
uth    = 1.0 * kalibriert
usysh  = 0.8 * kalibriert
Tc     = daten.S_FriWa_RL_Sek
utc    = 1.0 * kalibriert
usysc  = 0.8 * kalibriert
md     = daten.S_FriWa_Vpunkt_Sek * 0.998
u_md   = 5.0 * kalibriert
usysmd = 3.0 * kalibriert

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

FriWa_Sek
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 599 kWh ± 16 kWh
deterministische Unsicherheit: ± 16.161 kWh
stochastische Unsicherheit: ± 0.356 kWh
Verhältnis von Referenz zu Q: 0.9994
Variationskoeffizient letztes 1/3:0.000116

FriWa prim

name   = 'FriWa_Prim'
Th     = daten.S_FriWa_VL_Prim
uth    = 1.0 * kalibriert
usysh  = 0.8 * kalibriert
Tc     = daten.S_FriWa_RL_Prim
utc    = 1.0 * kalibriert
usysc  = 0.8 * kalibriert
md     = daten.S_FriWa_Vpunkt_Prim * 0.998
u_md   = 5.0 * kalibriert
usysmd = 3.0 * kalibriert

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

FriWa_Prim
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 468 kWh ± 14 kWh
deterministische Unsicherheit: ± 14.349 kWh
stochastische Unsicherheit: ± 0.71 kWh
Verhältnis von Referenz zu Q: 0.99517
Variationskoeffizient letztes 1/3:0.000128

Speicher

Speichermitteltemperatur stochastisch

## Ungenauigkeiten Speichermitteltemperatur

## Höhenanteile
H1 = 0.2415
H2 = 0.2317
H3 = 0.1935
H4 = 0.1725
H5 = 0.1606

## Ungenauigkeiten Höhenanteile
U_H  = 0.1
U_H1 = H1 * U_H
U_H2 = H2 * U_H
U_H3 = H3 * U_H
U_H4 = H4 * U_H
U_H5 = H5 * U_H

## Temperaturen
T1 = daten["S_Speicher_1"]  
T2 = daten["S_Speicher_2"]
T3 = daten["S_Speicher_3"]
T4 = daten["S_Speicher_4"]
T5 = daten["S_Speicher_5"]

## Ungenauigkeiten Temperatur
U_T = 0.8 * kalibriert
U_T1 = T1 * U_T
U_T2 = T2 * U_T
U_T3 = T3 * U_T
U_T4 = T4 * U_T
U_T5 = T5 * U_T

## Mitteltemperatur
T_M_1 = H1 * T1 
T_M_2 = H2 * T2 
T_M_3 = H3 * T3 
T_M_4 = H4 * T4 
T_M_5 = H5 * T5
T_M   = T_M_1 + T_M_2 + T_M_3 + T_M_4 + T_M_5


# ## Ungenauigkeit Mitteltemperatur
# U_T_M_1 = np.sqrt(pow(H1 * U_T ,2) + pow(U_H * T1 ,2))
# U_T_M_2 = np.sqrt(pow(H2 * U_T ,2) + pow(U_H * T2 ,2))
# U_T_M_3 = np.sqrt(pow(H3 * U_T ,2) + pow(U_H * T3 ,2))
# U_T_M_4 = np.sqrt(pow(H4 * U_T ,2) + pow(U_H * T4 ,2))
# U_T_M_5 = np.sqrt(pow(H5 * U_T ,2) + pow(U_H * T5 ,2))
# U_T_M   = np.sqrt(  pow(U_T_M_1,2) + pow(U_T_M_2,2) + pow(U_T_M_3,2) + pow(U_T_M_4,2) + pow(U_T_M_5,2)  )

## Vereinfacht: Ungenauigkeit Mitteltemperatur
U_T_M_1 = pow(H1 * U_T ,2) + pow(U_H * T1 ,2)
U_T_M_2 = pow(H2 * U_T ,2) + pow(U_H * T2 ,2)
U_T_M_3 = pow(H3 * U_T ,2) + pow(U_H * T3 ,2)
U_T_M_4 = pow(H4 * U_T ,2) + pow(U_H * T4 ,2)
U_T_M_5 = pow(H5 * U_T ,2) + pow(U_H * T5 ,2)
U_T_M   = np.sqrt(U_T_M_1 + U_T_M_2 + U_T_M_3 + U_T_M_4 + U_T_M_5)

daten['S_Speicher_Mitteltemperatur_sto']        =  T_M
# daten['S_Speicher_Mitteltemperatur_vorher'] =  daten['S_Speicher_Mitteltemperatur'].shift()
daten["u_Speicher_Mitteltemperatur_sto"]        =  U_T_M
#daten['u_Speicher_Mitteltemperatur_vorher'] =  U_T_M.shift()


## für die nächste Zelle
u_Speicher_Mitteltemperatur_sto = daten['u_Speicher_Mitteltemperatur_sto'].resample("Y").mean().mean()
# print(u_Speicher_Mitteltemperatur_sto)
# 19.860803889155626

Speichermitteltemperatur systematisch

# Berechnung der systematischen Messfehler
##########################################
def unc_TM_systematisch(H1,H2,H3,H4,H5,T1,T2,T3,T4,T5,usys_H,usys_T, nr): 
    rand0 = np.random.RandomState(seed = 8822)
    rand1 = np.random.RandomState(seed = 5429)
    rand2 = np.random.RandomState(seed = 7845)
    rand3 = np.random.RandomState(seed = 6257)
    rand4 = np.random.RandomState(seed = 4432)
    rand5 = np.random.RandomState(seed = 4689)
    rand6 = np.random.RandomState(seed = 2357)
    rand7 = np.random.RandomState(seed = 1254)
    rand8 = np.random.RandomState(seed = 6587)
    rand9 = np.random.RandomState(seed = 2145)
    u_H1 = rand0.normal(0, (usys_H  / 2), nr)
    u_H2 = rand1.normal(0, (usys_H  / 2), nr)
    u_H3 = rand2.normal(0, (usys_H  / 2), nr)
    u_H4 = rand3.normal(0, (usys_H  / 2), nr)
    u_H5 = rand4.normal(0, (usys_H  / 2), nr)
    u_T1 = rand5.normal(0, (usys_T  / 2), nr)
    u_T2 = rand6.normal(0, (usys_T  / 2), nr)
    u_T3 = rand7.normal(0, (usys_T  / 2), nr)
    u_T4 = rand8.normal(0, (usys_T  / 2), nr)
    u_T5 = rand9.normal(0, (usys_T  / 2), nr)

    for i in range(0,nr,1):            
            T1_sys   =  T1 + u_T1[i] 
            T2_sys   =  T2 + u_T2[i] 
            T3_sys   =  T3 + u_T3[i] 
            T4_sys   =  T4 + u_T4[i] 
            T5_sys   =  T5 + u_T5[i] 
            H1_sys   =  H1 + u_H1[i] 
            H2_sys   =  H2 + u_H2[i] 
            H3_sys   =  H3 + u_H3[i] 
            H4_sys   =  H4 + u_H4[i] 
            H5_sys   =  H5 + u_H5[i]             
            TM_tmp   = T1_sys*H1_sys+T2_sys*H2_sys+T3_sys*H3_sys+T4_sys*H4_sys+T5_sys*H5_sys

            tmp_str = "Q_{0}".format(i)
            if  i == 0:
                Q          = pd.DataFrame(TM_tmp, index=T1_sys.index).astype(np.float32)#MemoryError:
                Q.columns  = [tmp_str]
            else:
                Q[tmp_str] = TM_tmp.values.astype(np.float32) #MemoryError: Unable to allocate array with shape (892, 2088412) and data type float6

    Qday        = Q.mean(axis=1) 
    uQday_sys   = Q.std(axis=1)   
    del [[TM_tmp,  tmp_str ]]; gc.collect()
    return Qday,uQday_sys 


## Höhenanteile
H1 = 0.2415
H2 = 0.2317
H3 = 0.1935
H4 = 0.1725
H5 = 0.1606

## Ungenauigkeiten Höhenanteile
usys_H  = 0.1 

## Temperaturen
T1 = daten["S_Speicher_1"]  
T2 = daten["S_Speicher_2"]
T3 = daten["S_Speicher_3"]
T4 = daten["S_Speicher_4"]
T5 = daten["S_Speicher_5"]

## Ungenauigkeiten Temperatur
usys_T = 0.8 * kalibriert

nr = 1000

TM,uTM_sys  = unc_TM_systematisch(H1,H2,H3,H4,H5,T1,T2,T3,T4,T5,usys_H,usys_T,nr)

daten['S_Speicher_Mitteltemperatur_sys']        =  TM 
daten["u_Speicher_Mitteltemperatur_sys"]        =  uTM_sys


daten['S_Speicher_Mitteltemperatur_sys'].head() 

Zeit
2017-05-01 00:00:00    58.140083
2017-05-01 00:01:00    58.153553
2017-05-01 00:02:00    58.180882
2017-05-01 00:03:00    58.161358
2017-05-01 00:04:00    58.192280
Name: S_Speicher_Mitteltemperatur_sys, dtype: float32

Speichermitteltempertaur Unsicherheiten verbinden

daten['u_Speicher_Mitteltemperatur'] = unc_2sign(daten['u_Speicher_Mitteltemperatur_sys'] ,daten['u_Speicher_Mitteltemperatur_sto'])
vergleich = daten['S_Speicher_Mitteltemperatur_sys'].resample("Y").sum().sum() / daten['S_Speicher_Mitteltemperatur_sto'].resample("Y").sum().sum()
display(vergleich)
daten['S_Speicher_Mitteltemperatur'] = daten['S_Speicher_Mitteltemperatur_sto']

1.0056010545686662

Plot Speichermitteltemperaturen inkl Unsicherheiten

close_all()
fig, ax = plt.subplots()
## muss gesampelt werden, sonst schafft LaTeX nicht die PDF zu erzeugen
sample ='1H'
daten['S_Speicher_Mitteltemperatur'].resample(sample).mean().plot(    ax=ax,color=colo('blau',1),  linewidth=0.5,alpha = 1,label = 'Speicher Mitteltemperatur') 
daten['u_Speicher_Mitteltemperatur_sys'].resample(sample).mean().plot(ax=ax,color=colo('grün',1),  linewidth=0.5,alpha = 1,label = 'sys Unsicherheit')
daten['u_Speicher_Mitteltemperatur_sto'].resample(sample).mean().plot(ax=ax,color=colo('rot',1),   linewidth=0.5,alpha = 1,label = 'sto Unsicherheit')
daten['u_Speicher_Mitteltemperatur'].resample(sample).mean().plot(    ax=ax,color=colo('orange',1),linewidth=0.5,alpha = 1,label = 'comb. Unsicherheit')

ax.set_ylabel(r'\textbf{Temperatur} ($^\circ$C)') 
ax.set(xlim=[pd.to_datetime("05.01.17 00:00:00"),pd.to_datetime("30.04.18 23:00:00")])
ax.set(ylim=0) 
ax.set_xlabel('') 

h0, l0 = ax.get_legend_handles_labels() 
legend = plt.legend(h0, l0, loc=1 )   
set_legend_linewidth(legend) 

plt.savefig(output_folder + '/' + file_name + '_Speichermitteltemperatur.pdf') 
display(fig)
close_all()

Speicherverluste

name   = 'Speicherverluste_MCA'
Th     = daten.S_Speicher_Mitteltemperatur 
uth    = u_Speicher_Mitteltemperatur_sto # ist der Durchschnitt, weil hier keine "pd.series" funktioniert
usysh  = uth / 2
Tc     = daten.S_Dachbodentemperatur
utc    = 3.5
usysc  = 1.7
md     = daten.S_Speicher_UA
u_md   = 0.5 / 1000
usysmd = 1.1 / 1000


cp      = (4.2/3.6) / 1000.0 
dt      = res
dist    = "normal"
f_sigma = 2.0
nr      = 2000
plot    = 1
# Funktionsaufruf dist=getrennt für unabhängige Unsicherheiten der Temperaturen
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,1,res,'getrennt',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*1*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

Speicherverluste_MCA
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 1916 kWh ± 191 kWh
deterministische Unsicherheit: ± 191.729 kWh
stochastische Unsicherheit: ± 1.106 kWh
Verhältnis von Referenz zu Q: 0.9994
Variationskoeffizient letztes 1/3:0.000373

Speicherbilanz

## eigentlich nur bei täglicher Analyse sinnvoll

name   = 'Speicher_Bilanz'
Th     = daten.S_Speicher_Mitteltemperatur 
uth    = u_Speicher_Mitteltemperatur_sto
usysh  = uth / 2
Tc     = daten.S_Speicher_Mitteltemperatur.shift()
utc    = uth
usysc  = uth / 2
md     = 1022
u_md   = 0.0
usysmd = 10

# Funktionsaufruf
Qyear,u_Qyear_comb,u_Qyear,u_Qyear_sys, qsys_mean, movemean = unc_Q_combined(name,Th,uth,usysh,Tc,utc,usysc,md,u_md,usysmd,((4.2/3.6) / 1000.0),res,'normal',2000,2.0,1)
# Vergleichsrechnung
Q_single = (md*cp*np.maximum(Th-Tc,0)*dt).resample('Y').sum().sum()
Markdown('**'+name+'**    <br />'
         'Verteilung:             **'+dist+'**, \u03C3: **'+str(f_sigma)+'**, Runden: **'+str(nr)+'**, Datensätze: **'+str(Th.count())+'**, <span class="burk">Zeitschritt</span>: **'+str(int(dt*3600))+'s**    <br />'  
         'Wärmemenge Gesamtunsicherheit:                **'+str(int(Qyear.sum()))+' kWh \u00B1 '+str(int(u_Qyear_comb))+'** kWh   <br />'  
         'deterministische Unsicherheit:           \u00B1 '+str(round(u_Qyear_sys,3))+' kWh   <br />'         
         'stochastische Unsicherheit:              \u00B1 '+str(round(u_Qyear,3))+' kWh   <br />' 
         'Verhältnis von Referenz zu Q:  **'+str(round(Q_single/qsys_mean,5))+'**   <br />'          
         'Variationskoeffizient letztes 1/3:**'+str(round( (np.std(movemean[-int(nr/3):]) / np.mean(movemean[-int(nr/3):]) ), 6))+'**<br />' )

Speicher_Bilanz
Verteilung: normal, σ: 2.0, Runden: 2000, Datensätze: 522105, Zeitschritt: 60s
Wärmemenge Gesamtunsicherheit: 175 kWh ± 17482 kWh
deterministische Unsicherheit: ± 17481.334 kWh
stochastische Unsicherheit: ± 236.902 kWh
Verhältnis von Referenz zu Q: 0.01474
Variationskoeffizient letztes 1/3:0.007015

Korrekturen und Erweiterungen

## Korrekturen und Erweiterungen

## Die Bilanzierung der im Speicher enthaltenen Wärmeenergie ist bei monatlicher bzw Jährlicher Betrachtung nicht mehr relevant.
Energie_Jahr.Speicher_Wert    = 0
Energie_Jahr.Speicher_Fehler  = 0
Energie_Monat.Speicher_Wert   = 0
Energie_Monat.Speicher_Fehler = 0

# selten (14kWh/a) gibt es negative Energie vom Kessel, die wird dann auch zu 'raus' gezählt 
Energie_Tag['Kessel_Wert_neg']               = np.where(Energie_Tag['Kessel_Wert']        < 0, Energie_Tag['Kessel_Wert']          * -1 , 0)
Energie_Tag['Kessel_Wert']                   = np.where(Energie_Tag['Kessel_Wert']        > 0, Energie_Tag['Kessel_Wert']               , 0)
Energie_Tag['Kessel_Fehler_neg']             = np.where(Energie_Tag['Kessel_Wert']        < 0, Energie_Tag['Kessel_Fehler']        * -1 , 0)
Energie_Tag['Kessel_Fehler']                 = np.where(Energie_Tag['Kessel_Wert']        > 0, Energie_Tag['Kessel_Fehler']             , 0)

Energie_Monat['Kessel_Wert_neg']             = np.where(Energie_Monat['Kessel_Wert']        < 0, Energie_Monat['Kessel_Wert']    * -1 , 0)
Energie_Monat['Kessel_Wert']                 = np.where(Energie_Monat['Kessel_Wert']        > 0, Energie_Monat['Kessel_Wert']         , 0)
Energie_Monat['Kessel_Fehler_neg']           = np.where(Energie_Monat['Kessel_Wert']        < 0, Energie_Monat['Kessel_Fehler']  * -1 , 0)
Energie_Monat['Kessel_Fehler']               = np.where(Energie_Monat['Kessel_Wert']        > 0, Energie_Monat['Kessel_Fehler']       , 0)

Energie_Jahr['Kessel_Wert_neg']              = np.where(Energie_Jahr['Kessel_Wert']        < 0, Energie_Jahr['Kessel_Wert']       * -1 , 0)
Energie_Jahr['Kessel_Wert']                  = np.where(Energie_Jahr['Kessel_Wert']        > 0, Energie_Jahr['Kessel_Wert']            , 0)
Energie_Jahr['Kessel_Fehler_neg']            = np.where(Energie_Jahr['Kessel_Wert']        < 0, Energie_Jahr['Kessel_Fehler']     * -1 , 0)
Energie_Jahr['Kessel_Fehler']                = np.where(Energie_Jahr['Kessel_Wert']        > 0, Energie_Jahr['Kessel_Fehler']          , 0)

## eigentlich nur bei täglicher Betrachtung sinnvoll, daher Monat und Jahr auf null
# Speicher bilanzieren
Energie_Tag['Speicher_Bilanz_Wert_rein']     = np.where(Energie_Tag['Speicher_Bilanz_Wert'] < 0, Energie_Tag['Speicher_Bilanz_Wert']       * -1, 0)
Energie_Tag['Speicher_Bilanz_Wert_raus']     = np.where(Energie_Tag['Speicher_Bilanz_Wert'] > 0, Energie_Tag['Speicher_Bilanz_Wert']           , 0)
Energie_Tag['Speicher_Bilanz_Fehler_rein']   = np.where(Energie_Tag['Speicher_Bilanz_Wert'] < 0, Energie_Tag['Speicher_Bilanz_Fehler']         , 0)
Energie_Tag['Speicher_Bilanz_Fehler_raus']   = np.where(Energie_Tag['Speicher_Bilanz_Wert'] > 0, Energie_Tag['Speicher_Bilanz_Fehler']         , 0)

# Energie_Monat['Speicher_Bilanz_Wert_rein']   = np.where(Energie_Monat['Speicher_Bilanz_Wert'] < 0, Energie_Monat['Speicher_Bilanz_Wert']   * -1, 0)
# Energie_Monat['Speicher_Bilanz_Wert_raus']   = np.where(Energie_Monat['Speicher_Bilanz_Wert'] > 0, Energie_Monat['Speicher_Bilanz_Wert']       , 0)
# Energie_Monat['Speicher_Bilanz_Fehler_rein'] = np.where(Energie_Monat['Speicher_Bilanz_Wert'] < 0, Energie_Monat['Speicher_Bilanz_Fehler']     , 0)
# Energie_Monat['Speicher_Bilanz_Fehler_raus'] = np.where(Energie_Monat['Speicher_Bilanz_Wert'] > 0, Energie_Monat['Speicher_Bilanz_Fehler']     , 0)

# Energie_Jahr['Speicher_Bilanz_Wert_rein']    = np.where(Energie_Jahr['Speicher_Bilanz_Wert'] < 0, Energie_Jahr['Speicher_Bilanz_Wert']     * -1, 0)
# Energie_Jahr['Speicher_Bilanz_Wert_raus']    = np.where(Energie_Jahr['Speicher_Bilanz_Wert'] > 0, Energie_Jahr['Speicher_Bilanz_Wert']         , 0)
# Energie_Jahr['Speicher_Bilanz_Fehler_rein']  = np.where(Energie_Jahr['Speicher_Bilanz_Wert'] < 0, Energie_Jahr['Speicher_Bilanz_Fehler']       , 0)
# Energie_Jahr['Speicher_Bilanz_Fehler_raus']  = np.where(Energie_Jahr['Speicher_Bilanz_Wert'] > 0, Energie_Jahr['Speicher_Bilanz_Fehler']       , 0)


Energie_Monat['Speicher_Bilanz_Wert_rein']   = 0
Energie_Monat['Speicher_Bilanz_Wert_raus']   = 0
Energie_Monat['Speicher_Bilanz_Fehler_rein'] = 0
Energie_Monat['Speicher_Bilanz_Fehler_raus'] = 0

Energie_Jahr['Speicher_Bilanz_Wert_rein']    = 0
Energie_Jahr['Speicher_Bilanz_Wert_raus']    = 0
Energie_Jahr['Speicher_Bilanz_Fehler_rein']  = 0
Energie_Jahr['Speicher_Bilanz_Fehler_raus']  = 0

# display(Energie_Jahr)

Energie_Tag.to_csv('Energie_Fehler_tgl.csv')

Energie_Tag.columns

Index(['Solar_Wert', 'Solar_Fehler', 'Kessel_Wert', 'Kessel_Fehler',
       'Heizung_Wert', 'Heizung_Fehler', 'FriWa_Sek_Wert', 'FriWa_Sek_Fehler',
       'FriWa_Prim_Wert', 'FriWa_Prim_Fehler', 'Speicherverluste_MCA_Wert',
       'Speicherverluste_MCA_Fehler', 'Speicher_Bilanz_Wert',
       'Speicher_Bilanz_Fehler', 'Kessel_Wert_neg', 'Kessel_Fehler_neg',
       'Speicher_Bilanz_Wert_rein', 'Speicher_Bilanz_Wert_raus',
       'Speicher_Bilanz_Fehler_rein', 'Speicher_Bilanz_Fehler_raus'],
      dtype='object')

Zuweisungen für die Balkendiagramme

## Zuweisungen für die Balkendiagramme

Label_rein  = ['Kessel',         'Solar',          'Speicherbilanz'              ]
Werte_rein  = ['Kessel_Wert',    'Solar_Wert',     'Speicher_Bilanz_Wert_rein'   ]
Fehler_rein = ['Kessel_Fehler',  'Solar_Fehler',   'Speicher_Bilanz_Fehler_rein' ]
Farben_rein = [ colo('blau',1),   colo('orange',1), colo('violet',1)             ]

Label_raus  = ['Heizung',        'FriWa',             'Speicherverl.',                 'Speicherbilanz',                 'Kessel_neg'         ] 
Werte_raus  = ['Heizung_Wert',   'FriWa_Prim_Wert',   'Speicherverluste_MCA_Wert',        'Speicher_Bilanz_Wert_raus',      'Kessel_Wert_neg'    ]
Fehler_raus = ['Heizung_Fehler', 'FriWa_Prim_Fehler', 'Speicherverluste_MCA_Fehler',      'Speicher_Bilanz_Fehler_raus',    'Kessel_Fehler_neg'  ]
Farben_raus = [ colo('grau',1),   colo('rot',1),       colo('grün',1),                     colo('violet',1),                 colo('blau',1)      ]

Label = Label_rein + Label_raus

## Labels für die Legende, ohne die zweite Speicherbilanz und Kessel_neg
L_Kessel           = mpatches.Patch(facecolor=Farben_rein[0], label=Label_rein[0],edgecolor='black', linewidth=0.3) 
L_Solar            = mpatches.Patch(facecolor=Farben_rein[1], label=Label_rein[1],edgecolor='black', linewidth=0.3) 
L_Speicherbilanz   = mpatches.Patch(facecolor=Farben_rein[2], label=Label_rein[2],edgecolor='black', linewidth=0.3) 
L_Heizung          = mpatches.Patch(facecolor=Farben_raus[0], label=Label_raus[0],edgecolor='black', linewidth=0.3) 
L_FriWa            = mpatches.Patch(facecolor=Farben_raus[1], label=Label_raus[1],edgecolor='black', linewidth=0.3) 
L_Speicherverluste = mpatches.Patch(facecolor=Farben_raus[2], label=Label_raus[2],edgecolor='black', linewidth=0.3)  
L_Dummy            = mpatches.Patch(facecolor=Farben_raus[2], label='Dummy',edgecolor='black', linewidth=0.3)  
handles            = [L_Kessel,L_Solar,L_Speicherbilanz,L_Heizung,L_FriWa,L_Speicherverluste]

Ungenauigkeiten in den täglichen Bilanzen

## df erstellen um ihn zu füllen
Ungenauigkeiten = pd.DataFrame()

## Energien (rein und raus) auf täglicher Basis aufsummieren
Ungenauigkeiten['Werte_rein']             = Energie_Tag[Werte_rein].sum(axis=1)
Ungenauigkeiten['Werte_raus']             = Energie_Tag[Werte_raus].sum(axis=1)
Ungenauigkeiten['Werte_Summe']            = Ungenauigkeiten['Werte_rein']            + Ungenauigkeiten['Werte_raus']  
## Ungenauigkeiten berechnen
Ungenauigkeiten['Ungenauigkeit_absolut']  = Ungenauigkeiten['Werte_rein']            - Ungenauigkeiten['Werte_raus'] 
Ungenauigkeiten['Ungenauigkeit_relativ']  = Ungenauigkeiten['Ungenauigkeit_absolut'] / Ungenauigkeiten['Werte_Summe']  * 100
## Anteil Solarenergie bezogen auf gesamte erzeugte Wärmeenergie 
solar_relativ = Energie_Tag['Solar_Wert'] / (Energie_Tag['Solar_Wert'] + Energie_Tag['Kessel_Wert']) * 100#* Energie_Tag['Solar_Wert']
# solar_relativ = 1 / (Energie_Tag['Solar_Wert'] + Energie_Tag['Kessel_Wert'])  
## Kurve glätten auf 2D
sample ='1D'
## Größe ändern?
mpl.rcParams['figure.figsize'] = 5.9,3.5

## Plot
## constraines muss false wegen subplots_adjust
fig, (ax1, ax2) = plt.subplots(2, sharex=True , constrained_layout=False)  
plt.subplots_adjust(hspace=.5)
## erster Plot linke Achse
ax1.set_zorder(1)
ax1.patch.set_visible(False)
ax1.plot(Ungenauigkeiten['Ungenauigkeit_absolut'],color=colo('rot',1), linewidth=0.6, label = r'Ungenauigkeit absolut ($kWh$)') 
ax1.set_ylim(-30,30) 
ax1.set_yticks([-30,0,30])
## erster Plot rechte Achse
ax12 = ax1.twinx()
ax12.plot(Ungenauigkeiten['Ungenauigkeit_relativ'],color=colo('blau',1.), linewidth=0.4, label = r'Ungenauigkeit relativ ($\%$)') 
ax12.set_ylim(-105,105) 
ax12.set_yticks([-100,0,100])
## Legende erster Plot
h0, l0 = ax1.get_legend_handles_labels()
h2, l2 = ax12.get_legend_handles_labels()  
legend  = plt.legend(h0+h2, l0+l2, loc=1, ncol=2, bbox_to_anchor=(1., 1.35))  
set_legend_linewidth(legend) 
## zweiter Plot linke Achse
ax2.plot(daten['S_Speicher_Mitteltemperatur'].resample(sample).mean(),color=colo('grün',1), linewidth=0.6, label = r'Speichermitteltemperatur ($^\circ$C)')
ax2.set_ylim(30,80) 
ax2.set_yticks([40,70])
## zweiter Plot rechte Achse
ax22 = ax2.twinx()   
ax22.plot(Ungenauigkeiten['Ungenauigkeit_relativ'].resample(sample).mean(),color=colo('blau',1), linewidth=0.6, label = "_nolegend_")
ax22.plot(solar_relativ.resample(sample).mean(),color=colo('orange',1), linewidth=0.6, label = r'Solarenergie relativ ($\%$)')
ax22.set_ylim(-105,105) 
ax22.set_yticks([0,50,100])
## Zeroline
# plt.axhline(y=0, xmin=.5, xmax=1,linewidth=0.3,clip_on = False,color='black',ls='--')
## Legende zweiter Plot
h0, l0 = ax2.get_legend_handles_labels()
h2, l2 = ax22.get_legend_handles_labels()  
legend  = plt.legend(h0+h2, l0+l2, loc=1, ncol=2, bbox_to_anchor=(1., 1.35))  
set_legend_linewidth(legend) 
# ## X Achse formatieren
ax.set(xlim=[pd.to_datetime("05.01.17 00:00:00"),pd.to_datetime("30.04.18 23:00:00")])
ax2.set(xlim=[pd.to_datetime("05.01.17 00:00:00"),pd.to_datetime("30.04.18 23:00:00")])
monthlyX(ax2)
## Beschriftungen Y Achse
# ax1.text(0., 1,r'\textbf{Energie} ($kWh$)')
# ax12.text(0., 1,r'\textbf{Ungenauigkeit} ($\%$)')
# ax2.text(1, 1,r'\textbf{Temperatur} ($^\circ C$)')
# ax22.text(1, 1,r'\textbf{Anteil} ($\%$)')
ax2.text(-0.12, 93, r'\textbf{Temperatur} ($^\circ$C) \hphantom{XXxXX} \textbf{Energie} ($kWh$) ', va='center', rotation='vertical', transform=ax2.get_yaxis_transform())
ax2.text(1.1, 100,   r'\textbf{Anteil Solar} ($\%$) \hphantom{XXXXX} \textbf{Ungenauigkeit} ($\%$)', va='center', rotation='vertical', transform=ax2.get_yaxis_transform())
# Save
plt.savefig(output_folder + '/' + file_name + '_Ungenauigkeiten_doppelt.pdf') 
display(fig)
close_all()
## bach to default: 5.9,3
mpl.rcParams['figure.figsize'] = 5.9,3

Plots einzeln

## df erstellen um ihn zu füllen
Ungenauigkeiten = pd.DataFrame()
## Energien (rein und raus) auf täglicher Basis aufsummieren
Ungenauigkeiten['Werte_rein']             = Energie_Tag[Werte_rein].sum(axis=1)
Ungenauigkeiten['Werte_raus']             = Energie_Tag[Werte_raus].sum(axis=1)
Ungenauigkeiten['Werte_Summe']            = Ungenauigkeiten['Werte_rein']            + Ungenauigkeiten['Werte_raus']  
## Ungenauigkeiten berechnen
Ungenauigkeiten['Ungenauigkeit_absolut']  = Ungenauigkeiten['Werte_rein']            - Ungenauigkeiten['Werte_raus'] 
Ungenauigkeiten['Ungenauigkeit_relativ']  = Ungenauigkeiten['Ungenauigkeit_absolut'] / Ungenauigkeiten['Werte_Summe']  * 100

## Plot
fig, ax = plt.subplots()
## linke Achse
Ungenauigkeiten['Ungenauigkeit_absolut'].plot(ax=ax,color=colo('rot',1), linewidth=0.5, label = 'kWh')
ax.set_ylabel(r'\textbf{Ungenauigkeit} (kWh)')
## rechte Achse
ax2 = ax.twinx()
Ungenauigkeiten['Ungenauigkeit_relativ'].plot(ax=ax2,color=colo('blau',1) ,linewidth=0.5, label = '\%')
ax2.set_ylabel(r'\textbf{Ungenauigkeit} (\%)')
## Achsen formatieren
ax.set(xlim=[pd.to_datetime("23.07.17 00:00:00"),pd.to_datetime("30.07.17 23:00:00")])
ax.set_xlabel('')
## Legende formatieren
h0, l0 = ax.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()  
legend  = plt.legend(h0+h2, l0+l2, loc=1, ncol=2)  
set_legend_linewidth(legend) 
## Save
plt.savefig(output_folder + '/' + file_name + '_Ungenauigkeiten.pdf')
display(fig)
close_all()

# ## Plot mit Solar und Speicher
# fig, ax = plt.subplots()
# sample ='2D'
# ## linke Achse
# daten['S_Speicher_Mitteltemperatur'].resample(sample).mean().plot(ax=ax,color=colo('grün',1),linewidth=0.8, label = 'S_Speicher_Mitteltemperatur')
# solar_relativ.resample(sample).mean().plot(ax=ax,color=colo('orange',1), linewidth=0.8, label = 'Solarenergie (rel.)')
# ax.set_ylabel(r'\textbf{Energie} (kWh) / \textbf{Temperatur} ($^\circ$C)')
# # ## rechte Achse
# ax2 = ax.twinx() 
# Ungenauigkeiten['Ungenauigkeit_relativ'].resample(sample).mean().plot(ax=ax2,color=colo('blau',1),linewidth=0.8, label = 'Ungenauigkeit (\%)')
# ax2.set_ylabel(r'\textbf{Ungenauigkeit} (\%)')
# # ## X-Achse
# ax.set(xlim=[pd.to_datetime("05.01.17 00:00:00"),pd.to_datetime("30.04.18 23:00:00")])
# ax.set_xlabel('') 
# # ## Legende formatieren
# h0, l0 = ax.get_legend_handles_labels()
# h2, l2 = ax2.get_legend_handles_labels() 
# legend  = plt.legend(h2+h0, l2+l0, loc=1, ncol=1, bbox_to_anchor=(.94, .99))  
# set_legend_linewidth(legend) 
# ## Save
# plt.savefig(output_folder + '/' + file_name + '_Ungenauigkeiten_mit_Solar.pdf')
# display(fig)
# close_all() 

normierte Unsicherheiten

## normierte Unsicherheiten auf monatlicher Basis

F_rein                        = Energie_Monat[Fehler_rein]
F_raus                        = Energie_Monat[Fehler_raus]

index                         = ['Mai\n2017', 'Jun', 'Jul','Aug','Sep','Okt','Nov','Dez','Jan\n2018', 'Feb', 'Mrz','Apr']
gewichtete_Fehler             = pd.DataFrame(index=index)
Summe                         = F_rein.Kessel_Fehler.values + F_rein.Solar_Fehler.values + F_raus.Heizung_Fehler.values + F_raus.FriWa_Prim_Fehler.values + F_raus.Speicherverluste_MCA_Fehler.values

gewichtete_Fehler["Kessel"]   = (F_rein.Kessel_Fehler.values               / Summe)
gewichtete_Fehler["Solar"]    = (F_rein.Solar_Fehler.values                / Summe) 
gewichtete_Fehler["Heizung"]  = (F_raus.Heizung_Fehler.values              / Summe)
gewichtete_Fehler["FriWa"]    = (F_raus.FriWa_Prim_Fehler.values           / Summe)
gewichtete_Fehler["Speicher"] = (F_raus.Speicherverluste_MCA_Fehler.values / Summe) 

## halbe Bilanz monatlich für Linienplot
gesamt_U              = pd.DataFrame(index=index)
gesamt_U['kWh']       = F_rein.Kessel_Fehler.values + F_rein.Solar_Fehler.values + F_raus.Heizung_Fehler.values + F_raus.FriWa_Prim_Fehler.values + F_raus.Speicherverluste_MCA_Fehler.values

fig, ax = plt.subplots()
stacked = True
width = 0.6 

handles = [L_Speicherverluste,L_FriWa,L_Heizung, L_Solar,L_Kessel] 
Farben  = [colo('blau',1),colo('orange',1),colo('grau',1),colo('rot',1),colo('grün',1) ]

gewichtete_Fehler.plot.bar(position= 0.5, color=(Farben),  edgecolor='black',linewidth = 0.3,   width=width, ax=ax, stacked=stacked,alpha = 1) 


## notwendig um die Grafik etwas breiter zu machen, da sonst in der PDF die linke Seite abgeschnitten wird
ax.text(-.31, .5, r'\hphantom{Bilanz ausgeglichen}' , va='center', ha="left", fontsize=8, color='black', transform=ax.get_yaxis_transform())

# Legende 
# legend  = plt.legend(handles=handles, bbox_to_anchor=(-.3, 1.025), ncol=1, loc=2) 

# Legende1
handles = [L_Solar,L_Kessel]
legend1  = plt.legend(handles=handles ,bbox_to_anchor=(-.3, 0.16), ncol=1, loc=2)   
# Legende2
handles = [L_Speicherverluste,L_FriWa,L_Heizung ]
legend2  = plt.legend(handles=handles, bbox_to_anchor=(-.3, 1.025), ncol=1, loc=2) 
# erste Legende wiederholen
ax.add_artist(legend1)


## Liniendiagrammauf zweiter Achse
ax2 = ax.twinx()
gesamt_U['kWh'] .plot(ax=ax2,color=colo('black',1) ,linewidth=0.8)

## Achsen formatieren
ax.set_xlabel('') 
ax.set_xticklabels(index, rotation=0)
ax.set_ylabel(r'\textbf{normierte} \hphantom{ }' '\n' r'\textbf{Unsicherheiten} \hphantom{ }')
ax.set_ylim(0,1) 
ax.set_yticks([0,.5,1])
ax2.set_ylabel(r'\textbf{absolute Unsicherheit} (kWh)')

plt.savefig(output_folder + '/' + file_name + '_normierte_Unsicherheiten.pdf')
display(fig)
close_all()
del [[gewichtete_Fehler ]]; gc.collect()
#display(round(gewichtete_Fehler,1))

12

Einbruch im Dezember

sample = '1W'
Uns                        = pd.DataFrame()
Uns                        = Energie_Tag.resample(sample).mean() 
Uns['Summe_Fehler']        = Uns.Solar_Fehler + Uns.Kessel_Fehler + Uns.Heizung_Fehler + Uns.FriWa_Prim_Fehler + Uns.Speicherverluste_MCA_Fehler 
Uns['Summe_Energie']       = Uns.Solar_Wert + Uns.Kessel_Wert + Uns.Heizung_Wert + Uns.FriWa_Prim_Wert + Uns.Speicherverluste_MCA_Wert 
Uns['Solar_gew_Fehler']    = Uns.Solar_Fehler / Uns.Summe_Fehler
Uns['Kessel_gew_Fehler']   = Uns.Kessel_Fehler / Uns.Summe_Fehler
Uns['Heizung_gew_Fehler']  = Uns.Heizung_Fehler / Uns.Summe_Fehler
Uns['FriWa_gew_Fehler']    = Uns.FriWa_Prim_Fehler / Uns.Summe_Fehler
Uns['Speicher_gew_Fehler'] = Uns.Speicherverluste_MCA_Fehler / Uns.Summe_Fehler

## Delta T der Heizung
deltaT = daten.S_Heizung_VL - daten.S_Heizung_RL
Uns['Heizung_deltaT'] = deltaT.resample(sample).mean()
Uns['aussenT']        = daten.L_Aussenlufttemperatur_1


mpl.rcParams['figure.figsize'] = 15.9,3  
fig, ax = plt.subplots() 

## Unsicherheiten und Heizungsspreizung
Uns.Kessel_Fehler.plot(ax=ax,color=colo('blau',1.5) ,linewidth=1) 
Uns.Solar_Fehler.plot(ax=ax,color=colo('orange',1.5) ,linewidth=1) 
Uns.Heizung_Fehler.plot(ax=ax,color=colo('grau',1.5) ,linewidth=1) 
Uns.FriWa_Prim_Fehler.plot(ax=ax,color=colo('rot',1.5) ,linewidth=1) 
Uns.Speicherverluste_MCA_Fehler.plot(ax=ax,color=colo('grün',1.5) ,linewidth=1) 
Uns.Summe_Fehler.plot(ax=ax,color=colo('black',1.5) ,linewidth=1) 
Uns.Heizung_deltaT.plot(ax=ax,color=colo('violet',1.5) ,linewidth=1) 
Uns.aussenT.plot(ax=ax,color=colo('gelb',1.5) ,linewidth=1) 

## Wärmeenergien
ax2 = ax.twinx()
Uns.Kessel_Wert.plot(ax=ax2,color=colo('blau',1.5) ,linewidth=1.5) 
Uns.Solar_Wert.plot(ax=ax2,color=colo('orange',1.5) ,linewidth=1.5) 
Uns.Heizung_Wert.plot(ax=ax2,color=colo('grau',1.5) ,linewidth=1.5) 
Uns.FriWa_Prim_Fehler.plot(ax=ax2,color=colo('rot',1.5) ,linewidth=1.5) 
Uns.Speicherverluste_MCA_Fehler.plot(ax=ax2,color=colo('grün',1.5) ,linewidth=1.5) 
# Uns.Summe_Energie.plot(ax=ax2,color=colo('black',1.5) ,linewidth=1.5) 



# plt.savefig(output_folder + '/' + file_name + '_normierte_Unsicherheiten_tgl.pdf')
display(fig)
close_all() 

mpl.rcParams['figure.figsize'] = 5.9,3     
# display(round(Uns,1))

normierte Wärmemengen

## normierte Unsicherheiten auf monatlicher Basis
index                         = ['Mai\n2017', 'Jun', 'Jul','Aug','Sep','Okt','Nov','Dez','Jan\n2018', 'Feb', 'Mrz','Apr']
Farben                        = [colo('blau',1),colo('orange',1),colo('grau',1),colo('rot',1),colo('grün',1) ]

## Wärmemengen 
Q_rein                        = Energie_Monat[Werte_rein]
Q_raus                        = Energie_Monat[Werte_raus]
gewichtete_Wärme              = pd.DataFrame(index=index)

SummeQ                       = Q_rein.Kessel_Wert.values + Q_rein.Solar_Wert.values + Q_raus.Heizung_Wert.values + Q_raus.FriWa_Prim_Wert.values + Q_raus.Speicherverluste_MCA_Wert.values
gewichtete_Wärme["Kessel"]   = (Q_rein.Kessel_Wert.values               / SummeQ)
gewichtete_Wärme["Solar"]    = (Q_rein.Solar_Wert.values                / SummeQ) 
gewichtete_Wärme["Heizung"]  = (Q_raus.Heizung_Wert.values              / SummeQ)
gewichtete_Wärme["FriWa"]    = (Q_raus.FriWa_Prim_Wert.values           / SummeQ)
gewichtete_Wärme["Speicher"] = (Q_raus.Speicherverluste_MCA_Wert.values / SummeQ)

## halbe Bilanz monatlich für Linienplot
halbe_Bilanz              = pd.DataFrame(index=index)
halbe_Bilanz['Energie']   = (Q_rein.Kessel_Wert.values + Q_rein.Solar_Wert.values + Q_raus.Heizung_Wert.values + Q_raus.FriWa_Prim_Wert.values + Q_raus.Speicherverluste_MCA_Wert.values) / 2


L_halbe_Bilanz =  mpatches.Patch(facecolor=colo('grau',1), label='halbe Bilanz',edgecolor='black', linewidth=0.3) 

## Unsicherheiten 
F_rein                        = Energie_Monat[Fehler_rein]
F_raus                        = Energie_Monat[Fehler_raus]
gewichtete_Fehler             = pd.DataFrame(index=index)
SummeF                        = F_rein.Kessel_Fehler.values + F_rein.Solar_Fehler.values + F_raus.Heizung_Fehler.values + F_raus.FriWa_Prim_Fehler.values + F_raus.Speicherverluste_MCA_Fehler.values
gewichtete_Fehler["Kessel"]   = (F_rein.Kessel_Fehler.values               / SummeQ)
gewichtete_Fehler["Solar"]    = (F_rein.Solar_Fehler.values                / SummeQ)
gewichtete_Fehler["Heizung"]  = (F_raus.Heizung_Fehler.values              / SummeQ)
gewichtete_Fehler["FriWa"]    = (F_raus.FriWa_Prim_Fehler.values           / SummeQ)
gewichtete_Fehler["Speicher"] = (F_raus.Speicherverluste_MCA_Fehler.values / SummeQ)



## Barplot
fig, ax = plt.subplots()

###################################ls='None',uplims=False, lolims=False,
error_kw = dict(lw=2, capsize=.0001, uplims=True, capthick=.0001, ecolor=('white'))##     yerr=gewichtete_Fehler.values.T, error_kw=error_kw,    
gewichtete_Wärme.plot.bar(position= 0.5,  color=(Farben),yerr=gewichtete_Fehler.values.T, error_kw=error_kw,  edgecolor='black',linewidth = 0.3,   width=0.6, ax=ax, stacked=True) 


# Legende1
handles = [L_Solar,L_Kessel]
legend1  = plt.legend(handles=handles ,bbox_to_anchor=(-.3, 0.16), ncol=1, loc=2)   
# Legende2
handles = [L_Speicherverluste,L_FriWa,L_Heizung ]
legend2  = plt.legend(handles=handles, bbox_to_anchor=(-.3, .98), ncol=1, loc=2) 
# erste Legende wiederholen
# ax.add_artist(legend1)


# plt.errorbar(index, gewichtete_Wärme["Kessel"], xerr=4)

# Mittellinie und Text
plt.axhline(y=.5, xmin=0, xmax=.98,linewidth=0.5,clip_on = False,color='black',ls='--')
## notwendig um die Grafik etwas breiter zu machen, da sonst in der PDF die linke Seite abgeschnitten wird
ax.text(-.31, .5, r'\hphantom{Bilanz ausgeglichen}' , va='center', ha="left", fontsize=8, color='black', transform=ax.get_yaxis_transform())

## Liniendiagrammauf zweiter Achse
ax2 = ax.twinx()
halbe_Bilanz['Energie'].plot(ax=ax2,color=colo('black',1) ,linewidth=0.8)

## Achsen formatieren 
ax.set_xlabel('') 
ax.set_xticklabels(index, rotation=0)
ax.set_ylabel(r'\textbf{normierte Anteile}' '\n' r'\textbf{der Wärmemengen}')
ax.set_ylim(0,1) 
ax.set_yticks([0,.5,1])
ax2.set_ylabel(r'\textbf{absolute Wärmemenge} (kWh)')
ax2.get_yaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, loc: locale.format_string('%d', x, 1))) ## dot as thousand separator for X

leg2 = ax2.legend(['abs. Wärme'],bbox_to_anchor=(-0.018, 0.27))
# Manually add the first legend back
ax.add_artist(legend1)
ax.add_artist(legend2)


plt.savefig(output_folder + '/' + file_name + '_normierte_Wärmemengen.pdf')
display(fig)
close_all()

# del [[gewichtete_Fehler ]]; gc.collect() 
display(round(gewichtete_Fehler,2))
display(round(gewichtete_Wärme,2))
# display(round(Kombi,1))

# display(halbe_Bilanz)

# display(gewichtete_Fehler.values.T)
# alt = gewichtete_Fehler.values.T 
# display(type(alt))
# print(alt.shape)
# data = alt.reshape((alt.shape[0], alt.shape[1], 1))
# display(data)

Plot jährlich

# mpl.use("pgf")
# mpl.rcParams.update(params)

## beide Jahre zusammenfassen Energie_Jahr => Q
Q = round(Energie_Jahr,0) #round(Energie_Jahr.groupby((Energie_Jahr.index.year//10)*10).sum(),0)

W_rein  = Q[Werte_rein]
F_rein  = Q[Fehler_rein]
W_raus  = Q[Werte_raus]
F_raus  = Q[Fehler_raus]


# mpl.rcParams.update({'font.size': 10}) 
mpl.rcParams['figure.figsize'] = 3.3,2.3


fig, ax = plt.subplots(constrained_layout=True) 
ax.ticklabel_format(useLocale=True) ## dot as thousand separator 

W_rein.plot.barh(position =  .3, color = (Farben_rein), edgecolor='black',linewidth = 0.3, width = 0.5, ax = ax, stacked = True, alpha = 1,align='edge')
W_raus.plot.barh(position = 1.5, color = (Farben_raus), edgecolor='black',linewidth = 0.3, width = 0.5, ax = ax, stacked = True, alpha = 1,align='edge')

## Errorbars 
plt.errorbar(Q['Kessel_Wert'],                                                           0.40, xerr=Q['Kessel_Fehler'],               color="k", lw=0.5, capsize=1, capthick=0.5)
plt.errorbar(Q['Kessel_Wert']  + Q['Solar_Wert'],                                        0.30, xerr=Q['Solar_Fehler'],                color="k", lw=0.5, capsize=1, capthick=0.5) 
plt.errorbar(Q['Heizung_Wert'],                                                         -0.15, xerr=Q['Heizung_Fehler'],              color="k", lw=0.5, capsize=1, capthick=0.5)
plt.errorbar(Q['Heizung_Wert'] + Q['FriWa_Prim_Wert'],                                  -0.25, xerr=Q['FriWa_Prim_Fehler'],           color="k", lw=0.5, capsize=1, capthick=0.5)
plt.errorbar(Q['Heizung_Wert'] + Q['FriWa_Prim_Wert'] + Q['Speicherverluste_MCA_Wert'], -0.35, xerr=Q['Speicherverluste_MCA_Fehler'], color="k", lw=0.5, capsize=1, capthick=0.5)

# Legende
handles = [L_Kessel,L_Heizung,L_Solar,L_FriWa,L_Dummy,L_Speicherverluste] 
legend = plt.legend(handles=handles, loc=1, ncol=3 ) 
legend.get_frame().set_linewidth(0.3)   
legend.legendHandles[4].set_visible(False) 
legend.texts[4].set_visible(False) 


# Achsen
ax.set_ylim(-.6,1.3)
ax.set_yticks([])
ax.set_yticklabels('')
ax.set_ylabel('') 
ax.set_xlabel(r'\textbf{Wärmeenergie} (kWh)') 
ax.set_xlim(0,24500)
ax.set_xticks([0,10000,20000])
ax.get_xaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, loc: locale.format_string('%d', x, 1))) ## dot as thousand separator

plt.savefig(output_folder + '/' + file_name + '_Balken_jährlich.pdf')
display(fig)
close_all()
## Größe wieder zurücksetzen WICHTIG !!!!
mpl.rcParams['figure.figsize'] = 5.9,3 
#display(Q) 

Tabellen

## Tabelle für LaTeX Ausgabe
ungenauigkeit = Q.Kessel_Wert[0] + Q.Solar_Wert[0] - Q.Heizung_Wert[0] - Q.FriWa_Prim_Wert[0] - Q.Speicherverluste_MCA_Wert[0]
gesamtenergie = Q.Kessel_Wert[0] + Q.Solar_Wert[0] + Q.Heizung_Wert[0] + Q.FriWa_Prim_Wert[0] + Q.Speicherverluste_MCA_Wert[0] + ungenauigkeit
plusenergie   = Q.Kessel_Wert[0] + Q.Solar_Wert[0]  
minusenergie  = Q.Heizung_Wert[0] + Q.FriWa_Prim_Wert[0] + Q.Speicherverluste_MCA_Wert[0]

## mit ausgewiesener Ungenauigkeit
tabelle = pd.DataFrame(columns=[['Wert kWh', 'Wert %','Unsicherheit','Unsicherheit %']])
tabelle.loc['Kessel']           = [Q.Kessel_Wert[0],               round(Q.Kessel_Wert[0] / gesamtenergie *100,1),               Q.Kessel_Fehler[0],               round(Q.Kessel_Fehler[0]               / Q.Kessel_Wert[0]*100,1) ]
tabelle.loc['Solar']            = [Q.Solar_Wert[0],                round(Q.Solar_Wert[0] / gesamtenergie *100,1),                Q.Solar_Fehler[0],                round(Q.Solar_Fehler[0]                / Q.Solar_Wert[0]*100,1) ]
tabelle.loc['Heizung']          = [Q.Heizung_Wert[0],              round(Q.Heizung_Wert[0] / gesamtenergie *100,1),              Q.Heizung_Fehler[0],              round(Q.Heizung_Fehler[0]              / Q.Heizung_Wert[0]*100,1) ]
tabelle.loc['FriWa']            = [Q.FriWa_Prim_Wert[0],           round(Q.FriWa_Prim_Wert[0] / gesamtenergie *100,1),           Q.FriWa_Prim_Fehler[0],           round(Q.FriWa_Prim_Fehler[0]           / Q.FriWa_Prim_Wert[0]*100,1) ]
tabelle.loc['Speicherverluste'] = [Q.Speicherverluste_MCA_Wert[0], round(Q.Speicherverluste_MCA_Wert[0] / gesamtenergie *100,1), Q.Speicherverluste_MCA_Fehler[0], round(Q.Speicherverluste_MCA_Fehler[0] / Q.Speicherverluste_MCA_Wert[0]*100,1) ]
tabelle.loc['Ungenauigkeit']    = [ungenauigkeit,                  round(ungenauigkeit / gesamtenergie *100,1),                  '0',                              '0' ]

## mit verteileter Ungenauigkeit
tabelle_U = pd.DataFrame(columns=[['Verteilt','vorher', 'nachher' ]])
tabelle_U.loc['Kessel']           = Q.Kessel_Wert[0]               / plusenergie  * ungenauigkeit/2,    Q.Kessel_Wert[0],                   Q.Kessel_Wert[0]               + Q.Kessel_Wert[0]               / plusenergie * ungenauigkeit/2 
tabelle_U.loc['Solar']            = Q.Solar_Wert[0]                / plusenergie  * ungenauigkeit/2,    Q.Solar_Wert[0],                    Q.Solar_Wert[0]                + Q.Solar_Wert[0]                / plusenergie * ungenauigkeit/2 
tabelle_U.loc['Heizung']          = Q.Heizung_Wert[0]              / minusenergie * ungenauigkeit/2,    Q.Heizung_Wert[0],                  Q.Heizung_Wert[0]              + Q.Heizung_Wert[0]              / minusenergie * ungenauigkeit/2
tabelle_U.loc['FriWa']            = Q.FriWa_Prim_Wert[0]           / minusenergie * ungenauigkeit/2,    Q.FriWa_Prim_Wert[0],               Q.FriWa_Prim_Wert[0]           + Q.FriWa_Prim_Wert[0]           / minusenergie * ungenauigkeit/2
tabelle_U.loc['Speicherverluste'] = Q.Speicherverluste_MCA_Wert[0] / minusenergie * ungenauigkeit/2,    Q.Speicherverluste_MCA_Wert[0],     Q.Speicherverluste_MCA_Wert[0] + Q.Speicherverluste_MCA_Wert[0] / minusenergie * ungenauigkeit/2

print('Prozentwerte mit verteilter Ungenauigkeit')
print(round(tabelle_U.loc['Kessel']['nachher']           /  (tabelle_U.loc['Kessel']['nachher']  + tabelle_U.loc['Solar']['nachher'])                                                * 100,0)[0])
print(round(tabelle_U.loc['Solar']['nachher']            /  (tabelle_U.loc['Kessel']['nachher']  + tabelle_U.loc['Solar']['nachher'])                                                * 100,0)[0])
print(round(tabelle_U.loc['Heizung']['nachher']          /  (tabelle_U.loc['Heizung']['nachher'] + tabelle_U.loc['FriWa']['nachher'] + tabelle_U.loc['Speicherverluste']['nachher']) * 100,0)[0])
print(round(tabelle_U.loc['FriWa']['nachher']            /  (tabelle_U.loc['Heizung']['nachher'] + tabelle_U.loc['FriWa']['nachher'] + tabelle_U.loc['Speicherverluste']['nachher']) * 100,0)[0])
print(round(tabelle_U.loc['Speicherverluste']['nachher'] /  (tabelle_U.loc['Heizung']['nachher'] + tabelle_U.loc['FriWa']['nachher'] + tabelle_U.loc['Speicherverluste']['nachher']) * 100,0)[0])

display(round(tabelle_U,0))    
print('Tabelle für LaTeX')
print(tabelle.to_latex(index=True)) 

Prozentwerte mit verteilter Ungenauigkeit
87.0
13.0
89.0
2.0
9.0

Tabelle für LaTeX
\begin{tabular}{lrrll}
\toprule
{} & Wert kWh & Wert \% & Unsicherheit & Unsicherheit \% \\
\midrule
Kessel           &  20831.0 &   43.3 &          306 &            1.5 \\
Solar            &   3211.0 &    6.7 &          168 &            5.2 \\
Heizung          &  20087.0 &   41.8 &         1095 &            5.5 \\
FriWa            &    469.0 &    1.0 &           14 &              3 \\
Speicherverluste &   1916.0 &    4.0 &          192 &             10 \\
Ungenauigkeit    &   1570.0 &    3.3 &            0 &              0 \\
\bottomrule
\end{tabular}

Plot monatlich

W_rein  = Energie_Monat[Werte_rein]
F_rein  = Energie_Monat[Fehler_rein]
W_raus  = Energie_Monat[Werte_raus]
F_raus  = Energie_Monat[Fehler_raus]




fig, ax = plt.subplots(constrained_layout=True) 
ax.ticklabel_format(useLocale=True) ## dot as thousand separator
stacked = True
width         = 0.3
error_kw_rein = dict(lw=0.5, capsize=1, capthick=0.5, ecolor=('black'))##  yerr=F_rein.values.T,error_kw=error_kw_rein,
error_kw_raus = dict(lw=0.5, capsize=1, capthick=0.5, ecolor=('black'))##  yerr=F_raus.values.T,error_kw=error_kw_raus,

W_rein.plot.bar(position= 0.5, yerr=F_rein.values.T,error_kw=error_kw_rein, color=(Farben_rein), edgecolor='black',linewidth = 0.3, width=width,ax=ax,stacked=stacked,alpha = 1)
W_raus.plot.bar(position=-0.5, yerr=F_raus.values.T,error_kw=error_kw_raus, color=(Farben_raus), edgecolor='black',linewidth = 0.3, width=width,ax=ax,stacked=stacked,alpha = 1)


## Errorbars separat plotten
# W_rein.plot.bar(position= 0.5, color=(Farben_rein),  edgecolor='black',linewidth = 0.3, width=width,ax=ax,stacked=stacked,alpha = 1)
# W_raus.plot.bar(position=-0.5, color=(Farben_raus),  edgecolor='black',linewidth = 0.3, width=width,ax=ax,stacked=stacked,alpha = 1)
## Errorbars 
# plt.errorbar(Q['Kessel_Wert'],                                                           0.2, yerr=Q['Kessel_Fehler'],               color="k", lw=0.5, capsize=1, capthick=0.5)
# plt.errorbar(Q['Kessel_Wert']  + Q['Solar_Wert'],                                        0.7, yerr=Q['Solar_Fehler'],                color="k", lw=0.5, capsize=1, capthick=0.5) 
# plt.errorbar(Q['Heizung_Wert'],                                                         -0.2, yerr=Q['Heizung_Fehler'],              color="k", lw=0.5, capsize=1, capthick=0.5)
# plt.errorbar(Q['Heizung_Wert'] + Q['FriWa_Prim_Wert'],                                  -0.5, yerr=Q['FriWa_Prim_Fehler'],           color="k", lw=0.5, capsize=1, capthick=0.5)
# plt.errorbar(Q['Heizung_Wert'] + Q['FriWa_Prim_Wert'] + Q['Speicherverluste_MCA_Wert'], -0.7, yerr=Q['Speicherverluste_MCA_Fehler'], color="k", lw=0.5, capsize=1, capthick=0.5)
#plt.errorbar(-0.2,  W_rein.Kessel_Wert ,  yerr=5,  color="k", lw=.5, capsize=1, capthick=.5) ## TEST




# Legende
handles = [L_Dummy,L_Solar,L_Kessel, L_Speicherverluste,L_FriWa,L_Heizung] 
legend = plt.legend(handles=handles, loc=2, ncol=2 ) 
legend.legendHandles[0].set_visible(False) 
legend.texts[0].set_visible(False) 


## Achsen formatieren
ax.set_xlabel('')
ax.set_xlim(-0.5,12)  
ax.set_xticklabels(index, rotation=0)
ax.set_xticks(np.arange(0.15, 12, step = 1))

ax.set_ylim(0,4500)
ax.set_ylabel(r'\textbf{Wärmeenergie} (kWh)')
ax.get_yaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, loc: locale.format_string('%d', x, 1))) ## dot as thousand separator

plt.savefig(output_folder + '/' + file_name + '_monatlich.pdf')
display(fig)
close_all()

display(round(W_rein,0))
display(round(W_raus,0))
# from pprint import pprint
# pprint(W_rein)
# pprint('')
# pprint(F_rein.values.T)
# pprint(Q['Kessel_Wert']) 
# pprint(W_rein.Kessel_Wert)

# W_rein  = Energie_Monat[Werte_rein]
# F_rein  = Energie_Monat[Fehler_rein]
# W_raus  = Energie_Monat[Werte_raus]
# F_raus  = Energie_Monat[Fehler_raus]
Werte = W_rein.sum(axis=1) + W_raus.sum(axis=1)
Fehler = F_rein.sum(axis=1) + F_raus.sum(axis=1)
Anteil = Fehler / Werte * 100
print(Anteil) 

Zeit
2017-05-31    5.740407
2017-06-30    7.762514
2017-07-31    6.972255
2017-08-31    5.599983
2017-09-30    6.072151
2017-10-31    6.012533
2017-11-30    3.596573
2017-12-31    2.121069
2018-01-31    3.202016
2018-02-28    3.170875
2018-03-31    3.816876
2018-04-30    5.789474
Freq: M, dtype: float64

Plot Senkey

Energie_Sankey   = round(Energie_Jahr / 1000,1) #(round((Energie_Jahre / 50),0) * 50).astype(int) 

Faktor           = 1
Kessel           = Energie_Sankey.Kessel_Wert.loc['1'] * Faktor
Solar            = Energie_Sankey.Solar_Wert.loc['1'] * Faktor
Speicherverluste = Energie_Sankey.Speicherverluste_MCA_Wert.loc['1'] * Faktor
Heizung          = Energie_Sankey.Heizung_Wert.loc['1'] * Faktor
FriWa            = Energie_Sankey.FriWa_Prim_Wert.loc['1'] * Faktor
Gas_rein         = round(21.836 ,1)
Gas_raus         = Gas_rein * 0.902
Kesselverluste   = round((Gas_rein - Gas_raus) * - 1,1)

## Ungenauigkeit der Werte als Differenz zwischen rein und raus
ungenauigkeit_0 = round((Gas_raus - Kessel) * - 1, 1)
ungenauigkeit   = (Heizung + FriWa + Speicherverluste - Kessel - Solar) * -1 

## Zwischensummen für den mittleren Teil des Diagramms     
summe_s  = round(Gas_raus + ungenauigkeit_0,1)
summe_s0 = Solar  +  Kessel
summe_s1 = summe_s0 - ungenauigkeit  -  Speicherverluste

## Sankey plotten        
fig    = plt.figure()
ax     = fig.add_subplot(1, 1, 1,)
s      = Sankey(ax = ax, scale = 1/40, unit = 'MWh', gap = .4, shoulder = 0.05,)


## linker oberer Teil
s.add( 
    flows        = [ungenauigkeit_0,   Kesselverluste,     Gas_rein,   -summe_s  ], 
    orientations = [              1,               -1,            1,          0  ],
    labels       = [       "Ungen.", "Kesselverluste",     "Erdgas",       None  ],
    trunklength  = 0.8, pathlengths = 0.4, edgecolor = '#000000', facecolor = '#3f3f3f', 
    lw = 0.5,
)

## linker Teil
s.add(
    flows        = [  Solar,    Kessel,   -summe_s0  ], 
    orientations = [      1,         0,           0  ],
    labels       = ["Solar",  None,        None  ],
    trunklength  = 1.6, pathlengths = 0.4, edgecolor = '#000000', facecolor = '#5e5e5e', 
    prior = 0, connect = (3,1), lw = 0.5,
)

## mittlerer Teil
s.add(
    flows        = [summe_s0,  -ungenauigkeit,  -Speicherverluste,  -summe_s1  ],
    orientations = [       0,               1,                 -1,          0  ], 
    labels       = [None,     "Ungenauigkeit",  "Speicherverluste",       None  ],
    trunklength  = 1.6, pathlengths=0.45, edgecolor = '#000000', facecolor = '#7e7e7e',
    prior = 1, connect = (2,0), lw = 0.5,
    )

## rechter Teil
s.add(
    flows        = [summe_s1,    -Heizung,    -FriWa  ],
    orientations = [       0,          -1,        -1  ],
    labels       =     [None,   "Heizung",   "FriWa"  ],
    trunklength  = 1.7, pathlengths = 0.3, edgecolor = '#000000', facecolor = '#9e9e9e',
    prior = 2, connect = (3,0), lw = 0.5,
)


## Labels bearbeiten
diagrams = s.finish() 
## Label und Wert linksbündig
for d in diagrams:
    for t in d.texts:
        t.set_horizontalalignment('left')
## Positionsanzeige der Labels
#print(diagrams[0].texts[0])
#print(diagrams[0].texts[1])
#print(diagrams[0].texts[2])
#print(diagrams[1].texts[0])
#print(diagrams[1].texts[1]) 
#print(diagrams[2].texts[1]) 
#print(diagrams[2].texts[2])
#print(diagrams[3].texts[1]) 
#print(diagrams[3].texts[2])

## Positionierung der Labels        
diagrams[0].texts[0].set_position(xy = [-0.5,   1.0 ])  # Ungenauigkeit
diagrams[0].texts[1].set_position(xy = [ 0.3,  -1.0 ])  # Kesselverluste
diagrams[0].texts[2].set_position(xy = [-1.6,   1.0 ])  # Erdgas
diagrams[1].texts[0].set_position(xy = [ 0.5,   1.0 ])  # Solar
diagrams[1].texts[1].set_position(xy = [-0.3,   4.0 ])  # Kessel
diagrams[2].texts[1].set_position(xy = [ 2.0,   1.0 ])  # Ungenauigkeit
diagrams[2].texts[2].set_position(xy = [ 2.0,  -1.0 ])  # Specherverluste
diagrams[3].texts[1].set_position(xy = [ 5.0,  -1.0 ])  # Heizung
diagrams[3].texts[2].set_position(xy = [ 4.0,  -1.0 ])  # FriWa

## Keine Achsen 
plt.axis("off") 

plt.savefig(output_folder + '/' + file_name + '_Sankey.pdf') 
display(fig)
close_all()

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  

 MCA_Speicherverluste Lueftung_kalibrieren