# %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%Energy Price Plot
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import tikzplotlib
from matplotlib import rc
plt.rc('text', usetex=True)

import matplotlib
# matplotlib.use('pgf')
# matplotlib.rcParams.update({
#     'pgf.texsystem': 'pdflatex',
#     'font.family': 'lmodern',
#     'text.usetex': True,
#     'pgf.rcfonts': False,
#     'font.size': 8,
# })

# Lade die CSV-Datei
data = pd.read_csv('energyprice_clean_082023.csv')
# Konvertiere 'Time' zu datetime
data['Time'] = pd.to_datetime(data['Time'])

# Filtere die Daten für den 31. August 2023
start_date = "2023-08-31 00:00:00"
end_date = "2023-08-31 23:59:59"
mask = (data['Time'] >= start_date) & (data['Time'] <= end_date)
data_filtered = data.loc[mask]

# Umrechnen der A5-Abmessungen von mm in Zoll
breite_in_zoll = 148 / 25.4  # Breite in Zoll
hoehe_in_zoll = 210 / 25.4 /2.5   # Höhe in Zoll

# Erstellen der Grafik mit A5-Abmessungen
plt.figure(figsize=(breite_in_zoll, hoehe_in_zoll),tight_layout=True)

# # Setze den Plot
fig=plt.figure(figsize=(10, 6))

# Plotte die Preise
plt.plot(data_filtered['Time'], data_filtered['Strompreis_EPEX_SPOT_Auction_Day_Ahead_DE_LU_60min'], color='black', label='Day Ahead 60min')
plt.plot(data_filtered['Time'],data_filtered['Strompreis_EPEX_SPOT_Auction_Intraday_DE_LU_15min'], color='gray', label='Intraday 15min', linewidth=1)
plt.plot(data_filtered['Time'],data_filtered['Strompreis_EPEX_SPOT_Continuous_DE_LU_60min'], color='black',linestyle='--', label='Continuous 60min')
plt.plot(data_filtered['Time'],data_filtered['Strompreis_EPEX_SPOT_Continuous_DE_LU_15min'], color='gray', linestyle='--',label='Continuous 15min',linewidth=1)

# Stelle sicher, dass die x-Achse als Datum formatiert ist und setze die Intervalle auf jede Stunde
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=2))  # Intervall auf jede Stunde setzen
ax = plt.gca()  # Greift auf das aktuelle Achsen-Objekt zu
ax.tick_params(axis='both', which='major', labelsize=16)  # 
# Drehe die Datumsmarkierungen für bessere Lesbarkeit
plt.gcf().autofmt_xdate()

# Titel und Achsenbeschriftungen
#plt.title('Electricity prices on 31.08.2023')
plt.xlabel('Time in h',fontsize=16)
plt.ylabel(r'Price in  €/MWh', fontsize=16)
plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.2), ncol=2,fontsize=16)
plt.tight_layout()

#plt.savefig('energyprice310823_2.svg', format='svg')

#plt.savefig('energyprice310823_2.png')
plt.show()
print('Plot Energy Price sucessfull')
# %%
# Orginal Energiekosten  EMAG GT+eCHiller 31.08.23 08 Uhr
# Energiekosten 


import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

import matplotlib
# matplotlib.use('pgf')
# matplotlib.rcParams.update({
#     'pgf.texsystem': 'pdflatex',
#     'font.family': 'lmodern',
#     'text.usetex': True,
#     'pgf.rcfonts': False,
#     'font.size': 8,
# })

# Laden der Daten in Watt
verbrauchsdaten = pd.read_csv('Data310823_merge.csv')
strompreise = pd.read_csv('energyprice_clean_082023.csv')
simulierte_daten= pd.read_csv('simulated_machine_data_2h_30teile.csv')
#Chiller in kW
chiller_data = pd.read_csv('Merge_chiller_15_310823.csv')
chiller_power =  chiller_data['WKM_eCH45150Leistung_elek_aktuell'].iloc[2500:12500]


def ersetze_pges(verbrauchsdaten, simulierte_daten, chiller_power, startzeitpunkt, frequenz):
    # Erstelle einen neuen Zeitstempelvektor für die simulierten Daten
    simulierte_daten['Timestamp'] = pd.date_range(start=startzeitpunkt, periods=len(simulierte_daten), freq=frequenz)
        
    # Vergleiche die Länge der Datensätze und kürze die simulierten Daten, falls notwendig
    if len(simulierte_daten) > len(verbrauchsdaten):
        simulierte_daten = simulierte_daten.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    
    chiller_power = chiller_power.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    # Ersetze die 'Pges' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    #verbrauchsdaten['Pges'] = simulierte_daten['Pges']
    verbrauchsdaten['Chiller_Power'] = chiller_power
    # Ersetze die 'Timestamp' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Timestamp'] = simulierte_daten['Timestamp']
    
    return verbrauchsdaten

# Angenommener Startzeitpunkt
startzeitpunkt = '2023-08-31 08:00:00'
# startzeitpunkt = '2023-08-31 06:00:00'
#startzeitpunkt = verbrauchsdaten['Timestamp'].iloc[0]
frequenz = '1S'  # oder '15T' für 15 Minuten, '1H' für eine Stunde, etc.
verbrauchsdaten = ersetze_pges(verbrauchsdaten, simulierte_daten,chiller_power, startzeitpunkt, frequenz)


# Umwandlung der Zeitstempel in datetime
verbrauchsdaten['Timestamp'] = pd.to_datetime(verbrauchsdaten['Timestamp'])
strompreise['Time'] = pd.to_datetime(strompreise['Time'])

# plt.plot(verbrauchsdaten['Timestamp'],verbrauchsdaten['Pges'])
# plt.show()

# Umrechnung von Watt in Kilowatt
verbrauchsdaten['Pges_kW'] = verbrauchsdaten['Pges'] / 1000  # Umrechnung in kW

# Gesamtverbrauch
verbrauchsdaten['Verbrauch_Sum_kW'] = (verbrauchsdaten['Pges_kW'] + verbrauchsdaten['Chiller_Power'])
#verbrauchsdaten['Verbrauch_Sum_kW'] =  verbrauchsdaten['Chiller_Power']
#verbrauchsdaten['Verbrauch_Sum_kW'] = verbrauchsdaten['Pges_kW'] 

gesamtverbrauch = verbrauchsdaten['Verbrauch_Sum_kW'].sum() / 3600  # Gesamtverbrauch in kWh

# Umrechnung der Strompreise von Euro/MWh in Euro/kWh
strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Day_Ahead_DE_LU_60min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Intraday_DE_LU_15min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Continuous_DE_LU_15min'] / 1000


# Zuordnung der Strompreise zu den Verbrauchsdaten
verbrauchsdaten['Preis_kWh'] = verbrauchsdaten['Timestamp'].apply(
    lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
)

# Berechnung der Kosten pro Sekunde und Summierung für Gesamtkosten
verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Verbrauch_Sum_kW'] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde


gesamtkosten = verbrauchsdaten['Kosten_pro_Sek'].sum()


# # Gesamtzeitraum
start_zeitpunkt = verbrauchsdaten['Timestamp'].min()
end_zeitpunkt = verbrauchsdaten['Timestamp'].max()

# Ausgabe der Zusammenfassung
print(f"Zeitraum: Von {start_zeitpunkt} bis {end_zeitpunkt}")
print(f"Gesamtkosten der Energieverwendung: {gesamtkosten:.2f} Euro")
print(f"Gesamtverbrauch: {gesamtverbrauch:.2f} kWh")

# Berechnen Sie die kumulierte Summe der Kosten
verbrauchsdaten['Kumulierte_Kosten'] = verbrauchsdaten['Kosten_pro_Sek'].cumsum()
print('Berechnung Energy Cost  sucessfull')

 # %%
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.patches import Patch 
import numpy as np
fig,ax1 = plt.subplots(figsize=(10,6))

#Zeichnen Sie den Verbrauch in kW
ax1 = plt.gca()
line1, =plt.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Verbrauch_Sum_kW'], color='black', label='Power consumption')
ax1.set_ylabel('Power in kW',fontsize=16)
ax1.tick_params(axis='y', colors='black')
ax1.tick_params(axis='both', which='major', labelsize=16)

#Zweite Y-Achse für den Preis pro kWh
ax2 = ax1.twinx()
line2, = ax2.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Preis_kWh'], color='gray', label='Energy price', linestyle='--')
ax2.set_ylabel('Price in  €/kWh',fontsize=16)
ax2.tick_params(axis='y', colors='gray')
ax2.tick_params(axis='both', which='major', labelsize=16)
ax2.spines['right'].set_position(('outward', 60)) 

#Kumulierte Kosten als Flächendiagramm
ax3 = ax1.twinx()
# ax3.spines['right'].set_position(('outward',60))
ax3.fill_between(verbrauchsdaten['Timestamp'], verbrauchsdaten['Kumulierte_Kosten'], color='lightgray', alpha=0.5)
ax3.set_ylabel('Accumulated costs in €',fontsize=16)
ax3.tick_params(axis='both', which='major', labelsize=16)

# Anpassen der Skalierung der Y-Achse für kumulierte Kosten
y_min_kosten = 0  # Setzen Sie dies auf einen geeigneten Wert
y_max_kosten = verbrauchsdaten['Kumulierte_Kosten'].max() * 1.1  # 10% höher als das Maximum
ax3.set_ylim(y_min_kosten, y_max_kosten)

# # Legende unterhalb des Plots
# ax1.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=2)
# ax2.legend(loc='upper center', bbox_to_anchor=(0.5, -0.2), ncol=2)

# Kombinierte Legende erstellen
combined_handles = [line1, line2, Patch(facecolor='lightgray', edgecolor='black', label='Costs')]
combined_labels = [line1.get_label(), line2.get_label(), 'Costs']
ax1.legend(combined_handles, combined_labels, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3,fontsize=16)

#Einstellungen für die X-Achse
plt.gca().set_xlim([pd.Timestamp('2023-08-31 07:55:00'), pd.Timestamp('2023-08-31 10:05:00')])
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.gca().xaxis.set_major_locator(mdates.MinuteLocator(interval=15))
plt.gca().xaxis.set_minor_locator(mdates.MinuteLocator(interval=5))

plt.gcf().autofmt_xdate()

#Z-order festlegen, um die Zeichnungsreihenfolge zu steuern
ax1.set_zorder(ax2.get_zorder() + 1)  # Stellt ax1 über ax2
ax1.patch.set_visible(False)  # Verhindert, dass ax1 die ax2 verdeckt

#plt.title('Energy consumption, price and costs')
fig.tight_layout()
#plt.savefig('energycost_orginal.svg', format='svg')
#plt.savefig('energycost_orginal.png')
plt.show()


print("Referenzlastgang kosten Plot Erstellt")



########################################################################################################################
################################################################################
####################################################################################################
# %% 
# Energiekosten und Erlöse durch  Dauerbetrieb 31.08.23. 08:00 Uhr


import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

import matplotlib
# matplotlib.use('pgf')
# matplotlib.rcParams.update({
#     'pgf.texsystem': 'pdflatex',
#     'font.family': 'lmodern',
#     'text.usetex': True,
#     'pgf.rcfonts': False,
#     'font.size': 8,
# })

# Laden der Daten in Watt
verbrauchsdaten = pd.read_csv('Data310823_merge.csv')
strompreise = pd.read_csv('energyprice_clean_082023.csv')
simulierte_daten= pd.read_csv('simulated_machine_data_2h_30teile.csv')
#Chiller in kW
chiller_data = pd.read_csv('Merge_chiller_15_310823.csv')
chiller_power =  chiller_data['WKM_eCH45150Leistung_elek_aktuell'].iloc[2500:12500]


def ersetze_pges(verbrauchsdaten, simulierte_daten, chiller_power, startzeitpunkt, frequenz):
    # Erstelle einen neuen Zeitstempelvektor für die simulierten Daten
    simulierte_daten['Timestamp'] = pd.date_range(start=startzeitpunkt, periods=len(simulierte_daten), freq=frequenz)
        
    # Vergleiche die Länge der Datensätze und kürze die simulierten Daten, falls notwendig
    if len(simulierte_daten) > len(verbrauchsdaten):
        simulierte_daten = simulierte_daten.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    
    chiller_power = chiller_power.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    # Ersetze die 'Pges' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Pges'] = simulierte_daten['Pges']
    verbrauchsdaten['Chiller_Power'] = chiller_power
    # Ersetze die 'Timestamp' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Timestamp'] = simulierte_daten['Timestamp']
    
    return verbrauchsdaten

# Angenommener Startzeitpunkt
startzeitpunkt = '2023-08-31 08:00:00'
# startzeitpunkt = '2023-08-31 06:00:00'
#startzeitpunkt = verbrauchsdaten['Timestamp'].iloc[0]
frequenz = '1S'  # oder '15T' für 15 Minuten, '1H' für eine Stunde, etc.

verbrauchsdaten = ersetze_pges(verbrauchsdaten, simulierte_daten,chiller_power, startzeitpunkt, frequenz)


# Umwandlung der Zeitstempel in datetime
verbrauchsdaten['Timestamp'] = pd.to_datetime(verbrauchsdaten['Timestamp'])
strompreise['Time'] = pd.to_datetime(strompreise['Time'])

# plt.plot(verbrauchsdaten['Timestamp'],verbrauchsdaten['Pges'])
# plt.show()

# Umrechnung von Watt in Kilowatt
verbrauchsdaten['Pges_kW'] = verbrauchsdaten['Pges'] / 1000  # Umrechnung in kW

# Gesamtverbrauch
verbrauchsdaten['Verbrauch_Sum_kW'] = (verbrauchsdaten['Pges_kW'] + verbrauchsdaten['Chiller_Power'])
#verbrauchsdaten['Verbrauch_Sum_kW'] =  verbrauchsdaten['Chiller_Power']
#verbrauchsdaten['Verbrauch_Sum_kW'] = verbrauchsdaten['Pges_kW'] 

gesamtverbrauch = verbrauchsdaten['Verbrauch_Sum_kW'].sum() / 3600  # Gesamtverbrauch in kWh

# Umrechnung der Strompreise von Euro/MWh in Euro/kWh
strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Day_Ahead_DE_LU_60min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Intraday_DE_LU_15min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Continuous_DE_LU_15min'] / 1000


# Zuordnung der Strompreise zu den Verbrauchsdaten
verbrauchsdaten['Preis_kWh'] = verbrauchsdaten['Timestamp'].apply(
    lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
)

# Berechnung der Kosten pro Sekunde und Summierung für Gesamtkosten
verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Verbrauch_Sum_kW'] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde

gesamtkosten = verbrauchsdaten['Kosten_pro_Sek'].sum()


# # Gesamtzeitraum
start_zeitpunkt = verbrauchsdaten['Timestamp'].min()
end_zeitpunkt = verbrauchsdaten['Timestamp'].max()

# Ausgabe der Zusammenfassung
print(f"Zeitraum: Von {start_zeitpunkt} bis {end_zeitpunkt}")
print(f"Gesamtkosten der Energieverwendung: {gesamtkosten:.2f} Euro")
print(f"Gesamtverbrauch: {gesamtverbrauch:.2f} kWh")

# Berechnen Sie die kumulierte Summe der Kosten
verbrauchsdaten['Kumulierte_Kosten'] = verbrauchsdaten['Kosten_pro_Sek'].cumsum()


# Funktion zur Berechnung der Flexibilitätserlöse
def berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung_in_stunden):
    """
    Berechnet die Flexibilitätserlöse durch Lastverschiebung von Maschinen.
    """
    verbrauchsdaten['Verschobener_Timestamp'] = verbrauchsdaten['Timestamp'] + pd.Timedelta(hours=verschiebung_in_stunden)
    verbrauchsdaten['Verschobener_Preis_kWh'] = verbrauchsdaten['Verschobener_Timestamp'].apply(
        lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
    )
    verbrauchsdaten['Kosten_nach_Verschiebung'] = verbrauchsdaten['Verbrauch_Sum_kW']* verbrauchsdaten['Verschobener_Preis_kWh'] / 3600
    verbrauchsdaten['Ersparnis'] = verbrauchsdaten['Kosten_pro_Sek'] - verbrauchsdaten['Kosten_nach_Verschiebung']
    flexibilitaetserloese = verbrauchsdaten['Ersparnis'].sum()
    return flexibilitaetserloese

# Berechnung der Flexibilitätserlöse durch Lastverschiebung um 0 Stunden
verschiebung = 0 # in h
flexibilitaetserloese = berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung)
print(f"Flexibilitätserlöse durch Lastverschiebung: {flexibilitaetserloese:.2f} Euro")



import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.patches import Patch 
import numpy as np
fig,ax1 = plt.subplots(figsize=(10,6))

#Zeichnen Sie den Verbrauch in kW
ax1 = plt.gca()
line1,  = plt.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Verbrauch_Sum_kW'], color='black', label='Power consumption')
ax1.set_ylabel('Power in kW',fontsize=16)
ax1.tick_params(axis='y', colors='black')
ax1.tick_params(axis='both', which='major', labelsize=16)

#Zweite Y-Achse für den Preis pro kWh
ax2 = ax1.twinx()
ax2.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Preis_kWh'], color='gray', label='Energy price', linestyle='--')
ax2.set_ylabel('Price in  €/kWh',fontsize=16)
ax2.tick_params(axis='y', colors='gray')
ax2.tick_params(axis='both', which='major', labelsize=16)
ax2.spines['right'].set_position(('outward', 60)) 

#Kumulierte Kosten als Flächendiagramm
ax3 = ax1.twinx()
# ax3.spines['right'].set_position(('outward',60))
ax3.fill_between(verbrauchsdaten['Timestamp'], verbrauchsdaten['Kumulierte_Kosten'], color='lightgray', alpha=0.5)
ax3.set_ylabel('Accumulated costs in €',fontsize=16)
ax3.tick_params(axis='both', which='major', labelsize=16)
# Anpassen der Skalierung der Y-Achse für kumulierte Kosten
y_min_kosten = 0  # Setzen Sie dies auf einen geeigneten Wert
y_max_kosten = verbrauchsdaten['Kumulierte_Kosten'].max() * 1.1  # 10% höher als das Maximum
ax3.set_ylim(y_min_kosten, y_max_kosten)

# Kombinierte Legende erstellen
combined_handles = [line1, line2, Patch(facecolor='lightgray', edgecolor='black', label='Costs')]
combined_labels = [line1.get_label(), line2.get_label(), 'Costs']
ax1.legend(combined_handles, combined_labels, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3,fontsize=16)

#Einstellungen für die X-Achse
plt.gca().set_xlim([pd.Timestamp('2023-08-31 07:55:00'), pd.Timestamp('2023-08-31 10:05:00')])
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.gca().xaxis.set_major_locator(mdates.MinuteLocator(interval=15))
plt.gca().xaxis.set_minor_locator(mdates.MinuteLocator(interval=5))
plt.gcf().autofmt_xdate()

#Z-order festlegen, um die Zeichnungsreihenfolge zu steuern
ax1.set_zorder(ax2.get_zorder() + 1)  # Stellt ax1 über ax2
ax1.patch.set_visible(False)  # Verhindert, dass ax1 die ax2 verdeckt

#plt.title('Energy consumption, price and costs')
fig.tight_layout()
#plt.savefig('energycost_flex_gt_kompakt.svg', format='svg')
#plt.savefig('energycost_flex_gt_kompakt.png')
plt.show()

print("Plot Kompakte Produktion Erstellt")


# %% 
# Energiekosten und Erlöse durch  Dauerbetrieb 31.08.23. 12:00 Uhr


import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

import matplotlib
# matplotlib.use('pgf')
# matplotlib.rcParams.update({
#     'pgf.texsystem': 'pdflatex',
#     'font.family': 'lmodern',
#     'text.usetex': True,
#     'pgf.rcfonts': False,
#     'font.size': 8,
# })

# Laden der Daten in Watt
verbrauchsdaten = pd.read_csv('Data310823_merge.csv')
strompreise = pd.read_csv('energyprice_clean_082023.csv')
simulierte_daten= pd.read_csv('simulated_machine_data_2h_30teile.csv')
#Chiller in kW
chiller_data = pd.read_csv('Merge_chiller_15_310823.csv')
chiller_power =  chiller_data['WKM_eCH45150Leistung_elek_aktuell'].iloc[2500:12500]


def ersetze_pges(verbrauchsdaten, simulierte_daten, chiller_power, startzeitpunkt, frequenz):
    # Erstelle einen neuen Zeitstempelvektor für die simulierten Daten
    simulierte_daten['Timestamp'] = pd.date_range(start=startzeitpunkt, periods=len(simulierte_daten), freq=frequenz)
        
    # Vergleiche die Länge der Datensätze und kürze die simulierten Daten, falls notwendig
    if len(simulierte_daten) > len(verbrauchsdaten):
        simulierte_daten = simulierte_daten.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    
    chiller_power = chiller_power.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    # Ersetze die 'Pges' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Pges'] = simulierte_daten['Pges']
    verbrauchsdaten['Chiller_Power'] = chiller_power
    # Ersetze die 'Timestamp' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Timestamp'] = simulierte_daten['Timestamp']
    
    return verbrauchsdaten

# Angenommener Startzeitpunkt
startzeitpunkt = '2023-08-31 12:00:00'
# startzeitpunkt = '2023-08-31 06:00:00'
#startzeitpunkt = verbrauchsdaten['Timestamp'].iloc[0]
frequenz = '1S'  # oder '15T' für 15 Minuten, '1H' für eine Stunde, etc.

verbrauchsdaten = ersetze_pges(verbrauchsdaten, simulierte_daten,chiller_power, startzeitpunkt, frequenz)


# Umwandlung der Zeitstempel in datetime
verbrauchsdaten['Timestamp'] = pd.to_datetime(verbrauchsdaten['Timestamp'])
strompreise['Time'] = pd.to_datetime(strompreise['Time'])

# plt.plot(verbrauchsdaten['Timestamp'],verbrauchsdaten['Pges'])
# plt.show()

# Umrechnung von Watt in Kilowatt
verbrauchsdaten['Pges_kW'] = verbrauchsdaten['Pges'] / 1000  # Umrechnung in kW

# Gesamtverbrauch
verbrauchsdaten['Verbrauch_Sum_kW'] = (verbrauchsdaten['Pges_kW'] + verbrauchsdaten['Chiller_Power'])
#verbrauchsdaten['Verbrauch_Sum_kW'] =  verbrauchsdaten['Chiller_Power']
#verbrauchsdaten['Verbrauch_Sum_kW'] = verbrauchsdaten['Pges_kW'] 

gesamtverbrauch = verbrauchsdaten['Verbrauch_Sum_kW'].sum() / 3600  # Gesamtverbrauch in kWh

# Umrechnung der Strompreise von Euro/MWh in Euro/kWh
strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Day_Ahead_DE_LU_60min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Intraday_DE_LU_15min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Continuous_DE_LU_15min'] / 1000


# Zuordnung der Strompreise zu den Verbrauchsdaten
verbrauchsdaten['Preis_kWh'] = verbrauchsdaten['Timestamp'].apply(
    lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
)

# Berechnung der Kosten pro Sekunde und Summierung für Gesamtkosten
verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Verbrauch_Sum_kW'] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde
#verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Pges_kW'] + verbrauchsdaten[] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde

gesamtkosten = verbrauchsdaten['Kosten_pro_Sek'].sum()


# # Gesamtzeitraum
start_zeitpunkt = verbrauchsdaten['Timestamp'].min()
end_zeitpunkt = verbrauchsdaten['Timestamp'].max()

# Ausgabe der Zusammenfassung
print(f"Zeitraum: Von {start_zeitpunkt} bis {end_zeitpunkt}")
print(f"Gesamtkosten der Energieverwendung: {gesamtkosten:.2f} Euro")
print(f"Gesamtverbrauch: {gesamtverbrauch:.2f} kWh")

# Berechnen Sie die kumulierte Summe der Kosten
verbrauchsdaten['Kumulierte_Kosten'] = verbrauchsdaten['Kosten_pro_Sek'].cumsum()


# Funktion zur Berechnung der Flexibilitätserlöse
def berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung_in_stunden):
    """
    Berechnet die Flexibilitätserlöse durch Lastverschiebung von Maschinen.
    """
    verbrauchsdaten['Verschobener_Timestamp'] = verbrauchsdaten['Timestamp'] + pd.Timedelta(hours=verschiebung_in_stunden)
    verbrauchsdaten['Verschobener_Preis_kWh'] = verbrauchsdaten['Verschobener_Timestamp'].apply(
        lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
    )
    verbrauchsdaten['Kosten_nach_Verschiebung'] = verbrauchsdaten['Verbrauch_Sum_kW']* verbrauchsdaten['Verschobener_Preis_kWh'] / 3600
    verbrauchsdaten['Ersparnis'] = verbrauchsdaten['Kosten_pro_Sek'] - verbrauchsdaten['Kosten_nach_Verschiebung']
    flexibilitaetserloese = verbrauchsdaten['Ersparnis'].sum()
    return flexibilitaetserloese

# Berechnung der Flexibilitätserlöse durch Lastverschiebung um 0 Stunden
verschiebung = 0 # in h
flexibilitaetserloese = berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung)
print(f"Flexibilitätserlöse durch Lastverschiebung: {flexibilitaetserloese:.2f} Euro")


# %%
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.patches import Patch 
import numpy as np
fig,ax1 = plt.subplots(figsize=(10,6))

#Zeichnen Sie den Verbrauch in kW
ax1 = plt.gca()
line1,= plt.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Verbrauch_Sum_kW'], color='black', label='Power consumption')
ax1.set_ylabel('Power in kW',fontsize=16)
ax1.tick_params(axis='y', colors='black')
ax1.tick_params(axis='both', which='major', labelsize=16)

#Zweite Y-Achse für den Preis pro kWh
ax2 = ax1.twinx()
line2, = ax2.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Preis_kWh'], color='gray', label='Energy price', linestyle='--')
ax2.set_ylabel('Price in  €/kWh',fontsize=16)
ax2.tick_params(axis='y', colors='gray')
ax2.tick_params(axis='both', which='major', labelsize=16)
ax2.spines['right'].set_position(('outward', 60)) 

#Kumulierte Kosten als Flächendiagramm
ax3 = ax1.twinx()
# ax3.spines['right'].set_position(('outward',60))
ax3.fill_between(verbrauchsdaten['Timestamp'], verbrauchsdaten['Kumulierte_Kosten'], color='lightgray', alpha=0.5)
ax3.set_ylabel('Accumulated costs in €',fontsize=16)
ax3.tick_params(axis='both', which='major', labelsize=16)

# Anpassen der Skalierung der Y-Achse für kumulierte Kosten
y_min_kosten = 0  # Setzen Sie dies auf einen geeigneten Wert
y_max_kosten = verbrauchsdaten['Kumulierte_Kosten'].max() * 1.1  # 10% höher als das Maximum
ax3.set_ylim(y_min_kosten, y_max_kosten)

# Kombinierte Legende erstellen
combined_handles = [line1, line2, Patch(facecolor='lightgray', edgecolor='black', label='Costs')]
combined_labels = [line1.get_label(), line2.get_label(), 'Costs']
ax1.legend(combined_handles, combined_labels, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3,fontsize=16)


#Einstellungen für die X-Achse
plt.gca().set_xlim([pd.Timestamp('2023-08-31 11:55:00'), pd.Timestamp('2023-08-31 14:05:00')])
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.gca().xaxis.set_major_locator(mdates.MinuteLocator(interval=15))
plt.gca().xaxis.set_minor_locator(mdates.MinuteLocator(interval=5))

plt.gcf().autofmt_xdate()

#Z-order festlegen, um die Zeichnungsreihenfolge zu steuern
ax1.set_zorder(ax2.get_zorder() + 1)  # Stellt ax1 über ax2
ax1.patch.set_visible(False)  # Verhindert, dass ax1 die ax2 verdeckt

#plt.title('Energy consumption, price and costs')
fig.tight_layout()
#plt.savefig('energycost_flex_4hshift.svg', format='svg')
#plt.savefig('energycost_flex_4hshift.png')
plt.show()


print("Plot Kompakte Produktion verschoben um 4h auf 12 Uhr day aheadmarkt  Erstellt")


# %%
# Energiekosten und Erlöse durch  Dauerbetrieb  intraday 31.08.23. 12:00 Uhr


import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

import matplotlib


# Laden der Daten in Watt
verbrauchsdaten = pd.read_csv('Data310823_merge.csv')
strompreise = pd.read_csv('energyprice_clean_082023.csv')
simulierte_daten= pd.read_csv('simulated_machine_data_2h_30teile.csv')
#Chiller in kW
chiller_data = pd.read_csv('Merge_chiller_15_310823.csv')
chiller_power =  chiller_data['WKM_eCH45150Leistung_elek_aktuell'].iloc[2500:12500]


def ersetze_pges(verbrauchsdaten, simulierte_daten, chiller_power, startzeitpunkt, frequenz):
    # Erstelle einen neuen Zeitstempelvektor für die simulierten Daten
    simulierte_daten['Timestamp'] = pd.date_range(start=startzeitpunkt, periods=len(simulierte_daten), freq=frequenz)
        
    # Vergleiche die Länge der Datensätze und kürze die simulierten Daten, falls notwendig
    if len(simulierte_daten) > len(verbrauchsdaten):
        simulierte_daten = simulierte_daten.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    
    chiller_power = chiller_power.iloc[:len(verbrauchsdaten)].reset_index(drop=True)
    # Ersetze die 'Pges' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Pges'] = simulierte_daten['Pges']
    verbrauchsdaten['Chiller_Power'] = chiller_power
    # Ersetze die 'Timestamp' Spalte in den Verbrauchsdaten mit den Werten aus den simulierten Daten
    verbrauchsdaten['Timestamp'] = simulierte_daten['Timestamp']
    
    return verbrauchsdaten

# Angenommener Startzeitpunkt
startzeitpunkt = '2023-08-31 12:00:00'
# startzeitpunkt = '2023-08-31 06:00:00'
#startzeitpunkt = verbrauchsdaten['Timestamp'].iloc[0]
frequenz = '1S'  # oder '15T' für 15 Minuten, '1H' für eine Stunde, etc.

verbrauchsdaten = ersetze_pges(verbrauchsdaten, simulierte_daten,chiller_power, startzeitpunkt, frequenz)


# Umwandlung der Zeitstempel in datetime
verbrauchsdaten['Timestamp'] = pd.to_datetime(verbrauchsdaten['Timestamp'])
strompreise['Time'] = pd.to_datetime(strompreise['Time'])

# plt.plot(verbrauchsdaten['Timestamp'],verbrauchsdaten['Pges'])
# plt.show()

# Umrechnung von Watt in Kilowatt
verbrauchsdaten['Pges_kW'] = verbrauchsdaten['Pges'] / 1000  # Umrechnung in kW

# Gesamtverbrauch
verbrauchsdaten['Verbrauch_Sum_kW'] = (verbrauchsdaten['Pges_kW'] + verbrauchsdaten['Chiller_Power'])
#verbrauchsdaten['Verbrauch_Sum_kW'] =  verbrauchsdaten['Chiller_Power']
#verbrauchsdaten['Verbrauch_Sum_kW'] = verbrauchsdaten['Pges_kW'] 

gesamtverbrauch = verbrauchsdaten['Verbrauch_Sum_kW'].sum() / 3600  # Gesamtverbrauch in kWh

# Umrechnung der Strompreise von Euro/MWh in Euro/kWh
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Day_Ahead_DE_LU_60min'] / 1000
#strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Auction_Intraday_DE_LU_15min'] / 1000
strompreise['Preis_kWh'] = strompreise['Strompreis_EPEX_SPOT_Continuous_DE_LU_15min'] / 1000


# Zuordnung der Strompreise zu den Verbrauchsdaten
verbrauchsdaten['Preis_kWh'] = verbrauchsdaten['Timestamp'].apply(
    lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
)

# Berechnung der Kosten pro Sekunde und Summierung für Gesamtkosten
verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Verbrauch_Sum_kW'] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde
#verbrauchsdaten['Kosten_pro_Sek'] = verbrauchsdaten['Pges_kW'] + verbrauchsdaten[] * verbrauchsdaten['Preis_kWh'] / 3600  # Kosten pro Sekunde

gesamtkosten = verbrauchsdaten['Kosten_pro_Sek'].sum()


# # Gesamtzeitraum
start_zeitpunkt = verbrauchsdaten['Timestamp'].min()
end_zeitpunkt = verbrauchsdaten['Timestamp'].max()

# Ausgabe der Zusammenfassung
print(f"Zeitraum: Von {start_zeitpunkt} bis {end_zeitpunkt}")
print(f"Gesamtkosten der Energieverwendung: {gesamtkosten:.2f} Euro")
print(f"Gesamtverbrauch: {gesamtverbrauch:.2f} kWh")

# Berechnen Sie die kumulierte Summe der Kosten
verbrauchsdaten['Kumulierte_Kosten'] = verbrauchsdaten['Kosten_pro_Sek'].cumsum()


# Funktion zur Berechnung der Flexibilitätserlöse
def berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung_in_stunden):
    """
    Berechnet die Flexibilitätserlöse durch Lastverschiebung von Maschinen.
    """
    verbrauchsdaten['Verschobener_Timestamp'] = verbrauchsdaten['Timestamp'] + pd.Timedelta(hours=verschiebung_in_stunden)
    verbrauchsdaten['Verschobener_Preis_kWh'] = verbrauchsdaten['Verschobener_Timestamp'].apply(
        lambda x: strompreise[(strompreise['Time'] <= x)]['Preis_kWh'].iloc[-1]
    )
    verbrauchsdaten['Kosten_nach_Verschiebung'] = verbrauchsdaten['Verbrauch_Sum_kW']* verbrauchsdaten['Verschobener_Preis_kWh'] / 3600
    verbrauchsdaten['Ersparnis'] = verbrauchsdaten['Kosten_pro_Sek'] - verbrauchsdaten['Kosten_nach_Verschiebung']
    flexibilitaetserloese = verbrauchsdaten['Ersparnis'].sum()
    return flexibilitaetserloese

# Berechnung der Flexibilitätserlöse durch Lastverschiebung um 0 Stunden
verschiebung = 0 # in h
flexibilitaetserloese = berechne_flexibilitaetserloese(verbrauchsdaten, strompreise, verschiebung)
print(f"Flexibilitätserlöse durch Lastverschiebung: {flexibilitaetserloese:.2f} Euro")


# %% 
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.patches import Patch 
import numpy as np
fig,ax1 = plt.subplots(figsize=(10,6))

#Zeichnen Sie den Verbrauch in kW
ax1 = plt.gca()
line1, = plt.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Verbrauch_Sum_kW'], color='black', label='Power consumption')
ax1.set_ylabel('Power in kW',fontsize=16)
ax1.tick_params(axis='y', colors='black')
ax1.tick_params(axis='both', which='major', labelsize=16)

#Zweite Y-Achse für den Preis pro kWh
ax2 = ax1.twinx()
ax2.plot(verbrauchsdaten['Timestamp'], verbrauchsdaten['Preis_kWh'], color='gray', label='Energy price', linestyle='--')
ax2.set_ylabel('Price in  €/kWh',fontsize=16)
ax2.tick_params(axis='y', colors='gray')
ax2.tick_params(axis='both', which='major', labelsize=16)
ax2.spines['right'].set_position(('outward', 60)) 

#Kumulierte Kosten als Flächendiagramm
ax3 = ax1.twinx()
# ax3.spines['right'].set_position(('outward',60))
ax3.fill_between(verbrauchsdaten['Timestamp'], verbrauchsdaten['Kumulierte_Kosten'], color='lightgray', alpha=0.5)
ax3.set_ylabel('Accumulated costs in €',fontsize=16)
ax3.tick_params(axis='both', which='major', labelsize=16)

# Anpassen der Skalierung der Y-Achse für kumulierte Kosten
y_min_kosten = 0  # Setzen Sie dies auf einen geeigneten Wert
y_max_kosten = verbrauchsdaten['Kumulierte_Kosten'].max() * 1.1  # 10% höher als das Maximum
ax3.set_ylim(y_min_kosten, y_max_kosten)

# Kombinierte Legende erstellen
combined_handles = [line1, line2, Patch(facecolor='lightgray', edgecolor='black', label='Costs')]
combined_labels = [line1.get_label(), line2.get_label(), 'Costs']
ax1.legend(combined_handles, combined_labels, loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=3,fontsize=16)

#Einstellungen für die X-Achse
plt.gca().set_xlim([pd.Timestamp('2023-08-31 11:55:00'), pd.Timestamp('2023-08-31 14:05:00')])
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.gca().xaxis.set_major_locator(mdates.MinuteLocator(interval=15))
plt.gca().xaxis.set_minor_locator(mdates.MinuteLocator(interval=5))

#Z-order festlegen, um die Zeichnungsreihenfolge zu steuern
ax1.set_zorder(ax2.get_zorder() + 1)  # Stellt ax1 über ax2
ax1.patch.set_visible(False)  # Verhindert, dass ax1 die ax2 verdeckt

#plt.title('Energy consumption, price and costs')
fig.tight_layout()
#plt.savefig('energycost_flex_4hshift_intraday.svg', format='svg')
#plt.savefig('energycost_flex_4hshift_intraday.png')
plt.show()


print("Plot Kompakte Produktion verschoben um 4 auf 12 uhr  am intraday Erstellt")

