Update app.py

app.py

@@ -26,35 +26,31 @@ def get_renewable_energy_data(city_code):
 
     return result_df, None
 
-# Optimize energy system and use MGA
-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)
-
-    time_steps = range(len(data['Time']))
-    solar_cf = data['solar hourly capacity factor']
-    onshore_wind_cf = data['onshore_wind hourly capacity factor']
-    offshore_wind_cf = data['offshore_wind hourly capacity factor']
-    river_cf = data['river hourly capacity factor']
-    demand_cf = data['demand hourly capacity factor']
-
-    demand = demand_cf * yearly_demand * 1e6 / demand_cf.sum()  # MW
-
+# Generate scenarios for robust optimization
+def generate_scenarios(data, num_scenarios, demand_variation, supply_variation):
+    scenarios = []
+    for i in range(num_scenarios):
+        scenario = data.copy()
+        # Vary demand
+        demand_factor = 1 + np.random.uniform(-demand_variation, demand_variation)
+        scenario['demand hourly capacity factor'] *= demand_factor
+        # Vary supply capacity factors
+        for tech in ['solar', 'onshore_wind', 'offshore_wind', 'river']:
+            supply_factor = 1 + np.random.uniform(-supply_variation, supply_variation)
+            scenario[f'{tech} hourly capacity factor'] *= supply_factor
+            scenario[f'{tech} hourly capacity factor'] = scenario[f'{tech} hourly capacity factor'].clip(upper=1.0)
+        scenarios.append(scenario)
+    return scenarios
+
+# Optimize energy system for multiple scenarios
+def optimize_energy_system_robust(scenarios, technologies, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range):
     regions = ['region1']
-    capacity_factor = {
-        'solar': solar_cf,
-        'onshore_wind': onshore_wind_cf,
-        'offshore_wind': offshore_wind_cf,
-        'river': river_cf
-    }
-
     renewable_capacity_cost = {'solar': solar_cost, 'onshore_wind': onshore_wind_cost, 'offshore_wind': offshore_wind_cost, 'river': river_cost}
     battery_cost_per_mwh = battery_cost
     battery_efficiency = 0.9
 
     # Create the model
-    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
+    model = pulp.LpProblem("RobustEnergySystemOptimization", pulp.LpMinimize)
 
     # Variables
     renewable_capacity = pulp.LpVariable.dicts("renewable_capacity",
@@ -62,40 +58,51 @@ def optimize_energy_system(data, technologies, solar_cost, onshore_wind_cost, of
                                                lowBound=0, cat='Continuous')
     battery_capacity = pulp.LpVariable("battery_capacity", lowBound=0, cat='Continuous')
 
-    renewable_generation = pulp.LpVariable.dicts("renewable_generation",
-                                                 [(t, g) for t in time_steps for g in technologies],
-                                                 lowBound=0, cat='Continuous')
-    battery_charge = pulp.LpVariable.dicts("battery_charge",
-                                           time_steps, lowBound=0, cat='Continuous')
-    battery_discharge = pulp.LpVariable.dicts("battery_discharge",
-                                              time_steps, lowBound=0, cat='Continuous')
-    battery_storage = pulp.LpVariable.dicts("battery_storage",
-                                            time_steps, lowBound=0, cat='Continuous')
-
     # Objective: minimize total cost
     model += pulp.lpSum([renewable_capacity[('region1', g)] * renewable_capacity_cost[g] for g in technologies]) + \
              battery_capacity * battery_cost_per_mwh, "TotalCost"
 
-    # Constraints
-
-    # Renewable generation constraints
-    for t in time_steps:
-        for g in technologies:
-            model += renewable_generation[(t, g)] <= renewable_capacity[('region1', g)] * capacity_factor[g].iloc[t], f"GenCap_{t}_{g}"
-
-    # Energy balance constraints
-    for t in time_steps:
-        total_generation = pulp.lpSum([renewable_generation[(t, g)] for g in technologies])
-        model += total_generation + battery_discharge[t] == demand.iloc[t] + battery_charge[t], f"EnergyBalance_{t}"
-
-    # Battery storage constraints
-    for t in time_steps:
-        if t == 0:
-            model += battery_storage[t] == battery_capacity * 0.5 + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_{t}"
-        else:
-            model += battery_storage[t] == battery_storage[t - 1] + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_{t}"
-        model += battery_storage[t] <= battery_capacity, f"StorageCapacity_{t}"
-        model += battery_storage[t] >= 0, f"StorageNonNegative_{t}"
+    # Constraints for each scenario
+    for idx, data in enumerate(scenarios):
+        time_steps = range(len(data['Time']))
+        capacity_factor = {
+            'solar': data['solar hourly capacity factor'],
+            'onshore_wind': data['onshore_wind hourly capacity factor'],
+            'offshore_wind': data['offshore_wind hourly capacity factor'],
+            'river': data['river hourly capacity factor']
+        }
+        demand_cf = data['demand hourly capacity factor']
+        demand = demand_cf * yearly_demand * 1e6 / demand_cf.sum()  # MW
+
+        # Scenario-specific variables
+        renewable_generation = pulp.LpVariable.dicts(f"renewable_generation_s{idx}",
+                                                     [(t, g) for t in time_steps for g in technologies],
+                                                     lowBound=0, cat='Continuous')
+        battery_charge = pulp.LpVariable.dicts(f"battery_charge_s{idx}",
+                                               time_steps, lowBound=0, cat='Continuous')
+        battery_discharge = pulp.LpVariable.dicts(f"battery_discharge_s{idx}",
+                                                  time_steps, lowBound=0, cat='Continuous')
+        battery_storage = pulp.LpVariable.dicts(f"battery_storage_s{idx}",
+                                                time_steps, lowBound=0, cat='Continuous')
+
+        # Renewable generation constraints
+        for t in time_steps:
+            for g in technologies:
+                model += renewable_generation[(t, g)] <= renewable_capacity[('region1', g)] * capacity_factor[g].iloc[t], f"GenCap_s{idx}_{t}_{g}"
+
+        # Energy balance constraints
+        for t in time_steps:
+            total_generation = pulp.lpSum([renewable_generation[(t, g)] for g in technologies])
+            model += total_generation + battery_discharge[t] == demand.iloc[t] + battery_charge[t], f"EnergyBalance_s{idx}_{t}"
+
+        # Battery storage constraints
+        for t in time_steps:
+            if t == 0:
+                model += battery_storage[t] == battery_capacity * 0.5 + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_s{idx}_{t}"
+            else:
+                model += battery_storage[t] == battery_storage[t - 1] + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_s{idx}_{t}"
+            model += battery_storage[t] <= battery_capacity, f"StorageCapacity_s{idx}_{t}"
+            model += battery_storage[t] >= 0, f"StorageNonNegative_s{idx}_{t}"
 
     # Renewable capacity constraints (within specified ranges)
     model += renewable_capacity[('region1', 'solar')] >= solar_range[0], "SolarCapMin"
@@ -110,175 +117,23 @@ def optimize_energy_system(data, technologies, solar_cost, onshore_wind_cost, of
     model += renewable_capacity[('region1', 'river')] >= river_range[0], "RiverCapMin"
     model += renewable_capacity[('region1', 'river')] <= river_range[1], "RiverCapMax"
 
-    # Solve the initial model to find the optimal solution
+    # Solve the model
     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 = [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
-            alt_model = pulp.LpProblem(f"AlternativeModel_{tech}_{threshold}", pulp.LpMinimize)
-
-            # Variables (need to create new variables for the new model)
-            alt_renewable_capacity = pulp.LpVariable.dicts("alt_renewable_capacity",
-                                                           [(r, g) for r in regions for g in technologies],
-                                                           lowBound=0, cat='Continuous')
-            alt_battery_capacity = pulp.LpVariable("alt_battery_capacity", lowBound=0, cat='Continuous')
-
-            alt_renewable_generation = pulp.LpVariable.dicts("alt_renewable_generation",
-                                                             [(t, g) for t in time_steps for g in technologies],
-                                                             lowBound=0, cat='Continuous')
-            alt_battery_charge = pulp.LpVariable.dicts("alt_battery_charge",
-                                                       time_steps, lowBound=0, cat='Continuous')
-            alt_battery_discharge = pulp.LpVariable.dicts("alt_battery_discharge",
-                                                          time_steps, lowBound=0, cat='Continuous')
-            alt_battery_storage = pulp.LpVariable.dicts("alt_battery_storage",
-                                                        time_steps, lowBound=0, cat='Continuous')
-
-            # 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]) + \
-                         alt_battery_capacity * battery_cost_per_mwh <= relaxed_cost, "CostConstraint"
-
-            # Constraints
-
-            # Renewable generation constraints
-            for t in time_steps:
-                for g in technologies:
-                    alt_model += alt_renewable_generation[(t, g)] <= alt_renewable_capacity[('region1', g)] * capacity_factor[g].iloc[t], f"GenCap_{t}_{g}"
-
-            # Energy balance constraints
-            for t in time_steps:
-                total_generation = pulp.lpSum([alt_renewable_generation[(t, g)] for g in technologies])
-                alt_model += total_generation + alt_battery_discharge[t] == demand.iloc[t] + alt_battery_charge[t], f"EnergyBalance_{t}"
-
-            # Battery storage constraints
-            for t in time_steps:
-                if t == 0:
-                    alt_model += alt_battery_storage[t] == alt_battery_capacity * 0.5 + alt_battery_charge[t] * battery_efficiency - alt_battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_{t}"
-                else:
-                    alt_model += alt_battery_storage[t] == alt_battery_storage[t - 1] + alt_battery_charge[t] * battery_efficiency - alt_battery_discharge[t] * (1 / battery_efficiency), f"StorageBalance_{t}"
-                alt_model += alt_battery_storage[t] <= alt_battery_capacity, f"StorageCapacity_{t}"
-                alt_model += alt_battery_storage[t] >= 0, f"StorageNonNegative_{t}"
 
-            # Renewable capacity constraints (within specified ranges)
-            alt_model += alt_renewable_capacity[('region1', 'solar')] >= solar_range[0], "SolarCapMin"
-            alt_model += alt_renewable_capacity[('region1', 'solar')] <= solar_range[1], "SolarCapMax"
-
-            alt_model += alt_renewable_capacity[('region1', 'onshore_wind')] >= wind_range[0], "WindCapMin"
-            alt_model += alt_renewable_capacity[('region1', 'onshore_wind')] <= wind_range[1], "WindCapMax"
-
-            alt_model += alt_renewable_capacity[('region1', 'offshore_wind')] >= offshore_wind_range[0], "OffshoreWindCapMin"
-            alt_model += alt_renewable_capacity[('region1', 'offshore_wind')] <= offshore_wind_range[1], "OffshoreWindCapMax"
-
-            alt_model += alt_renewable_capacity[('region1', 'river')] >= river_range[0], "RiverCapMin"
-            alt_model += alt_renewable_capacity[('region1', 'river')] <= river_range[1], "RiverCapMax"
-
-            # Solve the alternative model
-            alt_model.solve()
-            if pulp.LpStatus[alt_model.status] == 'Optimal':
-                alt_solution = {
-                    'threshold': threshold,
-                    '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
-
-# Violin plot for each technology’s capacity distribution across alternative solutions
-def plot_capacity_distribution(alternative_solutions, selected_technologies):
-    # Collect capacity data for each technology at each threshold level
-    capacity_data = []
-    for sol in alternative_solutions:
-        for tech in selected_technologies:
-            capacity_data.append({
-                'Threshold (%)': sol['threshold'] * 100,
-                'Technology': tech,
-                'Capacity (MW)': sol['solution'][tech],
-                'Type': sol['type'],
-                'Varied Technology': sol['technology']
-            })
-    
-    capacity_df = pd.DataFrame(capacity_data)
-
-    # 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):
-    for idx, sol in enumerate(alternative_solutions):
-        cost_data = {
-            'Technology': selected_technologies + ['Battery'],
-            'Cost': [sol['solution'][tech] * renewable_capacity_cost[tech] for tech in selected_technologies] + [sol['battery_capacity'] * battery_cost_per_mwh]
+    if pulp.LpStatus[model.status] == 'Optimal':
+        solution = {
+            'renewable_capacity': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
+            'battery_capacity': battery_capacity.varValue,
+            'total_cost': pulp.value(model.objective)
         }
-        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}%, Technology Varied: {sol['technology']})",
-                         labels={'Cost': 'Cost (¥)'})
-        st.plotly_chart(fig_bar, use_container_width=True, key=f"cost_plot_{idx}")
-
-# Function to plot generation and demand over time
-def plot_generation_demand(data, alternative_solution, time_steps, technologies):
-    total_generation = np.zeros(len(time_steps))
-    for g in technologies:
-        gen = np.array(data[f'{g} hourly capacity factor']) * alternative_solution['solution'][g]
-        total_generation += gen
-    demand = data['demand hourly capacity factor'] * data['demand hourly capacity factor'].sum()
-    fig = px.line(x=time_steps, y=[total_generation, demand],
-                  labels={'x': 'Time', 'value': 'Power (MW)', 'variable': 'Legend'},
-                  title='Total Generation and Demand Over Time')
-    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)
+        return solution
+    else:
+        st.error("Optimization did not find an optimal solution.")
+        return None
 
 # 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')
+st.set_page_config(page_title='Robust Energy System Optimization', layout='wide')
+st.title('Robust Energy System Optimization Analysis')
 
 # Sidebar Inputs
 with st.sidebar:
@@ -294,57 +149,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 (%)", 
-        threshold_options,
-        default=threshold_default
-    )
-    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
+    num_scenarios = st.number_input("Number of Scenarios", min_value=1, max_value=10, value=3)
+    demand_variation = st.number_input("Demand Variation (%)", min_value=0.0, max_value=100.0, value=10.0) / 100
+    supply_variation = st.number_input("Supply Variation (%)", min_value=0.0, max_value=100.0, value=10.0) / 100
 
+if st.button("Run Robust Optimization"):
     # Fetch data
     data, error = get_renewable_energy_data(city_code)
     if error:
         st.error(error)
         st.stop()
 
+    # Generate scenarios
+    scenarios = generate_scenarios(data, num_scenarios, demand_variation, supply_variation)
+
     # 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 line plots
-        plot_capacity_distribution(alternative_solutions, technologies)
-
-        # Display cost breakdown stacked bar plots for each case
-        plot_cost_breakdown(alternative_solutions, technologies, {
-            'solar': solar_cost,
-            'onshore_wind': onshore_wind_cost,
-            'offshore_wind': offshore_wind_cost,
-            'river': river_cost
-        }, battery_cost)
-
-        # 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)
+    # Run robust optimization
+    solution = optimize_energy_system_robust(scenarios, technologies, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range)
+
+    if solution:
+        st.header("Optimization Results")
+        st.write(f"Total Cost: {solution['total_cost']}")
+        st.write(f"Battery Capacity (MWh): {solution['battery_capacity']}")
+        capacity_data = pd.DataFrame({
+            'Technology': list(solution['renewable_capacity'].keys()),
+            'Capacity (MW)': list(solution['renewable_capacity'].values())
+        })
+        st.write(capacity_data)
+
+        # Visualization
+        fig = px.bar(capacity_data, x='Technology', y='Capacity (MW)', title='Optimal Renewable Capacities')
+        st.plotly_chart(fig, use_container_width=True)