Upload 11 files

.gitattributes

@@ -0,0 +1,2 @@
+Input_Jahr_2023.xlsx filter=lfs diff=lfs merge=lfs -text
+model_data.pkl filter=lfs diff=lfs merge=lfs -text

Input_Jahr_2023.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:071c0d7133608f15f5daf16663cd7cbd172113d50fc9ec6026fa40f9f7d91128
+size 1050705

app.py

@@ -0,0 +1,1253 @@
+# -*- coding: utf-8 -*-
+"""
+Energy system optimization model
+
+HEMF EWL: Christopher Jahns, Julian Radek, Hendrik Kramer, Cornelia Klüter, Yannik Pflugfelder
+"""
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from io import BytesIO
+import xlsxwriter
+from linopy import Model
+import sourced as src
+import time
+
+
+# Main function to run the Streamlit app
+def main():
+    """
+    Main function to set up and solve the energy system optimization model, and handle user inputs and outputs.
+    """
+    setup_page()
+
+    settings = load_settings()
+
+    # fill session space with variables that are needed on all pages
+    if 'settings' not in st.session_state:
+        st.session_state.df = load_settings()
+    st.session_state.settings = settings   
+     
+    if 'url_excel' not in st.session_state:
+        st.session_state.url_excel = None
+
+    if 'ui_model' not in st.session_state:
+        st.session_state.url_excel = None
+        
+    if 'output' not in st.session_state:
+        st.session_state.output = BytesIO()
+
+
+    setup_sidebar(st.session_state.settings["df"])
+
+
+    
+    # # Navigation
+    # pg = st.navigation([st.Page(page_model, title=st.session_state.settings["df"].loc['menu_modell',st.session_state.lang], icon="📊"), 
+    #                      st.Page(page_documentation, title=st.session_state.settings["df"].loc['menu_doku',st.session_state.lang], icon="📓"), 
+    #                      st.Page(page_about_us, title=st.session_state.settings["df"].loc['menu_impressum',st.session_state.lang], icon="💬")],
+    #                    expanded=True)
+    
+    # # # Run the app
+    # pg.run()
+    
+    # Create tabs for navigation
+    tabs = st.tabs([
+        st.session_state.settings["df"].loc['menu_modell', st.session_state.lang],
+        st.session_state.settings["df"].loc['menu_doku', st.session_state.lang],
+        st.session_state.settings["df"].loc['menu_impressum', st.session_state.lang]
+    ])
+
+    # Load and display content based on the selected tab
+    with tabs[0]:  # Model page
+        page_model()
+    with tabs[1]:  # Documentation page
+        page_documentation()
+    with tabs[2]:  # About Us page
+        page_about_us()
+   
+
+
+
+# Load settings and initial configurations
+def load_settings():
+    """
+    Load settings for the app, including colors and language information.
+    """
+    settings = {
+        'write_pickle_from_standard_excel': True,
+        'df': pd.read_csv("language.csv", encoding="iso-8859-1", index_col="Label", sep=";"),
+        'color_dict': {
+            'Biomass': 'lightgreen',
+            'Lignite': 'saddlebrown',
+            'Fossil Hard coal': 'chocolate',  # Ein Braunton ähnlich Lignite
+            'Fossil Oil': 'black',
+            'CCGT': 'lightgray',  # Hellgrau
+            'OCGT': 'darkgray',   # Dunkelgrau
+            'RoR': 'aquamarine',
+            'Hydro Water Reservoir': 'lightsteelblue',
+            'Nuclear': 'gold',
+            'PV': 'yellow',
+            'WindOff': 'darkblue',
+            'WindOn': 'green',
+            'H2': 'tomato',
+            'Pumped Hydro Storage': 'skyblue',
+            'Battery storages': 'firebrick',
+            'Electrolyzer': 'yellowgreen'
+        },
+        'colors': {
+            'hemf_blau_dunkel': "#00386c",
+            'hemf_blau_hell': "#00529f",
+            'hemf_rot_dunkel': "#8b310d",
+            'hemf_rot_hell': "#d04119",
+            'hemf_grau': "#dadada"
+        }
+    }
+    return settings
+
+# Initialize Streamlit app
+def setup_page():
+    """
+    Set up the Streamlit page with a specific layout, title, and favicon.
+    """
+    st.set_page_config(layout="wide", page_title="Investment tool", page_icon="media/favicon.ico", initial_sidebar_state="expanded")
+
+
+# Sidebar for language and links
+def setup_sidebar(df):
+    """
+    Set up the sidebar with language options and external links.
+    """
+    st.session_state.lang = st.sidebar.selectbox("Language", ["🇬🇧  EN", "🇩🇪  DE"], key="foo", label_visibility="collapsed")[-2:]
+
+    st.sidebar.markdown("""
+    <style>
+        text-align: center;
+        display: block;
+        margin-left: auto;
+        margin-right: auto;
+        width: 100%;
+    </style>
+    """, unsafe_allow_html=True)
+
+    with st.sidebar:
+        left_co, cent_co, last_co = st.columns([0.1, 0.8, 0.1])
+        with cent_co:
+            st.text(" ")  # add vertical empty space
+            ""+df.loc['menu_text', st.session_state.lang]
+            st.text(" ")  # add vertical empty space
+
+            if st.session_state.lang == "DE":
+                st.write("Schaue vorbei beim")
+                st.markdown(r'[Lehrstuhl für Energiewirtschaft](https://www.ewl.wiwi.uni-due.de)', unsafe_allow_html=True)
+            elif st.session_state.lang == "EN":
+                st.write("Get in touch with the")
+                st.markdown(r'[Chair of Management Science and Energy Economics](https://www.ewl.wiwi.uni-due.de/en)', unsafe_allow_html=True)
+
+            st.text(" ")  # add vertical empty space
+            st.image("media/Logo_HEMF.svg", width=200)
+            st.image("media/Logo_UDE.svg", width=200)
+            
+            
+# Load model input data
+def load_model_input(df, write_pickle_from_standard_excel):
+    """
+    Load model input data from Excel or Pickle based on user input.
+    """
+    if st.session_state.url_excel is None:
+        if write_pickle_from_standard_excel:
+            url_excel = r'Input_Jahr_2023.xlsx'
+            sets_dict, params_dict = src.load_data_from_excel(url_excel, write_to_pickle_flag=True)
+        sets_dict, params_dict = src.load_from_pickle()
+        #st.write(df.loc['model_title1.1', st.session_state.lang])
+        # st.write('Running with standard data')
+    else:
+        url_excel = st.session_state.url_excel
+        sets_dict, params_dict = src.load_data_from_excel(url_excel, load_from_pickle_flag=False)
+        st.write(df.loc['model_title1.2', st.session_state.lang])
+
+    return sets_dict, params_dict
+
+
+
+def page_documentation():
+    """
+    Display documentation and mathematical model details.
+    """
+    
+    df = st.session_state.settings["df"]
+    
+    st.header(df.loc['constr_header1', st.session_state.lang])
+    st.write(df.loc['constr_header2', st.session_state.lang])
+    
+    col1, col2 = st.columns([6, 4])
+    
+    with col1:
+        st.header(df.loc['constr_header3', st.session_state.lang])
+        
+        with st.container():
+            
+            # Objective function
+            st.subheader(df.loc['constr_subheader_obj_func', st.session_state.lang])
+            st.write(df.loc['constr_subheader_obj_func_descr', st.session_state.lang])                
+            st.latex(r''' \text{min } C^{tot} = C^{op} + C^{inv}''')
+
+            # Operational costs minus revenue for produced hydrogen
+            st.write(df.loc['constr_c_op', st.session_state.lang])
+            st.latex(r''' C^{op} = \sum_{i} y_{t,i} \cdot \left( \frac{c^{fuel}_{i}}{\eta_i} + c_{i}^{other} \right) \cdot \Delta t - \sum_{i \in \mathcal{I}^{PtG}} y^{h2}_{t,i} \cdot p^{h2} \cdot \Delta t''')
+            
+            # Investment costs
+            st.write(df.loc['constr_c_inv', st.session_state.lang])           
+            st.latex(r''' C^{inv} = \sum_{i} a_{i} \cdot K_{i} \cdot c^{inv}_{i}''')
+            
+            # Constraints
+            st.subheader(df.loc['subheader_constr', st.session_state.lang])
+            
+            # Load-serving constraint
+            st.write(df.loc['constr_load_serve', st.session_state.lang])
+            st.latex(r''' \left( \sum_{i} y_{t,i} - \sum_{i} y_{t,i}^{ch} \right) \cdot \Delta t = D_t \cdot \Delta t, \quad \forall t \in \mathcal{T}''')
+            
+            # Maximum capacity limit
+            st.write(df.loc['constr_max_cap', st.session_state.lang])
+            st.latex(r''' y_{t,i} - K_{i} \leq K_{0,i}, \quad \forall i \in \mathcal{I}''')
+            
+            # Capacity limits for investment
+            st.write(df.loc['constr_inv_cap', st.session_state.lang])
+            st.latex(r''' K_{i} \leq 0, \quad \forall i \in \mathcal{I}^{no\_invest}''')
+            
+            # Prevent power production by PtG
+            st.write(df.loc['constr_prevent_ptg', st.session_state.lang])
+            st.latex(r''' y_{t,i} = 0, \quad \forall i \in \mathcal{I}^{PtG}''')
+            
+            # Prevent charging for non-storage technologies
+            st.write(df.loc['constr_prevent_chg', st.session_state.lang])
+            st.latex(r''' y_{t,i}^{ch} = 0, \quad \forall i \in \mathcal{I} \setminus \{ \mathcal{I}^{PtG} \cup \mathcal{I}^{Sto} \}''')
+            
+            # Maximum storage charging and discharging
+            st.write(df.loc['constr_max_chg', st.session_state.lang])
+            st.latex(r''' y_{t,i} + y_{t,i}^{ch} - K_{i} \leq K_{0,i}, \quad \forall i \in \mathcal{I}^{Sto}''')
+            
+            # Maximum electrolyzer capacity
+            st.write(df.loc['constr_max_cap_electrolyzer', st.session_state.lang])
+            st.latex(r''' y_{t,i}^{ch} - K_{i} \leq K_{0,i}, \quad \forall i \in \mathcal{I}^{PtG}''')
+            
+            # PtG H2 production
+            st.write(df.loc['constr_prod_ptg', st.session_state.lang])
+            st.latex(r''' y_{t,i}^{ch} \cdot \eta_i = y_{t,i}^{h2}, \quad \forall i \in \mathcal{I}^{PtG}''')
+            
+            # Infeed of renewables
+            st.write(df.loc['constr_inf_res', st.session_state.lang])
+            st.latex(r''' y_{t,i} + y_{t,i}^{curt} = s_{t,r,i} \cdot (K_{0,i} + K_i), \quad \forall i \in \mathcal{I}^{Res}''')
+            
+            # Maximum filling level restriction for storage power plants
+            st.write(df.loc['constr_max_fil_sto', st.session_state.lang])
+            # st.latex(r''' l_{t,i} \leq K_{0,i} \cdot e2p_i, \quad \forall i \in \mathcal{I}^{Sto}''')
+            st.latex(r''' l_{t,i} \leq (K_{0,i} + K_{i}) \cdot \gamma_i^{Sto}, \quad \forall i \in \mathcal{I}^{Sto}''')
+            
+            # Filling level restriction for hydro reservoir
+            st.write(df.loc['constr_fil_hyres', st.session_state.lang])
+            st.latex(r''' l_{t+1,i} = l_{t,i} + ( h_{t,i} - y_{t,i}) \cdot \Delta t, \quad \forall i \in \mathcal{I}^{HyRes}''')
+            
+            # Filling level restriction for other storages
+            st.write(df.loc['constr_fil_sto', st.session_state.lang])
+            st.latex(r''' l_{t+1,i} = l_{t,i} - \left(\frac{y_{t,i}}{\eta_i} - y_{t,i}^{ch} \cdot \eta_i \right) \cdot \Delta t, \quad \forall i \in \mathcal{I}^{Sto}''')
+            
+            # CO2 emission constraint
+            st.write(df.loc['constr_co2_lim', st.session_state.lang])
+            st.latex(r''' \sum_{t} \sum_{i} \frac{y_{t,i}}{\eta_i} \cdot \chi^{CO2}_i \cdot \Delta t \leq L^{CO2}''')
+
+            
+    with col2:
+        
+        symbols_container = st.container()
+        with symbols_container:
+            st.header(df.loc['symb_header1', st.session_state.lang])
+            st.write(df.loc['symb_header2', st.session_state.lang])
+            
+            st.subheader(df.loc['symb_header_sets', st.session_state.lang])          
+            st.write(f"$\mathcal{{T}}$: {df.loc['symb_time_steps', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}$: {df.loc['symb_tech', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{Sto}}}}$: {df.loc['symb_sto_tech', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{Conv}}}}$: {df.loc['symb_conv_tech', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{PtG}}}}$: {df.loc['symb_ptg', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{Res}}}}$: {df.loc['symb_res', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{HyRes}}}}$: {df.loc['symb_hyres', st.session_state.lang]}")
+            st.write(f"$\mathcal{{I}}^{{\\text{{no\_invest}}}}$: {df.loc['symb_no_inv', st.session_state.lang]}")
+
+
+            
+            # Variables section
+            st.subheader(df.loc['symb_header_variables', st.session_state.lang])          
+            st.write(f"$C^{{tot}}$: {df.loc['symb_tot_costs', st.session_state.lang]}")
+            st.write(f"$C^{{op}}$: {df.loc['symb_c_op', st.session_state.lang]}")
+            st.write(f"$C^{{inv}}$: {df.loc['symb_c_inv', st.session_state.lang]}")
+            st.write(f"$K_i$: {df.loc['symb_inst_cap', st.session_state.lang]}")
+            st.write(f"$y_{{t,i}}$: {df.loc['symb_el_prod', st.session_state.lang]}")
+            st.write(f"$y_{{t, i}}^{{ch}}$: {df.loc['symb_el_ch', st.session_state.lang]}")
+            st.write(f"$l_{{t,i}}$: {df.loc['symb_sto_fil', st.session_state.lang]}")
+            st.write(f"$y_{{t, i}}^{{curt}}$: {df.loc['symb_curt', st.session_state.lang]}")
+            st.write(f"$y_{{t, i}}^{{h2}}$: {df.loc['symb_h2_ptg', st.session_state.lang]}")
+
+            
+            # Parameters section
+            st.subheader(df.loc['symb_header_parameters', st.session_state.lang])
+            st.write(f"$D_t$: {df.loc['symb_energy_demand', st.session_state.lang]}")
+            st.write(f"$p^{{h2}}$: {df.loc['symb_price_h2', st.session_state.lang]}")
+            st.write(f"$c^{{fuel}}_{{i}}$: {df.loc['symb_fuel_costs', st.session_state.lang]}")
+            st.write(f"$c_{{i}}^{{other}}$: {df.loc['symb_c_op_other', st.session_state.lang]}")
+            st.write(f"$c^{{inv}}_{{i}}$: {df.loc['symb_c_inv_tech', st.session_state.lang]}")
+            st.write(f"$a_{{i}}$: {df.loc['symb_annuity', st.session_state.lang]}")
+            st.write(f"$\eta_i$: {df.loc['symb_eff_fac', st.session_state.lang]}")
+            st.write(f"$K_{{0,i}}$: {df.loc['symb_max_cap_tech', st.session_state.lang]}")
+            st.write(f"$\chi^{{CO2}}_i$: {df.loc['symb_co2_fac', st.session_state.lang]}")
+            st.write(f"$L^{{CO2}}$: {df.loc['symb_co2_limit', st.session_state.lang]}")
+            # st.write(f"$e2p_{{\\text{{Sto}}, i}}$: {df.loc['symb_etp', st.session_state.lang]}")
+            st.write(f"$\gamma^{{\\text{{Sto}}}}_{{i}}$: {df.loc['symb_etp', st.session_state.lang]}")
+            st.write(f"$s_{{t, r, i}}$: {df.loc['symb_res_supply', st.session_state.lang]}")
+            st.write(f"$h_{{t, i}}$: {df.loc['symb_hyRes_inflow', st.session_state.lang]}")
+    
+    # css = float_css_helper(top="50")        
+    # symbols_container.float(css)
+
+
+def page_about_us():
+    """
+    Display information about the team and the project.
+    """
+    st.write("About Us/Impressum")
+
+
+def page_model(): #, write_pickle_from_standard_excel, color_dict):    
+    """
+    Display the main model page for energy system optimization.
+
+    This function sets up the user interface for the model input parameters, loads data, and configures the 
+    optimization model before solving it and presenting the results.
+    """
+    
+    df = st.session_state.settings["df"]
+    color_dict = st.session_state.settings["color_dict"]
+    write_pickle_from_standard_excel = st.session_state.settings["write_pickle_from_standard_excel"]
+    
+    
+
+
+    # Load data from Excel or Pickle
+    sets_dict, params_dict = load_model_input(df, write_pickle_from_standard_excel)
+
+    # Unpack sets_dict into the workspace
+    t = sets_dict['t']
+    t_original = sets_dict['t']
+    i = sets_dict['i']
+    iSto = sets_dict['iSto']
+    iConv = sets_dict['iConv']
+    iPtG = sets_dict['iPtG']
+    iRes = sets_dict['iRes']
+    iHyRes = sets_dict['iHyRes']
+       
+    # Unpack params_dict into the workspace
+    l_co2 = params_dict['l_co2']
+    p_co2 = params_dict['p_co2']
+    eff_i = params_dict['eff_i']
+    life_i = params_dict['life_i']
+    c_fuel_i = params_dict['c_fuel_i']
+    c_other_i = params_dict['c_other_i']
+    c_inv_i = params_dict['c_inv_i']
+    co2_factor_i = params_dict['co2_factor_i']
+    K_0_i = params_dict['K_0_i']
+    e2p_iSto = params_dict['e2p_iSto']
+
+    # Adjust efficiency for storage technologies
+    eff_i.loc[iSto] = np.sqrt(eff_i.loc[iSto])  # Apply square root to cycle efficiency for storage technologies
+
+    # Create columns for UI layout
+    col1, col2 = st.columns([0.30, 0.70], gap="large")
+ 
+    # Load input data
+    with col1:
+        
+        st.title(df.loc['model_title1', st.session_state.lang])
+        
+        with open('Input_Jahr_2023.xlsx', 'rb') as f:
+            st.download_button(df.loc['model_title1.3',st.session_state.lang], f, file_name='Input_Jahr_2023.xlsx')  # Download button for Excel template
+        
+        with st.form("input_file"):
+
+        
+            st.session_state.url_excel = st.file_uploader(label=df.loc['model_title1.4',st.session_state.lang])  # File uploader for user Excel file
+        
+            #st.title(df.loc['model_title4', st.session_state.lang])
+ 
+            run_model_excel = st.form_submit_button(df.loc['model_run_info_excel', st.session_state.lang]) #, key="run_model_button", help=df.loc['run_model_button_info',st.session_state.lang])
+            #else:
+            #    run_model = st.button(df.loc['model_run_info_gui', st.session_state.lang], key="run_model_button", help=df.loc['run_model_button_info',st.session_state.lang])
+
+
+    
+
+
+    # Set up user interface for parameters
+    with col2:
+        
+        st.title(df.loc['model_title3', st.session_state.lang])
+
+
+    
+        with st.form("input_custom"):
+            
+            col1form, col2form, col3form = st.columns([0.25, 0.25, 0.50])
+        
+            # colum 1 form
+            l_co2 = col1form.slider(value=int(params_dict['l_co2']), min_value=0, max_value=750, label=df.loc['model_label_co2',st.session_state.lang], step=50)
+            price_h2 = col1form.slider(value=100, min_value=0, max_value=300, label=df.loc['model_label_h2',st.session_state.lang], step=10)
+            for i_idx in params_dict['c_fuel_i'].get_index('i'):
+                if i_idx in ['Lignite']:
+                    params_dict['c_fuel_i'].loc[i_idx] = col1form.slider(value=int(params_dict['c_fuel_i'].loc[i_idx]),
+                                                                       min_value=0, max_value=300, label=df.loc[f'model_label_{i_idx}',st.session_state.lang], step=10)
+            
+            # colum 1 form
+            for i_idx in params_dict['c_fuel_i'].get_index('i'):
+                if i_idx in ['Fossil Hard coal', 'Fossil Oil', 'CCGT']:
+                    params_dict['c_fuel_i'].loc[i_idx] = col2form.slider(value=int(params_dict['c_fuel_i'].loc[i_idx]),
+                                                                   min_value=0, max_value=300, label=df.loc[f'model_label_{i_idx}',st.session_state.lang], step=10)
+            params_dict['c_fuel_i'].loc['OCGT'] = params_dict['c_fuel_i'].loc['CCGT']
+            # Create a dictionary to map German names to English names
+            tech_mapping_de_to_en = {
+                df.loc[f'tech_{tech.lower()}', 'DE']: df.loc[f'tech_{tech.lower()}', 'EN']
+                for tech in sets_dict['i'] if f'tech_{tech.lower()}' in df.index
+            }
+            
+            # Set options and default values based on the selected language
+            if st.session_state.lang == 'DE':
+                # German options for the user interface
+                options = [
+                    df.loc[f'tech_{tech.lower()}', 'DE'] for tech in sets_dict['i'] if f'tech_{tech.lower()}' in df.index
+                ]
+                default = [
+                    df.loc[f'tech_{tech.lower()}', 'DE'] for tech in ['Lignite', 'CCGT', 'OCGT', 'Fossil Hard coal', 'Fossil Oil', 'PV', 'WindOff', 'WindOn', 'H2', 'Pumped Hydro Storage', 'Battery storages', 'Electrolyzer']
+                    if f'tech_{tech.lower()}' in df.index
+                ]
+            else:
+                # English options for the user interface
+                options = sets_dict['i']
+                default = ['Lignite', 'CCGT', 'OCGT', 'Fossil Hard coal', 'Fossil Oil', 'PV', 'WindOff', 'WindOn', 'H2', 'Pumped Hydro Storage', 'Battery storages', 'Electrolyzer']
+            
+            # Multiselect for technology options in the user interface
+            selected_technologies = col3form.multiselect(
+                label=df.loc['model_label_tech', st.session_state.lang],
+                options=options,
+                default=[tech for tech in default if tech in options]
+            )
+            
+            # If language is German, map selected German names back to their English equivalents
+            if st.session_state.lang == 'DE':
+                technologies_invest = [tech_mapping_de_to_en[tech] for tech in selected_technologies]
+            else:
+                technologies_invest = selected_technologies
+            
+            # Technologies that will not be invested in (based on English names)
+            technologies_no_invest = [tech for tech in sets_dict['i'] if tech not in technologies_invest]
+            
+            col4form, col5form = st.columns([0.25, 0.75])
+            dt = col4form.number_input(label=df.loc['model_label_t',st.session_state.lang], min_value=1, max_value=len(t), value=6,
+                                 help=df.loc['model_label_t_info',st.session_state.lang])
+            
+            run_model_manual = col5form.form_submit_button(df.loc['model_run_info_gui', st.session_state.lang])    
+
+            #run_model = st.button(df.loc['model_run_info_gui', st.session_state.lang], key="run_model_button", help=df.loc['run_model_button_info',st.session_state.lang])
+
+    st.markdown("-------")
+
+    # run_model_manual = True    
+        
+    if run_model_excel or run_model_manual:
+        # Model setup
+        
+        info_yellow_build = st.info(df.loc['label_build_model', st.session_state.lang])
+
+
+        if run_model_excel: # overwrite with excel values
+            #sets_dict, params_dict = load_model_input(df, write_pickle_from_standard_excel)
+            sets_dict, params_dict = src.load_data_from_excel(st.session_state.url_excel, write_to_pickle_flag=True)
+
+            # Unpack sets_dict into the workspace
+            t = sets_dict['t']
+            t_original = sets_dict['t']
+            i = sets_dict['i']
+            iSto = sets_dict['iSto']
+            iConv = sets_dict['iConv']
+            iPtG = sets_dict['iPtG']
+            iRes = sets_dict['iRes']
+            iHyRes = sets_dict['iHyRes']
+              
+            # Unpack params_dict into the workspace
+            l_co2 = params_dict['l_co2']
+            p_co2 = params_dict['p_co2']
+            eff_i = params_dict['eff_i']
+            # life_i = params_dict['life_i']
+            c_fuel_i = params_dict['c_fuel_i']
+            c_other_i = params_dict['c_other_i']
+            c_inv_i = params_dict['c_inv_i']
+            co2_factor_i = params_dict['co2_factor_i']
+            K_0_i = params_dict['K_0_i']
+            e2p_iSto = params_dict['e2p_iSto']
+       
+            # Adjust efficiency for storage technologies
+            eff_i.loc[iSto] = np.sqrt(eff_i.loc[iSto])  # Apply square root to cycle efficiency for storage technologies
+
+
+        # Time series aggregation for various parameters
+        D_t = timstep_aggregate(dt, params_dict['D_t'], t)
+        s_t_r_iRes = timstep_aggregate(dt, params_dict['s_t_r_iRes'], t)
+        h_t = timstep_aggregate(dt, params_dict['h_t'], t)
+        t = D_t.get_index('t')
+        partial_year_factor = (8760 / len(t)) / dt
+
+        m = Model()
+        
+        # Define Variables    
+        C_tot = m.add_variables(name='C_tot')  # Total costs
+        C_op = m.add_variables(name='C_op', lower=0)  # Operational costs
+        C_inv = m.add_variables(name='C_inv', lower=0)  # Investment costs
+        K = m.add_variables(coords=[i], name='K', lower=0)  # Endogenous capacity
+        y = m.add_variables(coords=[t, i], name='y', lower=0)  # Electricity production
+        y_ch = m.add_variables(coords=[t, i], name='y_ch', lower=0)  # Electricity consumption
+        l = m.add_variables(coords=[t, i], name='l', lower=0)  # Storage filling level
+        y_curt = m.add_variables(coords=[t, i], name='y_curt', lower=0)  # RES curtailment
+        y_h2 = m.add_variables(coords=[t, i], name='y_h2', lower=0)  # H2 production
+    
+        # Define Objective function
+        C_tot = C_op + C_inv
+        m.add_objective(C_tot)
+        
+        # Define Constraints
+        # Operational costs minus revenue for produced hydrogen
+        m.add_constraints((y * c_fuel_i / eff_i).sum() * dt - (y_h2.sel(i=iPtG) * price_h2).sum() * dt == C_op, name='C_op_sum')
+    
+        # Investment costs
+        m.add_constraints((K * c_inv_i).sum() == C_inv, name='C_inv_sum')
+    
+        # Load serving
+        m.add_constraints((((y).sum(dims='i') - y_ch.sum(dims='i')) * dt == D_t.sel(t=t) * dt), name='load')
+    
+        # Maximum capacity limit
+        m.add_constraints((y - K <= K_0_i), name='max_cap')
+    
+        # Capacity limits for investment
+        m.add_constraints((K.sel(i=technologies_no_invest) <= 0), name='max_cap_invest')
+    
+        # Prevent power production by PtG
+        m.add_constraints((y.sel(i=iPtG) <= 0), name='prevent_ptg_prod')
+    
+        # Prevent charging for non-storage technologies
+        m.add_constraints((y_ch.sel(i=[x for x in i if x not in iPtG and x not in iSto]) <= 0), name='no_charging')
+    
+        # Maximum storage charging and discharging
+        m.add_constraints((y.sel(i=iSto) + y_ch.sel(i=iSto) - K.sel(i=iSto) <= K_0_i.sel(i=iSto)), name='max_cha')
+    
+        # Maximum electrolyzer capacity
+        m.add_constraints((y_ch.sel(i=iPtG) - K.sel(i=iPtG) <= K_0_i.sel(i=iPtG)), name='max_cha_ptg')
+    
+        # PtG H2 production
+        m.add_constraints(y_ch.sel(i=iPtG) * eff_i.sel(i=iPtG) == y_h2.sel(i=iPtG), name='ptg_h2_prod')
+    
+        # Infeed of renewables
+        m.add_constraints((y.sel(i=iRes) - s_t_r_iRes.sel(i=iRes).sel(t=t) * K.sel(i=iRes) + y_curt.sel(i=iRes) == s_t_r_iRes.sel(i=iRes).sel(t=t) * K_0_i.sel(i=iRes)), name='infeed')
+    
+        # Maximum filling level restriction for storage power plants
+        m.add_constraints((l.sel(i=iSto) - K.sel(i=iSto) * e2p_iSto.sel(i=iSto) <= K_0_i.sel(i=iSto) * e2p_iSto.sel(i=iSto)), name='max_sto_filling')
+    
+        # Filling level restriction for hydro reservoir
+        m.add_constraints(l.sel(i=iHyRes) - l.sel(i=iHyRes).roll(t=-1) + y.sel(i=iHyRes) * dt == h_t.sel(t=t) * dt, name='filling_level_hydro')
+    
+        # Filling level restriction for other storages
+        m.add_constraints(l.sel(i=iSto) - (l.sel(i=iSto).roll(t=-1) - (y.sel(i=iSto) / eff_i.sel(i=iSto)) * dt + y_ch.sel(i=iSto) * eff_i.sel(i=iSto) * dt) == 0, name='filling_level')
+    
+        # CO2 limit
+        m.add_constraints(((y / eff_i) * co2_factor_i * dt).sum() <= l_co2 * 1_000_000, name='CO2_limit')
+    
+        # Solve the model
+        info_yellow_build.empty()
+        info_green_build = st.success(df.loc['label_build_model', st.session_state.lang])
+        info_yellow_solve = st.info(df.loc['label_solve_model', st.session_state.lang])
+        
+
+        m.solve(solver_name='highs')
+    
+        info_yellow_solve.empty()
+        info_green_solve = st.success(df.loc['label_solve_model', st.session_state.lang])
+        info_yellow_plot = st.info(df.loc['label_generate_plots', st.session_state.lang])
+
+
+    
+        # Prepare columns for figures
+        colb1, colb2 = st.columns(2)
+    
+        # Generate and display figures
+        st.markdown("---")
+        
+        df_total_costs = plot_total_costs(m, colb1, df)
+        df_CO2_price = plot_co2_price(m, colb2, df)
+        df_new_capacities = plot_new_capacities(m, color_dict, colb1, df)
+           
+        # Only plot production for technologies with capacity
+        i_with_capacity = m.solution['K'].where((m.solution['K'] > 0) & (m.solution['i'] != 'Electrolyzer')).dropna(dim='i').get_index('i')
+        df_production = plot_production(m, i_with_capacity, dt, color_dict, colb2, df)
+        # df_price = plot_electricity_prices(m, dt, colb2, df)
+        df_curtailment = plot_curtailment(m, iRes, color_dict, colb1, df)
+        df_residual_load_duration = plot_residual_load_duration(m, dt, colb1, df, D_t, i_with_capacity, iRes, color_dict, df_curtailment, iConv)
+        df_price = plot_electricity_prices(m, dt, colb2, df, df_residual_load_duration)
+         
+        df_contr_marg = plot_contribution_margin(m, dt, i_with_capacity, color_dict, colb1, df)
+        # df_curtailment = plot_curtailment(m, iRes, color_dict, colb1, df)
+        df_charging = plot_storage_charging(m, iSto, color_dict, colb2, df)
+        df_h2_prod = plot_hydrogen_production(m, iPtG, color_dict, colb1, df)
+        
+        # df_stackplot = plot_stackplot(m)
+    
+        # Export results
+        
+        st.session_state.output = BytesIO()
+        
+        
+        with pd.ExcelWriter(st.session_state.output, engine='xlsxwriter') as writer:
+            disaggregate_df(df_total_costs, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_total_costs', st.session_state.lang], index=False)
+            disaggregate_df(df_CO2_price, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_co2_price', st.session_state.lang], index=False)
+            disaggregate_df(df_price, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_prices', st.session_state.lang], index=False)
+            disaggregate_df(df_contr_marg, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_contribution_margin', st.session_state.lang], index=False)
+            disaggregate_df(df_new_capacities, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_capacities', st.session_state.lang], index=False)
+            disaggregate_df(df_production, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_production', st.session_state.lang], index=False)
+            disaggregate_df(df_charging, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_charging', st.session_state.lang], index=False)
+            disaggregate_df(D_t.to_dataframe().reset_index(), t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_demand', st.session_state.lang], index=False)
+            disaggregate_df(df_curtailment, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_curtailment', st.session_state.lang], index=False)
+            disaggregate_df(df_h2_prod, t, t_original, dt).to_excel(writer, sheet_name=df.loc['sheet_name_h2_production', st.session_state.lang], index=False)
+            
+        with col1:
+            st.title(df.loc['model_title2', st.session_state.lang])
+                   
+            st.download_button(label=df.loc['model_title2.1',st.session_state.lang], disabled=(st.session_state.output.getbuffer().nbytes==0), data=st.session_state.output.getvalue(), file_name="workbook.xlsx", mime="application/vnd.ms-excel")
+ 
+        info_yellow_plot.empty()
+        info_green_plot = st.success(df.loc['label_generate_plots', st.session_state.lang])
+
+        time.sleep(1)
+
+        info_green_build.empty()
+        info_green_solve.empty()
+        info_green_plot.empty()
+
+        st.stop()
+        
+
+        
+        # st.rerun()         
+
+
+def timstep_aggregate(time_steps_aggregate, xr_data, t):
+    """
+    Aggregates time steps in the data using rolling mean and selects based on step size.
+    """
+    return xr_data.rolling(t=time_steps_aggregate).mean().sel(t=t[0::time_steps_aggregate])
+
+# Visualization functions
+
+def plot_total_costs(m, col, df):
+    """
+    Displays the total costs.
+    """
+    total_costs = float(m.solution['C_inv'].values) + float(m.solution['C_op'].values)
+    total_costs_rounded = round(total_costs / 1e9, 2)
+    with col:
+        st.markdown(
+            f"<h3><b>{df.loc['plot_label_total_costs', st.session_state.lang]} {total_costs_rounded}</b></h3>", 
+            unsafe_allow_html=True
+        )
+        
+    df_total_costs = pd.DataFrame({'Total costs':[total_costs]})
+    return df_total_costs
+
+def plot_co2_price(m, col, df):
+    """
+    Displays the CO2 price based on the CO2 constraint dual values.
+    """
+    CO2_price = float(m.constraints['CO2_limit'].dual.values) * (-1)
+    CO2_price_rounded = round(CO2_price, 2)
+    df_CO2_price = pd.DataFrame({'CO2 price': [CO2_price]})
+    with col:
+        st.markdown(
+            f"<h3><b>{df.loc['plot_label_co2_price', st.session_state.lang]} {CO2_price_rounded}</b></h3>",
+            unsafe_allow_html=True
+        )
+    
+    return df_CO2_price
+
+
+def plot_new_capacities(m, color_dict, col, df):
+    """
+    Plots the new capacities installed in MW as a bar chart and pie chart.
+    Includes technologies with 0 MW capacity in the bar chart.
+    Supports both German and English labels for technologies while ensuring color consistency.
+    """
+    # Convert the solution for new capacities to a DataFrame
+    df_new_capacities = m.solution['K'].round(0).to_dataframe().reset_index()
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_new_capacities['i_en'] = df_new_capacities['i']
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_new_capacities['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_new_capacities['i'] = df_new_capacities['i_en'].replace(tech_mapping_en_to_de)
+
+    # Bar plot for new capacities (including technologies with 0 MW)
+    fig_bar = px.bar(df_new_capacities, y='i', x='K', orientation='h',
+                     title=df.loc['plot_label_new_capacities', st.session_state.lang], 
+                     color='i_en',  # Use the English names for consistent coloring
+                     color_discrete_map=color_dict,
+                     labels={'K': '', 'i': ''} # Delete double labeling
+                     )
+
+    # Hide the legend completely since the labels are already next to the bars
+    fig_bar.update_layout(showlegend=False)
+
+    with col:
+        st.plotly_chart(fig_bar)
+
+    # Pie chart for new capacities (only show technologies with K > 0 in pie chart)
+    df_new_capacities_filtered = df_new_capacities[df_new_capacities["K"] > 0]
+    fig_pie = px.pie(df_new_capacities_filtered, names='i', values='K',
+                     title=df.loc['plot_label_new_capacities_pie', st.session_state.lang], 
+                     color='i_en', color_discrete_map=color_dict)
+
+    # Remove English labels (i_en) from the pie chart legend
+    fig_pie.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    fig_pie.for_each_trace(lambda t: t.update(name=df_new_capacities_filtered['i'].iloc[0] if st.session_state.lang == 'DE' else t.name))
+
+    with col:
+        st.plotly_chart(fig_pie)
+        
+    return df_new_capacities
+
+
+def plot_production(m, i_with_capacity, dt, color_dict, col, df):
+    """
+    Plots the energy production for technologies with capacity as an area chart.
+    Supports both German and English labels for technologies while ensuring color consistency.
+    """
+    # Convert the production data to a DataFrame
+    df_production = m.solution['y'].sel(i=i_with_capacity).to_dataframe().reset_index()
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_production['i_en'] = df_production['i']
+    
+    # Convert 't'-column in a datetime format
+    df_production['t'] = df_production['t'].str.strip("'")
+    df_production['t'] = pd.to_datetime(df_production['t'], format='%Y-%m-%d %H:%M %z')
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_production['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_production['i'] = df_production['i_en'].replace(tech_mapping_en_to_de)
+
+    # Area plot for energy production
+    fig = px.area(df_production, y='y', x='t', 
+                  title=df.loc['plot_label_production', st.session_state.lang], 
+                  color='i_en',  # Use the English names for consistent coloring
+                  color_discrete_map=color_dict,
+                  labels={'y': '', 't': '', 'i_en': df.loc['label_technology', st.session_state.lang]} # Delete double labeling
+                  )
+    
+    # Update legend labels to display German names instead of English
+    if st.session_state.lang == 'DE':
+        fig.for_each_trace(lambda trace: trace.update(name=tech_mapping_en_to_de[trace.name]))
+    
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+    
+    # # Customize x-axis for better date formatting
+    # fig.update_layout(
+    #     xaxis=dict(
+    #         tickformat="%d/%m/%Y",  # Display months and years in MM/YYYY format
+    #         title='',  # No title for the x-axis
+    #         type="date"  # Ensure x-axis is treated as a date axis
+    #     ),
+    #     xaxis_tickangle=-45  # Tilt the ticks for better readability
+    # )
+    
+    with col:
+        st.plotly_chart(fig)
+
+    # Pie chart for total production
+    df_production_sum = (df_production.groupby(['i', 'i_en'])['y'].sum() * dt / 1000).round(0).reset_index()
+
+    # If the language is set to German, display German labels, otherwise use English
+    pie_column = 'i' if st.session_state.lang == 'DE' else 'i_en'
+
+    # Pie chart for total production
+    fig_pie = px.pie(df_production_sum, names=pie_column, values='y',
+                     title=df.loc['plot_label_total_production_pie', st.session_state.lang], 
+                     color='i_en',  # Ensure the coloring stays consistent using the 'i_en' column
+                     color_discrete_map=color_dict)
+
+    # Update legend title to reflect the correct language
+    fig_pie.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    
+    with col:
+        st.plotly_chart(fig_pie)
+
+    return df_production
+
+
+def plot_electricity_prices(m, dt, col, df, df_residual_load_duration):
+    """
+    Plots the electricity price and the price duration curve.
+    Supports both German and English labels for the plot titles and axis labels.
+    """
+    # Convert the dual constraints to a DataFrame
+    df_price = m.constraints['load'].dual.to_dataframe().reset_index()
+    
+    # Convert 't'-column in a datetime format
+    df_price['t'] = df_price['t'].str.strip("'")
+    df_price['t'] = pd.to_datetime(df_price['t'], format='%Y-%m-%d %H:%M %z')
+
+    # Line plot for electricity prices
+    fig_price = px.line(df_price, y='dual', x='t', 
+                        title=df.loc['plot_label_electricity_prices', st.session_state.lang], 
+                        labels={'dual': '', 't': ''}
+                        )
+    with col:
+        st.plotly_chart(fig_price)
+
+    # Create the price duration curve
+    df_sorted_price = df_price["dual"].repeat(dt).sort_values(ascending=False).reset_index(drop=True) / int(dt)
+    df_residual_load_sorted = df_residual_load_duration.sort_values(by='Residual_Load', ascending=False).reset_index(drop=True)
+    df_axis2 = df_residual_load_sorted['Residual_Load']
+    
+    ax2_max = np.max(df_axis2)
+    ax2_min = np.min(df_axis2)
+    
+    fig_duration = go.Figure()
+    
+    # Add primary y-axis trace (Price duration curve)
+    fig_duration.add_trace(go.Scatter(
+        x=df_sorted_price.index,
+        y=df_sorted_price,
+        mode='lines',
+        name=df.loc['plot_label_price_duration_curve', st.session_state.lang],
+        line=dict(color='blue', width=2)
+    ))
+    
+    # Add secondary y-axis trace (Residual load)
+    fig_duration.add_trace(go.Scatter(
+        x=df_axis2.index,
+        y=df_axis2,
+        mode='lines',
+        name=df.loc['plot_label_residual_load', st.session_state.lang],
+        line=dict(color='red', width=2),
+        yaxis='y2'
+    ))
+    
+    # Layout mit neuen title-formaten (kein titlefont mehr!)
+    fig_duration.update_layout(
+        title=df.loc['plot_label_price_duration_curve', st.session_state.lang],
+        xaxis=dict(
+            title=df.loc['label_hours', st.session_state.lang]
+        ),
+        yaxis=dict(
+            title=dict(
+                text=df.loc['plot_label_price_duration_curve', st.session_state.lang],
+                font=dict(color='blue')
+            ),
+            range=[-(100/(ax2_max/(ax2_max-ax2_min))-100), 100],
+            tickfont=dict(color='blue')
+        ),
+        yaxis2=dict(
+            title=dict(
+                text=df.loc['plot_label_residual_load', st.session_state.lang],
+                font=dict(color='red')
+            ),
+            range=[ax2_min, ax2_max],
+            tickfont=dict(color='red'),
+            overlaying='y',
+            side='right'
+        ),
+        legend=dict(
+            x=1,
+            y=1,
+            xanchor='right',
+            yanchor='top',
+            bgcolor='rgba(255, 255, 255, 0.5)',
+            bordercolor='black',
+            borderwidth=1
+        )
+    )
+
+    with col:
+        st.plotly_chart(fig_duration)
+    
+    return df_price
+
+def plot_residual_load_duration(m, dt, col, df, D_t, i_with_capacity, iRes, color_dict, df_curtailment, iConv):
+    """
+    Plots the residual load and corresponding production as a stacked area chart.
+    Supports both German and English labels for the plot titles and axis labels.
+    Consistent color coding for technologies using a predefined color dictionary.
+    """
+
+    # Extract load data and repeat each value to match the total number of hours in the year
+    df_load = D_t.values.flatten()
+    total_hours = len(df_load) * dt  # Calculate the total number of hours dynamically
+    repeated_load = np.repeat(df_load, dt)[:total_hours]  # Repeat values to represent each hour
+
+    # Convert production data to DataFrame
+    df_production = m.solution['y'].sel(i=i_with_capacity).to_dataframe().reset_index()
+
+    # Pivot production data to get technologies as columns and time 't' as index
+    df_production_pivot = df_production.pivot(index='t', columns='i', values='y')
+
+    # Repeat the pivoted production data to match the number of hours
+    repeated_index = np.repeat(df_production_pivot.index, dt)[:total_hours]  # Create repeated index
+    df_production_repeated = df_production_pivot.loc[repeated_index].reset_index(drop=True)
+
+    # Create load series with the same index as the repeated production data
+    df_load_series = pd.Series(repeated_load, index=df_production_repeated.index, name='Load')
+
+    # Combine load with repeated production data
+    df_combined = df_production_repeated.copy()
+    df_combined['Load'] = df_load_series
+
+    # Identify renewable technologies from iRes
+    iRes_list = iRes.tolist()  # Convert the Index to a list
+
+    # Calculate renewable generation (only include available technologies in df_combined)
+    renewable_columns = [col for col in iRes_list if col in df_combined.columns]
+    df_combined['Renewable_Generation'] = df_combined[renewable_columns].sum(axis=1) if renewable_columns else 0
+    
+    # Create pivot table of curtailment
+    df_curtailment_pivot = df_curtailment.pivot(index='t', columns='i', values='y_curt')
+    repeated_index = np.repeat(df_curtailment_pivot.index, dt)[:total_hours]  # Create repeated index
+    df_curtailment_repeated = df_curtailment_pivot.loc[repeated_index].reset_index(drop=True)
+    df_curtailment_repeated['Sum'] = df_curtailment_repeated.sum(axis=1)
+    df_combined['Sum_curtailment'] = -df_curtailment_repeated['Sum']
+
+    # Calculate residual load as the difference between total load and renewable generation
+    df_combined['Residual_Load'] = df_combined['Load'] - df_combined['Renewable_Generation'] + df_combined['Sum_curtailment']
+
+    # Sort DataFrame by residual load (descending order) to create the duration curve
+    df_sorted = df_combined.sort_values(by='Residual_Load', ascending=False).reset_index(drop=True)
+
+    # Identify all technology columns except 'Load', 'Residual_Load', 'Renewable_Generation'
+    technology_columns = [col for col in df_combined.columns if col not in ['Load', 'Residual_Load', 'Renewable_Generation', 'Sum_curtailment']]
+
+    # Mapping English technology names to German (if desired)
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in technology_columns if f'tech_{tech.lower()}' in df.index
+        }
+    else:
+        tech_mapping_en_to_de = {tech: tech for tech in technology_columns}  # Use the original names if not in German
+
+
+    # Plotting with Plotly - Creating stacked area chart
+    fig = go.Figure()
+    
+    # Sort technology_columns based on the highest index in df_sorted (only for iConv); others are placed at the end
+    sorted_technology_columns = sorted(
+        technology_columns,
+        key=lambda tech: (
+            tech not in iConv,  # Place non-iConv technologies at the end
+            -df_sorted[df_sorted[tech] != 0].index.max() if tech in iConv and not df_sorted[df_sorted[tech] != 0].empty else float('inf')
+        )
+    )
+
+
+    # Add stacked area traces for each production technology with consistent colors and language-specific names
+    for tech in sorted_technology_columns:
+        tech_name = tech_mapping_en_to_de.get(tech, tech)  # Get the translated name or fallback to the original
+        fig.add_trace(go.Scatter(
+            x=df_sorted.index,
+            y=df_sorted[tech],
+            mode='lines',
+            stackgroup='one',  # For stacking traces
+            name=tech_name,
+            line=dict(width=0.5, color=color_dict.get(tech))
+        ))
+
+    # Add residual load trace as a red line
+    fig.add_trace(go.Scatter(
+        x=df_sorted.index,
+        y=df_sorted['Residual_Load'],
+        mode='lines',
+        name=df.loc['plot_label_residual_load', st.session_state.lang],  # Residual load label in current language
+        line=dict(color='red', width=2)
+    ))
+
+    
+    # Add curtailment trace as a shaded area with a dark yellow tone
+    fig.add_trace(go.Scatter(
+        x=df_sorted.index,
+        y=df_sorted['Sum_curtailment'],
+        mode='lines',  # Line mode for the boundary of the area
+        name=df.loc['plot_label_sum_curtailment', st.session_state.lang],  # Curtailment label in current language
+        line=dict(color='rgba(204, 153, 0, 1)', width=1.5),  # Dark yellow line
+        fill='tozeroy',  # Fill area down to the x-axis
+        fillcolor='rgba(204, 153, 0, 0.3)'  # Semi-transparent dark yellow for the fill
+    ))
+    
+    # Layout settings for the plot
+    fig.update_layout(
+        title=df.loc['plot_label_residual_load_curve', st.session_state.lang],
+        xaxis_title=df.loc['label_hours', st.session_state.lang],
+        template="plotly_white",
+    )
+
+    # Display the plot in Streamlit
+    with col:
+        st.plotly_chart(fig)
+
+    return df_combined
+        
+    
+
+def plot_contribution_margin(m, dt, i_with_capacity, color_dict, col, df):
+    """
+    Plots the contribution margin for each technology.
+    Supports both German and English labels for titles and axes while ensuring color consistency.
+    """
+    # Convert the dual constraints to a DataFrame
+    df_contr_marg = m.constraints['max_cap'].dual.sel(i=i_with_capacity).to_dataframe().reset_index()
+
+    # Adjust the 'dual' values for the contribution margin calculation
+    df_contr_marg['dual'] = df_contr_marg['dual'] / dt * (-1)
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_contr_marg['i_en'] = df_contr_marg['i']
+    
+    # Convert 't'-column in a datetime format
+    df_contr_marg['t'] = pd.to_datetime(df_contr_marg['t'].str.strip("'"), format='%Y-%m-%d %H:%M %z')
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_contr_marg['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_contr_marg['i'] = df_contr_marg['i_en'].replace(tech_mapping_en_to_de)
+
+    # Plot contribution margin for each technology
+    fig = px.line(df_contr_marg, y='dual', x='t',
+                  title=df.loc['plot_label_contribution_margin', st.session_state.lang],
+                  color='i_en',  # Use the English names for consistent coloring
+                  range_y=[0, 250], color_discrete_map=color_dict,
+                  labels={'dual':'', 't':'', 'i_en':''}
+                  )
+
+    # Update legend to display the correct language
+    fig.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    
+    # For German language, update the legend to show German technology names
+    if st.session_state.lang == 'DE':
+        fig.for_each_trace(lambda t: t.update(name=df_contr_marg.loc[df_contr_marg['i_en'] == t.name, 'i'].values[0]))
+
+    # Display the plot
+    with col:
+        st.plotly_chart(fig)
+
+    return df_contr_marg
+
+
+
+
+def plot_curtailment(m, iRes, color_dict, col, df):
+    """
+    Plots the curtailment of renewable energy.
+    Supports both German and English labels for titles and axes while ensuring color consistency.
+    """
+    # Convert the curtailment solution to a DataFrame
+    df_curtailment = m.solution['y_curt'].sel(i=iRes).to_dataframe().reset_index()
+    
+    # Convert 't'-column in a datetime format
+    df_curtailment['t'] = pd.to_datetime(df_curtailment['t'].str.strip("'"), format='%Y-%m-%d %H:%M %z')
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_curtailment['i_en'] = df_curtailment['i']
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_curtailment['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_curtailment['i'] = df_curtailment['i_en'].replace(tech_mapping_en_to_de)
+    else:
+        df_curtailment['i'] = df_curtailment['i_en']  # Use English names if not German
+
+    # Area plot for curtailment of renewable energy
+    fig = px.area(df_curtailment, y='y_curt', x='t', 
+                  title=df.loc['plot_label_curtailment', st.session_state.lang], 
+                  color='i_en',  # Use the English names for consistent coloring
+                  color_discrete_map=color_dict,
+                  labels={'y_curt': '', 't': ''} # Delete double labeling
+                  )
+
+    # Remove line traces and use fill colors for the area plot
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+
+    # Update the legend title to reflect the correct language (German or English)
+    fig.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    
+    # For German language, update the legend to show German technology names
+    if st.session_state.lang == 'DE':
+        fig.for_each_trace(lambda t: t.update(name=df_curtailment.loc[df_curtailment['i_en'] == t.name, 'i'].values[0]))
+
+    # Display the plot
+    with col:
+        st.plotly_chart(fig)
+
+    return df_curtailment
+
+
+
+def plot_storage_charging(m, iSto, color_dict, col, df):
+    """
+    Plots the charging of storage technologies.
+    Supports both German and English labels for titles and axes while ensuring color consistency.
+    """
+    # Convert the storage charging solution to a DataFrame
+    df_charging = m.solution['y_ch'].sel(i=iSto).to_dataframe().reset_index()
+    
+    # Drop out infinitesimal numbers
+    df_charging['y_ch'] = df_charging['y_ch'].apply(lambda x: 0 if x < 0.01 else x)
+    
+    # Convert 't'-column in a datetime format
+    df_charging['t'] = pd.to_datetime(df_charging['t'].str.strip("'"), format='%Y-%m-%d %H:%M %z')
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_charging['i_en'] = df_charging['i']
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_charging['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_charging['i'] = df_charging['i_en'].replace(tech_mapping_en_to_de)
+    else:
+        df_charging['i'] = df_charging['i_en']  # Use English names if not German
+
+    # Area plot for storage charging
+    fig = px.area(df_charging, y='y_ch', x='t', 
+                  title=df.loc['plot_label_storage_charging', st.session_state.lang], 
+                  color='i_en',  # Use the English names for consistent coloring
+                  color_discrete_map=color_dict,
+                  labels={'y_ch': '', 't': ''} # Delete double labeling                            
+                  )
+
+    # Remove line traces and use fill colors for the area plot
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+
+    # Update the legend title to reflect the correct language (German or English)
+    fig.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    
+    # For German language, update the legend to show German technology names
+    if st.session_state.lang == 'DE':
+        fig.for_each_trace(lambda t: t.update(name=df_charging.loc[df_charging['i_en'] == t.name, 'i'].values[0]))
+
+    # Display the plot
+    with col:
+        st.plotly_chart(fig)
+
+    return df_charging
+
+
+
+def plot_hydrogen_production(m, iPtG, color_dict, col, df):
+    """
+    Plots the hydrogen production.
+    Supports both German and English labels for titles and axes while ensuring color consistency.
+    """
+    # Convert the hydrogen production data to a DataFrame
+    df_h2_prod = m.solution['y_h2'].sel(i=iPtG).to_dataframe().reset_index()
+    
+    # Convert 't'-column in a datetime format
+    df_h2_prod['t'] = pd.to_datetime(df_h2_prod['t'].str.strip("'"), format='%Y-%m-%d %H:%M %z')
+
+    # Store the English technology names in a separate column to maintain color consistency
+    df_h2_prod['i_en'] = df_h2_prod['i']
+
+    # Check if the language is German and map English names to German for display
+    if st.session_state.lang == 'DE':
+        tech_mapping_en_to_de = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in df_h2_prod['i_en'] if f'tech_{tech.lower()}' in df.index
+        }
+        # Replace the English technology names with German ones for display
+        df_h2_prod['i'] = df_h2_prod['i_en'].replace(tech_mapping_en_to_de)
+    else:
+        df_h2_prod['i'] = df_h2_prod['i_en']  # Keep English names if not German
+
+    # Area plot for hydrogen production
+    fig = px.area(df_h2_prod, y='y_h2', x='t', 
+                  title=df.loc['plot_label_hydrogen_production', st.session_state.lang], 
+                  color='i_en',  # Use the English names for consistent coloring
+                  color_discrete_map=color_dict,
+                  labels={'y_h2': '', 't': ''} # Delete double labeling                  
+                  )
+
+    # Remove line traces and use fill colors for the area plot
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+
+    # Update the legend title to reflect the correct language (German or English)
+    fig.update_layout(legend_title_text=df.loc['label_technology', st.session_state.lang])
+    
+    # For German language, update the legend to show German technology names
+    if st.session_state.lang == 'DE':
+        fig.for_each_trace(lambda t: t.update(name=df_h2_prod.loc[df_h2_prod['i_en'] == t.name, 'i'].values[0]))
+
+    # Display the plot
+    with col:
+        st.plotly_chart(fig)
+
+    return df_h2_prod
+
+
+
+def disaggregate_df(df, t, t_original, dt):
+    """
+    Disaggregates the DataFrame based on the original time steps.
+    """
+    if "t" not in list(df.columns):
+        return df
+
+    # Change format of t back
+    df['t'] = "'" + pd.to_datetime(df['t'], utc=True).dt.tz_convert('Europe/Berlin').dt.strftime('%Y-%m-%d %H:%M %z') + "'"
+    
+    df_t_all = pd.DataFrame({"t_all": t_original.to_series(), 't': t.repeat(dt)}).reset_index(drop=True)
+    df_output = df.merge(df_t_all, on='t').drop('t', axis=1).rename({'t_all': 't'}, axis=1)
+    df_output = df_output[[df_output.columns[-1]] + list(df_output.columns[:-1])]
+    # Drop the helping column i_en
+    df_output = df_output.drop(columns=['i_en'], errors='ignore')
+    return df_output.sort_values('t')
+
+
+if __name__ == "__main__":
+    main()

language.csv

@@ -0,0 +1,138 @@
+Label;DE;EN
+menu_modell;Modell;Model
+menu_doku;Dokumentation;Documentation
+menu_impressum;�ber uns;About
+menu_text;Ein Browser-Tool, das f�r ein besseres Verst�ndnis der mathematischen Optimierung in der Energiewirtschaft bestimmt ist. Sei neugierig!;A tool designated for better understanding of mathematical optimization in the context of energy economics. Be eager!
+toast_text;�ffne das Men� links um zur Dokumentation und Sprachwahl zu gelangen!;Open the menu on the left side to access the documentation and to change the language!
+model_title1;Input aus Datei;Settings from file
+model_title2;Ergebnisse exportieren;Export result data
+model_title3;Manueller Input aus der GUI;Manual settings from GUI 
+model_title4;Modell rechnen;Run model
+model_title2.1;Ergebnisse als Exceldatei herunterladen;Download Excel workbook results
+model_title1.3;Excel Vorlage herunterladen;Download Excel Template
+model_title1.4;Eigenes Exceldokument hochladen;Upload own Excel File
+model_run_info_gui;Rechne mit manuellen Werten aus der GUI;Run model with manual values from the GUI
+model_run_info_excel;Rechne mit Werten aus der Excel;Run model with uploaded Excel values
+model_label_co2;CO2 Budget [mio. t]; CO2 limit [mio. t]
+model_label_CCGT;Erdgas Preis [EUR/MWh]; Fossil Gas Price [EUR/MWh]
+model_label_OCGT;Erdgas Preis [EUR/MWh]; Fossil Gas Price [EUR/MWh]
+model_label_h2;H2 Preis [EUR/MWh]; H2 Price [EUR/MWh]
+model_label_Fossil Hard coal;Steinkohle Preis [EUR/MWh]; Fossil Hard Coal Price [EUR/MWh]
+model_label_Lignite;Braunkohle Preis [EUR/MWh]; Fossil Lignite Price [EUR/MWh]
+model_label_Fossil Oil;Erd�l Preis [EUR/MWh]; Fossil Oil Price [EUR/MWh]
+model_label_t;L�nge der Zeitschritte [h]; Timestep length [h]
+model_label_t_info;Nur Werte zwischen 1 und 8760 eintragen (bzw. 8784 f�r Schaltjahre).;Enter only integers between 1 and 8760 (or 8784 for leap years).
+model_label_tech;Technologien;Technologies for investment
+tech_nuclear;Atomkraft;Nuclear
+tech_biomass;Biomasse;Biomass
+tech_lignite;Braunkohle;Lignite
+tech_CCGT;Gas- und Dampfkraftwerk;Combined Cycle Gas Turbine
+tech_OCGT;Gasturbine;Gasturbine
+tech_fossil hard coal;Steinkohle;Fossil Hard coal
+tech_fossil oil;�l;Fossil Oil
+tech_ror;Laufwasser;RoR
+tech_hydro water reservoir;Wasserreservoir;Hydro Water Reservoir
+tech_pv;PV;PV
+tech_windoff;Offshore Wind;WindOff
+tech_windon;Onshore Wind;WindOn
+tech_h2;Wasserstoff;H2
+tech_pumped hydro storage;Pumpspeicher;Pumped Hydro Storage
+tech_battery storages;Batteriespeicher;Battery storages
+tech_electrolyzer;Elektrolyseure;Electrolyzer
+run_model_button;Starte das Modell;Run Model
+run_model_button_info;Hier klicken um die Optimierungsrechnung des Energiesystems zu starten.;Click to run the energy system optimization model.
+plot_label_total_costs;Gesamtkosten in Mrd. EUR: ;Total costs in bn. EUR: 
+plot_label_co2_price;CO2 Preis in EUR/t: ;CO2 price in EUR/t: 
+plot_label_new_capacities;Neue Kapazit�ten [MW];New Capacities [MW]
+plot_label_new_capacities_pie;Neue Kapazit�ten [MW] als Kreisdiagramm;New Capacities [MW] as pie chart
+plot_label_production;Stromproduktion [MW];Production [MW]
+plot_label_total_production_pie;Gesamtproduktion [GWh] als Kreisdiagramm;Total Production [GWh] as pie chart
+plot_label_electricity_prices;Strompreise [EUR/MWh];Electricity prices [EUR/MWh]
+plot_label_price_duration_curve;Preisdauerlinie [EUR/MWh];Price duration curve [EUR/MWh]
+plot_label_load_duration_curve;Lastdauerlinie [MWh];Load duration curve [MWh]
+label_electricity_price;Strompreis;Electricity price
+label_time;Zeit;Time
+label_technology;Technologien;Technologies
+label_hours_of_year;Stunden des Jahres;Hours of the year
+label_hours;Stunden;Hours
+plot_label_contribution_margin;Deckungsbeitr�ge [EUR];Contribution margins [EUR]
+plot_label_curtailment;Abregelung [MWh];Curtailment [MWh]
+plot_label_storage_charging;Einspeicherung [MWh];Storage charging [MWh]
+plot_label_hydrogen_production;Wasserstofferzeugung [MWh_th];Hydrogen production [MWh_th]
+plot_label_residual_load;Residuallast [MW];Residual load [MW]
+plot_label_load;Last [MW];Load [MW]
+plot_label_residual_load_curve;Residuallastdauerlinie und gestapelte Erzeugung [MW];Residual load duration curve and stacked production [MW]
+plot_label_sum_curtailment;Summe der EE-Abregelung [MW];Sum of the RES curtailment [MW]
+;;
+constr_header1;Mathematische Modellformulierung;Mathematical model formulation
+constr_header2;Diese Seite zeigt die Details der mathematischen Modellformulierung & Nebenbedingungen des optimierenden Energiesystemmodells.;This page provides details on the mathematical formulation & constraints of the energy system optimization model.
+constr_header3;Zielfunktion und Nebenbedingungen;Objective function and constraints
+constr_subheader_obj_func;Zielfunktion;Objective function
+constr_subheader_obj_func_descr;Minimierung der Gesamtkosten;Minimization of total costs
+subheader_constr;Nebenbedingungen;Constraints
+constr_load_serve;Energiebedarf muss gedeckt werden:;Load-serving constraint:
+constr_c_op;Betriebskosten abz�glich Einnahmen durch Wasserstoffproduktion:;Operational costs minus revenue for produced hydrogen:
+constr_c_inv;Investitionskostenbeschr�nkung:;Investment costs constraint:
+constr_max_cap;Begrenzung der maximalen Kapazit�t:;Maximum capacity constraint:
+constr_inv_cap;Beschr�nkung der Kapazit�tsinvestitionen:;Capacity limits for investment:
+constr_prevent_ptg;Verhinderung der Stromproduktion durch PtG:;Prevent power production by PtG:
+constr_prevent_chg;Verhinderung des Aufladens f�r Nicht-Speichertechnologien:;Prevent charging for non-storage technologies:
+constr_max_chg;Maximale Auflade- und Entladebeschr�nkung f�r Speicher:;Maximum storage charging and discharging constraint:
+constr_max_cap_electrolyzer;Maximale Kapazit�t des Elektrolyseurs:;Maximum electrolyzer capacity constraint:
+constr_prod_ptg;H2-Produktion durch PtG:;PtG hydrogen production constraint:
+constr_inf_res;Einspeisung erneuerbarer Energien:;Infeed of renewables constraint:
+constr_max_fil_sto;Maximale F�llstandbeschr�nkung f�r Speicherwerke:;Maximum filling level restriction for storage power plants:
+constr_fil_hyres;F�llstandbeschr�nkung f�r Wasserkraftspeicher:;Filling level restriction for hydro reservoir:
+constr_fil_sto;F�llstandbeschr�nkung f�r andere Speicher:;Filling level restriction for other storages:
+constr_co2_lim;CO2-Beschr�nkung:;CO2 emission constraint:
+;;
+symb_header1;Symbole;Symbols
+symb_header2;Wir verwenden Gro�- und Kleinbuchstaben f�r Variablen und Parameter. Hochgestellte Buchstaben werden zur weiteren Beschreibung verwendet. Die tiefgestellten Buchstaben stehen f�r Mengen.;We use capital and lowercase letters for variables and parameters. Superscripts are used for further description. Subscripts represent sets.
+symb_header_sets;Sets/Mengen;Sets
+symb_time_steps;Menge der Zeitschritte;Set of time steps
+symb_tech;Menge der Technologien;Set of technologies
+symb_sto_tech;Menge der Speichertechnologien;Set of storage technologies
+symb_conv_tech;Menge der Umwandlungstechnologien;Set of conversion technologies
+symb_ptg;Menge der PtG-Technologien;Set of power-to-gas technologies
+symb_res;Menge der erneuerbaren Erzeugungstechnologien;Set of renewable energy sources
+symb_hyres;Menge der Hydroreservoirs;Set of hydro reservoir technologies
+symb_no_inv;Menge der Technologien, in die nicht investiert wird;Set of technologies without investment
+symb_header_variables;Variablen;Variables
+symb_tot_costs;Gesamtkosten (Zielfunktion);Total costs (objective function)
+symb_c_op;Betriebskosten;Operational costs
+symb_c_inv;Investitionskosten;Investment costs
+symb_inst_cap;Installierte Leistung einer Technologie $i$;Installed capacity of technology $i$
+symb_el_prod;Stromproduktion der Technologie $i$ zum Zeitpunkt $t$;Electricity production of technology $i$ at time $t$
+symb_el_ch;Stromverbrauch zum Laden des Speichers der Technologie $i$ zum Zeitpunkt $t$;Electricity consumption for charging storage of technology $i$ at time $t$
+symb_sto_fil;Speicherf�llstand der Technologie $i$ zum Zeitpunkt $t$;Storage filling level of technology $i$ at time $t$
+symb_curt;Abregelung der erneuerbaren Energie f�r Technologie $i$ zum Zeitpunkt $t$;Curtailment of renewable energy for technology $i$ at time $t$
+symb_h2_ptg;Wasserstoffproduktion f�r die Power-to-Gas-Technologie $i$ zum Zeitpunkt $t$;Hydrogen production for power-to-gas technology $i$ at time $t$
+symb_header_parameters;Parameter;Parameters
+symb_energy_demand;Stromverbrauch zum Zeitpunkt $t$;Energy demand at time $t$
+symb_price_h2;Market Price Hydrogen;Market price hydrogen
+symb_fuel_costs;Brennstoffkosten f�r Technologie $i$;Fuel cost for technology $i$
+symb_c_op_other;Weitere Betriebskosten f�r Technologie $i$;Other operational costs for technology $i$
+symb_c_inv_tech;Investitionskosten f�r Technologie $i$;Investment cost for technology $i$
+symb_eff_fac;Wirkungsgrad der Technologie $i$;Efficiency of technology $i$
+symb_max_cap_tech;Kapazit�t f�r Technologie $i$ zum Zeitpunkt t = 0;Installed capacity for technology $i$ at $t=0$
+symb_co2_fac;CO2-Emissionsfaktor f�r Technologie $i$;CO2 emissions factor for technology $i$
+symb_co2_limit;CO2-Emissionsgrenze;CO2 emissions limit
+symb_etp;Energie-Leistung-Verh�ltnis (Speicherzeit) f�r Speichertechnologie $i$;Energy-to-power ratio for storage technology $i$
+symb_res_supply;Erneuerbare Stromerzeugung zum Zeitpunkt $t$ f�r erneuerbare Technologie $i$;Renewable supply at time $t$ for renewable technology $i$
+symb_hyRes_inflow;Zufluss Hydroreservoir;Inflow for hydro reservoir
+symb_annuity;Annuit�tenfaktor f�r Technologie $i$;Annuity factor for technology $i$    
+;;
+sheet_name_total_costs;Gesamtkosten;Total costs
+sheet_name_co2_price;CO2 Preis;CO2 price
+sheet_name_prices;Preise;Prices
+sheet_name_contribution_margin;Deckungsbeitr�ge;Contribution Margin
+sheet_name_capacities;Kapazit�ten;Capacities
+sheet_name_production;Produktion;Production
+sheet_name_charging;Ein-Ausspeichern;Charging
+sheet_name_demand;Nachfrage;Demand
+sheet_name_curtailment;Abregelung;Curtailment
+sheet_name_h2_production;H2 Produktion;H2 production
+;;
+label_build_model;Erstelle das Modell�;Build model�
+label_solve_model;L�se das Modell�;Solve model...
+label_generate_plots;Grafiken erstellen�;Generate output figures�

model_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e8333b788fd8e853be74fca60a4cfb4c57c32177bd4ebc6fb2bc9f971302521
+size 1373852

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+numpy
+pandas
+xarray
+plotly
+streamlit
+xlsxwriter
+linopy
+openpyxl
+highspy

sourced.py

@@ -0,0 +1,215 @@
+# %%
+import pandas as pd
+
+import pickle
+
+
+# %%
+# Define the file path for the pickle file
+pickle_file_path = 'model_data.pkl'
+
+# Function to save dictionaries to a pickle file
+def save_to_pickle(sets_dict, params_dict):
+    with open(pickle_file_path, 'wb') as file:
+        pickle.dump({'sets': sets_dict, 'params': params_dict}, file)
+
+# Function to load dictionaries from a pickle file
+def load_from_pickle():
+    with open(pickle_file_path, 'rb') as file:
+        data = pickle.load(file)
+    return data['sets'], data['params']
+
+
+ 
+def load_data_from_excel(url_excel, write_to_pickle_flag = True):
+
+
+
+    # Timesteps
+    df_excel = pd.read_excel(url_excel, sheet_name='Timesteps_All', header=None)
+    t = pd.Index(df_excel.iloc[:, 0], name='t')
+
+    # Technologies
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    i = pd.Index(df_excel.iloc[:, 0], name='i')
+
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    iConv = pd.Index(df_excel.iloc[0:7, 2], name='iConv')
+
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    iRes = pd.Index(df_excel.iloc[0:4, 4], name='iRes')
+
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    iSto = pd.Index(df_excel.iloc[0:2, 6], name='iSto')
+
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    iPtG = pd.Index(df_excel.iloc[0:1, 8], name='iPtG')
+
+    df_excel = pd.read_excel(url_excel, sheet_name='Technologies')
+    iHyRes = pd.Index(df_excel.iloc[0:1, 10], name='iHyRes')
+
+    # Parameters
+    l_co2 =  pd.read_excel(url_excel, sheet_name='CO2_Cap').iloc[0,0]
+    p_co2 = 0
+    dt = 1
+
+    # Demand
+    df_excel= pd.read_excel(url_excel, sheet_name = 'Demand')
+    #df_melt = pd.melt(df_excel, id_vars='Zeit')
+    df_excel = df_excel.rename(columns = {'Timesteps':'t', 'Unnamed: 1':'Demand'})
+    #df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('t')
+    D_t = df_excel.iloc[:,0].to_xarray()
+
+    ## Efficiencies
+    df_excel = pd.read_excel(url_excel, sheet_name = 'Efficiency')
+    df_excel = df_excel.rename(columns = {'All':'i', 'Unnamed: 1':'Efficiency'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    eff_i = df_excel.iloc[:,0].to_xarray()
+
+     ## Lifespan
+    df_excel = pd.read_excel(url_excel, sheet_name = 'Lifespan')
+    df_excel = df_excel.rename(columns = {'All':'i', 'Unnamed: 1':'Lifespan'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    life_i = df_excel.iloc[:,0].to_xarray()
+
+    ## Variable costs
+    # Fuel costs
+    df_excel = pd.read_excel(url_excel, sheet_name = 'FuelCosts')
+    df_excel = df_excel.rename(columns = {'Conventionals':'i', 'Unnamed: 1':'FuelCosts'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    c_fuel_i = df_excel.iloc[:,0].to_xarray()
+    # Apply slider value
+    #c_fuel_i.loc[dict(i = 'Fossil Gas')]  = price_gas
+    #c_fuel_i.loc[dict(i = 'H2')]  = price_h2
+
+    # Other var. costs
+    df_excel = pd.read_excel(url_excel, sheet_name = 'OtherVarCosts')
+    df_excel = df_excel.rename(columns = {'Conventionals':'i', 'Unnamed: 1':'OtherVarCosts'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    c_other_i = df_excel.iloc[:,0].to_xarray()
+
+    # Investment costs
+    df_excel = pd.read_excel(url_excel, sheet_name = 'InvCosts')
+    df_excel = df_excel.rename(columns = {'All':'i', 'Unnamed: 1':'InvCosts'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    interest_rate = 0.07
+    annuity_factor_i = (interest_rate * (1 + interest_rate)**life_i) / ((1 + interest_rate)**life_i - 1)
+    c_inv_i = df_excel.iloc[:,0].to_xarray()*1000*annuity_factor_i
+
+    # Emission factor
+    df_excel = pd.read_excel(url_excel, sheet_name = 'EmFactor')
+    df_excel = df_excel.rename(columns = {'Conventionals':'i', 'Unnamed: 1':'EmFactor'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    co2_factor_i = df_excel.iloc[:,0].to_xarray()
+
+    ## Calculation of variable costs
+    c_var_i = (c_fuel_i.sel(i = iConv) + p_co2 * co2_factor_i.sel(i = iConv)) / eff_i.sel(i = iConv) + c_other_i.sel(i = iConv)
+
+    # RES capacity factors
+    #df_excel = pd.read_excel(url_excel, sheet_name = 'RES',header=[0,1])
+    #df_excel = pd.read_excel(url_excel, sheet_name = 'RES', index_col=['Timesteps'], columns=['PV', 'WindOn', 'WindOff', 'RoR'])
+    df_excel = pd.read_excel(url_excel, sheet_name = 'RES')
+    df_excel = df_excel.set_index(['Timesteps'])
+    df_test = df_excel
+    df_excel = df_excel.stack()
+    #df_excel = df_excel.rename(columns={'PV', 'WindOn', 'WindOff', 'RoR'})
+    df_test2 = df_excel
+    #df_excel = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    #df_excel = df_excel.fillna(0)
+
+    #df_test = df_excel.set_index(['Timesteps', 'PV', 'WindOn', 'WindOff', 'RoR']).stack([0])
+    #df_test.index = df_test.index.set_names(['t','i'])
+    s_t_r_iRes = df_excel.to_xarray().rename({'level_1': 'i','Timesteps':'t'})
+
+    #s_t_r_iRes = df_excel.iloc[:,0].to_xarray()
+
+    # Base capacities
+    df_excel = pd.read_excel(url_excel, sheet_name = 'InstalledCap')
+    df_excel = df_excel.rename(columns = {'All':'i', 'Unnamed: 1':'InstalledCap'})
+    df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    K_0_i = df_excel.iloc[:,0].to_xarray()
+
+    # Energy-to-power ratio storages
+    df_excel = pd.read_excel(url_excel, sheet_name = 'E2P')  
+    df_excel = df_excel.rename(columns = {'Storage':'i', 'Unnamed: 1':'E2P ratio'})
+    #df_excel  = i.to_frame().reset_index(drop=True).merge(df_excel, how = 'left')
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('i')
+    e2p_iSto = df_excel.iloc[:,0].to_xarray()
+
+    # Inflow for hydro reservoir
+    df_excel = pd.read_excel(url_excel, sheet_name = 'HydroInflow')
+    df_excel = df_excel.rename(columns = {'Timesteps':'t', 'Hydro Water Reservoir':'Inflow'})
+    df_excel = df_excel.fillna(0)
+    df_excel = df_excel.set_index('t')
+    h_t = df_excel.iloc[:,0].to_xarray()
+
+
+    
+    sets_dict = {}
+    params_dict = {}
+    # Append parameters to the dictionary
+    sets_dict['t'] = t
+    sets_dict['i'] = i
+    sets_dict['iSto'] = iSto
+    sets_dict['iConv'] = iConv
+    sets_dict['iPtG'] = iPtG
+    sets_dict['iRes'] = iRes
+    sets_dict['iHyRes'] = iHyRes
+    # Append parameters to the dictionary
+    params_dict['l_co2'] = l_co2
+    params_dict['p_co2'] = p_co2
+    params_dict['dt'] = dt
+    params_dict['D_t'] = D_t
+    params_dict['eff_i'] = eff_i
+    params_dict['life_i'] = life_i
+    params_dict['c_fuel_i'] = c_fuel_i
+    params_dict['c_other_i'] = c_other_i
+    params_dict['c_inv_i'] = c_inv_i
+    params_dict['co2_factor_i'] = co2_factor_i
+    params_dict['c_var_i'] = c_var_i
+    params_dict['s_t_r_iRes'] = s_t_r_iRes
+    params_dict['K_0_i'] = K_0_i
+    params_dict['e2p_iSto'] = e2p_iSto
+    params_dict['h_t'] = h_t
+
+    if write_to_pickle_flag:
+        save_to_pickle(sets_dict, params_dict)
+
+    return sets_dict, params_dict
+
+
+# %%
+# # Example usage:
+# url_excel = "Input_Jahr_2021.xlsx"  # Replace with your actual file path
+# limit_co2 = 0.5
+# price_co2 = 50
+# price_gas = 3
+# price_h2 = 5
+
+# sets, params = load_data_from_excel(url_excel,write_to_pickle_flag=True)
+
+# # %%
+# sets, params = load_data_from_excel(url_excel,load_from_pickle_flag=True)
+# # %%
+
+
+if __name__ == "__main__":
+        url_excel = r'Input_Jahr_2023.xlsx'
+        sets_dict, params_dict= load_data_from_excel(url_excel, write_to_pickle_flag= False)