Update app.py

app.py

@@ -2,21 +2,20 @@ import streamlit as st
 import requests
 import pandas as pd
 import pulp
+import plotly.graph_objs as go
 import plotly.express as px
-import plotly.graph_objects as go
 import numpy as np
-import matplotlib.pyplot as plt
 
-# Renewable energy data fetch function
+# 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."
+        return None, "データの取得に失敗しました。"
 
     data = response.json()
     if not data:
-        return None, "No data found."
+        return None, "データが見つかりませんでした。"
 
     base_times = data[next(iter(data))]['x']
     result_df = pd.DataFrame({"Time": base_times})
@@ -28,14 +27,12 @@ def get_renewable_energy_data(city_code):
 
     return result_df, None
 
-# Optimize energy system with MGA
-def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, nuclear_cost, coal_cost,
-                           battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range,
-                           nuclear_range, coal_range, thresholds, selected_tech):
+# Function to optimize the energy system and create visualizations
+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):
     data, error = get_renewable_energy_data(city_code)
     if error:
         st.error(error)
-        return None
+        return None, None, None, None, None, None
 
     for col in data.columns[1:]:
         data[col] = pd.to_numeric(data[col], errors='coerce')
@@ -46,40 +43,18 @@ def optimize_energy_system(city_code, solar_cost, onshore_wind_cost, offshore_wi
     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']
-    nuclear_cf = 1.0  # Assume nuclear operates at full capacity
-    coal_cf = 0.8  # Assume coal operates at 80% capacity
     demand_cf = data['demand hourly capacity factor']
 
     regions = ['region1']
-    technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river', 'nuclear', 'coal']
+    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,
-        'nuclear': [nuclear_cf] * len(time_steps),
-        'coal': [coal_cf] * len(time_steps)
-    }
-
-    renewable_capacity_cost = {
-        'solar': solar_cost,
-        'onshore_wind': onshore_wind_cost,
-        'offshore_wind': offshore_wind_cost,
-        'river': river_cost,
-        'nuclear': nuclear_cost,
-        'coal': coal_cost
-    }
-
-    # CO2 emissions per MWh
-    co2_emissions = {
-        'solar': 0,
-        'onshore_wind': 0,
-        'offshore_wind': 0,
-        'river': 0,
-        'nuclear': 0,
-        'coal': 820  # in kg CO2 per MWh
+        '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
 
@@ -96,142 +71,265 @@ 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')
 
-    # Add a variable for CO2 emissions
-    total_co2_emissions = pulp.LpVariable("total_co2_emissions", lowBound=0, cat='Continuous')
-
-    model = pulp.LpProblem("EnergySystemOptimizationWithBatteryAndCO2", pulp.LpMinimize)
+    model = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
 
-    # Objective: minimize total cost and CO2 emissions
     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 + \
-             0.01 * total_co2_emissions, "TotalCostAndCO2"
+             battery_capacity * battery_cost_per_mwh, "TotalCost"
 
-    # Constraints: meet demand, manage battery SOC, calculate CO2 emissions
     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}"
 
-    # Add CO2 emissions constraint
-    model += total_co2_emissions == pulp.lpSum([renewable_capacity[(r, 'coal')] * coal_cf * co2_emissions['coal'] for r in regions]), "CO2Emissions"
-
-    # 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]
-    model += renewable_capacity[('region1', 'nuclear')] >= nuclear_range[0]
-    model += renewable_capacity[('region1', 'nuclear')] <= nuclear_range[1]
-    model += renewable_capacity[('region1', 'coal')] >= coal_range[0]
-    model += renewable_capacity[('region1', 'coal')] <= coal_range[1]
-
-    # Solve the initial model to find the optimal solution
+    model += renewable_capacity[('region1', 'solar')] >= solar_range[0], "SolarMinConstraint"
+    model += renewable_capacity[('region1', 'solar')] <= solar_range[1], "SolarMaxConstraint"
+    model += renewable_capacity[('region1', 'onshore_wind')] >= wind_range[0], "WindMinConstraint"
+    model += renewable_capacity[('region1', 'onshore_wind')] <= wind_range[1], "WindMaxConstraint"
+    model += renewable_capacity[('region1', 'offshore_wind')] >= offshore_wind_range[0], "OffshoreWindMinConstraint"
+    model += renewable_capacity[('region1', 'offshore_wind')] <= offshore_wind_range[1], "OffshoreWindMaxConstraint"
+    model += renewable_capacity[('region1', 'river')] >= river_range[0], "RiverMinConstraint"
+    model += renewable_capacity[('region1', 'river')] <= river_range[1], "RiverMaxConstraint"
+
     model.solve()
-    optimal_cost = pulp.value(model.objective)
-
-    # MGA: Generate alternative solutions
-    alternative_solutions = []
-    for threshold in thresholds:
-        relaxed_cost = optimal_cost * (1 + threshold)
-        for tech in selected_tech:
-            alt_model = pulp.LpProblem(f"AlternativeModel_{tech}_{threshold}", pulp.LpMinimize)
-            alt_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 + 0.01 * total_co2_emissions <= relaxed_cost
-
-            # Avoid overlapping constraint names by appending unique suffixes
-            for i, (name, constraint) in enumerate(model.constraints.items()):
-                alt_model += constraint.copy(), f"{name}_{tech}_{threshold}_{i}"
-
-            # Modify the objective to minimize or maximize capacity of selected technology
-            alt_model += renewable_capacity[('region1', tech)], f"Minimize_{tech}_Capacity"
-            alt_model.solve()
-
-            if pulp.LpStatus[alt_model.status] == 'Optimal':
-                alternative_solutions.append({
-                    'threshold': threshold,
-                    'technology': tech,
-                    'solution': {g: renewable_capacity[('region1', g)].varValue for g in technologies},
-                    'battery_capacity': battery_capacity.varValue,
-                    'total_cost': pulp.value(alt_model.objective),
-                    'total_co2_emissions': total_co2_emissions.varValue
-                })
-
-    return alternative_solutions, data, renewable_capacity, battery_discharge, battery_charge, demand, curtailment
 
-# Streamlit UI setup
-st.set_page_config(page_title='Energy System Optimization with Nuclear, Coal, and CO2', layout='wide')
-st.title('Energy System Optimization with MGA: Including Nuclear, Coal, and CO2 Considerations')
+    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]
+
+    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)
+
+    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)))
+    fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_offshore_wind, mode='lines', stackgroup='one', name='Offshore Wind', line=dict(color='#66C2A5', width=0)))
+    fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_river, mode='lines', stackgroup='one', name='Run of River', line=dict(color='#FF7F00', width=0)))
+    fig_energy.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)))
+    fig_energy.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)))
+    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)))
+    
+    fig_energy.update_layout(
+        title_text='Power Supply and Demand',
+        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')
+    )
+
+    # 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')
+        df_heatmap['day_of_year'] = df_heatmap['Time'].dt.dayofyear
+        df_heatmap['hour_of_day'] = df_heatmap['Time'].dt.hour
+
+        pivot_df = df_heatmap.pivot_table(
+            index='hour_of_day',
+            columns='day_of_year',
+            values=f'{energy_source} hourly capacity factor',
+            aggfunc='mean'
+        )
+
+        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"),
+            x=pivot_df.columns,
+            y=pivot_df.index,
+            aspect="auto",
+            color_continuous_scale='Plasma'
+        )
 
-technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river', 'nuclear', 'coal']
+        fig_heatmap.update_layout(
+            title=f'{energy_source.replace("_", " ").title()} Hourly Capacity Factor (24 Hours x 365 Days)',
+            xaxis_title='Day of Year',
+            yaxis_title='Hour of Day',
+            font=dict(size=12),
+            plot_bgcolor='white',
+            margin=dict(l=40, r=40, t=40, b=40),
+        )
+        heatmaps.append(fig_heatmap)
+
+    # Create capacity range visualization for each technology
+    fig_capacity_ranges = go.Figure()
+    technologies = ['solar', 'onshore_wind', 'offshore_wind', 'river']
+    capacity_ranges = [solar_range, wind_range, offshore_wind_range, river_range]
+    optimized_capacities = [
+        renewable_capacity[('region1', 'solar')].varValue,
+        renewable_capacity[('region1', 'onshore_wind')].varValue,
+        renewable_capacity[('region1', 'offshore_wind')].varValue,
+        renewable_capacity[('region1', 'river')].varValue
+    ]
+
+    for tech, cap_range, optimized_cap in zip(technologies, capacity_ranges, optimized_capacities):
+        fig_capacity_ranges.add_trace(go.Scatter(
+            x=[tech, tech],
+            y=cap_range,
+            mode='lines',
+            name=f'{tech} capacity range',
+            line=dict(color='blue', width=4)
+        ))
+        fig_capacity_ranges.add_trace(go.Scatter(
+            x=[tech],
+            y=[optimized_cap],
+            mode='markers',
+            name=f'{tech} optimized capacity',
+            marker=dict(color='red', symbol='x', size=10)
+        ))
+
+    fig_capacity_ranges.update_layout(
+        title_text='Optimized Capacity vs. Capacity Ranges',
+        title_x=0.5,
+        yaxis_title='Capacity (MW)',
+        xaxis_title='Technology',
+        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 fig_energy, heatmaps, curtailment_values, SOC_normalized, fig_capacity_ranges, renewable_capacity
+
+# 資源コストの感度解析を行う関数
+def analyze_cost_sensitivity(renewable_capacity_cost, technologies, renewable_capacity):
+    # コストの変動範囲（0.5倍から1.5倍）
+    cost_multipliers = np.linspace(0.5, 1.5, 11)
+
+    # 結果を格納する辞書
+    sensitivity_results = {}
+
+    for tech in technologies:
+        # 各技術ごとのコスト変動に対する総コストの変化を計算
+        original_cost = renewable_capacity_cost[tech]
+        total_costs = []
+
+        for multiplier in cost_multipliers:
+            # コストを変更
+            modified_cost = original_cost * multiplier
+            # 総コスト = 変更後のコスト * 設備容量
+            total_cost = modified_cost * renewable_capacity[('region1', tech)].varValue
+            total_costs.append(total_cost)
+
+        # 技術ごとに結果を保存
+        sensitivity_results[tech] = total_costs
+
+    # 可視化
+    fig = go.Figure()
+
+    for tech, total_costs in sensitivity_results.items():
+        fig.add_trace(go.Scatter(
+            x=cost_multipliers,
+            y=total_costs,
+            mode='lines+markers',
+            name=f'{tech} Cost Sensitivity'
+        ))
+
+    # グラフのレイアウト
+    fig.update_layout(
+        title='Cost Sensitivity Analysis: Impact of Cost Changes on Total System Cost',
+        xaxis_title='Cost Multiplier (0.5x to 1.5x)',
+        yaxis_title='Total System Cost (￥)',
+        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 fig
+
+# Streamlit UI setup
+st.set_page_config(page_title='Renewable Energy System Optimization', layout='wide')
+st.title('Renewable Energy System Optimization')
+
+st.markdown("""
+### Model Overview
+This application is designed to optimize renewable energy systems for a specific region. The model allows the user to set the costs for different renewable energy technologies and battery storage, as well as minimum and maximum capacity limits for each technology. The optimization uses linear programming to minimize the total cost while ensuring demand is met, incorporating energy storage to help manage intermittency.
+The renewable technologies considered are:
+- Solar PV
+- Onshore Wind
+- Offshore Wind
+- Run of River (Hydro)
+The optimization problem aims to balance supply and demand at minimal cost, while also providing flexibility in the form of battery energy storage. Curtailment and battery state of charge are also considered in the model.
+""")
 
 with st.sidebar:
     st.header('Input Parameters')
-    city_code = st.text_input("City Code", "999999")
-    solar_cost = st.number_input("Solar Cost (¥/MW)", value=80.0)
-    onshore_wind_cost = st.number_input("Onshore Wind Cost (¥/MW)", value=120.0)
-    offshore_wind_cost = st.number_input("Offshore Wind Cost (¥/MW)", value=180.0)
-    river_cost = st.number_input("River Cost (¥/MW)", value=1000.0)
-    nuclear_cost = st.number_input("Nuclear Cost (¥/MW)", value=500.0)
-    coal_cost = st.number_input("Coal Cost (¥/MW)", value=300.0)
-    battery_cost = st.number_input("Battery Cost (¥/MWh)", value=80.0)
-    yearly_demand = st.number_input("Yearly Demand (TWh/year)", value=15.0)
+    city_code = st.text_input("Enter City Code", value=999999)
+    solar_cost = st.number_input("Solar Capacity Cost (￥/MW)", value=80.0)
+    onshore_wind_cost = st.number_input("Onshore Wind Capacity Cost (￥/MW)", value=120.0)
+    offshore_wind_cost = st.number_input("Offshore Wind Capacity Cost (￥/MW)", value=180.0)
+    river_cost = st.number_input("River Capacity Cost (￥/MW)", value=1000.0)
+    battery_cost = st.number_input("Battery Cost (￥/MWh)", value=80.0)
+    yearly_demand = st.number_input("Yearly Power Demand (TWh/year)", value=15.0)
     solar_range = st.slider("Solar Capacity Range (MW)", 0, 10000, (0, 10000))
     wind_range = st.slider("Onshore Wind Capacity Range (MW)", 0, 10000, (0, 10000))
     offshore_wind_range = st.slider("Offshore Wind Capacity Range (MW)", 0, 10000, (0, 10000))
     river_range = st.slider("River Capacity Range (MW)", 0, 10000, (0, 10000))
-    nuclear_range = st.slider("Nuclear Capacity Range (MW)", 0, 10000, (0, 10000))
-    coal_range = st.slider("Coal Capacity Range (MW)", 0, 10000, (0, 10000))
-    thresholds = st.multiselect("Thresholds (%)", [0, 5, 10], default=[0, 5])
-    selected_technologies = st.multiselect("Technologies", technologies, default=technologies)
-
-if st.button("Run Optimization"):
-    solutions, data, renewable_capacity, battery_discharge, battery_charge, demand, curtailment = optimize_energy_system(
-        city_code, solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost,
-        nuclear_cost, coal_cost, battery_cost, yearly_demand, solar_range, wind_range,
-        river_range, offshore_wind_range, nuclear_range, coal_range,
-        [t / 100 for t in thresholds], selected_technologies)
-    if solutions:
-        st.write("Optimization Results", solutions)
-
-        supply_solar = [renewable_capacity[("region1", "solar")].varValue * cf for cf in data['solar hourly capacity factor']]
-        supply_onshore_wind = [renewable_capacity[("region1", "onshore_wind")].varValue * cf for cf in data['onshore_wind hourly capacity factor']]
-        supply_offshore_wind = [renewable_capacity[("region1", "offshore_wind")].varValue * cf for cf in data['offshore_wind hourly capacity factor']]
-        supply_river = [renewable_capacity[("region1", "river")].varValue * cf for cf in data['river hourly capacity factor']]
-        battery_discharge_values = [battery_discharge[t].varValue for t in range(len(data['Time']))]
-        battery_charge_values = [battery_charge[t].varValue for t in range(len(data['Time']))]
-        curtailment_values = [curtailment[("region1", t)].varValue for t in range(len(data['Time']))]
-
-        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)))
-        fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_offshore_wind, mode='lines', stackgroup='one', name='Offshore Wind', line=dict(color='#66C2A5', width=0)))
-        fig_energy.add_trace(go.Scatter(x=data['Time'], y=supply_river, mode='lines', stackgroup='one', name='Run of River', line=dict(color='#FF7F00', width=0)))
-        fig_energy.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)))
-        fig_energy.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)))
-        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)))
-
-        fig_energy.update_layout(
-            title_text='Power Supply and Demand',
-            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')
-        )
 
-        st.plotly_chart(fig_energy)
+calculated_optimal_energy_mix = False
+
+if st.button('Calculate Optimal Energy Mix'):
+    fig_energy, heatmaps, curtailment_values, soc_per_hour, fig_capacity_ranges, renewable_capacity = 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
+    )
+    
+    if fig_energy:
+        st.plotly_chart(fig_energy, use_container_width=True, height=800)
+
+        # Additional visualizations
+        st.markdown("### Hourly Capacity Factor Heatmaps")
+        for fig_heatmap in heatmaps:
+            st.plotly_chart(fig_heatmap, use_container_width=True, height=800)
+
+        st.markdown("### Additional Analysis")
+        st.markdown("The following plots provide additional insights into the renewable energy mix, curtailment, and electricity price variations.")
+
+        # Plot curtailment over time
+        curtailment_df = pd.DataFrame({"Time": fig_energy.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
+        soc_df = pd.DataFrame({"Time": fig_energy.data[0].x, "State of charge [%]": soc_per_hour})
+        fig_battery_operation = px.line(soc_df, x='Time', y='State of charge [%]', title='State of charge in battery', template='plotly_white')
+        st.plotly_chart(fig_battery_operation, use_container_width=True, height=800)
+
+        # Plot optimized capacity vs. capacity ranges
+        st.plotly_chart(fig_capacity_ranges, use_container_width=True, height=800)
+
+        calculated_optimal_energy_mix = True
+
+# Streamlit UIに感度解析ボタンを追加
+if st.button('Analyze Cost Sensitivity'):
+    if calculated_optimal_energy_mix:
+        fig_sensitivity = analyze_cost_sensitivity({
+            'solar': solar_cost,
+            'onshore_wind': onshore_wind_cost,
+            'offshore_wind': offshore_wind_cost,
+            'river': river_cost
+        }, ['solar', 'onshore_wind', 'offshore_wind', 'river'], renewable_capacity)
+        st.plotly_chart(fig_sensitivity, use_container_width=True, height=800)
+    else:
+        st.error("Please calculate the optimal energy mix first before running the cost sensitivity analysis.")