Update app.py

app.py

@@ -1,55 +1,296 @@
-# Create a figure for power supply and demand
-fig_supply_demand = go.Figure()
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_solar, mode='lines', stackgroup='one', name='Solar'))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_onshore_wind, mode='lines', stackgroup='one', name='Onshore Wind'))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_offshore_wind, mode='lines', stackgroup='one', name='Offshore Wind'))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_river, mode='lines', stackgroup='one', name='River'))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=battery_discharge_values, mode='lines', name='Battery Discharge', line=dict(color='red')))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=battery_charge_values, mode='lines', name='Battery Charge', line=dict(color='blue')))
-fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=-demand, mode='lines', name='Demand', line=dict(color='black')))
-
-# Create a figure for state of charge (SOC)
-fig_soc = go.Figure()
-fig_soc.add_trace(go.Scatter(x=data['Time'], y=SOC_normalized, mode='lines', name='State of Charge (SOC)'))
-
-# Create a figure for electricity price over time
-fig_price = go.Figure()
-fig_price.add_trace(go.Scatter(x=data['Time'], y=price_per_hour, mode='lines', name='Electricity Price'))
-
-# Update layouts for each figure
-fig_supply_demand.update_layout(
-    title_text='Power Supply and Demand',
-    yaxis_title='Power dispatch (MW)',
-    legend_title='Source',
-    font=dict(size=12),
-    margin=dict(l=40, r=40, t=40, b=40),
-    hovermode='x unified',
-    plot_bgcolor='white',
-    xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
-    yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
-)
-
-fig_soc.update_layout(
-    title_text='State of Charge (Battery)',
-    yaxis_title='State of Charge (%)',
-    font=dict(size=12),
-    margin=dict(l=40, r=40, t=40, b=40),
-    hovermode='x unified',
-    plot_bgcolor='white',
-    xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
-    yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
-)
-
-fig_price.update_layout(
-    title_text='Electricity Price Over Time',
-    yaxis_title='Electricity Price (\u00a5/MWh)',
-    font=dict(size=12),
-    margin=dict(l=40, r=40, t=40, b=40),
-    hovermode='x unified',
-    plot_bgcolor='white',
-    xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
-    yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
-)
-
-# Return the figures
-return fig_supply_demand, fig_soc, fig_price, curtailment_values, price_per_hour
+import streamlit as st
+import requests
+import pandas as pd
+from io import StringIO
+import pulp
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+import plotly.express as px
+import datetime
+
+# Function to fetch renewable energy data
+def get_renewable_energy_data(city_code):
+    """
+    Fetch renewable energy data from an external source based on a city code.
+    
+    Args:
+    - city_code (str): The code representing the city for which the renewable energy data is to be fetched.
+    Returns:
+    - result_df (DataFrame): A DataFrame containing the energy data with time and capacity factors for each energy type.
+    - error (str): Error message if the data fetching fails.
+    """
+    url = f"https://energy-sustainability.jp/_ajax/renewable_energy/get/?code={city_code}"
+    response = requests.get(url)
+    if response.status_code != 200:
+        return None, "データの取得に失敗しました。"  # Data fetch failed.
+
+    data = response.json()
+    if not data:
+        return None, "データが見つかりませんでした。"  # Data not found.
+
+    # Extract base times from the first energy type.
+    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.
+    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
+def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand):
+    """
+    Optimize the energy system using linear programming to minimize cost while meeting demand with renewable sources and batteries.
+    
+    Args:
+    - city_code (str): The code of the city for which energy data is to be optimized.
+    - solar_cost (float): The cost of solar capacity per MW.
+    - onshore_wind_cost (float): The cost of onshore wind capacity per MW.
+    - offshore_wind_cost (float): The cost of offshore wind capacity per MW.
+    - river_cost (float): The cost of river (hydro) capacity per MW.
+    - battery_cost (float): The cost of battery capacity per MWh.
+    - yearly_demand (float): The total yearly demand in TWh/year.
+    Returns:
+    - fig (Figure): A plotly figure showing the optimized energy dispatch and state of charge (SOC) over time.
+    - curtailment_values (list): List of curtailment values for visualization.
+    - price_per_hour (list): List of estimated electricity price per hour for visualization.
+    """
+    data, error = get_renewable_energy_data(city_code)
+    if error:
+        st.error(error)
+        return None, None, None
+
+    # Convert capacity factor columns to numeric values, handling any errors and filling missing data.
+    for col in data.columns[1:]:
+        data[col] = pd.to_numeric(data[col], errors='coerce')
+
+    data = data.fillna(0)  # Fill missing values with zero.
+
+    # Extract necessary data for optimization.
+    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']
+
+    # Define regions and technologies.
+    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
+    }
+
+    # Cost definitions for renewable capacity and battery.
+    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  # Battery efficiency.
+    
+    # Scale demand from capacity factor and 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')
+    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')
+
+    # Define the optimization problem: minimize the total system cost.
+    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
+
+    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:
+            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}"
+
+    # 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
+    supply_river = river_cf * renewable_capacity[('region1', 'river')].varValue
+
+    battery_discharge_values = [battery_discharge[t].varValue for t in time_steps]
+    battery_charge_values = [-battery_charge[t].varValue for t in time_steps]
+    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]  # Base price + factor for demand.
+
+    # 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 a subplot with 3 rows for energy dispatch, state of charge (SOC), and electricity price.
+    ", "Electricity Price Over Time"))
+
+    # Create separate figure for power supply and demand
+    fig_supply_demand = go.Figure()
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_solar, mode='lines', stackgroup='one', name='Solar', line=dict(color='#FFD700', width=0)))  # Solar: Gold
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_onshore_wind, mode='lines', stackgroup='one', name='Onshore Wind', line=dict(color='#1F78B4', width=0)))  # Onshore Wind: Blue
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_offshore_wind, mode='lines', stackgroup='one', name='Offshore Wind', line=dict(color='#66C2A5', width=0)))  # Offshore Wind: Light Green
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=supply_river, mode='lines', stackgroup='one', name='Run of River', line=dict(color='#FF7F00', width=0)))  # Run of River: Orange
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=battery_discharge_values, mode='lines', stackgroup='one', name='Battery Discharge', fill='tonexty', line=dict(color='#6A3D9A', width=0)))  # Battery Discharge: Brown
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=battery_charge_values, mode='lines', stackgroup='two', name='Battery Charge', fill='tonexty', line=dict(color='#6A3D9A', width=0)))  # Battery Charge: Purple
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=-demand, mode='lines', stackgroup='two', name='Demand', line=dict(color='black', width=0)))  # Demand: Black
+    fig_supply_demand.add_trace(go.Scatter(x=data['Time'], y=curtailment_values, mode='lines', stackgroup='two', name='Curtailment', line=dict(color='#aaaaaa', width=0)))  # Curtailment: Grey
+    
+    fig_supply_demand.update_layout(
+        title_text='Power Supply and Demand',
+        yaxis_title='Power dispatch (MW)',
+        legend_title='Source',
+        font=dict(size=12),
+        margin=dict(l=40, r=40, t=40, b=40),
+        hovermode='x unified',
+        plot_bgcolor='white',
+        xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
+        yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
+    )  # Curtailment: Grey
+
+    # Create separate figure for state of charge (SOC)
+    fig_soc = go.Figure()
+    fig_soc.add_trace(go.Scatter(x=data['Time'], y=SOC_normalized, mode='lines', name='State of Charge (SOC) - Normalized', line=dict(color='black')))
+    
+    fig_soc.update_layout(
+        title_text='State of Charge (Battery)',
+        yaxis_title='State of Charge (%)',
+        font=dict(size=12),
+        margin=dict(l=40, r=40, t=40, b=40),
+        hovermode='x unified',
+        plot_bgcolor='white',
+        xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
+        yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
+    )
+
+    # Create separate figure for electricity price over time
+    fig_price = go.Figure()
+    fig_price.add_trace(go.Scatter(x=data['Time'], y=price_per_hour, mode='lines', name='Electricity Price', line=dict(color='#FF4500')))
+    
+    fig_price.update_layout(
+        title_text='Electricity Price Over Time',
+        yaxis_title='Electricity Price (¥/MWh)',
+        font=dict(size=12),
+        margin=dict(l=40, r=40, t=40, b=40),
+        hovermode='x unified',
+        plot_bgcolor='white',
+        xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
+        yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
+    )  # Price: Red-Orange
+
+    # Layout settings for the figure.
+    fig.update_layout(
+        title_text='Optimized result',
+        title_x=0.5,
+        yaxis_title='Power dispatch (MW)',
+        legend_title='Source',
+        font=dict(size=12),
+        margin=dict(l=40, r=40, t=40, b=40),
+        hovermode='x unified',
+        plot_bgcolor='white',
+        xaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray'),
+        yaxis=dict(showgrid=True, gridwidth=0.5, gridcolor='lightgray')
+    )
+    # Update the y-axis titles for each subplot.
+    fig.update_yaxes(title_text="State of Charge (%)", row=2, col=1)
+    fig.update_yaxes(title_text="Electricity Price (¥/MWh)", row=3, col=1)
+
+    return fig, curtailment_values, price_per_hour
+
+# Streamlit UI for the application
+st.set_page_config(page_title='Renewable Energy System Optimization', layout='wide')
+st.title('Renewable Energy System Optimization')
+
+# Explanation of 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.
+""")
+
+# Input fields for the user
+with st.sidebar:
+    st.header('Input Parameters')
+    city_code = st.text_input("Enter City Code", value="")
+    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=100.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
+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_supply_demand, use_container_width=True, height=800)
+    st.plotly_chart(fig_soc, use_container_width=True, height=800)
+    st.plotly_chart(fig_price, 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.")
+
+        # Data for additional visualizations
+        renewable_data = {
+            'Solar': solar_cost,
+            'Onshore Wind': onshore_wind_cost,
+            'Offshore Wind': offshore_wind_cost,
+            'Run of River': river_cost
+        }
+        cost_df = pd.DataFrame(list(renewable_data.items()), columns=['Technology', 'Cost (¥/MW)'])
+
+        # Plot cost comparison
+        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 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 of renewable capacity factors
+        if city_code:
+            st.markdown("### Correlation Between Renewable Energy Sources")
+            correlation_matrix = get_renewable_energy_data(city_code)[0].corr()
+            if correlation_matrix is not None:
+                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)
+            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)
+
+# Note: You may need to adjust initial values or labels to fit your requirements.