Update app.py

app.py

@@ -13,23 +13,18 @@ import seaborn as sns
 
 # Function to fetch renewable energy data
 def get_renewable_energy_data(city_code):
-    # Construct the URL for fetching renewable energy data for a given city code
     url = f"https://energy-sustainability.jp/_ajax/renewable_energy/get/?code={city_code}"
     response = requests.get(url)
-    # If the request is unsuccessful, return an error message
     if response.status_code != 200:
         return None, "データの取得に失敗しました。"
 
     data = response.json()
-    # If no data is found, return an error message
     if not data:
         return None, "データが見つかりませんでした。"
 
-    # Extract base times from the first energy type and create a DataFrame
     base_times = data[next(iter(data))]['x']
     result_df = pd.DataFrame({"Time": base_times})
 
-    # Loop through each energy type and append hourly capacity factor data to the DataFrame
     for energy_type, energy_data in data.items():
         if 'x' in energy_data and 'y' in energy_data:
             values = energy_data['y']
@@ -37,26 +32,17 @@ def get_renewable_energy_data(city_code):
 
     return result_df, None
 
-# Function to filter numeric columns
-def filter_numeric_columns(df):
-    # Select only numeric columns from the DataFrame
-    numeric_df = df.select_dtypes(include=['number'])
-    return numeric_df
-
 # Function to optimize the energy system and create heatmaps
-def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand):
-    # Fetch renewable energy data
+def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_min, solar_max, wind_min, wind_max):
     data, error = get_renewable_energy_data(city_code)
     if error:
         st.error(error)
         return None, None, None, None
 
-    # Convert all capacity factor columns to numeric, handling errors and filling missing values with zero
     for col in data.columns[1:]:
         data[col] = pd.to_numeric(data[col], errors='coerce')
     data = data.fillna(0)
 
-    # Define the time steps based on the length of the data
     time_steps = range(len(data['Time']))
     solar_cf = data['solar hourly capacity factor']
     onshore_wind_cf = data['onshore_wind hourly capacity factor']
@@ -64,7 +50,6 @@ 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']
 
-    # Define regions and technologies
     regions = ['region1']
     technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
     capacity_factor = {
@@ -74,15 +59,12 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
         'river': river_cf
     }
 
-    # Define the costs for each renewable capacity and battery storage
     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
-    
-    # Scale demand from yearly demand in TWh/year to hourly demand in MW
+
     demand = demand_cf * yearly_demand / 100 * 1000 * 1000
 
-    # Define LP variables for renewable capacities, curtailment, battery capacity, charge, discharge, and state of charge (SOC)
     renewable_capacity = pulp.LpVariable.dicts("renewable_capacity",
                                                [(r, g) for r in regions for g in technologies],
                                                lowBound=0, cat='Continuous')
@@ -94,34 +76,31 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     battery_discharge = pulp.LpVariable.dicts("battery_discharge", time_steps, lowBound=0, cat='Continuous')
     SOC = pulp.LpVariable.dicts("SOC", time_steps, lowBound=0, cat='Continuous')
 
-    # Define the optimization problem to minimize the total system cost
     model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
 
-    # Objective function: minimize the cost of renewable capacities and battery storage
     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 to meet demand, manage curtailment, and update state of charge for the battery
     for r in regions:
         for t in time_steps:
-            # Ensure that generation plus battery discharge meets demand, accounting for curtailment and battery charge
             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}"
 
-            # Update state of charge for the battery
             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}"
 
-            # Ensure SOC does not exceed battery capacity
             model += SOC[t] <= battery_capacity, f"SOCUpperBound_{t}"
 
-    # Solve the optimization model
+    model += renewable_capacity[('region1', 'solar')] >= solar_min, "SolarMinConstraint"
+    model += renewable_capacity[('region1', 'solar')] <= solar_max, "SolarMaxConstraint"
+    model += renewable_capacity[('region1', 'onshore_wind')] >= wind_min, "WindMinConstraint"
+    model += renewable_capacity[('region1', 'onshore_wind')] <= wind_max, "WindMaxConstraint"
+
     model.solve()
 
-    # Extract optimized supply and battery values
     supply_solar = solar_cf * renewable_capacity[('region1', 'solar')].varValue
     supply_onshore_wind = onshore_wind_cf * renewable_capacity[('region1', 'onshore_wind')].varValue
     supply_offshore_wind = offshore_wind_cf * renewable_capacity[('region1', 'offshore_wind')].varValue
@@ -132,14 +111,11 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     SOC_values = [SOC[t].varValue for t in time_steps]
     curtailment_values = [-curtailment[(r, t)].varValue for r in regions for t in time_steps]
 
-    # Calculate price per hour based on demand and generation (simplified example)
     price_per_hour = [100 + 0.05 * demand[t] for t in time_steps]
 
-    # Normalize state of charge (SOC) to a percentage
     max_SOC = max(SOC_values)
     SOC_normalized = [(soc / max_SOC) * 100 for soc in SOC_values] if max_SOC > 0 else [0] * len(SOC_values)
 
-    # Create plot for energy dispatch
     fig_energy = go.Figure()
     fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_solar, mode='lines', stackgroup='one', name='Solar', line=dict(color='#FFD700', width=0)))
     fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_onshore_wind, mode='lines', stackgroup='one', name='Onshore Wind', line=dict(color='#1F78B4', width=0)))
@@ -150,7 +126,6 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     fig_energy.add_trace(go.Scatter(x=data['Time'], y=-demand, mode='lines', stackgroup='two', name='Demand', line=dict(color='black', width=0)))
     fig_energy.add_trace(go.Scatter(x=data['Time'], y=curtailment_values, mode='lines', stackgroup='two', name='Curtailment', line=dict(color='#aaaaaa', width=0)))
     
-    # Layout settings for energy dispatch plot
     fig_energy.update_layout(
         title_text='Power Supply and Demand',
         title_x=0.5,
@@ -163,16 +138,15 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
         xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
         yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
     )
-    
-    # Create a heatmap for each energy source (solar, onshore wind, offshore wind, river)
+
+    # Heatmap generation for each renewable energy source
     heatmaps = []
     for energy_source in ['solar', 'onshore_wind', 'offshore_wind', 'river']:
         df_heatmap = data[['Time', f'{energy_source} hourly capacity factor']].copy()
-        df_heatmap['Time'] = pd.to_datetime(df_heatmap['Time'], errors='coerce')  # Ensure Time is in datetime format
+        df_heatmap['Time'] = pd.to_datetime(df_heatmap['Time'], errors='coerce')
         df_heatmap['day_of_year'] = df_heatmap['Time'].dt.dayofyear
         df_heatmap['hour_of_day'] = df_heatmap['Time'].dt.hour
-    
-        # Use pivot_table instead of pivot to handle duplicates
+
         pivot_df = df_heatmap.pivot_table(
             index='hour_of_day',
             columns='day_of_year',
@@ -180,7 +154,6 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
             aggfunc='mean'
         )
 
-        # Create Plotly heatmap
         fig_heatmap = px.imshow(
             pivot_df.values,
             labels=dict(x="Day of Year", y="Hour of Day", color=f"{energy_source.replace('_', ' ').title()} Capacity Factor"),
@@ -206,28 +179,22 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
 st.set_page_config(page_title='Renewable Energy System Optimization', layout='wide')
 st.title('Renewable Energy System Optimization')
 
-# Overview section explaining the project
-st.markdown("""
-### Overview
-This application is designed to help researchers and policymakers explore and optimize renewable energy systems for a specified region. By inputting cost parameters for different renewable energy sources and energy storage systems, the application determines the optimal mix of resources to meet energy demand while minimizing cost.
-The optimization problem is solved using linear programming, ensuring a balance between supply and demand, and incorporating battery energy storage to manage intermittency issues inherent in renewable energy.
-The visualizations provided help to better understand how different energy sources contribute to the overall power supply, how energy storage systems are utilized, and the impact of cost variations on energy prices.
-""")
-
-# Sidebar input fields for user to provide parameters
 with st.sidebar:
     st.header('Input Parameters')
     city_code = st.text_input("Enter City Code", value=999999)
-    solar_cost = st.number_input("Solar Capacity Cost (¥/MW)", value=80.0, help="Estimated average cost of solar capacity per MW")
-    onshore_wind_cost = st.number_input("Onshore Wind Capacity Cost (¥/MW)", value=120.0, help="Estimated average cost of onshore wind capacity per MW")
-    offshore_wind_cost = st.number_input("Offshore Wind Capacity Cost (¥/MW)", value=180.0, help="Estimated average cost of offshore wind capacity per MW")
-    river_cost = st.number_input("River Capacity Cost (¥/MW)", value=1000.0, help="Estimated average cost of river (hydro) capacity per MW")
-    battery_cost = st.number_input("Battery Cost (¥/MWh)", value=80.0, help="Estimated average cost of battery storage per MWh")
-    yearly_demand = st.number_input("Yearly Power Demand (TWh/year)", value=15.0, help="Total yearly power demand in TWh")
-
-# Button to trigger optimization
+    solar_cost = st.number_input("Solar Capacity Cost (\u00a5/MW)", value=80.0)
+    onshore_wind_cost = st.number_input("Onshore Wind Capacity Cost (\u00a5/MW)", value=120.0)
+    offshore_wind_cost = st.number_input("Offshore Wind Capacity Cost (\u00a5/MW)", value=180.0)
+    river_cost = st.number_input("River Capacity Cost (\u00a5/MW)", value=1000.0)
+    battery_cost = st.number_input("Battery Cost (\u00a5/MWh)", value=80.0)
+    yearly_demand = st.number_input("Yearly Power Demand (TWh/year)", value=15.0)
+    solar_min = st.slider("Minimum Solar Capacity (MW)", 0, 10000, 0)
+    solar_max = st.slider("Maximum Solar Capacity (MW)", 0, 10000, 10000)
+    wind_min = st.slider("Minimum Onshore Wind Capacity (MW)", 0, 10000, 0)
+    wind_max = st.slider("Maximum Onshore Wind Capacity (MW)", 0, 10000, 10000)
+
 if st.button('Calculate Optimal Energy Mix'):
-    fig_energy, heatmaps, curtailment_values, price_per_hour = optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand)
+    fig_energy, heatmaps, curtailment_values, price_per_hour = optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_min, solar_max, wind_min, wind_max)
     
     if fig_energy:
         st.plotly_chart(fig_energy, use_container_width=True, height=800)
@@ -247,9 +214,9 @@ if st.button('Calculate Optimal Energy Mix'):
             'Offshore Wind': offshore_wind_cost,
             'Run of River': river_cost
         }
-        cost_df = pd.DataFrame(list(renewable_data.items()), columns=['Technology', 'Cost (¥/MW)'])
+        cost_df = pd.DataFrame(list(renewable_data.items()), columns=['Technology', 'Cost (\u00a5/MW)'])
 
-        fig_cost = px.bar(cost_df, x='Technology', y='Cost (¥/MW)', color='Technology', title='Cost Comparison of Different Renewable Technologies', template='plotly_white')
+        fig_cost = px.bar(cost_df, x='Technology', y='Cost (\u00a5/MW)', color='Technology', title='Cost Comparison of Different Renewable Technologies', template='plotly_white')
         st.plotly_chart(fig_cost, use_container_width=True, height=800)
 
         # Plot curtailment over time
@@ -258,6 +225,6 @@ if st.button('Calculate Optimal Energy Mix'):
         st.plotly_chart(fig_curtailment, use_container_width=True, height=800)
 
         # Plot electricity price variation over time
-        price_df = pd.DataFrame({"Time": fig_energy.data[0].x, "Electricity Price (¥/MWh)": price_per_hour})
-        fig_price = px.line(price_df, x='Time', y='Electricity Price (¥/MWh)', title='Electricity Price Variation Over Time', template='plotly_white')
-        st.plotly_chart(fig_price, use_container_width=True, height=800)
+        price_df = pd.DataFrame({"Time": fig_energy.data[0].x, "Electricity Price (\u00a5/MWh)": price_per_hour})
+        fig_price = px.line(price_df, x='Time', y='Electricity Price (\u00a5/MWh)', title='Electricity Price Variation Over Time', template='plotly_white')
+        st.plotly_chart(fig_price, use_container_width=True, height=800)