Update app.py

app.py

@@ -5,153 +5,10 @@ import pulp
 import plotly.graph_objs as go
 import plotly.express as px
 import numpy as np
+import matplotlib.pyplot as plt  # ここでpltをインポート
 
-# Function to fetch renewable energy data
-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
-
-# Function to optimize the energy system and create visualizations with 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
+# 先ほどのコードからの関数: optimize_energy_system()
+# ここに alternative_solutions が返されるコードが既に含まれていると仮定しています。
 
 # Streamlit UI setup
 st.set_page_config(page_title='Renewable Energy System Optimization with MGA', layout='wide')
@@ -202,4 +59,4 @@ if st.button("Run MGA Optimization"):
         ax.grid(True, linestyle='--', alpha=0.7)
 
         # Streamlitにプロットを表示
-        st.pyplot(fig)
+        st.pyplot(fig)