Update app.py

app.py

@@ -5,10 +5,154 @@ import pulp
 import plotly.graph_objs as go
 import plotly.express as px
 import numpy as np
-import matplotlib.pyplot as plt  # ここでpltをインポート
+import matplotlib.pyplot as plt  # 修正：matplotlibのインポートを追加
 
-# 先ほどのコードからの関数: optimize_energy_system()
-# ここに alternative_solutions が返されるコードが既に含まれていると仮定しています。
+# Renewable energy data fetch function
+def get_renewable_energy_data(city_code):
+    url = f"https://energy-sustainability.jp/_ajax/renewable_energy/get/?code={city_code}"
+    response = requests.get(url)
+    if response.status_code != 200:
+        return None, "Failed to retrieve data."
+
+    data = response.json()
+    if not data:
+        return None, "No data found."
+
+    base_times = data[next(iter(data))]['x']
+    result_df = pd.DataFrame({"Time": base_times})
+
+    for energy_type, energy_data in data.items():
+        if 'x' in energy_data and 'y' in energy_data:
+            values = energy_data['y']
+            result_df[f"{energy_type} hourly capacity factor"] = values
+
+    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):
+    data, error = get_renewable_energy_data(city_code)
+    if error:
+        st.error(error)
+        return None, None, None, None, None, None, None
+
+    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']
+
+    regions = ['region1']
+    technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
+    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
+
+    demand = demand_cf * yearly_demand / 100 * 1000 * 1000
+
+    renewable_capacity = pulp.LpVariable.dicts("renewable_capacity",
+                                               [(r, g) for r in regions for g in technologies],
+                                               lowBound=0, cat='Continuous')
+    curtailment = pulp.LpVariable.dicts("curtailment",
+                                        [(r, t) for r in regions for t in time_steps],
+                                        lowBound=0, cat='Continuous')
+    battery_capacity = pulp.LpVariable("battery_capacity", 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')
+    SOC = pulp.LpVariable.dicts("SOC", time_steps, lowBound=0, cat='Continuous')
+
+    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
+
+    # 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]) + \
+             battery_capacity * battery_cost_per_mwh, "TotalCost"
+
+    # Constraints: meet demand, manage battery SOC
+    for r in regions:
+        for t in time_steps:
+            model += pulp.lpSum([renewable_capacity[(r, g)] * capacity_factor[g][t]
+                                 for g in technologies]) + battery_discharge[t] == demand[t] + battery_charge[t] + curtailment[(r, t)], f"DemandConstraint_{r}_{t}"
+            if t == 0:
+                model += SOC[t] == battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"SOCUpdate_{t}"
+            else:
+                model += SOC[t] == SOC[t - 1] + battery_charge[t] * battery_efficiency - battery_discharge[t] * (1 / battery_efficiency), f"SOCUpdate_{t}"
+            model += SOC[t] <= battery_capacity, f"SOCUpperBound_{t}"
+
+    # Capacity range constraints
+    model += renewable_capacity[('region1', 'solar')] >= solar_range[0]
+    model += renewable_capacity[('region1', 'solar')] <= solar_range[1]
+    model += renewable_capacity[('region1', 'onshore_wind')] >= wind_range[0]
+    model += renewable_capacity[('region1', 'onshore_wind')] <= wind_range[1]
+    model += renewable_capacity[('region1', 'offshore_wind')] >= offshore_wind_range[0]
+    model += renewable_capacity[('region1', 'offshore_wind')] <= offshore_wind_range[1]
+    model += renewable_capacity[('region1', 'river')] >= river_range[0]
+    model += renewable_capacity[('region1', 'river')] <= river_range[1]
+
+    # Solve the initial model to find the optimal solution
+    model.solve()
+    optimal_cost = pulp.value(model.objective)
+
+    # MGA: Generate alternative solutions
+    mga_models = []
+    alternative_solutions = []
+    for threshold in thresholds:
+        relaxed_cost = optimal_cost * (1 + threshold)
+        for tech in 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
+                })
+            
+            # 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':
+                alternative_solutions.append({
+                    'threshold': threshold,
+                    'type': 'max',
+                    'technology': tech,
+                    'solution': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
+                    'battery_capacity': battery_capacity.varValue
+                })
+
+    return alternative_solutions
 
 # Streamlit UI setup
 st.set_page_config(page_title='Renewable Energy System Optimization with MGA', layout='wide')