Upload 3 files

Input_Jahr_2023.xlsx

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

app.py

@@ -4,7 +4,7 @@ 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
@@ -72,7 +72,7 @@ def main():
    
 
 
-
+# %%
 # Load settings and initial configurations
 def load_settings():
     """
@@ -117,13 +117,62 @@ def setup_page():
     st.set_page_config(layout="wide", page_title="Investment tool", page_icon="media/favicon.ico", initial_sidebar_state="expanded")
 
 
-# Sidebar for language and links
+# # 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)
+
+
 def setup_sidebar(df):
     """
-    Set up the sidebar with language options and external links.
+    Set up the sidebar with language and level options as two-step selection,
+    using localized text from the loaded dataframe.
     """
-    st.session_state.lang = st.sidebar.selectbox("Language", ["🇬🇧  EN", "🇩🇪  DE"], key="foo", label_visibility="collapsed")[-2:]
 
+    # Step 1: Language selection
+    lang_choice = st.sidebar.selectbox("Language", ["🇩🇪  DE", "🇬🇧  EN"], key="lang_select", label_visibility="collapsed")
+    st.session_state.lang = lang_choice[-2:]  # 'EN' or 'DE'
+
+    # Step 2: Localized level selection
+    level_options = {
+        f"🎓 {df.loc['menu_untergraduate', st.session_state.lang]}": "undergraduate",
+        f"🎓 {df.loc['menu_graduate', st.session_state.lang]}": "graduate"
+    }
+
+    level_choice = st.sidebar.selectbox(df.loc['menu_level', st.session_state.lang], list(level_options.keys()), key="level_select")
+    st.session_state.level = level_options[level_choice]
+
+    # Optional styling and centered sidebar content
     st.sidebar.markdown("""
     <style>
         text-align: center;
@@ -137,9 +186,9 @@ def setup_sidebar(df):
     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
+            st.text(" ")
+            st.markdown(df.loc['menu_text', st.session_state.lang])
+            st.text(" ")
 
             if st.session_state.lang == "DE":
                 st.write("Schaue vorbei beim")
@@ -152,7 +201,6 @@ def setup_sidebar(df):
             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):
     """
@@ -320,7 +368,7 @@ def page_about_us():
     """
     st.write("About Us/Impressum")
 
-
+# %%
 def page_model(): #, write_pickle_from_standard_excel, color_dict):    
     """
     Display the main model page for energy system optimization.
@@ -400,7 +448,12 @@ def page_model(): #, write_pickle_from_standard_excel, color_dict):
         with st.form("input_custom"):
             
             col1form, col2form, col3form = st.columns([0.25, 0.25, 0.50])
-        
+            # 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
+            }
+
             # 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)
@@ -408,41 +461,60 @@ def page_model(): #, write_pickle_from_standard_excel, color_dict):
                 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']:
+                elif 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)
+                                                                         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']
             # 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']
+            # Set core technology list (will later depend on level)
             
+            if st.session_state.level == 'undergraduate':
+                    # Exclude specific technologies for undergraduates
+                excluded_techs = {'Lignite', 'Pumped Hydro Storage', 'Electrolyzer'}
+                tech_list = [tech for tech in sets_dict['i'] if tech not in excluded_techs]
+                # tech_list = sets_dict['i']  # same for now
+            else:
+                tech_list = sets_dict['i']  # original set
+
+            # Localize display labels based on selected language
+            lang = st.session_state.lang
+            options = [
+                df.loc[f'tech_{tech.lower()}', lang] if f'tech_{tech.lower()}' in df.index else tech
+                for tech in tech_list
+            ]
+
+            # Define default technologies (internal names) — same across all users
+            default_techs = ['Lignite', 'CCGT', 'OCGT', 'Fossil Hard coal', 'Fossil Oil', 'PV', 'WindOff', 'WindOn', 'H2', 'Pumped Hydro Storage', 'Battery storages', 'Electrolyzer']
+
+            # Translate default selections for UI (still uses internal list for logic)
+            default = [
+                df.loc[f'tech_{tech.lower()}', lang] if f'tech_{tech.lower()}' in df.index else tech
+                for tech in default_techs if tech in tech_list
+            ]
+
             # 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]
@@ -590,22 +662,49 @@ def page_model(): #, write_pickle_from_standard_excel, color_dict):
         # 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)
+
+        if st.session_state.level == "undergraduate":
+            i_with_capacity = m.solution['K'].where((m.solution['K'] > 0) & (m.solution['i'] != 'Electrolyzer')).dropna(dim='i').get_index('i')
+            df_curtailment = plot_curtailment(m, iRes, color_dict, colb1, df, show = False)
+            # df_production = plot_production(m, i_with_capacity, dt, color_dict, colb1, df, show = False)
+            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)
+            df_residual_load_duration = plot_residual_load_duration(m, dt, colb2, df, D_t, i_with_capacity, iRes, color_dict, df_curtailment, iConv)
+
+            df_fullload = calculate_and_plot_fullload_hours(m, dt, color_dict, colb1)
+            # df_production = plot_production(m, i_with_capacity, dt, color_dict, colb1, df)s
+            df_price = plot_electricity_prices(m, dt, colb2, df, df_residual_load_duration)
+
+            df_production = plot_production(m, i_with_capacity, dt, color_dict, colb1, df)
+            
+            df_emissions = calculate_and_plot_emissions(m, eff_i, co2_factor_i, dt=1, color_dict=color_dict, col=colb1)
+            df_emissions_cumulative = calculate_and_plot_cumulative_emissions(m, eff_i, co2_factor_i,dt, color_dict, colb2, df)
+            # df_residual_load_duration = plot_residual_load_duration(m, dt, colb2, df, D_t, i_with_capacity, iRes, color_dict, df_curtailment, iConv)
+
+
+            df_curtailment = plot_curtailment(m, iRes, color_dict, colb1, df, show= True)
+            df_charging = plot_storage_charging(m, iSto, color_dict, colb2, df)
+            # df_filtered = calculate_and_plot_investment_costs(m,df_new_capacities, c_inv_i, color_dict, colb1, df)
+            # df_contr_marg_sum = calculate_and_plot_contribution_margin(m, i, iRes, dt, color_dict, colb2, df)
+        else:
+            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)
+            # 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)
     
@@ -618,13 +717,13 @@ def page_model(): #, write_pickle_from_standard_excel, color_dict):
             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_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)
+            # 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])
@@ -721,23 +820,24 @@ def plot_new_capacities(m, color_dict, col, df):
     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)
+    if st.session_state.level == "graduate":
+        # 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))
+        # 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)
+        with col:
+            st.plotly_chart(fig_pie)
         
     return df_new_capacities
 
 
-def plot_production(m, i_with_capacity, dt, color_dict, col, df):
+def plot_production(m, i_with_capacity, dt, color_dict, col, df, show=True):
     """
     Plots the energy production for technologies with capacity as an area chart.
     Supports both German and English labels for technologies while ensuring color consistency.
@@ -790,22 +890,23 @@ def plot_production(m, i_with_capacity, dt, color_dict, col, df):
         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 st.session_state.level == "graduate":
+        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'
+        # 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)
+        # 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)
+        # 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
 
@@ -822,13 +923,14 @@ def plot_electricity_prices(m, dt, col, df, df_residual_load_duration):
     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)
+    # # 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], 
+    #                     # range_y=[0, 250], 
+    #                     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)
@@ -845,8 +947,8 @@ def plot_electricity_prices(m, dt, col, df, df_residual_load_duration):
         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)
+        name=df.loc['plot_label_price_duration_curve', st.session_state.lang],  # Price duration label
+        line=dict(color='blue', width=2)  # Blue line for primary y-axis
     ))
     
     # Add secondary y-axis trace (Residual load)
@@ -854,48 +956,60 @@ def plot_electricity_prices(m, dt, col, df, df_residual_load_duration):
         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'
+        name=df.loc['plot_label_residual_load', st.session_state.lang],  # Residual load label
+        line=dict(color='red', width=2),  # Red line for secondary y-axis
+        yaxis='y2'  # Link this trace to the secondary y-axis
     ))
     
-    # Layout mit neuen title-formaten (kein titlefont mehr!)
+    # Layout mit separaten Achsen
     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]
+            title=df.loc['label_hours', st.session_state.lang]  # Common x-axis
         ),
         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')
+            title=df.loc['plot_label_price_duration_curve', st.session_state.lang],  # Title for primary y-axis
+            range=[-(100/(ax2_max/(ax2_max-ax2_min))-100), 100],  # Primary y-axis range
+            titlefont=dict(color='blue'),  # Blue color for primary axis title
+            tickfont=dict(color='blue')  # Blue ticks for primary axis
         ),
         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'
+            title=df.loc['plot_label_residual_load', st.session_state.lang],  # Title for secondary y-axis
+            range=[ax2_min, ax2_max],  # Secondary y-axis range
+            titlefont=dict(color='red'),  # Red color for secondary axis title
+            tickfont=dict(color='red'),  # Red ticks for secondary axis
+            overlaying='y',  # Overlay secondary axis on primary
+            side='right'  # Place secondary y-axis on the right side
         ),
-        legend=dict(
-            x=1,
-            y=1,
-            xanchor='right',
-            yanchor='top',
-            bgcolor='rgba(255, 255, 255, 0.5)',
-            bordercolor='black',
-            borderwidth=1
-        )
+    legend=dict(
+        x=1,  # Positioniert die Legende am rechten Rand
+        y=1,  # Positioniert die Legende am oberen Rand
+        xanchor='right',  # Verankert die Legende am rechten Rand
+        yanchor='top',  # Verankert die Legende am oberen Rand
+        bgcolor='rgba(255, 255, 255, 0.5)',  # Weißer Hintergrund mit Transparenz
+        bordercolor='black',
+        borderwidth=1
+    )
     )
 
+    
     with col:
         st.plotly_chart(fig_duration)
+
+    # Set y-axis range conditionally
+    range_y = [0, 250] if st.session_state.level == "graduate" else None
+    # 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': ''}
+                        )
+    
+    # Apply axis range if needed
+    if range_y is not None:
+        fig_price.update_yaxes(range=range_y)
+    
+    with col:
+        st.plotly_chart(fig_price)
     
     return df_price
 
@@ -1072,7 +1186,7 @@ def plot_contribution_margin(m, dt, i_with_capacity, color_dict, col, df):
 
 
 
-def plot_curtailment(m, iRes, color_dict, col, df):
+def plot_curtailment(m, iRes, color_dict, col, df, show=True):
     """
     Plots the curtailment of renewable energy.
     Supports both German and English labels for titles and axes while ensuring color consistency.
@@ -1117,8 +1231,9 @@ def plot_curtailment(m, iRes, color_dict, col, df):
         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)
+    if show: 
+        with col:
+            st.plotly_chart(fig)
 
     return df_curtailment
 
@@ -1231,6 +1346,364 @@ def plot_hydrogen_production(m, iPtG, color_dict, col, df):
 
 
 
+def calculate_and_plot_fullload_hours(m, dt, color_dict, col):
+    """
+    Calculates full load hours for units with positive capacity and plots the result.
+
+    Parameters:
+    - m: Optimization model object containing solution['K'] (capacity) and solution['y'] (production).
+    - dt: Time resolution of the production data (e.g., in hours).
+    - color_dict: Dictionary mapping unit identifiers (i) to colors for plotting.
+    - col: Streamlit column or panel where the plot should be rendered (e.g., colb1).
+    """
+    # Filter indices with positive capacity
+    i_with_capacity = m.solution['K'].where(m.solution['K'] > 0).dropna(dim='i').get_index('i')
+
+    # Extract production and capacity data
+    df_production = m.solution['y'].sel(i=i_with_capacity).to_dataframe().reset_index()
+    df_capacity = m.solution['K'].sel(i=i_with_capacity).to_dataframe().reset_index()
+
+    # Sum production and calculate full load hours
+    df_production_sum = (df_production.groupby('i')['y'].sum() * dt).round(0).reset_index()
+    df_production_sum = df_production_sum.set_index('i').loc[i_with_capacity].reset_index()
+
+    df_fullload = df_production_sum['y'] / df_capacity['K']
+    df_fullload = df_fullload.to_frame(name='fullload')
+    df_fullload['i'] = df_production_sum['i']
+    df_fullload = df_fullload[['i', 'fullload']]
+
+    # Plot
+    fig = px.bar(
+        df_fullload,
+        y='i',
+        x='fullload',
+        orientation='h',
+        title='Volllaststunden [h]',
+        color='i',
+        color_discrete_map=color_dict
+    )
+    col.plotly_chart(fig)
+
+    return df_fullload
+
+
+
+def calculate_and_plot_emissions(m, eff_i, co2_factor_i, dt, color_dict, col):
+    """
+    Calculates emissions from model output and plots an area chart of emissions over time.
+
+    Parameters:
+    - m: Optimization model with solution['y'] (production) and solution['K'] (capacity).
+    - eff_i: xarray DataArray of efficiency values indexed by 'i'.
+    - co2_factor_i: xarray DataArray of CO₂ emission factors indexed by 'i'.
+    - dt: Time resolution of the data (e.g., in hours).
+    - color_dict: Dictionary mapping unit identifiers (i) to colors.
+    - col: Streamlit column or panel for rendering the plot.
+
+    Returns:
+    - df_production_emissions_unpivot: DataFrame with emissions per unit and time.
+    """
+
+    # Filter technologies with positive capacity
+    i_with_capacity = m.solution['K'].where(m.solution['K'] > 0).dropna(dim='i').get_index('i')
+
+    # Get production data for those technologies
+    df_production = m.solution['y'].sel(i=i_with_capacity).to_dataframe().reset_index()
+
+    # Pivot production data
+    df_production_pivot = df_production.pivot(index='t', columns='i', values='y')
+    available_columns = df_production_pivot.columns.intersection(i_with_capacity)
+    df_production_pivot = df_production_pivot[available_columns]
+
+    # Get efficiency and CO₂ factors only for available technologies
+    df_efficiency = eff_i.sel(i=available_columns)
+    co2_factor_i_with_capacity = co2_factor_i.sel(i=available_columns)
+    color_dict_with_capacity = {i: color_dict[i] for i in available_columns}
+    desired_order = available_columns.tolist()
+
+    # Compute emissions
+    df_production_emissions = df_production_pivot / df_efficiency * co2_factor_i_with_capacity * dt
+
+    # Unpivot for plotting
+    df_production_emissions_unpivot = df_production_emissions.reset_index().melt(
+        id_vars='t', var_name='i', value_name='y'
+    )
+    df_production_emissions_unpivot['i'] = pd.Categorical(
+        df_production_emissions_unpivot['i'],
+        categories=desired_order,
+        ordered=True
+    )
+    df_production_emissions_unpivot = df_production_emissions_unpivot.sort_values(by=['t', 'i'])
+
+    # Plot
+    fig = px.area(
+        df_production_emissions_unpivot,
+        y='y',
+        x='t',
+        title='CO₂-Emissionen [t]',
+        color='i',
+        color_discrete_map=color_dict_with_capacity
+    )
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+
+    # Display in Streamlit
+    col.plotly_chart(fig)
+
+    return df_production_emissions_unpivot
+
+
+def calculate_and_plot_cumulative_emissions(m, eff_i, co2_factor_i, dt, color_dict, col, df):
+    """
+    Calculates and plots cumulative CO₂ emissions sorted by time for units with capacity > 0,
+    with support for multilingual labels and consistent coloring.
+
+    Parameters:
+    - m: Optimization model with 'K' and 'y'
+    - eff_i: DataArray of efficiencies indexed by 'i'
+    - co2_factor_i: DataArray of CO₂ factors indexed by 'i'
+    - dt: Time resolution
+    - color_dict: Dict mapping English tech names to colors
+    - col: Streamlit column for plot
+    - df: DataFrame for label translations (e.g., from Excel)
+
+    Returns:
+    - df_cumulative_emissions_unpivot: Cumulative emissions DataFrame (melted format)
+    """
+
+    # Step 1: Filter technologies with capacity > 0
+    i_with_capacity = m.solution['K'].where(m.solution['K'] > 0).dropna(dim='i').get_index('i')
+
+    # Step 2: Get production data
+    df_production = m.solution['y'].sel(i=i_with_capacity).to_dataframe().reset_index()
+    df_production['i_en'] = df_production['i']
+
+    # Translate if needed
+    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'].unique()
+            if f'tech_{tech.lower()}' in df.index
+        }
+        df_production['i'] = df_production['i_en'].replace(tech_mapping_en_to_de)
+
+    # Step 3: Pivot and align
+    df_production_pivot = df_production.pivot(index='t', columns='i_en', values='y')
+    available_columns = df_production_pivot.columns.intersection(i_with_capacity)
+    df_production_pivot = df_production_pivot[available_columns]
+
+    # Step 4: Emissions calculation
+    df_efficiency = eff_i.sel(i=available_columns)
+    co2_factor_i_with_capacity = co2_factor_i.sel(i=available_columns)
+    df_emissions = df_production_pivot / df_efficiency * co2_factor_i_with_capacity * dt
+
+    # Step 5: Add total and sort
+    df_emissions['total'] = df_emissions.sum(axis=1)
+    df_emissions_sorted = df_emissions.sort_values(by='total', ascending=True)
+
+    # Step 6: Cumulative sum and cleanup
+    df_cumsum = df_emissions_sorted.drop(columns='total').cumsum(axis=0)
+    df_cumsum = df_cumsum.loc[:, (df_cumsum != 0).any(axis=0)]
+
+    # Step 7: Unpivot
+    df_cumulative_emissions_unpivot = df_cumsum.reset_index().melt(
+        id_vars='t', var_name='i_en', value_name='y'
+    )
+
+    # Step 8: Translate display names (if needed)
+    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_cumulative_emissions_unpivot['i_en'].unique()
+            if f'tech_{tech.lower()}' in df.index
+        }
+        df_cumulative_emissions_unpivot['i'] = df_cumulative_emissions_unpivot['i_en'].replace(tech_mapping_en_to_de)
+    else:
+        df_cumulative_emissions_unpivot['i'] = df_cumulative_emissions_unpivot['i_en']
+
+    # Set 0 → NaN for plotting
+    df_cumulative_emissions_unpivot['y'] = df_cumulative_emissions_unpivot['y'].replace(0, np.nan)
+
+    # Step 9: Plot
+    color_dict_with_capacity = {i: color_dict[i] for i in df_cumulative_emissions_unpivot['i_en'].unique() if i in color_dict}
+
+    fig = px.area(
+        df_cumulative_emissions_unpivot,
+        y='y',
+        x='t',
+        title=df.loc['plot_label_cumulative_emissions', st.session_state.lang],
+        color='i_en',
+        color_discrete_map=color_dict_with_capacity,
+        labels={'i': '', 'y': ''}
+    )
+
+    # Rename legend entries to display translated names
+    legend_map = dict(zip(
+        df_cumulative_emissions_unpivot['i_en'],
+        df_cumulative_emissions_unpivot['i']
+    ))
+
+    fig.for_each_trace(
+        lambda t: t.update(name=legend_map.get(t.name, t.name),
+                        legendgroup=legend_map.get(t.name, t.name),
+                        hovertemplate=t.hovertemplate.replace(t.name, legend_map.get(t.name, t.name)))
+    )
+    fig.update_traces(line=dict(width=0))
+    fig.for_each_trace(lambda trace: trace.update(fillcolor=trace.line.color))
+    fig.update_layout(legend_title_text=None)
+
+    col.plotly_chart(fig)
+
+    return df_cumulative_emissions_unpivot
+
+
+
+def calculate_and_plot_investment_costs(m, df_new_capacities, c_inv_i, color_dict, col, df):
+    """
+    Calculates and plots investment costs per technology, with multilingual support.
+    - Uses 'i_en' for color consistency.
+    - Displays 'i' in the selected language.
+    - Filters out 'Battery storages'.
+    
+    Parameters:
+    - df_new_capacities: DataFrame with columns ['i', 'K'] for new capacities.
+    - c_inv_i: xarray DataArray or Series with investment costs indexed by 'i'.
+    - color_dict: Dictionary mapping English technology identifiers (i_en) to colors.
+    - col: Streamlit column to display the plot.
+    - df: Translation/label lookup DataFrame with keys like 'tech_pv', 'tech_windon' etc.
+
+    Returns:
+    - df_invest_costs: DataFrame with investment costs per technology.
+    """
+
+    # Ensure 'i_en' is available for color mapping
+    df_new_capacities = df_new_capacities.copy()
+    df_new_capacities['i_en'] = df_new_capacities['i']
+    i_with_capacity = m.solution['K'].where(m.solution['K'] > 0).dropna(dim='i').get_index('i')
+    available_columns = df_new_capacities.columns.intersection(i_with_capacity)
+
+    # Translate if language is German
+    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
+        }
+        df_new_capacities['i'] = df_new_capacities['i_en'].replace(tech_mapping_en_to_de)
+
+    # Filter out 'Battery storages'
+    df_filtered = df_new_capacities[df_new_capacities['i_en'] != 'Battery storages'].copy()
+
+    # # Calculate investment costs
+    df_filtered['Investment'] = df_filtered['K'] * c_inv_i
+    color_dict_with_capacity = {i: color_dict[i] for i in available_columns}
+    # Plot
+    fig = px.bar(
+        df_filtered,
+        y='i',
+        x='Investment',
+        orientation='h',
+        title=df.loc['plot_label_investment_costs', st.session_state.lang],
+        color='i_en',
+        color_discrete_map=color_dict_with_capacity,  
+        labels={'i': '', 'Investment': ''}
+    )
+    fig.update_layout(showlegend=False)
+    col.plotly_chart(fig)
+
+    return df_filtered
+
+
+def calculate_and_plot_contribution_margin(m, i, iRes, dt, color_dict, col, df):
+    """
+    Calculates and plots the contribution margin (Deckungsbeitrag) per technology.
+    Mirrors original working logic, with optional language and coloring.
+
+    Parameters:
+    - m: Optimization model with 'y', 'max_cap', 'load'
+    - i: Full list of technologies (for ordering and reindexing)
+    - iRes: Subset of residual techs (e.g. PV, WindOn)
+    - dt: Time step length in hours
+    - color_dict: Dictionary of colors (keyed by technology names)
+    - col: Streamlit column to display the plot
+    - df: Translation table with tech labels and plot titles
+
+    Returns:
+    - df_contr_marg_sum: DataFrame with contribution margin results
+    """
+
+    # Production data for all technologies
+    df_production_all = m.solution['y'].sel(i=i).to_dataframe().reset_index()
+    
+    # Dual values from max_cap constraint
+    df_contr_marg = m.constraints['max_cap'].dual.to_dataframe().reset_index()
+
+    # Merge and multiply
+    df_merged = pd.merge(df_production_all, df_contr_marg, on=['t', 'i'])
+    df_merged['y_new'] = df_merged['y'] * df_merged['dual']
+    df_merged = df_merged[['t', 'i', 'y_new']]
+    df_contr_marg_sum = df_merged.groupby('i')['y_new'].sum().reset_index()
+
+    # Handle residual technologies with load constraint duals
+    df_production_res = m.solution['y'].sel(i=iRes).to_dataframe().reset_index()
+    df_price_res = m.constraints['load'].dual.to_dataframe().reset_index()
+    df_merged_res = pd.merge(df_production_res, df_price_res, on='t')
+    df_merged_res['multiplied_value'] = df_merged_res['y'] * df_merged_res['dual']
+    df_merged_res = df_merged_res[['t', 'i', 'multiplied_value']]
+    df_contr_marg_res = df_merged_res.groupby('i')['multiplied_value'].sum().reset_index()
+    df_contr_marg_res['multiplied_value'] = df_contr_marg_res['multiplied_value'] * -dt
+
+    # Combine both results
+    df_contr_marg_sum = pd.merge(df_contr_marg_sum, df_contr_marg_res, on='i', how='left')
+    df_contr_marg_sum['y_new'] = df_contr_marg_sum['multiplied_value'].combine_first(df_contr_marg_sum['y_new'])
+    df_contr_marg_sum = df_contr_marg_sum.drop(columns=['multiplied_value'])
+    df_contr_marg_sum['y'] = df_contr_marg_sum['y_new'] * -1
+
+    # Translate labels if needed
+    if st.session_state.lang == 'DE':
+        tech_mapping = {
+            df.loc[f'tech_{tech.lower()}', 'EN']: df.loc[f'tech_{tech.lower()}', 'DE']
+            for tech in i if f'tech_{tech.lower()}' in df.index
+        }
+        df_contr_marg_sum['i_en'] = df_contr_marg_sum['i']
+        df_contr_marg_sum['i'] = df_contr_marg_sum['i_en'].replace(tech_mapping)
+    else:
+        df_contr_marg_sum['i_en'] = df_contr_marg_sum['i']
+
+    # Reorder by original list
+    # df_contr_marg_sum = df_contr_marg_sum.set_index('i_en').loc[i].reset_index(drop=False)
+    if 'i' in df_contr_marg_sum.columns:
+        df_contr_marg_sum = df_contr_marg_sum.drop(columns='i')
+
+    df_contr_marg_sum = df_contr_marg_sum.set_index('i_en').loc[i].reset_index()
+
+    # Plot
+    title = df.loc['plot_label_contribution_margin', st.session_state.lang]
+    fig = px.bar(
+        df_contr_marg_sum,
+        y='i',
+        x='y',
+        orientation='h',
+        title=title,
+        color='i_en',
+        color_discrete_map=color_dict,
+        labels={'i': '', 'y': ''}
+    )
+
+    # Localized legend
+    legend_map = dict(zip(df_contr_marg_sum['i_en'], df_contr_marg_sum['i']))
+    fig.for_each_trace(lambda t: t.update(
+        name=legend_map.get(t.name, t.name),
+        legendgroup=legend_map.get(t.name, t.name),
+        hovertemplate=t.hovertemplate.replace(t.name, legend_map.get(t.name, t.name))
+    ))
+    fig.update_layout(legend_title_text=None)
+
+    col.plotly_chart(fig)
+
+    return df_contr_marg_sum
+
+
+
 def disaggregate_df(df, t, t_original, dt):
     """
     Disaggregates the DataFrame based on the original time steps.

language.csv

@@ -2,6 +2,9 @@ Label;DE;EN
 menu_modell;Modell;Model
 menu_doku;Dokumentation;Documentation
 menu_impressum;�ber uns;About
+menu_level;Auswahl Schwierigkeitsgrad;Select level
+menu_graduate;Master;Graduate
+menu_untergraduate;Bachelor;Undergraduate
 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
@@ -26,8 +29,8 @@ 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_ccgt;GuD-Kraftwerk;CCGT
+tech_ocgt;Gasturbine;OCGT
 tech_fossil hard coal;Steinkohle;Fossil Hard coal
 tech_fossil oil;�l;Fossil Oil
 tech_ror;Laufwasser;RoR
@@ -50,6 +53,11 @@ plot_label_total_production_pie;Gesamtproduktion [GWh] als Kreisdiagramm;Total P
 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]
+plot_label_fullload-hours;Volllaststunden [h/a];Full load hours [h/a]
+plot_label_emissions;Emittierte CO2-Emissionen im Jahresverlauf [t];CO2-Emissions [t]
+plot_label_cumulative_emissions;Kumulierte CO2-Emissionen [t];Cumulative CO2-Emissions [t]
+plot_label_investment_costs;Investitionskosten [EUR];Investment costs [EUR]
+plot_label_contribution_margin_undergrad;Deckungsbeitrag [EUR];Contribution Margin [EUR]
 label_electricity_price;Strompreis;Electricity price
 label_time;Zeit;Time
 label_technology;Technologien;Technologies