Update app.py

app.py

@@ -11,18 +11,23 @@ import numpy as np
 
 # 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']
@@ -32,21 +37,24 @@ def get_renewable_energy_data(city_code):
 
 # 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
 def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand):
+    # Fetch renewable energy data
     data, error = get_renewable_energy_data(city_code)
     if error:
         st.error(error)
         return 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']
@@ -54,6 +62,7 @@ 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 = {
@@ -63,12 +72,15 @@ 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')
@@ -80,26 +92,34 @@ 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.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
@@ -110,11 +130,14 @@ 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)))
@@ -125,6 +148,7 @@ 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,
@@ -140,9 +164,11 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     
     return fig_energy, curtailment_values, price_per_hour
 
+# Streamlit UI setup
 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.
@@ -150,6 +176,7 @@ The optimization problem is solved using linear programming, ensuring a balance
 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="")
@@ -160,14 +187,17 @@ with st.sidebar:
     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
 if st.button('Calculate Optimal Energy Mix'):
     fig, curtailment_values, price_per_hour = optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand)
     if fig:
         st.plotly_chart(fig, use_container_width=True, height=800)
 
+        # Additional analysis and visualizations
         st.markdown("### Additional Analysis")
         st.markdown("The following plots provide additional insights into the renewable energy mix, curtailment, and electricity price variations.")
 
+        # Plot cost comparison of different renewable technologies
         renewable_data = {
             'Solar': solar_cost,
             'Onshore Wind': onshore_wind_cost,
@@ -179,14 +209,17 @@ if st.button('Calculate Optimal Energy Mix'):
         fig_cost = px.bar(cost_df, x='Technology', y='Cost (¥/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
         curtailment_df = pd.DataFrame({"Time": fig.data[0].x, "Curtailment (MW)": curtailment_values})
         fig_curtailment = px.line(curtailment_df, x='Time', y='Curtailment (MW)', title='Curtailment Over Time', template='plotly_white')
         st.plotly_chart(fig_curtailment, use_container_width=True, height=800)
 
+        # Plot electricity price variation over time
         price_df = pd.DataFrame({"Time": fig.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)
 
+        # Correlation analysis between renewable energy sources
         if city_code:
             st.markdown("### Correlation Between Renewable Energy Sources")
             energy_data_df, error = get_renewable_energy_data(city_code)
@@ -203,9 +236,10 @@ if st.button('Calculate Optimal Energy Mix'):
                     fig_corr = px.imshow(correlation_matrix, title='Correlation Matrix of Renewable Capacity Factors', labels={'color': 'Correlation'}, template='plotly_white')
                     st.plotly_chart(fig_corr, use_container_width=True, height=800)
 
+        # Heatmap of renewable energy and demand characteristics
         st.markdown("### Heatmap of Renewable Energy and Demand Characteristics")
         hourly_data = numeric_energy_data_df.copy()
-        hourly_data['Time'] = pd.to_datetime(data['Time'], errors='coerce')
+        hourly_data['Time'] = pd.to_datetime(energy_data_df['Time'], errors='coerce')
         hourly_data['Date'] = hourly_data['Time'].dt.date
         hourly_data['Hour'] = hourly_data['Time'].dt.hour