Update app.py

app.py

@@ -44,6 +44,8 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     river_cf = data['river hourly capacity factor']
     demand_cf = data['demand hourly capacity factor']
 
+    demand = demand_cf * yearly_demand * 1e6 / demand_cf.sum()  # MW
+
     regions = ['region1']
     technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
     capacity_factor = {
@@ -57,71 +59,146 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     battery_cost_per_mwh = battery_cost
     battery_efficiency = 0.9
 
-    demand = demand_cf * yearly_demand / 100 * 1000 * 1000
+    # Create the model
+    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
 
+    # Variables
     renewable_capacity = pulp.LpVariable.dicts("renewable_capacity",
                                                [(r, g) for r in regions for g in technologies],
                                                lowBound=0, cat='Continuous')
     battery_capacity = pulp.LpVariable("battery_capacity", lowBound=0, cat='Continuous')
 
-    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
+    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 (renewable capacities and battery)
-    model += pulp.lpSum([renewable_capacity[(r, g)] * renewable_capacity_cost[g]
-                         for r in regions for g in technologies]) + \
+    # 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] / battery_efficiency, f"StorageBalance_{t}"
+        else:
+            model += battery_storage[t] == battery_storage[t - 1] + battery_charge[t] * battery_efficiency - battery_discharge[t] / battery_efficiency, f"StorageBalance_{t}"
+        model += battery_storage[t] <= battery_capacity, f"StorageCapacity_{t}"
+        model += battery_storage[t] >= 0, f"StorageNonNegative_{t}"
+
+    # Renewable capacity constraints (within specified ranges)
+    model += renewable_capacity[('region1', 'solar')] >= solar_range[0], "SolarCapMin"
+    model += renewable_capacity[('region1', 'solar')] <= solar_range[1], "SolarCapMax"
+
+    model += renewable_capacity[('region1', 'onshore_wind')] >= wind_range[0], "WindCapMin"
+    model += renewable_capacity[('region1', 'onshore_wind')] <= wind_range[1], "WindCapMax"
+
+    model += renewable_capacity[('region1', 'offshore_wind')] >= offshore_wind_range[0], "OffshoreWindCapMin"
+    model += renewable_capacity[('region1', 'offshore_wind')] <= offshore_wind_range[1], "OffshoreWindCapMax"
+
+    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
     model.solve()
     optimal_cost = pulp.value(model.objective)
 
     # MGA: Generate alternative solutions for selected technologies only
     alternative_solutions = []
+
     for threshold in thresholds:
         relaxed_cost = optimal_cost * (1 + threshold)
-        for tech in selected_tech:  # Run only for selected technologies
-            # Minimize capacity of each technology
-            alt_model_min = pulp.LpProblem(f"AlternativeModel_Min_{tech}_{threshold}", pulp.LpMinimize)
-            alt_model_min += pulp.lpSum([renewable_capacity[(r, g)] * renewable_capacity_cost[g]
-                                         for r in regions for g in technologies]) + battery_capacity * battery_cost_per_mwh <= relaxed_cost
-            
-            # Copy original constraints with unique names
-            for name, constraint in model.constraints.items():
-                alt_model_min += constraint.copy(), f"{name}_min_{tech}_{threshold}"
-            
-            # Minimize the capacity of the selected technology
-            alt_model_min += renewable_capacity[('region1', tech)], f"Minimize_{tech}_Capacity"
-            alt_model_min.solve()
-            if pulp.LpStatus[alt_model_min.status] == 'Optimal':
-                alternative_solutions.append({
-                    'threshold': threshold,
-                    'type': 'min',
-                    'technology': tech,
-                    'solution': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
-                    'battery_capacity': battery_capacity.varValue,
-                    'total_cost': pulp.value(alt_model_min.objective)
-                })
-            
-            # Maximize capacity of each technology
-            alt_model_max = pulp.LpProblem(f"AlternativeModel_Max_{tech}_{threshold}", pulp.LpMinimize)
-            alt_model_max += pulp.lpSum([renewable_capacity[(r, g)] * renewable_capacity_cost[g]
-                                         for r in regions for g in technologies]) + battery_capacity * battery_cost_per_mwh <= relaxed_cost
-            
-            # Copy original constraints with unique names
-            for name, constraint in model.constraints.items():
-                alt_model_max += constraint.copy(), f"{name}_max_{tech}_{threshold}"
-            
-            # Maximize the capacity of the selected technology
-            alt_model_max += -renewable_capacity[('region1', tech)], f"Maximize_{tech}_Capacity"
-            alt_model_max.solve()
-            if pulp.LpStatus[alt_model_max.status] == 'Optimal':
+        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("renewable_capacity",
+                                                           [(r, g) for r in regions for g in technologies],
+                                                           lowBound=0, cat='Continuous')
+            alt_battery_capacity = pulp.LpVariable("battery_capacity", lowBound=0, cat='Continuous')
+
+            alt_renewable_generation = pulp.LpVariable.dicts("renewable_generation",
+                                                             [(t, g) for t in time_steps for g in technologies],
+                                                             lowBound=0, cat='Continuous')
+            alt_battery_charge = pulp.LpVariable.dicts("battery_charge",
+                                                       time_steps, lowBound=0, cat='Continuous')
+            alt_battery_discharge = pulp.LpVariable.dicts("battery_discharge",
+                                                          time_steps, lowBound=0, cat='Continuous')
+            alt_battery_storage = pulp.LpVariable.dicts("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"
+
+            # 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] / 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] / 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':
                 alternative_solutions.append({
                     'threshold': threshold,
-                    'type': 'max',
+                    'type': 'min' if threshold == 0 else 'max',
                     'technology': tech,
-                    'solution': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
-                    'battery_capacity': battery_capacity.varValue,
-                    'total_cost': pulp.value(alt_model_max.objective)
+                    '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)
                 })
 
     return alternative_solutions
@@ -149,7 +226,6 @@ def plot_capacity_distribution(alternative_solutions, selected_technologies):
 
 # 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):
-    # Generate a bar plot for each case based on threshold and technology type
     for idx, sol in enumerate(alternative_solutions):
         cost_data = {
             'Technology': selected_technologies + ['Battery'],
@@ -162,6 +238,19 @@ def plot_cost_breakdown(alternative_solutions, selected_technologies, renewable_
                          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)
+
 # 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')
@@ -188,7 +277,8 @@ with st.sidebar:
     selected_technologies = st.multiselect("Select Technologies to Optimize", ['solar', 'onshore_wind', 'offshore_wind', 'river'], default=['solar', 'onshore_wind', 'offshore_wind', 'river'])
 
 if st.button("Run MGA Optimization"):
-    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, [t / 100 for t in thresholds], selected_technologies)
+    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)
     
     if alternative_solutions:
         # Display capacity distribution using violin plots
@@ -202,3 +292,7 @@ if st.button("Run MGA Optimization"):
             '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)