Update app.py

app.py

@@ -129,6 +129,7 @@ upper_space.markdown("""
 
 
 countries = {
+    'Overall': 'Overall',
     'Netherlands': 'NL',
     'Germany': 'DE',
     'France': 'FR',
@@ -143,54 +144,55 @@ st.sidebar.caption("Choose the country for which you want to display data or for
 
 selected_country = st.sidebar.selectbox('Select Country', list(countries.keys()))
 
+# Ensure the date range provides two dates
 
-st.sidebar.subheader("Select Date Range ")
-st.sidebar.caption("Define the time period over which the accuracy metrics will be calculated.")
 
-st.write()
-date_range = st.sidebar.date_input("Select Date Range for Metrics Calculation:", 
+# Sidebar with radio buttons for different sections
+if selected_country != 'Overall':
+    st.sidebar.subheader("Section")
+    st.sidebar.caption("Select the type of information you want to explore.")
+    section = st.sidebar.radio('', ['Data Quality', 'Forecasts Quality', 'Insights'], index=1)
+    date_range = st.sidebar.date_input("Select Date Range for Metrics Calculation:", 
                                    value=(pd.to_datetime("2024-01-01"), pd.to_datetime(pd.Timestamp('today'))))
+    if len(date_range) == 2:
+        start_date = pd.Timestamp(date_range[0])
+        end_date = pd.Timestamp(date_range[1])
+    else:
+        st.error("Please select a valid date range.")
+        st.stop()
 
-# Ensure the date range provides two dates
-if len(date_range) == 2:
-    start_date = pd.Timestamp(date_range[0])
-    end_date = pd.Timestamp(date_range[1])
 else:
-    st.error("Please select a valid date range.")
-    st.stop()
-
-st.sidebar.subheader("Section")
-st.sidebar.caption("Select the type of information you want to explore.")
+    section = None  # No section is shown when "Overall" is selected
 
-
-# Sidebar with radio buttons for different sections
-section = st.sidebar.radio('', ['Data', 'Forecasts', 'Insights'],index=1)
-
-country_code = countries[selected_country]
-if country_code == 'BE':
-    data = Data_BE
-    weather_columns = ['Temperature', 'Wind Speed Onshore', 'Wind Speed Offshore']
-    data['Temperature'] = data['temperature_2m_8']
-    data['Wind Speed Offshore'] = data['wind_speed_100m_4']
-    data['Wind Speed Onshore'] = data['wind_speed_100m_8']
-
-elif country_code == 'DE':
-    data = Data_DE
-    weather_columns = ['Temperature', 'Wind Speed']
-    data['Temperature'] = data['temperature_2m']
-    data['Wind Speed'] = data['wind_speed_100m']
-
-elif country_code == 'NL':
-    data = Data_NL
-    weather_columns = ['Temperature', 'Wind Speed']
-    data['Temperature'] = data['temperature_2m']
-    data['Wind Speed'] = data['wind_speed_100m']
-
-elif country_code == 'FR':
-    data = Data_FR
-    weather_columns = ['Temperature', 'Wind Speed']
-    data['Temperature'] = data['temperature_2m']
-    data['Wind Speed'] = data['wind_speed_100m']
+if selected_country == 'Overall':
+    data = None  # You can set data to None or a specific dataset based on your logic
+    section = None  # No section selected when "Overall" is chosen
+else:
+    country_code = countries[selected_country]
+    if country_code == 'BE':
+        data = Data_BE
+        weather_columns = ['Temperature', 'Wind Speed Onshore', 'Wind Speed Offshore']
+        data['Temperature'] = data['temperature_2m_8']
+        data['Wind Speed Offshore'] = data['wind_speed_100m_4']
+        data['Wind Speed Onshore'] = data['wind_speed_100m_8']
+
+    elif country_code == 'DE':
+        data = Data_DE
+        weather_columns = ['Temperature', 'Wind Speed']
+        data['Temperature'] = data['temperature_2m']
+        data['Wind Speed'] = data['wind_speed_100m']
+
+    elif country_code == 'NL':
+        data = Data_NL
+        weather_columns = ['Temperature', 'Wind Speed']
+        data['Temperature'] = data['temperature_2m']
+        data['Wind Speed'] = data['wind_speed_100m']
+
+    elif country_code == 'FR':
+        data = Data_FR
+        weather_columns = ['Temperature', 'Wind Speed']
+        data['Temperature'] = data['temperature_2m']
+        data['Wind Speed'] = data['wind_speed_100m']
 
 def add_feature(df2, df_main):
     #df_main.index = pd.to_datetime(df_main.index)
@@ -208,12 +210,7 @@ def add_feature(df2, df_main):
 forecast_columns = [
     'Load_entsoe','Load_forecast_entsoe','Wind_onshore_entsoe','Wind_onshore_forecast_entsoe','Wind_offshore_entsoe','Wind_offshore_forecast_entsoe','Solar_entsoe','Solar_forecast_entsoe']
 
-if section == 'Data':
-    st.header("Data")
-    st.write("""
-    This section allows you to explore and upload your datasets.
-    You can visualize raw data, clean it, and prepare it for analysis.
-    """)
+if section == 'Data Quality':
    
     st.header('Data Quality')
     
@@ -282,17 +279,14 @@ if section == 'Data':
     st.write('<b><u>Extreme/Nonsensical values (%)</u></b>: Values that are considered implausible such as negative or out-of-bound values i.e., (generation<0) or (generation>capacity)', unsafe_allow_html=True)
 
 # Section 2: Forecasts
-elif section == 'Forecasts':
+elif section == 'Forecasts Quality':
    
     st.header('Forecast Quality')
     
     # Time series for last 1 week
-    st.subheader('Time Series: Last 1 Week')
     last_week = data.loc[data.index >= (data.index[-1] - pd.Timedelta(days=7))]
-    st.write('The below plots show the time series of forecasts vs. observations provided by the ENTSO-E Transparency platform between the selected data range.')
+    st.write('The below plots show the time series of forecasts vs. observations provided by the ENTSO-E Transparency platform from the past week.')
 
-    forecast_columns = [
-    'Load_entsoe','Load_forecast_entsoe','Wind_onshore_entsoe','Wind_onshore_forecast_entsoe','Wind_offshore_entsoe','Wind_offshore_forecast_entsoe','Solar_entsoe','Solar_forecast_entsoe']
     num_per_var=2
 
     forecast_columns_line=forecast_columns
@@ -308,259 +302,6 @@ elif section == 'Forecasts':
             fig.update_layout(title=f'Forecasts vs Actual for {actual_col}', xaxis_title='Date', yaxis_title='Value [MW]')
         
             st.plotly_chart(fig)
-
-
-    def plot_category(df_dict, category_prefix, title):
-        fig = go.Figure()
-
-        # Define base colors for each model
-        model_colors = {
-            'LightGBMModel.TimeCov.Temp.Forecast_elia': '#1f77b4',  # Blue
-            'LightGBMModel.TimeCov.Temp': '#2ca02c',  # Green
-            'Naive': '#ff7f0e'  # Orange
-        }
-
-        # To keep track of which model has been added to the legend
-        legend_added = {'LightGBMModel.TimeCov.Temp.Forecast_elia': False, 'LightGBMModel.TimeCov.Temp': False, 'Naive': False}
-
-        for file_name, df in df_dict.items():
-            # Extract the hour from the filename, assuming the format is "Predictions_Xh.csv"
-            hour = int(file_name.split('_')[1].replace('h.csv', ''))
-            
-            filtered_columns = [col for col in df.columns if col.startswith(category_prefix)]
-            for column in filtered_columns:
-                # Identify the model type with more precise logic
-                if 'LightGBMModel' in column:
-                    if 'Forecast_elia' in column:
-                        model_key = 'LightGBMModel.TimeCov.Temp.Forecast_elia'
-                    elif 'TimeCov' in column:
-                        model_key = 'LightGBMModel.TimeCov.Temp'
-                elif 'Naive' in column:
-                    model_key = 'Naive'
-                else:
-                    continue  # Skip if it doesn't match any model type
-
-                # Extract the relevant part of the model name
-                parts = column.split('.')
-                model_name_parts = parts[1:]  # Skip the variable prefix
-                model_name = '.'.join(model_name_parts)  # Rejoin the parts to form the model name
-
-                # Get the base color for the model
-                base_color = model_colors[model_key]
-
-                # Calculate the color shade based on the hour
-                color_scale = pc.hex_to_rgb(base_color)
-                scale_factor = 0.3 + (hour / 40)  # Adjust scale to ensure the gradient is visible
-                adjusted_color = tuple(int(c * scale_factor) for c in color_scale)
-                # Convert to RGBA with transparency for plot lines
-                line_color = f'rgba({adjusted_color[0]}, {adjusted_color[1]}, {adjusted_color[2]}, 0.1)'  # Transparent color for lines
-
-                # Combine the hour and the model name for the legend, but only add the legend entry once
-                show_legend = not legend_added[model_key]
-
-                fig.add_trace(go.Scatter(
-                    x=df.index,  # Assuming 'Date' is the index, use 'df.index' for x-axis
-                    y=df[column],
-                    mode='lines',
-                    name=model_name if show_legend else None,  # Use the model name for the legend, but only once
-                    line=dict(color=base_color if show_legend else line_color),  # Use opaque color for legend, transparent for lines
-                    showlegend=show_legend,  # Show legend only once per model
-                    legendgroup=model_key  # Grouping for consistent legend color
-                ))
-
-                # Mark that this model has been added to the legend
-                if show_legend:
-                    legend_added[model_key] = True
-                
-            # Add real values as a separate trace, if provided
-            filtered_Data_BE_df = Data_BE.loc[df.index]
-
-        if filtered_Data_BE_df[f'{category_prefix}_entsoe'].notna().any():
-            fig.add_trace(go.Scatter(
-                x=filtered_Data_BE_df.index,
-                y=filtered_Data_BE_df[f'{category_prefix}_entsoe'],
-                mode='lines',
-                name=f'Actual {category_prefix}',
-                line=dict(color='black', width=2),  # Black line for real values
-                showlegend=True  # Always show this in the legend
-            ))
-
-        # Update layout to position the legend at the top, side by side
-        fig.update_layout(
-            title=dict(
-                text=title,
-                x=0,  # Center the title horizontally
-                y=1.00,  # Slightly lower the title to create more space
-                xanchor='left',
-                yanchor='top'
-            ),
-            xaxis_title='Date',
-            yaxis_title='Value',
-            legend=dict(
-                orientation="h",  # Horizontal legend
-                yanchor="bottom",  # Align to the bottom of the legend box
-                y=1,  # Increase y position to avoid overlap with the title
-                xanchor="center",  # Center the legend horizontally
-                x=0.5  # Position at the center of the plot
-            )
-        )
-        return fig
-    
-
-    def calculate_mae(y_true, y_pred):
-        return np.mean(np.abs(y_true - y_pred))
-    def plot_mae_comparison(df_dict, category_prefix, title, real_values_df):
-        hours = list(range(24))
-        if category_prefix=='Load':
-            model_colors = {
-                'LightGBMModel.7D.TimeCov.Temp.Forecast_elia': '#1F77B4',  # Blue
-                'LightGBMModel.7D.TimeCov.Temp': '#2CA02C',  # Green
-                'Naive': '#FF7F0E'  # Orange
-            }
-        else:
-            model_colors = {
-                'LightGBMModel.1D.TimeCov.Temp.Forecast_elia': '#1F77B4',  # Blue
-                'LightGBMModel.1D.TimeCov.Temp': '#2CA02C',  # Green
-                'Naive': '#FF7F0E'  # Orange
-            }
-        fig = go.Figure()
-        for model_key, base_color in model_colors.items():
-            hours_with_data = []
-            mae_ratios = []
-            for hour in hours:
-                file_name = f'Predictions_{hour}h.csv'
-                df = df_dict.get(file_name, None)
-                if df is None:
-                    continue
-                if isinstance(df.index, pd.DatetimeIndex):
-                    first_day = df.index.min().normalize()
-                    last_day = df.index.max().normalize()
-                    df = df[df.index.normalize() != first_day]
-                    df = df[df.index.normalize() != last_day]
-                # Adjusted filtering logic based on actual column names
-                filtered_columns = [col for col in df.columns if col.startswith(f"{category_prefix}_entsoe") and model_key in col]
-                if not filtered_columns:
-                    continue
-                # Assuming only one column matches, otherwise refine the selection logic
-                model_predictions = df[filtered_columns[0]]
-                actual_values = real_values_df[f'{category_prefix}_entsoe']
-                actual_values = actual_values.dropna()
-                # Align both series by their common indices
-                common_indices = model_predictions.index.intersection(actual_values.index)
-                aligned_model_predictions = model_predictions.loc[common_indices]
-                aligned_actual_values = actual_values.loc[common_indices]
-                # Calculate MAE for the model
-                model_mae = calculate_mae(aligned_actual_values, aligned_model_predictions)
-                # Calculate MAE for the entsoe forecast
-                entsoe_forecast = real_values_df[f'{category_prefix}_forecast_entsoe'].loc[common_indices]
-                entsoe_mae = calculate_mae(aligned_actual_values, entsoe_forecast)
-                # Calculate MAE ratio
-                mae_ratio = model_mae / entsoe_mae
-                mae_ratios.append(mae_ratio)
-                hours_with_data.append(hour)
-            # Plot the MAE ratio for this model as points
-            if mae_ratios:  # Only plot if there's data
-                fig.add_trace(go.Scatter(
-                    x=hours_with_data,  # The hours where we have data
-                    y=mae_ratios,
-                    mode='markers+lines',  # Plot as points connected by lines
-                    name=model_key,
-                    line=dict(color=base_color),
-                    marker=dict(color=base_color, size=8)  # Customize marker size
-                ))
-        # Update layout
-        fig.update_layout(
-            title=f'{category_prefix}: rMAE<span style="font-size:11px;">ENTSO-E</span> by hour of Forecasting.',
-            xaxis_title='Hour of Forecast',
-            yaxis_title='MAE Ratio (Model / entsoe)',
-            legend=dict(
-                orientation="h",
-                yanchor="bottom",
-                y=1.02,
-                xanchor="center",
-                x=0.5
-            )
-        )
-        return fig
-    
- 
-
-    def plot_mae_comparison_clock(df_dict, category_prefix, title, real_values_df):
-        hours = list(range(24))
-        if category_prefix=='Load':
-            model_colors = {
-                'LightGBM_with_Forecast_elia': '#1F77B4',  # Blue
-                'LightGBM': '#2CA02C',  # Green
-                'Naive': '#FF7F0E'  # Orange
-            }
-        else:
-            model_colors = {
-                'LightGBM_with_Forecast_elia': '#1F77B4',  # Blue
-                'LightGBM': '#2CA02C',  # Green
-                'Naive': '#FF7F0E'  # Orange
-            }
-
-        fig = go.Figure()
-
-        for model_key, base_color in model_colors.items():
-            hours_with_data = []
-            mae_ratios = []
-
-            for hour in hours:
-                file_name = f'Predictions_{hour}h.csv'
-                df = df_dict.get(file_name, None)
-                if df is None:
-                    continue
-
-                if isinstance(df.index, pd.DatetimeIndex):
-                    first_day = df.index.min().normalize()
-                    last_day = df.index.max().normalize()
-                    df = df[df.index.normalize() != first_day]
-                    df = df[df.index.normalize() != last_day]
-
-                filtered_columns = [col for col in df.columns if col.startswith(f"{category_prefix}_entsoe") and model_key in col]
-                if not filtered_columns:
-                    print(f"No matching columns for {model_key} at hour {hour}. Skipping...")
-                    continue
-
-                model_predictions = df[filtered_columns[0]]
-                actual_values = real_values_df[f'{category_prefix}_entsoe']
-                actual_values = actual_values.dropna()
-
-                common_indices = model_predictions.index.intersection(actual_values.index)
-                aligned_model_predictions = model_predictions.loc[common_indices]
-                aligned_actual_values = actual_values.loc[common_indices]
-
-                model_mae = calculate_mae(aligned_actual_values, aligned_model_predictions)
-                entsoe_forecast = real_values_df[f'{category_prefix}_forecast_entsoe'].loc[common_indices]
-                entsoe_mae = calculate_mae(aligned_actual_values, entsoe_forecast)
-
-                mae_ratio = model_mae / entsoe_mae
-                mae_ratios.append(mae_ratio)
-                hours_with_data.append(hour)
-
-            if mae_ratios:
-                fig.add_trace(go.Scatterpolar(
-                    r=mae_ratios + [mae_ratios[0]],  # Ensure closure of the polar plot
-                    theta=[h * 15 for h in hours_with_data] + [0],  # Ensure closure at 0 degrees
-                    mode='lines+markers',
-                    name=model_key,
-                    line=dict(color=base_color),
-                    marker=dict(color=base_color, size=8)
-                ))
-            else:
-                print(f"No data to plot for {model_key}.")  # Debugging print
-
-        fig.update_layout(
-            polar=dict(
-                radialaxis=dict(visible=True, range=[0, max(max(mae_ratios), 1.0) * 1.1] if mae_ratios else [0, 1.0]),
-                angularaxis=dict(tickmode='array', tickvals=[h * 15 for h in hours], ticktext=hours)
-            ),
-            title=f'{category_prefix}: rMAE<span style="font-size:11px;">ENTSO-E</span> by Hour of Forecasting',
-            showlegend=True
-        )
-
-        return fig
     
 
     # Scatter plots for error distribution
@@ -637,10 +378,8 @@ elif section == 'Forecasts':
                     
         $\text{rMAE} = \frac{\text{MAE}}{MAE_{\text{Persistence Model}}}$
                     
-
         """)
 
-    
 
     st.subheader('ACF plots of Errors')
     st.write('The below plots show the ACF (Auto-Correlation Function) for the errors of all three data fields obtained from ENTSO-E: Solar, Wind and Load.')
@@ -669,44 +408,151 @@ elif section == 'Insights':
     """)
 
     # Scatter plots for correlation between wind, solar, and load
-    st.subheader('Correlation between Wind, Solar, and Load')
-    st.write('The below scatter plots are made for checking whether there exists a correlation between all three data fields obtained from ENTSO-E: Solar, Wind and Load.')
-
-    combinations = [('Solar_entsoe', 'Load_entsoe'), ('Wind_onshore_entsoe', 'Load_entsoe'), ('Wind_offshore_entsoe', 'Load_entsoe'), ('Solar_entsoe', 'Wind_onshore_entsoe'), ('Solar_entsoe', 'Wind_offshore_entsoe')]
-
-    for x_col, y_col in combinations:
-        if x_col in data.columns and y_col in data.columns:
-            # For solar combinations, filter out zero values
-            if 'Solar_entsoe' in x_col:
-                filtered_data = data[data['Solar_entsoe'] > 0]
-                x_values = filtered_data[x_col]
-                y_values = filtered_data[y_col]
-            else:
-                x_values = data[x_col]
-                y_values = data[y_col]
-
-            corr_coef = x_values.corr(y_values)
-            fig = px.scatter(
-                x=x_values,
-                y=y_values,
-                labels={'x': f'{x_col} [MW]', 'y': f'{y_col} [MW]'},
-                title=f'{x_col} vs {y_col} (Correlation: {corr_coef:.2f})', color_discrete_sequence=['grey'])
-            st.plotly_chart(fig)
+    st.subheader('Correlation between Wind, Solar, Load and Weather Features')
+    st.write('The below scatter plots are made for checking whether there exists a correlation between the data fields obtained: Solar, Wind, Load and Weather Features.')
+
+    selected_columns=['Load_entsoe', 'Solar_entsoe', 'Wind_offshore_entsoe', 'Wind_onshore_entsoe'] + weather_columns
+    selected_df=data[selected_columns]
+    selected_df.columns = [col.replace('_entsoe', '').replace('_', ' ') for col in selected_df.columns]
+    selected_df = selected_df.dropna()
+    print(selected_df)
+    sns.set_theme(style="ticks")
+    pairplot_fig = sns.pairplot(selected_df)
+
+    # Display the pairplot in Streamlit
+    st.pyplot(pairplot_fig)
+
+elif selected_country == 'Overall':
+    st.subheader("Net Load Error Map")
+    st.write("""
+        The net load error map highlights the error in the forecasted versus actual net load for each country. 
+        Hover over each country to see details on the latest net load error and the timestamp of the last recorded data.
+    """)
+    
+    def plot_net_load_error_map(data_dict):
+        # Define forecast columns used in calculation
+
+        def calculate_net_load_error(df):
+            filter_df = df[forecast_columns].dropna()
+            net_load = filter_df['Load_entsoe'] - filter_df['Wind_onshore_entsoe'] - filter_df['Wind_offshore_entsoe'] - filter_df['Solar_entsoe']
+            net_load_forecast = filter_df['Load_forecast_entsoe'] - filter_df['Wind_onshore_forecast_entsoe'] - filter_df['Wind_offshore_forecast_entsoe'] - filter_df['Solar_forecast_entsoe']
+            error = (net_load - net_load_forecast).iloc[-1]
+            date = filter_df.index[-1].strftime("%Y-%m-%d %H:%M")  # Get the latest date in string format
+            return error, date
+
+        # Calculate net load errors and dates for each country
+        net_load_errors = {country_name: calculate_net_load_error(data) for country_name, data in data_dict.items()}
+
+        # Create DataFrame for Folium with additional date column
+        df_net_load_error = pd.DataFrame({
+            'country': list(net_load_errors.keys()),
+            'net_load_error': [v[0] for v in net_load_errors.values()],
+            'date': [v[1] for v in net_load_errors.values()]
+        })
+
+        # Load the GeoJSON file
+        geojson_url = "https://raw.githubusercontent.com/python-visualization/folium/master/examples/data/world-countries.json"
+        geo_data = requests.get(geojson_url).json()
+
+        # Filter GeoJSON to only include the selected countries
+        selected_countries = list(data_dict.keys())  # Get the list of selected countries (Belgium, France, Germany, Netherlands)
+        filtered_geojson = {
+            "type": "FeatureCollection",
+            "features": [feature for feature in geo_data["features"] if feature["properties"]["name"] in selected_countries]
+        }
 
+        # Merge the geojson with the error and date data
+        for feature in filtered_geojson["features"]:
+            country_name = feature["properties"]["name"]
+            row = df_net_load_error[df_net_load_error['country'] == country_name]
+            if not row.empty:
+                feature["properties"]["net_load_error"] = row.iloc[0]["net_load_error"]
+                feature["properties"]["date"] = row.iloc[0]["date"]
+
+        # Initialize the Folium map centered on Central Europe
+        m = folium.Map(location=[51, 10], zoom_start=5, tiles="cartodb positron")
+
+        # Add choropleth layer to map net load errors by country
+        folium.Choropleth(
+            geo_data=filtered_geojson,
+            name="choropleth",
+            data=df_net_load_error,
+            columns=["country", "net_load_error"],
+            key_on="feature.properties.name",
+            fill_color="RdYlBu",  # Use a more vibrant color palette
+            fill_opacity=0.7,
+            line_opacity=0.5,
+            line_color="black",  # Neutral border color
+            legend_name="Net Load Error"
+        ).add_to(m)
+
+        # Add a GeoJson layer with custom tooltip for country, error, and date
+        folium.GeoJson(
+            filtered_geojson,
+            style_function=lambda x: {'fillOpacity': 0, 'color': 'black', 'weight': 0},
+            tooltip=folium.GeoJsonTooltip(
+                fields=["name", "net_load_error", "date"],
+                aliases=["Country:", "Net Load Error:", "Date:"],
+                localize=True
+            )
+        ).add_to(m)
+
+        # Display Folium map in Streamlit
+        st_folium(m, width=700, height=600)
 
-    st.subheader('Weather vs. Generation/Demand')
-    st.write('The below scatter plots show the relation between weather parameters (i.e., Temperature, Wind Speed) and the generation/demand data from ENTSO-E.')
+    # Data dictionary with full country names
+    data_dict = {
+        'Belgium': Data_BE,
+        'France': Data_FR,
+        'Germany': Data_DE,
+        'Netherlands': Data_NL
+    }
 
-    for weather_col in weather_columns:
-        for actual_col in ['Load_entsoe', 'Solar_entsoe', 'Wind_onshore_entsoe', 'Wind_offshore_entsoe']:
-            if weather_col in data.columns and actual_col in data.columns:
-                clean_label = actual_col.replace('_entsoe', '')
+    # Call the function to plot the map
+    plot_net_load_error_map(data_dict)
 
-                if weather_col == 'Temperature':
-                    fig = px.scatter(x=data[weather_col], y=data[actual_col], labels={'x': f'{weather_col} (°C)', 'y': f'{clean_label} Generation [MW]'}, color_discrete_sequence=['orange'])
-                else:
-                    fig = px.scatter(x=data[weather_col], y=data[actual_col], labels={'x': f'{weather_col} (km/h)', 'y': clean_label})
-                fig.update_layout(title=f'{weather_col} vs {actual_col}')
-                st.plotly_chart(fig)
+    st.subheader("rMAE of Forecasts published on ENTSO-E TP")
+    st.write("""
+        The radar chart below compares the forecast accuracy across Load, Onshore Wind, Offshore Wind, and Solar for each country. 
+    """)
 
+    def calculate_mae(actual, forecast):
+        return np.mean(np.abs(actual - forecast))
+
+    # Function to calculate persistence MAE
+    def calculate_persistence_mae(data, shift_hours):
+        return np.mean(np.abs(data - data.shift(shift_hours)))
+
+    # Function to calculate rMAE for each country
+    def calculate_rmae_for_country(df):
+        rmae = {}
+        rmae['Load'] = calculate_mae(df['Load_entsoe'], df['Load_forecast_entsoe']) / calculate_persistence_mae(df['Load_entsoe'], 168)
+        rmae['Wind_onshore'] = calculate_mae(df['Wind_onshore_entsoe'], df['Wind_onshore_forecast_entsoe']) / calculate_persistence_mae(df['Wind_onshore_entsoe'], 24)
+        rmae['Wind_offshore'] = calculate_mae(df['Wind_offshore_entsoe'], df['Wind_offshore_forecast_entsoe']) / calculate_persistence_mae(df['Wind_offshore_entsoe'], 24)
+        rmae['Solar'] = calculate_mae(df['Solar_entsoe'], df['Solar_forecast_entsoe']) / calculate_persistence_mae(df['Solar_entsoe'], 24)
+        return rmae
+
+    # Function to create rMAE DataFrame
+    def create_rmae_dataframe(data_dict):
+        rmae_values = {'Country': [], 'Load': [], 'Wind_onshore': [], 'Wind_offshore': [], 'Solar': []}
+        for country_name, df in data_dict.items():
+            df_filtered = df[forecast_columns].dropna()
+            rmae = calculate_rmae_for_country(df_filtered)
+            rmae_values['Country'].append(country_name)
+            for key in rmae:
+                rmae_values[key].append(rmae[key])
+        return pd.DataFrame(rmae_values)
+
+    # Function to plot radar chart
+    def plot_rmae_radar_chart(rmae_df):
+        fig = go.Figure()
+        angles = ['Load', 'Wind_onshore', 'Wind_offshore', 'Solar']
+        for _, row in rmae_df.iterrows():
+            fig.add_trace(go.Scatterpolar(r=[row[angle] for angle in angles], theta=angles, fill='toself', name=row['Country']))
+        fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 2])), showlegend=True, title="rMAE Radar Chart by Country")
+        st.plotly_chart(fig)
+
+    # Main execution to create and display radar plot
+    rmae_df = create_rmae_dataframe(data_dict)
+    plot_rmae_radar_chart(rmae_df)