Update app.py

app.py

@@ -1,274 +1,258 @@
+# app.py
+# -*- coding: utf-8 -*-
 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_objs as go
+import pulp
 import numpy as np
 import json
+from io import StringIO
 
-# Function to fetch renewable energy data
+# -----------------------------
+# Data I/O
+# -----------------------------
 def get_json():
     """
-    open data.json
+    Open data.json and return a tidy DataFrame.
+    Columns expected (examples):
+      - 'Time'
+      - 'solar hourly capacity factor'
+      - 'onshore_wind hourly capacity factor'
+      - 'offshore_wind hourly capacity factor'
+      - 'river hourly capacity factor'
+      - 'demand hourly capacity factor'
     """
-    with open('data.json') as f:
-        data = json.load(f)
-    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
-
-# Function to optimize the energy system and create visualizations
-def optimize_energy_system(solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost, battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range):
-    data = get_json()
-
-    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
+    with open('data.json', 'r', encoding='utf-8') as f:
+        data_local = json.load(f)
+    if not data_local:
+        return None
+
+    base_times = data_local[next(iter(data_local))]['x']
+    df_local = pd.DataFrame({"Time": base_times})
+
+    for k_local, v_local in data_local.items():
+        if isinstance(v_local, dict) and 'x' in v_local and 'y' in v_local:
+            df_local[f"{k_local} hourly capacity factor"] = v_local['y']
+
+    # Coerce numeric + NA fill
+    for col_local in df_local.columns[1:]:
+        df_local[col_local] = pd.to_numeric(df_local[col_local], errors='coerce')
+    df_local = df_local.fillna(0.0)
+
+    return df_local
+
+# -----------------------------
+# Core LP builder/solver with duals
+# -----------------------------
+def optimize_with_duals(
+    solar_cost_local: float,
+    onshore_wind_cost_local: float,
+    offshore_wind_cost_local: float,
+    river_cost_local: float,
+    battery_cost_per_mwh_local: float,
+    yearly_demand_twh_local: float,
+    solar_range_local: tuple,
+    wind_range_local: tuple,
+    river_range_local: tuple,
+    offshore_wind_range_local: tuple,
+    battery_eff_local: float = 0.9
+):
+    """
+    Build and solve the capacity-planning LP with storage and extract duals.
+
+    Returns:
+        dict:
+            {
+              'status': str,
+              'objective': float,
+              'df': pandas.DataFrame (input CFs + Time),
+              'caps': dict of optimized capacities,
+              'soc': list of SOC values,
+              'charge': list of charge,
+              'discharge': list of discharge,
+              'curtail': list of curtailment,
+              'lmp': pandas.Series of LMP (one value per time),
+              'demand': numpy.ndarray of demand (MW)
+            }
+    Notes:
+        - All variables are continuous; duals (shadow prices) are available from CBC.
+        - LMP is taken as the (signed) dual of the demand-balance constraint per time.
+          We map it so that a positive value means: "Increasing demand by 1 MW raises total cost by that amount."
+    """
+    df_local = get_json()
+    if df_local is None:
+        raise RuntimeError("data.json not found or empty.")
+
+    # Time index
+    t_idx_local = list(range(len(df_local['Time'])))
+
+    # Capacity factors
+    cf_map_local = {
+        'solar': df_local['solar hourly capacity factor'].astype(float).values,
+        'onshore_wind': df_local['onshore_wind hourly capacity factor'].astype(float).values,
+        'offshore_wind': df_local['offshore_wind hourly capacity factor'].astype(float).values,
+        'river': df_local['river hourly capacity factor'].astype(float).values
     }
-
-    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)
-
-    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"
-
-    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}"
-
-    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()
-
-    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')
+    demand_cf_local = df_local['demand hourly capacity factor'].astype(float).values
+
+    # Demand level (MW): TWh/year -> MWh/year -> scale by hourly CF share
+    # Here demand_cf is a % share per hour that sums to ~100%*hours if provided as percentage.
+    # If it's in [0,1] and sums to 1 over the year, adjust accordingly as needed by your data design.
+    demand_mw_total_local = yearly_demand_twh_local * 1e6  # TWh -> MWh, then per hour sum will distribute via cf
+    # Assuming demand_cf_local sums to 100 over the year (percentage), divide by 100 to get shares.
+    demand_local = (demand_cf_local / 100.0) * demand_mw_total_local
+
+    # Model
+    mdl_local = pulp.LpProblem("EnergySystemOptimizationWithBattery", pulp.LpMinimize)
+
+    # Variables
+    caps_local = {
+        ('region1', 'solar'): pulp.LpVariable("cap_solar", lowBound=0, cat='Continuous'),
+        ('region1', 'onshore_wind'): pulp.LpVariable("cap_onshore", lowBound=0, cat='Continuous'),
+        ('region1', 'offshore_wind'): pulp.LpVariable("cap_offshore", lowBound=0, cat='Continuous'),
+        ('region1', 'river'): pulp.LpVariable("cap_river", lowBound=0, cat='Continuous')
+    }
+    cap_batt_local = pulp.LpVariable("cap_battery", lowBound=0, cat='Continuous')
+
+    chg_local = {t: pulp.LpVariable(f"charge_{t}", lowBound=0, cat='Continuous') for t in t_idx_local}
+    dch_local = {t: pulp.LpVariable(f"discharge_{t}", lowBound=0, cat='Continuous') for t in t_idx_local}
+    soc_local = {t: pulp.LpVariable(f"soc_{t}", lowBound=0, cat='Continuous') for t in t_idx_local}
+    curt_local = {t: pulp.LpVariable(f"curtail_{t}", lowBound=0, cat='Continuous') for t in t_idx_local}
+
+    # Objective: capacity costs only (as in your original)
+    cost_map_local = {
+        'solar': solar_cost_local,
+        'onshore_wind': onshore_wind_cost_local,
+        'offshore_wind': offshore_wind_cost_local,
+        'river': river_cost_local
+    }
+    obj_local = (
+        caps_local[('region1', 'solar')] * cost_map_local['solar'] +
+        caps_local[('region1', 'onshore_wind')] * cost_map_local['onshore_wind'] +
+        caps_local[('region1', 'offshore_wind')] * cost_map_local['offshore_wind'] +
+        caps_local[('region1', 'river')] * cost_map_local['river'] +
+        cap_batt_local * battery_cost_per_mwh_local
     )
-
-    # 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'
+    mdl_local += obj_local
+
+    # Capacity bounds
+    mdl_local += caps_local[('region1', 'solar')].ge(solar_range_local[0]), "SolarMin"
+    mdl_local += caps_local[('region1', 'solar')].le(solar_range_local[1]), "SolarMax"
+    mdl_local += caps_local[('region1', 'onshore_wind')].ge(wind_range_local[0]), "WindMin"
+    mdl_local += caps_local[('region1', 'onshore_wind')].le(wind_range_local[1]), "WindMax"
+    mdl_local += caps_local[('region1', 'offshore_wind')].ge(offshore_wind_range_local[0]), "OffshoreMin"
+    mdl_local += caps_local[('region1', 'offshore_wind')].le(offshore_wind_range_local[1]), "OffshoreMax"
+    mdl_local += caps_local[('region1', 'river')].ge(river_range_local[0]), "RiverMin"
+    mdl_local += caps_local[('region1', 'river')].le(river_range_local[1]), "RiverMax"
+
+    # Demand balance constraints per time (keep objects for duals)
+    bal_cons_local = {}
+    for t in t_idx_local:
+        gen_t_local = (
+            caps_local[('region1', 'solar')] * cf_map_local['solar'][t] +
+            caps_local[('region1', 'onshore_wind')] * cf_map_local['onshore_wind'][t] +
+            caps_local[('region1', 'offshore_wind')] * cf_map_local['offshore_wind'][t] +
+            caps_local[('region1', 'river')] * cf_map_local['river'][t]
         )
+        # Write as: gen + discharge - demand - charge - curtailment == 0
+        expr_local = gen_t_local + dch_local[t] - demand_local[t] - chg_local[t] - curt_local[t]
+        cons_local = pulp.LpConstraint(e=expr_local, sense=pulp.LpConstraintEQ, name=f"Balance_t{t}")
+        mdl_local += cons_local
+        bal_cons_local[t] = cons_local
+
+        # SOC and limits
+        if t == 0:
+            mdl_local += (soc_local[t] == chg_local[t] * battery_eff_local - dch_local[t] * (1.0 / battery_eff_local)), f"SOC_t{t}"
+        else:
+            mdl_local += (soc_local[t] == soc_local[t-1] + chg_local[t] * battery_eff_local - dch_local[t] * (1.0 / battery_eff_local)), f"SOC_t{t}"
+        mdl_local += (soc_local[t] <= cap_batt_local), f"SOCcap_t{t}"
+
+    # Solve (CBC)
+    solver_local = pulp.PULP_CBC_CMD(msg=False)
+    mdl_status_local = mdl_local.solve(solver_local)
+
+    # Extract solution
+    soc_vals_local = [pulp.value(soc_local[t]) for t in t_idx_local]
+    chg_vals_local = [pulp.value(chg_local[t]) for t in t_idx_local]
+    dch_vals_local = [pulp.value(dch_local[t]) for t in t_idx_local]
+    curt_vals_local = [pulp.value(curt_local[t]) for t in t_idx_local]
+    cap_dict_local = {
+        'solar': pulp.value(caps_local[('region1', 'solar')]),
+        'onshore_wind': pulp.value(caps_local[('region1', 'onshore_wind')]),
+        'offshore_wind': pulp.value(caps_local[('region1', 'offshore_wind')]),
+        'river': pulp.value(caps_local[('region1', 'river')]),
+        'battery': pulp.value(cap_batt_local)
+    }
 
-        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')
-    )
+    # Duals -> LMPs
+    # CBC returns duals for LPs; for equality of form (supply - demand == 0),
+    # the economically meaningful LMP (cost increase when demand increases) is -dual.
+    dual_raw_local = np.array([bal_cons_local[t].pi for t in t_idx_local], dtype=float)
+    lmp_local = -dual_raw_local  # positive means "increase in cost for +1 MW of demand"
+
+    return {
+        'status': pulp.LpStatus[mdl_local.status],
+        'objective': float(pulp.value(mdl_local.objective)),
+        'df': df_local,
+        'caps': cap_dict_local,
+        'soc': soc_vals_local,
+        'charge': chg_vals_local,
+        'discharge': dch_vals_local,
+        'curtail': curt_vals_local,
+        'lmp': pd.Series(lmp_local, index=df_local['Time'], name='LMP'),
+        'demand': demand_local
+    }
 
-    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')
-    )
+# -----------------------------
+# Visualization helpers
+# -----------------------------
+def make_supply_plot(df_local, cap_dict_local, charge_vals_local, discharge_vals_local, demand_local, curt_vals_local):
+    """
+    Build stacked supply-demand plot (Plotly).
+    """
+    time_local = df_local['Time']
+    sup_solar_local = df_local['solar hourly capacity factor'] * cap_dict_local['solar']
+    sup_on_local = df_local['onshore_wind hourly capacity factor'] * cap_dict_local['onshore_wind']
+    sup_off_local = df_local['offshore_wind hourly capacity factor'] * cap_dict_local['offshore_wind']
+    sup_riv_local = df_local['river hourly capacity factor'] * cap_dict_local['river']
+
+    fig_local = go.Figure()
+    fig_local.add_trace(go.Scatter(x=time_local, y=sup_solar_local, mode='lines', stackgroup='one', name='Solar', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=sup_on_local, mode='lines', stackgroup='one', name='Onshore', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=sup_off_local, mode='lines', stackgroup='one', name='Offshore', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=sup_riv_local, mode='lines', stackgroup='one', name='River', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=discharge_vals_local, mode='lines', stackgroup='one', name='Battery Discharge', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=-np.array(charge_vals_local), mode='lines', stackgroup='two', name='Battery Charge', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=-demand_local, mode='lines', stackgroup='two', name='Demand', line=dict(width=0)))
+    fig_local.add_trace(go.Scatter(x=time_local, y=-np.array(curt_vals_local), mode='lines', stackgroup='two', name='Curtailment', line=dict(width=0)))
+    fig_local.update_layout(title='Power Supply and Demand', yaxis_title='MW', hovermode='x unified', plot_bgcolor='white')
+    return fig_local
+
+def make_lmp_fig(lmp_series_local: pd.Series):
+    """
+    Build LMP time-series chart.
+    """
+    fig_local = px.line(lmp_series_local.reset_index(), x='Time', y='LMP', title='LMP (dual of demand balance)')
+    fig_local.update_layout(hovermode='x unified', plot_bgcolor='white')
+    return fig_local
 
-    return fig
+def make_lmp_hist(lmp_series_local: pd.Series):
+    """
+    Build LMP distribution chart.
+    """
+    fig_local = px.histogram(lmp_series_local, nbins=60, title='LMP distribution')
+    fig_local.update_layout(plot_bgcolor='white')
+    return fig_local
 
-# Streamlit UI setup
-st.set_page_config(page_title='Renewable Energy System Optimization', layout='wide')
-st.title('Renewable Energy System Optimization')
+# -----------------------------
+# Streamlit UI
+# -----------------------------
+st.set_page_config(page_title='Renewable Energy System Optimization with LMP', layout='wide')
+st.title('Renewable Energy System Optimization + LMP (dual)')
 
 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.
+最適化モデルに双対変数を用いた LMP 計算を追加しました。投資 LP における各時刻の限界コスト（長期的な影響）として解釈してください。
 """)
 
 with st.sidebar:
@@ -284,48 +268,44 @@ with st.sidebar:
     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))
 
-calculated_optimal_energy_mix = False
+if 'last_result' not in st.session_state:
+    st.session_state['last_result'] = None
 
-if st.button('Calculate Optimal Energy Mix'):
-    fig_energy, heatmaps, curtailment_values, soc_per_hour, fig_capacity_ranges, renewable_capacity = optimize_energy_system(
-        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.")
+col_a, col_b = st.columns(2)
+
+with col_a:
+    if st.button('Calculate Optimal Energy Mix'):
+        res = optimize_with_duals(
+            solar_cost, onshore_wind_cost, offshore_wind_cost, river_cost,
+            battery_cost, yearly_demand, solar_range, wind_range, river_range, offshore_wind_range
+        )
+        st.session_state['last_result'] = res
+
+        st.success(f"Solve status: {res['status']} | Objective (￥): {res['objective']:.2f}")
+        fig_energy = make_supply_plot(res['df'], res['caps'], res['charge'], res['discharge'], res['demand'], res['curtail'])
+        st.plotly_chart(fig_energy, use_container_width=True, height=600)
+
+with col_b:
+    if st.button('Compute LMP (dual)'):
+        res = st.session_state.get('last_result')
+        if not res:
+            st.error("Please run optimization first.")
+        else:
+            lmp_ser = res['lmp']
+            st.plotly_chart(make_lmp_fig(lmp_ser), use_container_width=True, height=600)
+            st.plotly_chart(make_lmp_hist(lmp_ser), use_container_width=True, height=400)
+
+            # Top-24 hours by LMP
+            top_df = lmp_ser.sort_values(ascending=False).head(24).reset_index()
+            top_df.columns = ['Time', 'LMP']
+            st.markdown("### Top-24 hours by LMP")
+            st.dataframe(top_df)
+
+            # Download
+            csv_buf = StringIO()
+            out_df = lmp_ser.reset_index()
+            out_df.to_csv(csv_buf, index=False, encoding='utf-8')
+            st.download_button("Download LMP CSV", data=csv_buf.getvalue(), file_name="lmp_timeseries.csv", mime="text/csv")
+
+st.markdown("---")
+st.markdown("ヒント：現実的な短期 LMP を得るには、技術ごとの可変費用（￥/MWh）、ネットワーク潮流・線容量制約の導入が有効です。")