Update app.py

app.py

@@ -27,12 +27,7 @@ def get_renewable_energy_data(city_code):
     return result_df, None
 
 # Optimize energy system and use MGA
-def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range, thresholds, selected_tech):
-    data, error = get_renewable_energy_data(city_code)
-    if error:
-        st.error(error)
-        return None
-
+def optimize_energy_system(data, technologies, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range, thresholds, selected_tech):
     for col in data.columns[1:]:
         data[col] = pd.to_numeric(data[col], errors='coerce')
     data = data.fillna(0)
@@ -47,7 +42,6 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     demand = demand_cf * yearly_demand * 1e6 / demand_cf.sum()  # MW
 
     regions = ['region1']
-    technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
     capacity_factor = {
         'solar': solar_cf,
         'onshore_wind': onshore_wind_cf,
@@ -120,10 +114,22 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     model.solve()
     optimal_cost = pulp.value(model.objective)
 
+    # Collect the initial solution
+    initial_solution = {
+        'threshold': 0,
+        'type': 'optimal',
+        'technology': 'all',
+        'solution': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
+        'battery_capacity': battery_capacity.varValue,
+        'total_cost': optimal_cost
+    }
+
     # MGA: Generate alternative solutions for selected technologies only
-    alternative_solutions = []
+    alternative_solutions = [initial_solution]
 
     for threshold in thresholds:
+        if threshold == 0:
+            continue  # Already have the optimal solution
         relaxed_cost = optimal_cost * (1 + threshold)
         for tech in selected_tech:
             # Create a copy of the model
@@ -145,11 +151,8 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
             alt_battery_storage = pulp.LpVariable.dicts("alt_battery_storage",
                                                         time_steps, lowBound=0, cat='Continuous')
 
-            # Objective: minimize or maximize the capacity of the selected technology
-            if threshold == 0:
-                alt_model += alt_renewable_capacity[('region1', tech)], f"Minimize_{tech}_Capacity"
-            else:
-                alt_model += -alt_renewable_capacity[('region1', tech)], f"Maximize_{tech}_Capacity"
+            # Objective: maximize the capacity of the selected technology
+            alt_model += -alt_renewable_capacity[('region1', tech)], f"Maximize_{tech}_Capacity"
 
             # Add the cost constraint
             alt_model += pulp.lpSum([alt_renewable_capacity[('region1', g)] * renewable_capacity_cost[g] for g in technologies]) + \
@@ -192,14 +195,15 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
             # Solve the alternative model
             alt_model.solve()
             if pulp.LpStatus[alt_model.status] == 'Optimal':
-                alternative_solutions.append({
+                alt_solution = {
                     'threshold': threshold,
-                    'type': 'min' if threshold == 0 else 'max',
+                    'type': 'max',
                     'technology': tech,
                     'solution': {g: alt_renewable_capacity[('region1', g)].varValue for g in technologies},
                     'battery_capacity': alt_battery_capacity.varValue,
                     'total_cost': pulp.value(alt_model.objective)
-                })
+                }
+                alternative_solutions.append(alt_solution)
 
     return alternative_solutions
 
@@ -212,17 +216,18 @@ def plot_capacity_distribution(alternative_solutions, selected_technologies):
             capacity_data.append({
                 'Threshold (%)': sol['threshold'] * 100,
                 'Technology': tech,
-                'Capacity (MW)': sol['solution'][tech]
+                'Capacity (MW)': sol['solution'][tech],
+                'Type': sol['type'],
+                'Varied Technology': sol['technology']
             })
     
     capacity_df = pd.DataFrame(capacity_data)
 
-    # Create violin plot with Plotly Express (horizontal)
-    fig_violin = px.violin(capacity_df, y="Technology", x="Capacity (MW)", color="Technology",
-                           box=True, points="all", orientation="h", title="Capacity Distribution by Technology")
-    fig_violin.update_layout(yaxis_title="Technology", xaxis_title="Installed Capacity (MW)")
-
-    return fig_violin
+    # Create line plot to show capacity changes over thresholds
+    fig_line = px.line(capacity_df, x="Threshold (%)", y="Capacity (MW)", color="Technology",
+                       line_dash="Varied Technology", markers=True,
+                       title="Technology Capacity Changes Over Thresholds")
+    st.plotly_chart(fig_line, use_container_width=True)
 
 # Function to create cost breakdown stacked bar plot for each threshold and technology type
 def plot_cost_breakdown(alternative_solutions, selected_technologies, renewable_capacity_cost, battery_cost_per_mwh):
@@ -234,7 +239,7 @@ def plot_cost_breakdown(alternative_solutions, selected_technologies, renewable_
         cost_df = pd.DataFrame(cost_data)
 
         # Create stacked bar chart with unique key to avoid StreamlitDuplicateElementId error
-        fig_bar = px.bar(cost_df, x='Technology', y='Cost', title=f"Cost Breakdown (Threshold: {sol['threshold'] * 100}%, Type: {sol['type']})",
+        fig_bar = px.bar(cost_df, x='Technology', y='Cost', title=f"Cost Breakdown (Threshold: {sol['threshold'] * 100}%, Technology Varied: {sol['technology']})",
                          labels={'Cost': 'Cost (¥)'})
         st.plotly_chart(fig_bar, use_container_width=True, key=f"cost_plot_{idx}")
 
@@ -251,6 +256,26 @@ def plot_generation_demand(data, alternative_solution, time_steps, technologies)
     fig.update_traces(mode='lines')
     st.plotly_chart(fig, use_container_width=True)
 
+# Function to plot battery storage levels over time
+def plot_battery_storage(data, alternative_solution, time_steps):
+    # For simplicity, re-calculate battery storage levels
+    battery_storage = np.zeros(len(time_steps))
+    battery_capacity = alternative_solution['battery_capacity']
+    battery_charge = data['battery_charge'] if 'battery_charge' in data else np.zeros(len(time_steps))
+    battery_discharge = data['battery_discharge'] if 'battery_discharge' in data else np.zeros(len(time_steps))
+    battery_efficiency = 0.9
+
+    for t in range(len(time_steps)):
+        if t == 0:
+            battery_storage[t] = battery_capacity * 0.5 + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency)
+        else:
+            battery_storage[t] = battery_storage[t - 1] + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency)
+
+    fig = px.line(x=time_steps, y=battery_storage,
+                  labels={'x': 'Time', 'y': 'Battery Storage Level (MWh)'},
+                  title='Battery Storage Level Over Time')
+    st.plotly_chart(fig, use_container_width=True)
+
 # Streamlit UI setup
 st.set_page_config(page_title='Renewable Energy System Optimization with MGA', layout='wide')
 st.title('Modeling to Generate Alternatives (MGA) in Renewable Energy System Optimization')
@@ -269,24 +294,36 @@ with st.sidebar:
     wind_range = st.slider("Onshore Wind Capacity Range (MW)", 0, 10000, (0, 10000))
     offshore_wind_range = st.slider("Offshore Wind Capacity Range (MW)", 0, 10000, (0, 10000))
     river_range = st.slider("River Capacity Range (MW)", 0, 10000, (0, 10000))
+    threshold_options = list(np.arange(0, 11, 0.5))
+    threshold_default = [0, 5, 10]
     thresholds = st.multiselect(
         "Select MGA Cost Deviation Thresholds (%)", 
-        list(np.arange(0, 11, 0.5)),
-        default=[0, 5, 10]
+        threshold_options,
+        default=threshold_default
     )
-    selected_technologies = st.multiselect("Select Technologies to Optimize", ['solar', 'onshore_wind', 'offshore_wind', 'river'], default=['solar', 'onshore_wind', 'offshore_wind', 'river'])
+    selected_technologies = st.multiselect("Select Technologies to Optimize", ['solar', 'onshore_wind', 'offshore_wind', 'river'], default=['solar'])
 
 if st.button("Run MGA Optimization"):
     thresholds = [t / 100 for t in thresholds]  # Convert percentages to decimals
-    alternative_solutions = optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range, thresholds, selected_technologies)
+
+    # Fetch data
+    data, error = get_renewable_energy_data(city_code)
+    if error:
+        st.error(error)
+        st.stop()
+
+    # Define technologies
+    technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
+
+    # Run optimization
+    alternative_solutions = optimize_energy_system(data, technologies, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range, thresholds, selected_technologies)
     
     if alternative_solutions:
-        # Display capacity distribution using violin plots
-        fig_violin = plot_capacity_distribution(alternative_solutions, selected_technologies)
-        st.plotly_chart(fig_violin, use_container_width=True)
+        # Display capacity distribution using line plots
+        plot_capacity_distribution(alternative_solutions, technologies)
 
         # Display cost breakdown stacked bar plots for each case
-        plot_cost_breakdown(alternative_solutions, selected_technologies, {
+        plot_cost_breakdown(alternative_solutions, technologies, {
             'solar': solar_cost,
             'onshore_wind': onshore_wind_cost,
             'offshore_wind': offshore_wind_cost,
@@ -296,3 +333,18 @@ if st.button("Run MGA Optimization"):
         # Plot generation and demand over time for the first alternative solution
         st.header("Generation and Demand Over Time")
         plot_generation_demand(data, alternative_solutions[0], data['Time'], technologies)
+
+        # Plot battery storage levels over time
+        st.header("Battery Storage Level Over Time")
+        plot_battery_storage(data, alternative_solutions[0], data['Time'])
+
+        # Display alternative solutions in a table
+        st.header("Alternative Solutions Summary")
+        summary_data = []
+        for sol in alternative_solutions:
+            row = {'Threshold (%)': sol['threshold'] * 100, 'Type': sol['type'], 'Varied Technology': sol['technology'], 'Battery Capacity (MWh)': sol['battery_capacity'], 'Total Cost (¥)': sol['total_cost']}
+            for tech in technologies:
+                row[f"{tech.capitalize()} Capacity (MW)"] = sol['solution'][tech]
+            summary_data.append(row)
+        summary_df = pd.DataFrame(summary_data)
+        st.dataframe(summary_df)