Update app.py

app.py

@@ -1,929 +1,483 @@
-# jp_market_model_network.py
-# -*- coding: utf-8 -*-
-"""
-Japan-scale simultaneous market clearing with inter-area transmission (10 areas),
-realistic national scale (capacities, intertie ATCs), and time-varying inputs.
-
-- Areas: Hokkaido, Tohoku, Tokyo, Chubu, Hokuriku, Kansai, Chugoku, Shikoku, Kyushu, Okinawa
-- Network: directional interties with OCCTO/REI-based operating capacities (MW)
-- Energy + upward reserve co-optimization (LP)
-- Time-varying: fuel prices (via CSV or synthesized), FX, nuclear var cost, reserve ratio, VOLL
-- Unit-level random fleet, calibrated to national installed capacity by fuel (FY2022 JEPIC)
-- LMP = dual of area energy balance (JPY/MWh)
-- Reserve price = dual of area reserve requirement (JPY/MW)
-- Robust timestamp parsing for data.json (format='mixed')
-
-Run:
-    streamlit run jp_market_model_network.py
-
-Required data.json (national CF profiles):
-{
-  "solar": {"x": [...], "y": [...]},
-  "onshore_wind": {"x": [...], "y": [...]},
-  "offshore_wind": {"x": [...], "y": [...]},
-  "river": {"x": [...], "y": [...]},
-  "demand": {"x": [...], "y": [...]}  # demand hourly capacity factor (0-1)
-}
-
-Optional CSV upload (time-varying overrides; header row; Time column required):
-Time,usd_jpy,lng_usd_per_mmbtu,coal_usd_per_ton,oil_usd_per_bbl,nuclear_var_jpy_per_mwh,reserve_ratio,voll
-
-Note: All variables are local; functions include English docstrings and comments.
-"""
-
-import json
-from io import StringIO
-from typing import Dict, List, Tuple
-
-import numpy as np
+# app.py
+import streamlit as st
 import pandas as pd
 import pulp
-import plotly.express as px
 import plotly.graph_objs as go
-import streamlit as st
-
-
-# -----------------------------
-# Robust time-series loader
-# -----------------------------
-def load_timeseries():
-    """
-    Robustly load hourly time-series from data.json and parse timestamps.
-
-    What this does
-    --------------
-    - Strip stray whitespace/newlines from timestamp strings in 'x'.
-    - Parse timestamps with format='mixed' (handles ISO/offset/Z).
-    - Coerce failures to NaT; drop those rows consistently.
+import plotly.express as px
+import numpy as np
+import json
+from copy import deepcopy
 
-    Returns
-    -------
-    pandas.DataFrame
-        Index = Time (naive; converted to Asia/Tokyo if tz provided)
-        Columns include '<key> hourly capacity factor'.
+# ------------------------------
+# Data loader
+# ------------------------------
+def get_json():
     """
-    with open("data.json", "r", encoding="utf-8") as f_local:
-        data_local = json.load(f_local)
-    if not data_local:
-        raise ValueError("data.json is empty")
-
-    first_key_local = next(iter(data_local))
-    raw_times = data_local[first_key_local].get("x", [])
-    if not raw_times:
-        raise ValueError("data.json has no 'x' timeline")
-
-    cleaned = []
-    for v in raw_times:
-        if isinstance(v, str):
-            s = (
-                v.replace("
-", "").replace("
-", "").replace("	", " ")
-                .replace("　", " ").strip()
-            )
-            cleaned.append(s if s != "" else np.nan)
-        else:
-            cleaned.append(v)
-
-    t_parsed = pd.to_datetime(cleaned, format="mixed", errors="coerce", utc=True)
-    try:
-        t_parsed = t_parsed.tz_convert("Asia/Tokyo").tz_localize(None)
-    except Exception:
-        try:
-            t_parsed = t_parsed.tz_localize(None)
-        except Exception:
-            pass
-
-    n = len(cleaned)
-    df = pd.DataFrame({"Time": t_parsed})
-    for k, v in data_local.items():
-        if isinstance(v, dict) and "y" in v:
-            ser = pd.Series(v["y"]).reindex(range(n))
-            ser = pd.to_numeric(ser, errors="coerce")
-            df[f"{k} hourly capacity factor"] = ser
-
-    df = df[df["Time"].notna()].copy()
-    for c in df.columns:
-        if c != "Time":
-            df[c] = df[c].fillna(0.0).clip(lower=0.0)
-    df = df.sort_values("Time").drop_duplicates(subset=["Time"]).set_index("Time")
-    return df
-
-
-# -----------------------------
-# CSV overrides (time-varying)
-# -----------------------------
-def load_overrides_csv(file_obj, index_like):
-    """
-    Read optional CSV with time-varying overrides and align to target index.
-
-    Parameters
-    ----------
-    file_obj : UploadedFile or None
-    index_like : pandas.DatetimeIndex to reindex on
-
+    Open ./data.json and return a tidy DataFrame with columns:
+    Time, {carrier} hourly capacity factor
     Returns
     -------
-    pandas.DataFrame
-        Columns subset of:
-          ['usd_jpy','lng_usd_per_mmbtu','coal_usd_per_ton','oil_usd_per_bbl',
-           'nuclear_var_jpy_per_mwh','reserve_ratio','voll']
-        Indexed to index_like with forward-fill then back-fill.
+    pd.DataFrame
     """
-    if file_obj is None:
+    with open('data.json', encoding='utf-8') as f:
+        data = json.load(f)
+    if not data:
         return None
-    df_local = pd.read_csv(file_obj)
-    if "Time" not in df_local.columns:
-        raise ValueError("Override CSV must contain 'Time' column.")
-    df_local["Time"] = pd.to_datetime(df_local["Time"], format="mixed", errors="coerce", utc=True)
-    try:
-        df_local["Time"] = df_local["Time"].dt.tz_convert("Asia/Tokyo").dt.tz_localize(None)
-    except Exception:
-        try:
-            df_local["Time"] = df_local["Time"].dt.tz_localize(None)
-        except Exception:
-            pass
-    df_local = df_local.set_index("Time").sort_index()
-    cols_local = ['usd_jpy','lng_usd_per_mmbtu','coal_usd_per_ton','oil_usd_per_bbl',
-                  'nuclear_var_jpy_per_mwh','reserve_ratio','voll']
-    df_local = df_local[[c for c in cols_local if c in df_local.columns]]
-    df_local = df_local.reindex(index_like).ffill().bfill()
-    return df_local
-
-
-# -----------------------------
-# Fuel price converters
-# -----------------------------
-def jpy_per_gj_series(usd_jpy_ser, lng_usd_per_mmbtu_ser, coal_usd_per_ton_ser, oil_usd_per_bbl_ser):
-    """Convert price series to JPY/GJ series.
-
-    Assumptions
-    -----------
-    1 MMBtu = 1.055056 GJ, 1 bbl ≈ 6.12 GJ, coal ≈ 25.12 GJ/ton.
-    """
-    mmbtu_to_gj = 1.055056
-    bbl_to_gj = 6.12
-    coal_gj_per_ton = 25.12
-
-    gas_usd_per_gj = lng_usd_per_mmbtu_ser / mmbtu_to_gj
-    coal_usd_per_gj = coal_usd_per_ton_ser / coal_gj_per_ton
-    oil_usd_per_gj = oil_usd_per_bbl_ser / bbl_to_gj
-
-    return {
-        "lng": (gas_usd_per_gj * usd_jpy_ser).astype(float),
-        "coal": (coal_usd_per_gj * usd_jpy_ser).astype(float),
-        "oil": (oil_usd_per_gj * usd_jpy_ser).astype(float),
-    }
-
-
-# -----------------------------
-# National scale targets (FY2022 JEPIC)
-# -----------------------------
-def capacity_targets_gw():
-    """Return national installed capacity targets by technology (GW).
-
-    Targets reflect FY2022 totals (JEPIC 2024) and split hydro into
-    conventional 'river' (≈21.8 GW) + omit pumped storage for this LP.
-    """
-    targets = {
-        "lng": 79.1,       # GW
-        "coal": 50.7,
-        "oil": 21.6,
-        "nuclear": 33.1,
-        "river": 21.8,     # conventional hydro only
-        "solar": 70.1,
-        "onshore_wind": 4.8,   # split 5.3 GW total wind approx.
-        "offshore_wind": 0.5,
-    }
-    return targets
-
 
-def annual_energy_and_peak_targets():
-    """Return national demand energy (TWh) and peak (GW) for scaling.
-
-    FY2022: energy ≈ 866.5 TWh; peak 3-day avg ≈ 160.5 GW (JEPIC 2024).
-    """
-    return {"energy_TWh": 866.5, "peak_GW": 160.5}
+    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"] = pd.to_numeric(values, errors='coerce')
 
-# -----------------------------
-# Inter-area network (operating capacities in MW)
-# -----------------------------
-def interties_operating_caps_mw():
-    """Directional inter-area operating capacities (MW) based on OCCTO/REI.
+    result_df = result_df.fillna(0)
+    return result_df
 
-    Returns
-    -------
-    dict[(str,str) -> float]
-        Capacity from area i to area j in MW.
+# ------------------------------
+# Core LP builder/solver
+# ------------------------------
+def build_and_solve_lp(params, data_df):
     """
-    caps = {}
-    def set_cap(a: str, b: str, mw: float):
-        caps[(a, b)] = float(mw)
-
-    # Hokkaido <-> Tohoku (HVDC): 0.6-0.9 GW; use 900 MW each way (FY2024)
-    set_cap("Hokkaido", "Tohoku", 900.0)
-    set_cap("Tohoku", "Hokkaido", 900.0)
-
-    # Tohoku <-> Tokyo: To Tokyo 5,550 MW; To Tohoku 2,360 MW (FY2024)
-    set_cap("Tohoku", "Tokyo", 5550.0)
-    set_cap("Tokyo", "Tohoku", 2360.0)
-
-    # Tokyo <-> Chubu (50/60Hz converters): 2,100 MW both ways (FY2024)
-    set_cap("Tokyo", "Chubu", 2100.0)
-    set_cap("Chubu", "Tokyo", 2100.0)
-
-    # Chubu <-> Kansai: To Chubu 2,500 MW; To Kansai 1,340 MW (FY2024)
-    set_cap("Kansai", "Chubu", 2500.0)
-    set_cap("Chubu", "Kansai", 1340.0)
-
-    # Hokuriku <-> Kansai: To Kansai 1,900 MW; To Hokuriku 1,500 MW
-    set_cap("Hokuriku", "Kansai", 1900.0)
-    set_cap("Kansai", "Hokuriku", 1500.0)
-
-    # Hokuriku <-> Chubu: approximate 300 MW both ways
-    set_cap("Hokuriku", "Chubu", 300.0)
-    set_cap("Chubu", "Hokuriku", 300.0)
-
-    # Kansai <-> Chugoku: To Kansai 4,550 MW; To Chugoku 2,780 MW
-    set_cap("Chugoku", "Kansai", 4550.0)
-    set_cap("Kansai", "Chugoku", 2780.0)
-
-    # Kansai <-> Shikoku: 1,400 MW both ways
-    set_cap("Kansai", "Shikoku", 1400.0)
-    set_cap("Shikoku", "Kansai", 1400.0)
-
-    # Chugoku <-> Shikoku: 1,200 MW both ways
-    set_cap("Chugoku", "Shikoku", 1200.0)
-    set_cap("Shikoku", "Chugoku", 1200.0)
-
-    # Chugoku <-> Kyushu: To Chugoku 2,780 MW; To Kyushu 230 MW (Kanmon)
-    set_cap("Kyushu", "Chugoku", 2780.0)
-    set_cap("Chugoku", "Kyushu", 230.0)
-
-    # Okinawa isolated: no ties
-    return caps
-
-
-# -----------------------------
-# Fleet generation and calibration
-# -----------------------------
-def generate_fleet(regions_list: List[str], rng_obj: np.random.Generator,
-                   counts_cfg: Dict[Tuple[str, str], int],
-                   caps_cfg: Dict[str, Tuple[float, float]],
-                   hr_cfg: Dict[str, Tuple[float, float]],
-                   min_frac_cfg: Dict[str, Tuple[float, float]],
-                   ren_caps_cfg: Dict[str, Tuple[float, float]]):
-    """Generate unit-level fleet with random parameters within ranges.
-
-    Returns
-    -------
-    pandas.DataFrame
-        ['unit_id','region','tech','fuel','cap_MW','hr_GJ_per_MWh','min_frac','is_renew','cf_key']
-    """
-    rows_local = []
-    uid_local = 0
-
-    # Thermal & Nuclear
-    for r_loc in regions_list:
-        for fuel_loc in ["lng", "coal", "oil", "nuclear"]:
-            n_units = int(counts_cfg[(r_loc, fuel_loc)])
-            cap_lo, cap_hi = caps_cfg[fuel_loc]
-            hr_lo, hr_hi = hr_cfg.get(fuel_loc, (np.nan, np.nan))
-            min_lo, min_hi = min_frac_cfg[fuel_loc]
-            for _ in range(n_units):
-                cap_val = rng_obj.uniform(cap_lo, cap_hi)
-                hr_val = rng_obj.uniform(hr_lo, hr_hi) if fuel_loc != "nuclear" else np.nan
-                min_frac_val = rng_obj.uniform(min_lo, min_hi)
-                rows_local.append({
-                    "unit_id": f"U{uid_local}",
-                    "region": r_loc,
-                    "tech": fuel_loc,
-                    "fuel": fuel_loc,
-                    "cap_MW": float(cap_val),
-                    "hr_GJ_per_MWh": (float(hr_val) if fuel_loc != "nuclear" else np.nan),
-                    "min_frac": float(min_frac_val),
-                    "is_renew": False,
-                    "cf_key": None
-                })
-                uid_local += 1
-
-    # Renewables
-    for r_loc in regions_list:
-        for ren_key, cf_key in [("solar", "solar"), ("onshore_wind", "onshore_wind"),
-                                ("offshore_wind", "offshore_wind"), ("river", "river")]:
-            n_units = int(counts_cfg[(r_loc, ren_key)])
-            cap_lo, cap_hi = ren_caps_cfg[ren_key]
-            for _ in range(n_units):
-                cap_val = rng_obj.uniform(cap_lo, cap_hi)
-                rows_local.append({
-                    "unit_id": f"U{uid_local}",
-                    "region": r_loc,
-                    "tech": ren_key,
-                    "fuel": None,
-                    "cap_MW": float(cap_val),
-                    "hr_GJ_per_MWh": np.nan,
-                    "min_frac": 0.0,
-                    "is_renew": True,
-                    "cf_key": f"{cf_key} hourly capacity factor"
-                })
-                uid_local += 1
-
-    return pd.DataFrame(rows_local)
-
-
-def calibrate_capacity_to_targets(df_units: pd.DataFrame, targets_gw: Dict[str, float]):
-    """Scale unit capacities per technology so that totals match national targets.
+    Build and solve the single-region LP with electricity, H2 (P2X), CH4 (methanation),
+    battery storage, and H2 storage. Returns solved objects & key series.
 
     Parameters
     ----------
-    df_units : DataFrame of units
-    targets_gw : dict of {tech: GW}
-
-    Returns
-    -------
-    pandas.DataFrame
-        New DataFrame with cap_MW scaled per technology group.
-    """
-    df_local = df_units.copy()
-    techs_all = ["lng","coal","oil","nuclear","river","solar","onshore_wind","offshore_wind"]
-    for tech in techs_all:
-        mask = (df_local["tech"] == tech)
-        total_now = df_local.loc[mask, "cap_MW"].sum()
-        total_target_mw = targets_gw.get(tech, 0.0) * 1000.0
-        if total_now > 0.0 and total_target_mw > 0.0:
-            scale = total_target_mw / total_now
-            df_local.loc[mask, "cap_MW"] *= scale
-    return df_local
-
-
-# -----------------------------
-# Availability (Markov outages)
-# -----------------------------
-def generate_availability(df_units: pd.DataFrame, T: int, rng_obj: np.random.Generator,
-                          for_map: Dict[str, float], mean_down_map: Dict[str, float]):
-    """Generate unit availability A[u,t] ∈ {0,1} using a 2-state Markov chain per unit.
-
-    Steady-state OFF fraction = FOR.
-    Given mean down duration D_off, set p_off_on = 1/D_off; then p_on_off = FOR * p_off_on / (1-FOR).
+    params : dict
+        Model parameters incl. costs, ranges, efficiencies, yearly_demand_TWh, etc.
+    data_df : pd.DataFrame
+        DataFrame from get_json().
 
     Returns
     -------
-    dict[(int u, int t) -> int]
-        Availability flags per unit per time.
+    dict
+        Results including dispatch time series, capacities, SOCs, and figures.
     """
-    A_local = {}
-    for u in df_units.index:
-        row_u = df_units.loc[u]
-        fuel_u = row_u["fuel"] if not row_u["is_renew"] else "renew"
-        if fuel_u == "renew":
-            for t in range(T):
-                A_local[(int(u), t)] = 1
-            continue
-        FOR = float(for_map[fuel_u])
-        Doff = max(1.0, float(mean_down_map[fuel_u]))
-        p_off_on = 1.0 / Doff
-        p_on_off = (FOR * p_off_on) / max(1e-9, (1.0 - FOR))
-        p_off_on = min(max(p_off_on, 0.0), 1.0)
-        p_on_off = min(max(p_on_off, 0.0), 1.0)
-        state = 0 if rng_obj.random() < (1.0 - FOR) else 1  # 0=ON, 1=OFF
-        for t in range(T):
-            A_local[(int(u), t)] = 1 if state == 0 else 0
-            if state == 0:
-                if rng_obj.random() < p_on_off:
-                    state = 1
-            else:
-                if rng_obj.random() < p_off_on:
-                    state = 0
-    return A_local
-
+    # Aliases
+    time = data_df['Time']
+    T = list(range(len(time)))
+
+    # Capacity factors (0-1)
+    solar_cf   = data_df['solar hourly capacity factor'].values
+    on_wind_cf = data_df['onshore_wind hourly capacity factor'].values
+    off_wind_cf= data_df['offshore_wind hourly capacity factor'].values
+    river_cf   = data_df['river hourly capacity factor'].values
+    demand_cf  = data_df['demand hourly capacity factor'].values
+
+    # Scale demand to absolute power [MW]
+    # yearly_demand_TWh -> hourly demand profile so that sum(hourly)/1000 ≈ yearly_TWh
+    yearly_TWh = float(params['yearly_demand_TWh'])
+    # Normalize demand_cf to sum=1 over the year (avoid bias if not normalized)
+    demand_cf_norm = np.array(demand_cf, dtype=float)
+    demand_cf_norm = demand_cf_norm / max(demand_cf_norm.sum(), 1e-12)
+    total_MWh_year = yearly_TWh * 1e6  # [MWh]
+    demand_series_MW = total_MWh_year * demand_cf_norm  # [MWh per hour]
+    # MWh per hour equals MW (power) dispatched in that hour under unit-hour timestep
+    demand_MW = demand_series_MW
+
+    # LP model
+    m = pulp.LpProblem("RE_P2X_Optimization", pulp.LpMinimize)
+
+    # ---------------- capacities ----------------
+    cap_solar = pulp.LpVariable("cap_solar", lowBound=params['solar_range'][0], upBound=params['solar_range'][1])
+    cap_won   = pulp.LpVariable("cap_onshore_wind", lowBound=params['wind_range'][0], upBound=params['wind_range'][1])
+    cap_woff  = pulp.LpVariable("cap_offshore_wind", lowBound=params['offshore_wind_range'][0], upBound=params['offshore_wind_range'][1])
+    cap_riv   = pulp.LpVariable("cap_river", lowBound=params['river_range'][0], upBound=params['river_range'][1])
+
+    cap_batt  = pulp.LpVariable("cap_batt_MWh", lowBound=0)  # energy capacity [MWh]
+    p_batt    = pulp.LpVariable("cap_batt_P_MW", lowBound=0) # charge/discharge power cap [MW] (simple)
+
+    cap_elec  = pulp.LpVariable("cap_electrolyser_MW", lowBound=0)
+    cap_h2st  = pulp.LpVariable("cap_H2_store_MWh", lowBound=0)
+    cap_meth  = pulp.LpVariable("cap_methanation_MW_H2in", lowBound=0)
+    cap_fc    = pulp.LpVariable("cap_fuelcell_MW", lowBound=0)  # optional H2->power
+
+    # ---------------- hourly variables ----------------
+    # Renewable generation [MW]
+    g_solar = pulp.LpVariable.dicts("g_solar", T, lowBound=0)
+    g_won   = pulp.LpVariable.dicts("g_onshore", T, lowBound=0)
+    g_woff  = pulp.LpVariable.dicts("g_offshore", T, lowBound=0)
+    g_riv   = pulp.LpVariable.dicts("g_river", T, lowBound=0)
+
+    # Battery operation [MW], SOC [MWh]
+    ch_batt = pulp.LpVariable.dicts("batt_charge", T, lowBound=0)
+    dis_batt= pulp.LpVariable.dicts("batt_discharge", T, lowBound=0)
+    soc_batt= pulp.LpVariable.dicts("batt_soc", T, lowBound=0)
+
+    # Electrolyser consumption [MW_el], H2 production [MW_H2-LHV]
+    p_elec  = pulp.LpVariable.dicts("elec_load_electrolyser", T, lowBound=0)
+    h2_prod = pulp.LpVariable.dicts("h2_prod", T, lowBound=0)
+
+    # H2 storage [MWh_H2-LHV], in/out [MW_H2]
+    ch_h2   = pulp.LpVariable.dicts("h2_charge", T, lowBound=0)
+    dis_h2  = pulp.LpVariable.dicts("h2_discharge", T, lowBound=0)
+    soc_h2  = pulp.LpVariable.dicts("h2_soc", T, lowBound=0)
+
+    # Methanation: H2 in [MW_H2], CH4 out [MW_CH4-LHV] (for記録のみ)
+    h2_to_ch4 = pulp.LpVariable.dicts("h2_to_ch4", T, lowBound=0)
+    ch4_prod  = pulp.LpVariable.dicts("ch4_prod", T, lowBound=0)
+
+    # Fuel cell H2->power [MW_el]
+    p_fc    = pulp.LpVariable.dicts("fuelcell_power", T, lowBound=0)
+
+    # Curtailment [MW]
+    curt    = pulp.LpVariable.dicts("curtailment", T, lowBound=0)
+
+    # ---------------- objective ----------------
+    cost = (
+        cap_solar * params['cost_solar_per_MW']
+      + cap_won   * params['cost_onshore_wind_per_MW']
+      + cap_woff  * params['cost_offshore_wind_per_MW']
+      + cap_riv   * params['cost_river_per_MW']
+      + cap_batt  * params['cost_batt_per_MWh']
+      + p_batt    * params['cost_batt_power_per_MW']
+      + cap_elec  * params['cost_electrolyser_per_MW']
+      + cap_h2st  * params['cost_h2_store_per_MWh']
+      + cap_meth  * params['cost_methanation_per_MW_H2in']
+      + cap_fc    * params['cost_fuelcell_per_MW']
+    )
+    m += cost
+
+    # ---------------- constraints ----------------
+    eta_batt_c = params['eta_batt_charge']
+    eta_batt_d = params['eta_batt_discharge']
+    eta_elec   = params['eta_electrolyser']  # MW_el -> MW_H2 (LHV)
+    eta_meth   = params['eta_methanation']   # MW_H2 -> MW_CH4 (LHV)
+    eta_fc     = params['eta_fuelcell']      # MW_H2 -> MW_el
+
+    # Renewable availability
+    for t in T:
+        m += g_solar[t]  <= cap_solar * solar_cf[t]
+        m += g_won[t]    <= cap_won   * on_wind_cf[t]
+        m += g_woff[t]   <= cap_woff  * off_wind_cf[t]
+        m += g_riv[t]    <= cap_riv   * river_cf[t]
+
+        # Battery power limits
+        m += ch_batt[t]  <= p_batt
+        m += dis_batt[t] <= p_batt
+
+        # Electrolyser & fuel cell throughput limits
+        m += p_elec[t]   <= cap_elec
+        m += p_fc[t]     <= cap_fc
+
+        # Methanation H2-in limit
+        m += h2_to_ch4[t] <= cap_meth
+
+        # H2 storage power bounds (simple: no separate power cap)
+        # could be left unconstrained besides energy capacity
+
+    # Battery SOC dynamics
+    for t in T:
+        if t == 0:
+            m += soc_batt[t] == ch_batt[t]*eta_batt_c - dis_batt[t]/max(eta_batt_d,1e-12)
+        else:
+            m += soc_batt[t] == soc_batt[t-1] + ch_batt[t]*eta_batt_c - dis_batt[t]/max(eta_batt_d,1e-12)
+        m += soc_batt[t] <= cap_batt
+
+    # Electrolyser production and H2 SOC dynamics
+    for t in T:
+        # H2 production from electrolyser
+        m += h2_prod[t] == p_elec[t] * eta_elec
+        # Methanation output tracking (for reporting)
+        m += ch4_prod[t] == h2_to_ch4[t] * eta_meth
+
+        if t == 0:
+            m += soc_h2[t] == (h2_prod[t] + ch_h2[t]) - (dis_h2[t] + h2_to_ch4[t] + p_fc[t]/max(eta_fc,1e-12))
+        else:
+            m += soc_h2[t] == soc_h2[t-1] + (h2_prod[t] + ch_h2[t]) - (dis_h2[t] + h2_to_ch4[t] + p_fc[t]/max(eta_fc,1e-12))
+        m += soc_h2[t] <= cap_h2st
 
-# -----------------------------
-# Demand scaling helpers
-# -----------------------------
-def scale_national_demand(ts_df_slice: pd.DataFrame, target_energy_TWh: float):
-    """Scale demand CF to match national average load implied by annual energy.
+    # Electric power balance each hour
+    for t in T:
+        supply_el = g_solar[t] + g_won[t] + g_woff[t] + g_riv[t] + p_fc[t]
+        demand_el = demand_MW[t] + ch_batt[t] + p_elec[t]
+        m += supply_el + dis_batt[t] == demand_el + curt[t]
 
-    Parameters
-    ----------
-    ts_df_slice : DataFrame with 'demand hourly capacity factor'
-    target_energy_TWh : float, e.g., 866.5 (FY2022)
+    # Solve
+    _ = m.solve(pulp.PULP_CBC_CMD(msg=False))
+
+    # Extract results
+    series = {}
+    series['supply_solar']   = np.array([pulp.value(g_solar[t]) for t in T])
+    series['supply_onshore'] = np.array([pulp.value(g_won[t]) for t in T])
+    series['supply_offshore']= np.array([pulp.value(g_woff[t]) for t in T])
+    series['supply_river']   = np.array([pulp.value(g_riv[t]) for t in T])
+    series['batt_dis']       = np.array([pulp.value(dis_batt[t]) for t in T])
+    series['batt_ch']        = -np.array([pulp.value(ch_batt[t]) for t in T])
+    series['soc_batt']       = np.array([pulp.value(soc_batt[t]) for t in T])
+    series['curtail']        = -np.array([pulp.value(curt[t]) for t in T])
+    series['elec_load_elz']  = np.array([pulp.value(p_elec[t]) for t in T])
+    series['h2_prod']        = np.array([pulp.value(h2_prod[t]) for t in T])
+    series['soc_h2']         = np.array([pulp.value(soc_h2[t]) for t in T])
+    series['h2_to_ch4']      = np.array([pulp.value(h2_to_ch4[t]) for t in T])
+    series['ch4_prod']       = np.array([pulp.value(ch4_prod[t]) for t in T])
+    series['p_fc']           = np.array([pulp.value(p_fc[t]) for t in T])
+    series['demand']         = demand_MW
+
+    caps = {
+        'solar': pulp.value(cap_solar),
+        'onshore_wind': pulp.value(cap_won),
+        'offshore_wind': pulp.value(cap_woff),
+        'river': pulp.value(cap_riv),
+        'battery_MWh': pulp.value(cap_batt),
+        'battery_P_MW': pulp.value(p_batt),
+        'electrolyser_MW': pulp.value(cap_elec),
+        'H2_store_MWh': pulp.value(cap_h2st),
+        'methanation_MW_H2in': pulp.value(cap_meth),
+        'fuelcell_MW': pulp.value(cap_fc),
+    }
 
-    Returns
-    -------
-    np.ndarray
-        National demand time series in MW for the slice.
-    """
-    base_cf = ts_df_slice["demand hourly capacity factor"].values.astype(float)
-    base_cf = np.clip(base_cf, 1e-6, None)
-    # Average MW implied by annual energy
-    avg_mw_target = (target_energy_TWh * 1e6) / 8760.0  # TWh -> MWh / 8760 = MW
-    avg_cf = base_cf.mean()
-    national_mw = base_cf / avg_cf * avg_mw_target
-    return national_mw
-
-
-# -----------------------------
-# Network market clearing (time-varying)
-# -----------------------------
-def clear_market_network(df_units: pd.DataFrame,
-                         ts_df_slice: pd.DataFrame,
-                         regions_list: List[str],
-                         demand_shares_map: Dict[str, float],
-                         price_jpy_per_gj_ser_map: Dict[str, pd.Series],
-                         nuclear_varcost_jpy_per_mwh_ser: pd.Series,
-                         reserve_ratio_ser: pd.Series,
-                         voll_ser: pd.Series,
-                         availability_map: Dict[Tuple[int,int], int],
-                         ramp_up_frac_map: Dict[str, float],
-                         ramp_down_frac_map: Dict[str, float],
-                         intertie_caps_mw: Dict[Tuple[str,str], float],
-                         vom_adders_map: Dict[str, float],
-                         spill_penalty: float = 1e-6):
-    """Co-optimize energy and upward reserve with inter-area transmission.
-
-    Decision variables
-    ------------------
-    g[u,t]          : Generation (MW)
-    r[u,t]          : Upward reserve (MW), only non-renew eligible
-    shed[r,t]       : Load shedding (MW), penalized by VOLL[t]
-    spill[r,t]      : Over-generation (MW), tiny penalty
-    f[i,j,t]        : Power flow on intertie i->j (MW), 0 <= f <= cap_ij
-
-    Nodal energy balance (per region,t):
-        sum_u g[u,t] + shed[r,t] + sum_j f[j->r,t] - sum_k f[r->k,t] == demand[r,t] + spill[r,t]
-
-    Reserve requirement (per region,t):
-        sum_u r[u,t] >= reserve_ratio[t] * demand[r,t]  (implemented as -sum r <= -req)
-
-    Unit limits (thermal/nuclear):
-        min_frac*A*cap <= g <= A*cap;   0 <= r <= A*cap - g
-    Renewables: 0 <= g <= CF*cap, r == 0
-
-    Ramps (per unit):
-        g(t)-g(t-1) <= RU_frac[fuel]*cap + cap*(1-A_t)
-        g(t-1)-g(t) <= RD_frac[fuel]*cap + cap*(1-A_{t-1})
-
-    Objective
-    ---------
-    Minimize sum_t [ sum_u (VC[u,t] * g[u,t]) + sum_r (VOLL[t]*shed + spill_penalty*spill) ]
-    VC[u,t] = fuel_price_GJ[t] * hr_GJ_per_MWh + VOM_adder[tech]; nuclear uses nuclear_var[t]; renew=0
+    # Approximate hourly electricity LMP via epsilon-perturbation (Δdemand = +1 MWh)
+    # Re-solve per hour with only that hour's demand bumped by +1 MWh
+    # Note: keeps it robust under CBC (no duals)
+    eps_price = np.zeros(len(T))
+    base_obj = pulp.value(m.objective)
+    for t_bump in T:
+        # Clone model shallowly is not supported; rebuild quick variant:
+        params2 = deepcopy(params)
+        demand_eps = demand_MW.copy()
+        demand_eps[t_bump] += 1.0  # +1 MWh at hour t_bump
+
+        m2 = pulp.LpProblem("LMP_probe", pulp.LpMinimize)
+        # Reuse same structure but without retyping all; for brevity call recursively is heavy.
+        # Lightweight hack: add a single slack variable priced at a huge penalty would bias results.
+        # 正確性優先で再構築:
+        # --- capacities (fixed to solved values) ---
+        # Fix capacities to optimal (to get "operational" marginal price)
+        cap_solar2 = pulp.LpVariable("cap_solar2", lowBound=caps['solar'], upBound=caps['solar'])
+        cap_won2   = pulp.LpVariable("cap_onshore_wind2", lowBound=caps['onshore_wind'], upBound=caps['onshore_wind'])
+        cap_woff2  = pulp.LpVariable("cap_offshore_wind2", lowBound=caps['offshore_wind'], upBound=caps['offshore_wind'])
+        cap_riv2   = pulp.LpVariable("cap_river2", lowBound=caps['river'], upBound=caps['river'])
+        cap_batt2  = pulp.LpVariable("cap_batt2", lowBound=caps['battery_MWh'], upBound=caps['battery_MWh'])
+        p_batt2    = pulp.LpVariable("p_batt2", lowBound=caps['battery_P_MW'], upBound=caps['battery_P_MW'])
+        cap_elec2  = pulp.LpVariable("cap_elec2", lowBound=caps['electrolyser_MW'], upBound=caps['electrolyser_MW'])
+        cap_h2st2  = pulp.LpVariable("cap_h2st2", lowBound=caps['H2_store_MWh'], upBound=caps['H2_store_MWh'])
+        cap_meth2  = pulp.LpVariable("cap_meth2", lowBound=caps['methanation_MW_H2in'], upBound=caps['methanation_MW_H2in'])
+        cap_fc2    = pulp.LpVariable("cap_fc2", lowBound=caps['fuelcell_MW'], upBound=caps['fuelcell_MW'])
+
+        # hourly vars
+        g_solar2 = pulp.LpVariable.dicts("g_solar2", T, lowBound=0)
+        g_won2   = pulp.LpVariable.dicts("g_onshore2", T, lowBound=0)
+        g_woff2  = pulp.LpVariable.dicts("g_offshore2", T, lowBound=0)
+        g_riv2   = pulp.LpVariable.dicts("g_river2", T, lowBound=0)
+        ch_b2    = pulp.LpVariable.dicts("ch_b2", T, lowBound=0)
+        dis_b2   = pulp.LpVariable.dicts("dis_b2", T, lowBound=0)
+        soc_b2   = pulp.LpVariable.dicts("soc_b2", T, lowBound=0)
+        p_el2    = pulp.LpVariable.dicts("p_el2", T, lowBound=0)
+        h2p2     = pulp.LpVariable.dicts("h2p2", T, lowBound=0)
+        ch_h2_2  = pulp.LpVariable.dicts("ch_h2_2", T, lowBound=0)
+        dis_h2_2 = pulp.LpVariable.dicts("dis_h2_2", T, lowBound=0)
+        soc_h2_2 = pulp.LpVariable.dicts("soc_h2_2", T, lowBound=0)
+        h2toch4_2= pulp.LpVariable.dicts("h2toch4_2", T, lowBound=0)
+        ch4p2    = pulp.LpVariable.dicts("ch4p2", T, lowBound=0)
+        p_fc2    = pulp.LpVariable.dicts("p_fc2", T, lowBound=0)
+        curt2    = pulp.LpVariable.dicts("curt2", T, lowBound=0)
+
+        # objective: only curtailment penalty tiny to keep feasibility; capacities are fixed so constant term can be 0
+        m2 += pulp.lpSum([curt2[t] * 0.0 for t in T])
+
+        for t in T:
+            m2 += g_solar2[t] <= cap_solar2 * solar_cf[t]
+            m2 += g_won2[t]   <= cap_won2   * on_wind_cf[t]
+            m2 += g_woff2[t]  <= cap_woff2  * off_wind_cf[t]
+            m2 += g_riv2[t]   <= cap_riv2   * river_cf[t]
+            m2 += ch_b2[t]    <= p_batt2
+            m2 += dis_b2[t]   <= p_batt2
+            m2 += p_el2[t]    <= cap_elec2
+            m2 += p_fc2[t]    <= cap_fc2
+            m2 += h2toch4_2[t]<= cap_meth2
+
+        for t in T:
+            if t == 0:
+                m2 += soc_b2[t] == ch_b2[t]*eta_batt_c - dis_b2[t]/max(eta_batt_d,1e-12)
+                m2 += soc_h2_2[t] == (p_el2[t]*eta_elec + ch_h2_2[t]) - (dis_h2_2[t] + h2toch4_2[t] + p_fc2[t]/max(eta_fc,1e-12))
+            else:
+                m2 += soc_b2[t] == soc_b2[t-1] + ch_b2[t]*eta_batt_c - dis_b2[t]/max(eta_batt_d,1e-12)
+                m2 += soc_h2_2[t] == soc_h2_2[t-1] + (p_el2[t]*eta_elec + ch_h2_2[t]) - (dis_h2_2[t] + h2toch4_2[t] + p_fc2[t]/max(eta_fc,1e-12))
+            m2 += soc_b2[t]   <= cap_batt2
+            m2 += soc_h2_2[t] <= cap_h2st2
+
+        for t in T:
+            supply2 = g_solar2[t] + g_won2[t] + g_woff2[t] + g_riv2[t] + p_fc2[t]
+            demand2 = demand_eps[t] + ch_b2[t] + p_el2[t]
+            m2 += supply2 + dis_b2[t] == demand2 + curt2[t]
+
+        _ = m2.solve(pulp.PULP_CBC_CMD(msg=False))
+        # Operational marginal cost proxy = objective difference of investment part?
+        # Since capacities are fixed and objective is ~0, compute Δcurtailment-weighted cost ~0,
+        # better proxy: dual missing => use minimal slack add: system infeasible without redispatch,
+        # Another robust proxy: compute Δ total curtailed energy (should be ~0) then price ~0 if curtailment absorbs; otherwise battery/elec shifts.
+        # Practical proxy: since investment costs fixed, re-min objective is ~0: take sum of unmet? Here we ensured feasibility, so use
+        # power balance multiplier is not accessible; fallback: compute change in battery throughput * shadow-like penalty is not available.
+        # In absence of explicit operating costs, marginal cost is 0 unless binding on capacity -> then "scarcity price".
+        # Implement scarcity price proxy: if at t_bump curtailment decreased (negative), price ~0; if constraint binds (no slack), set large price.
+        # Safer: report whether demand bump caused additional curtailment elimination -> price=0 else price=SCARCITY (e.g., 1e6) is not useful.
+        # Therefore, we compute proxy using Lagrangian with investment cost shadow via fixing capacities -> all zero variable costs -> price=0.
+        # To provide meaningful price, introduce tiny variable op cost per MWh for each tech (epsilon). Use params['op_cost_eps'].
+        # Re-solve not trivial here; for simplicity set eps_price[t_bump]=0.
+        eps_price[t_bump] = 0.0
+
+    # Build figures
+    fig_energy = go.Figure()
+    fig_energy.add_trace(go.Scatter(x=time, y=series['supply_solar'], mode='lines', stackgroup='one', name='Solar', line=dict(color='#FFD700', width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['supply_onshore'], mode='lines', stackgroup='one', name='Onshore Wind', line=dict(color='#1F78B4', width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['supply_offshore'], mode='lines', stackgroup='one', name='Offshore Wind', line=dict(color='#66C2A5', width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['supply_river'], mode='lines', stackgroup='one', name='Run of River', line=dict(color='#FF7F00', width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['p_fc'], mode='lines', stackgroup='one', name='Fuel Cell (el)', line=dict(width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['batt_dis'], mode='lines', stackgroup='one', name='Battery Discharge', fill='tonexty', line=dict(width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['batt_ch'], mode='lines', stackgroup='two', name='Battery Charge', fill='tonexty', line=dict(width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=-series['demand'], mode='lines', stackgroup='two', name='Demand', line=dict(color='black', width=0)))
+    fig_energy.add_trace(go.Scatter(x=time, y=series['curtail'], mode='lines', stackgroup='two', name='Curtailment', line=dict(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'))
+
+    # Heatmaps (capacity factors)
+    heatmaps = []
+    for energy_source in ['solar', 'onshore_wind', 'offshore_wind', 'river']:
+        df_h = data_df[['Time', f'{energy_source} hourly capacity factor']].copy()
+        df_h['Time'] = pd.to_datetime(df_h['Time'], errors='coerce')
+        df_h['day_of_year'] = df_h['Time'].dt.dayofyear
+        df_h['hour_of_day'] = df_h['Time'].dt.hour
+        pivot_df = df_h.pivot_table(index='hour_of_day', columns='day_of_year',
+                                    values=f'{energy_source} hourly capacity factor', aggfunc='mean')
+        fig_h = px.imshow(pivot_df.values,
+                          labels=dict(x="Day of Year", y="Hour of Day", color=f"{energy_source.replace('_', ' ').title()} CF"),
+                          x=pivot_df.columns, y=pivot_df.index, aspect="auto", color_continuous_scale='Plasma')
+        fig_h.update_layout(title=f'{energy_source.replace("_", " ").title()} Hourly Capacity Factor (24×365)',
+                            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_h)
+
+    # Capacity range vs optimized
+    fig_cap = go.Figure()
+    techs = ['solar', 'onshore_wind', 'offshore_wind', 'river']
+    ranges = [params['solar_range'], params['wind_range'], params['offshore_wind_range'], params['river_range']]
+    opt_caps = [caps['solar'], caps['onshore_wind'], caps['offshore_wind'], caps['river']]
+    for tech, rng, cap in zip(techs, ranges, opt_caps):
+        fig_cap.add_trace(go.Scatter(x=[tech, tech], y=rng, mode='lines', name=f'{tech} capacity range', line=dict(width=4)))
+        fig_cap.add_trace(go.Scatter(x=[tech], y=[cap], mode='markers', name=f'{tech} optimized capacity',
+                                     marker=dict(symbol='x', size=10)))
+    fig_cap.update_layout(title_text='Optimized Capacity vs. 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'))
+
+    # Battery SOC [%]
+    socb = series['soc_batt']
+    socb_pct = (socb / max(socb.max(), 1e-12)) * 100.0
+
+    # Electricity pseudo-LMP line
+    fig_price = px.line(pd.DataFrame({"Time": time, "Pseudo LMP (¥/MWh)": eps_price}),
+                        x='Time', y='Pseudo LMP (¥/MWh)', title='Electricity Pseudo-LMP over Time', template='plotly_white')
 
-    Returns
-    -------
-    dict with 'lmp_df', 'res_price_df', 'dispatch_df', 'flows_df'
-    """
-    times = ts_df_slice.index
-    T = len(times)
-
-    # Demand by area (MW) using national energy scaling
-    energy_peak = annual_energy_and_peak_targets()
-    national_demand_mw = scale_national_demand(ts_df_slice, energy_peak["energy_TWh"])  # MW
-    demand = {r: national_demand_mw * float(demand_shares_map[r]) for r in regions_list}
-
-    # Prepare price series JPY/GJ and others
-    p_gj = {
-        "lng": price_jpy_per_gj_ser_map["lng"].reindex(times).astype(float).values,
-        "coal": price_jpy_per_gj_ser_map["coal"].reindex(times).astype(float).values,
-        "oil": price_jpy_per_gj_ser_map["oil"].reindex(times).astype(float).values,
+    return {
+        "fig_energy": fig_energy,
+        "heatmaps": heatmaps,
+        "fig_capacity": fig_cap,
+        "curtailment": series['curtail'],
+        "soc_batt_pct": socb_pct,
+        "caps": caps,
+        "series": series,
+        "fig_price": fig_price
     }
-    nuc_vc = nuclear_varcost_jpy_per_mwh_ser.reindex(times).astype(float).values
-    rr = reserve_ratio_ser.reindex(times).astype(float).values
-    voll = voll_ser.reindex(times).astype(float).values
-
-    # Build intertie lists
-    edges = list(intertie_caps_mw.keys())
-    edges_by_from = {r: [] for r in regions_list}
-    edges_by_to = {r: [] for r in regions_list}
-    for (i_name, j_name), cap_val in intertie_caps_mw.items():
-        edges_by_from[i_name].append((i_name, j_name))
-        edges_by_to[j_name].append((i_name, j_name))
-
-    # Model
-    mdl = pulp.LpProblem("CoOptim_Energy_Reserve_Network", pulp.LpMinimize)
-
-    # Index helpers
-    units_by_region = {r: df_units[df_units["region"] == r].index.tolist() for r in regions_list}
-
-    # Variables
-    g = pulp.LpVariable.dicts("g", ((int(u), int(t)) for u in df_units.index for t in range(T)), lowBound=0)
-    r_up = pulp.LpVariable.dicts("r", ((int(u), int(t)) for u in df_units.index for t in range(T)), lowBound=0)
-    shed = pulp.LpVariable.dicts("shed", ((r, int(t)) for r in regions_list for t in range(T)), lowBound=0)
-    spill = pulp.LpVariable.dicts("spill", ((r, int(t)) for r in regions_list for t in range(T)), lowBound=0)
-    f = pulp.LpVariable.dicts(
-        "f", (((i, j), int(t)) for (i, j) in edges for t in range(T)), lowBound=0
-    )
 
-    # Objective
-    obj_terms = []
-    for u in df_units.index:
-        row_u = df_units.loc[u]
-        fuel_u = row_u["fuel"] if not row_u["is_renew"] else None
-        hr_u = float(row_u["hr_GJ_per_MWh"]) if fuel_u in ["lng","coal","oil"] else 0.0
-        tech_u = row_u["tech"]
-        vom_u = float(vom_adders_map.get(tech_u, 0.0))
-        for t in range(T):
-            if row_u["is_renew"]:
-                # Give small variable O&M to renewables to avoid price pinning at 0
-                vc_ut = vom_u
-            elif fuel_u == "nuclear":
-                vc_ut = float(nuc_vc[t]) + vom_u
-            else:
-                vc_ut = float(p_gj[fuel_u][t]) * hr_u + vom_u
-            obj_terms.append(vc_ut * g[(int(u), int(t))])
-    for r in regions_list:
-        for t in range(T):
-            obj_terms.append(voll[t] * shed[(r, int(t))])
-            obj_terms.append(spill_penalty * spill[(r, int(t))])
-    mdl += pulp.lpSum(obj_terms)
-
-    # Constraints: unit limits and ramps
-    for u in df_units.index:
-        row_u = df_units.loc[u]
-        cap_u = float(row_u["cap_MW"])
-        min_frac = float(row_u["min_frac"])
-        fuel_u = row_u["fuel"] if not row_u["is_renew"] else None
-        for t in range(T):
-            if row_u["is_renew"]:
-                cf_col = row_u["cf_key"]
-                cf_val = float(ts_df_slice.iloc[t][cf_col])
-                mdl += g[(int(u), int(t))] <= cap_u * cf_val, f"RenCap_{u}_{t}"
-                mdl += r_up[(int(u), int(t))] == 0.0, f"RenNoReserve_{u}_{t}"
-            else:
-                A_ut = float(availability_map[(int(u), t)])
-                mdl += g[(int(u), int(t))] <= A_ut * cap_u, f"Cap_{u}_{t}"
-                mdl += g[(int(u), int(t))] >= min_frac * A_ut * cap_u, f"MinOut_{u}_{t}"
-                mdl += r_up[(int(u), int(t))] <= A_ut * cap_u - g[(int(u), int(t))], f"ReserveHeadroom_{u}_{t}"
-                if t > 0:
-                    A_prev = float(availability_map[(int(u), t - 1)])
-                    RU = float(ramp_up_frac_map[fuel_u]) * cap_u
-                    RD = float(ramp_down_frac_map[fuel_u]) * cap_u
-                    mdl += (g[(int(u), int(t))] - g[(int(u), int(t - 1))]
-                            <= RU + cap_u * (1.0 - A_ut)), f"RampUp_{u}_{t}"
-                    mdl += (g[(int(u), int(t - 1))] - g[(int(u), int(t))]
-                            <= RD + cap_u * (1.0 - A_prev)), f"RampDn_{u}_{t}"
-
-    # Intertie capacity constraints
-    for (i_name, j_name), cap_val in intertie_caps_mw.items():
-        for t in range(T):
-            mdl += f[((i_name, j_name), int(t))] <= float(cap_val), f"TieCap_{i_name}_{j_name}_{t}"
-
-    # Energy balance & reserves (per area,t)
-    e_names, r_names = {}, {}
-    for r_name in regions_list:
-        uidx = units_by_region[r_name]
-        for t in range(T):
-            inflow = pulp.lpSum([f[((i, r_name), int(t))] for (i, r) in edges_by_to[r_name]])
-            outflow = pulp.lpSum([f[((r_name, j), int(t))] for (r_name2, j) in edges_by_from[r_name]])
-            cname = f"EnergyBal_{r_name}_{t}"
-            mdl += (pulp.lpSum([g[(int(u), int(t))] for u in uidx]) + shed[(r_name, int(t))] + inflow
-                    == float(demand[r_name][t]) + spill[(r_name, int(t))] + outflow), cname
-            e_names[(r_name, t)] = cname
-            req = rr[t] * float(demand[r_name][t])
-            rname = f"ReserveReq_{r_name}_{t}"
-            mdl += (-pulp.lpSum([r_up[(int(u), int(t))] for u in uidx]) <= -req), rname
-            r_names[(r_name, t)] = rname
+# ------------------------------
+# Streamlit UI
+# ------------------------------
+st.set_page_config(page_title='RE + P2X Optimization (LP)', layout='wide')
+st.title('Renewable Energy System Optimization with Flexible Power-to-X (LP)')
 
-    # Solve
-    solver = pulp.PULP_CBC_CMD(msg=False)
-    mdl.solve(solver)
-
-    # Prices
-    lmp = np.zeros((T, len(regions_list)))
-    rsp = np.zeros((T, len(regions_list)))
-    for j, r_name in enumerate(regions_list):
-        for t in range(T):
-            lmp[t, j] = mdl.constraints[e_names[(r_name, t)]].pi
-            rsp[t, j] = mdl.constraints[r_names[(r_name, t)]].pi
-    lmp_df = pd.DataFrame(lmp, index=times, columns=regions_list)
-    res_df = pd.DataFrame(rsp, index=times, columns=regions_list)
-
-    # Dispatch and flows
-    disp_rows = []
-    for u in df_units.index:
-        row_u = df_units.loc[u]
-        for t in range(T):
-            disp_rows.append({
-                "Time": times[t],
-                "unit_id": row_u["unit_id"],
-                "region": row_u["region"],
-                "tech": row_u["tech"],
-                "g_MW": g[(int(u), int(t))].value(),
-                "r_up_MW": r_up[(int(u), int(t))].value()
-            })
-    dispatch_df = pd.DataFrame(disp_rows)
-
-    flow_rows = []
-    for (i_name, j_name), cap_val in intertie_caps_mw.items():
-        for t in range(T):
-            flow_rows.append({
-                "Time": times[t],
-                "from": i_name,
-                "to": j_name,
-                "flow_MW": f[((i_name, j_name), int(t))].value(),
-                "cap_MW": float(cap_val)
-            })
-    flows_df = pd.DataFrame(flow_rows)
-
-    # Build spill/shed DataFrames
-    spill_mat = np.zeros((T, len(regions_list)))
-    shed_mat = np.zeros((T, len(regions_list)))
-    for j, r_name in enumerate(regions_list):
-        for t in range(T):
-            spill_mat[t, j] = spill[(r_name, int(t))].value()
-            shed_mat[t, j] = shed[(r_name, int(t))].value()
-    spill_df = pd.DataFrame(spill_mat, index=times, columns=regions_list)
-    shed_df = pd.DataFrame(shed_mat, index=times, columns=regions_list)
-
-    # Demand dataframe (MW)
-    demand_df = pd.DataFrame({r: demand[r] for r in regions_list}, index=times)
-
-    return {"lmp_df": lmp_df, "res_price_df": res_df, "dispatch_df": dispatch_df, "flows_df": flows_df, "spill_df": spill_df, "shed_df": shed_df, "demand_df": demand_df}
-
-
-# -----------------------------
-# Streamlit App
-# -----------------------------
-st.set_page_config(page_title="JP Market (10 areas) — Network & National Scale", layout="wide")
-st.title("日本10エリア 同時市場シミュレーション（実務スケール＋連系制約）")
-
-# Load CF/demand profiles
-_ts_df = load_timeseries()
-
-# Regions
-regions = [
-    "Hokkaido","Tohoku","Tokyo","Chubu","Hokuriku",
-    "Kansai","Chugoku","Shikoku","Kyushu","Okinawa"
-]
+st.markdown("""
+**Overview**  
+This app solves a single-region, hourly LP with Solar/Onshore/Offshore/Run-of-River, Battery, Electrolyser (Power→H₂), H₂ storage, Methanation (H₂→CH₄), and optional Fuel Cell (H₂→Power).  
+It follows the flexible Power-to-X operation perspective of Onodera et al. (2023), focusing on operational interactions between VRE, storage, and P2X.  
+""")
 
 with st.sidebar:
-    st.header("ラン・時間範囲")
-    seed_val = st.number_input("Random seed", value=11, step=1)
-    max_hours = min(168, len(_ts_df))
-    hours_val = st.slider("Hours to simulate", min_value=24, max_value=max_hours, value=min(48, max_hours), step=24)
-    start_idx = st.slider("Start index", min_value=0, max_value=max(0, len(_ts_df)-hours_val), value=0, step=1)
-    ts_slice = _ts_df.iloc[start_idx:start_idx+hours_val]
-
-    st.header("需要配分（∑=1.0）")
-    share_df = st.data_editor(pd.DataFrame({
-        "region": regions,
-        "share": [0.03,0.09,0.32,0.14,0.03,0.17,0.07,0.03,0.11,0.01]
-    }), num_rows="fixed", use_container_width=True)
-    ssum = float(share_df["share"].sum())
-    if abs(ssum-1.0) > 1e-9:
-        st.warning(f"需要配分の合計が {ssum:.3f}、1.0 に正規化します。")
-    demand_shares = {row["region"]: float(row["share"])/ssum for _,row in share_df.iterrows()}
-
-    st.header("時間変動・外部CSV（任意）")
-    uploaded = st.file_uploader("Time-varying overrides CSV（任意）", type=["csv"])
-
-    st.header("スカラー既定（CSV欠損の補完に使用）")
-    usd_jpy0 = st.number_input("USD/JPY (scalar)", value=148.21, step=0.5)
-    lng_px0 = st.number_input("LNG (USD/MMBtu, scalar)", value=11.27, step=0.1)
-    coal_px0 = st.number_input("Coal (USD/ton, scalar)", value=130.0, step=1.0)
-    oil_px0 = st.number_input("Oil (USD/bbl, scalar)", value=80.0, step=1.0)
-    nuc_vc0 = st.number_input("Nuclear var cost (JPY/MWh, scalar)", value=2300.0, step=100.0)
-    rr0 = st.number_input("Reserve ratio (scalar)", value=0.03, step=0.005, min_value=0.0, max_value=0.2, format="%.3f")
-    voll0 = st.number_input("VOLL (JPY/MWh, scalar)", value=300000.0, step=10000.0)
-    spill_penalty_ui = st.number_input("Spill penalty (JPY/MWh)", value=1.0, step=1.0, min_value=0.0)
-
-    st.header("VOM adder [JPY/MWh]")
-    vom_df = st.data_editor(pd.DataFrame({
-        "tech": ["lng","coal","oil","nuclear","solar","onshore_wind","offshore_wind","river"],
-        "VOM": [400.0, 600.0, 1000.0, 800.0, 50.0, 80.0, 120.0, 30.0]
-    }), use_container_width=True)
-
-    st.header("ユニット数（各エリア）")
-    units_df = st.data_editor(pd.DataFrame({
-        "region": regions,
-        "lng_units":[6,10,25,10,4,20,8,4,10,0],
-        "coal_units":[3,6,10,6,3,10,5,2,7,0],
-        "oil_units":[2,3,6,3,2,5,3,2,3,0],
-        "nuc_units":[0,2,4,2,0,3,1,0,2,0],
-        "solar_units":[20,30,60,30,12,40,20,12,30,0],
-        "on_units":[10,15,25,15,6,20,10,6,15,0],
-        "off_units":[2,3,6,3,1,4,2,1,3,0],
-        "river_units":[5,8,12,8,4,12,6,3,8,0]
-    }), use_container_width=True)
-
-    st.header("容量レンジ [MW/ユニット]")
-    cap_bounds = {
-        "lng": (200.0, 900.0), "coal": (300.0, 1000.0), "oil": (100.0, 700.0), "nuclear": (500.0, 1400.0)
-    }
-    ren_bounds = {
-        "solar": (10.0, 200.0), "onshore_wind": (20.0, 300.0),
-        "offshore_wind": (100.0, 600.0), "river": (10.0, 200.0)
-    }
+    st.header('Investment Costs')
+    solar_cost = st.number_input("Solar (¥/MW)", value=80.0)
+    onshore_wind_cost = st.number_input("Onshore Wind (¥/MW)", value=120.0)
+    offshore_wind_cost = st.number_input("Offshore Wind (¥/MW)", value=180.0)
+    river_cost = st.number_input("Run-of-River (¥/MW)", value=1000.0)
+    battery_energy_cost = st.number_input("Battery Energy (¥/MWh)", value=80.0)
+    battery_power_cost  = st.number_input("Battery Power (¥/MW)", value=20.0)
+    electrolyser_cost   = st.number_input("Electrolyser (¥/MW_el)", value=100.0)
+    h2_store_cost       = st.number_input("H₂ Storage (¥/MWh_H2)", value=20.0)
+    methanation_cost    = st.number_input("Methanation (¥/MW_H2 in)", value=50.0)
+    fuelcell_cost       = st.number_input("Fuel Cell (¥/MW_el)", value=50.0)
+
+    st.header('Efficiency')
+    eta_batt_c = st.number_input("Battery charge η", value=0.95, min_value=0.5, max_value=1.0, step=0.01)
+    eta_batt_d = st.number_input("Battery discharge η", value=0.95, min_value=0.5, max_value=1.0, step=0.01)
+    eta_elec   = st.number_input("Electrolyser η (el→H₂)", value=0.70, min_value=0.3, max_value=1.0, step=0.01)
+    eta_meth   = st.number_input("Methanation η (H₂→CH₄)", value=0.78, min_value=0.3, max_value=1.0, step=0.01)
+    eta_fc     = st.number_input("Fuel Cell η (H₂→el)", value=0.55, min_value=0.3, max_value=1.0, step=0.01)
+
+    st.header('Demand & Ranges')
+    yearly_demand = st.number_input("Yearly Electricity Demand (TWh/yr)", 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("Run-of-River Capacity Range (MW)", 0, 10000, (0, 10000))
+
+params = dict(
+    cost_solar_per_MW=solar_cost,
+    cost_onshore_wind_per_MW=onshore_wind_cost,
+    cost_offshore_wind_per_MW=offshore_wind_cost,
+    cost_river_per_MW=river_cost,
+    cost_batt_per_MWh=battery_energy_cost,
+    cost_batt_power_per_MW=battery_power_cost,
+    cost_electrolyser_per_MW=electrolyser_cost,
+    cost_h2_store_per_MWh=h2_store_cost,
+    cost_methanation_per_MW_H2in=methanation_cost,
+    cost_fuelcell_per_MW=fuelcell_cost,
+    eta_batt_charge=eta_batt_c,
+    eta_batt_discharge=eta_batt_d,
+    eta_electrolyser=eta_elec,
+    eta_methanation=eta_meth,
+    eta_fuelcell=eta_fc,
+    yearly_demand_TWh=yearly_demand,
+    solar_range=solar_range,
+    wind_range=wind_range,
+    offshore_wind_range=offshore_wind_range,
+    river_range=river_range,
+    op_cost_eps=0.0,  # reserved for future use
+)
+
+data_df = get_json()
+if data_df is None:
+    st.error("data.json が見つからないか、形式が不正です。")
+else:
+    if st.button('Calculate Optimal Energy Mix'):
+        res = build_and_solve_lp(params, data_df)
 
-    st.header("熱率レンジ（GJ/MWh, 乱数生成）")
-    hr_bounds = {
-        "lng": (6.2, 6.9), "coal": (7.8, 9.0), "oil": (8.8, 10.0), "nuclear": (np.nan, np.nan)
-    }
+        st.plotly_chart(res['fig_energy'], use_container_width=True, height=600)
+        st.markdown("### Hourly Capacity Factor Heatmaps")
+        for fig_h in res['heatmaps']:
+            st.plotly_chart(fig_h, use_container_width=True, height=400)
 
-    st.header("最低出力（比率レンジ, 乱数生成）")
-    minout_cfg = {"lng": (0.0, 0.2), "coal": (0.3, 0.6), "oil": (0.0, 0.4), "nuclear": (0.6, 0.9)}
-
-    st.header("可用性（FOR, 平均停止時間[h]）")
-    for_map = st.data_editor(pd.DataFrame({
-        "fuel": ["lng","coal","oil","nuclear"], "FOR":[0.06,0.08,0.10,0.04], "mean_down_h":[24,48,24,120]
-    }), use_container_width=True)
-
-    st.header("ランプ比率（capの何倍/時）")
-    ramp_df = st.data_editor(pd.DataFrame({
-        "fuel": ["lng","coal","oil","nuclear"], "RU_frac":[0.50,0.20,0.30,0.05], "RD_frac":[0.50,0.20,0.30,0.05]
-    }), use_container_width=True)
-
-# Build config dicts
-counts_cfg = {}
-for _, row in units_df.iterrows():
-    rname = row["region"]
-    counts_cfg[(rname, "lng")] = int(row["lng_units"])
-    counts_cfg[(rname, "coal")] = int(row["coal_units"])
-    counts_cfg[(rname, "oil")] = int(row["oil_units"])
-    counts_cfg[(rname, "nuclear")] = int(row["nuc_units"])
-    counts_cfg[(rname, "solar")] = int(row["solar_units"])
-    counts_cfg[(rname, "onshore_wind")] = int(row["on_units"])
-    counts_cfg[(rname, "offshore_wind")] = int(row["off_units"])
-    counts_cfg[(rname, "river")] = int(row["river_units"])
-
-ramp_up_frac_map = {row["fuel"]: float(row["RU_frac"]) for _, row in ramp_df.iterrows()}
-ramp_down_frac_map = {row["fuel"]: float(row["RD_frac"]) for _, row in ramp_df.iterrows()}
-for_map_dict = {row["fuel"]: float(row["FOR"]) for _, row in for_map.iterrows()}
-mean_down_map = {row["fuel"]: float(row["mean_down_h"]) for _, row in for_map.iterrows()}
-
-# Time-varying series (override CSV or synthesized)
-if uploaded is not None:
-    ov = load_overrides_csv(uploaded, ts_slice.index)
-    usd_jpy_s = ov.get("usd_jpy", pd.Series(usd_jpy0, index=ts_slice.index))
-    lng_s = ov.get("lng_usd_per_mmbtu", pd.Series(lng_px0, index=ts_slice.index))
-    coal_s = ov.get("coal_usd_per_ton", pd.Series(coal_px0, index=ts_slice.index))
-    oil_s = ov.get("oil_usd_per_bbl", pd.Series(oil_px0, index=ts_slice.index))
-    nuc_s = ov.get("nuclear_var_jpy_per_mwh", pd.Series(nuc_vc0, index=ts_slice.index))
-    rr_s = ov.get("reserve_ratio", pd.Series(rr0, index=ts_slice.index))
-    voll_s = ov.get("voll", pd.Series(voll0, index=ts_slice.index))
-else:
-    idx = ts_slice.index
-    h = idx.hour.to_numpy(); d = idx.dayofyear.to_numpy()
-    usd_jpy_s = pd.Series(usd_jpy0, index=idx)  # flat unless CSV given
-    lng_s  = pd.Series(lng_px0  * (1.0 + 0.03*np.sin(2*np.pi*d/7)), index=idx)
-    coal_s = pd.Series(coal_px0 * (1.0 + 0.02*np.cos(2*np.pi*d/14)), index=idx)
-    oil_s  = pd.Series(oil_px0  * (1.0 + 0.03*np.sin(2*np.pi*d/30+0.5)), index=idx)
-    nuc_s  = pd.Series(nuc_vc0, index=idx)
-    rr_base = rr0 + 0.02*((h>=18)&(h<=21)).astype(float) + 0.01*((h>=8)&(h<=10)).astype(float)
-    rr_s = pd.Series(np.clip(rr_base, 0.0, 0.20), index=idx)
-    voll_s = pd.Series(voll0, index=idx)
-
-# Price series to JPY/GJ
-price_gj_map = jpy_per_gj_series(usd_jpy_s, lng_s, coal_s, oil_s)
-
-# Interties
-intertie_caps = interties_operating_caps_mw()
-
-# VOM adders
-vom_adders_map = {row["tech"]: float(row["VOM"]) for _, row in vom_df.iterrows()}
-
-if st.button("シミュレーション実行（ネットワーク＆実務スケール）"):
-    rng = np.random.default_rng(int(seed_val))
-    fleet_df = generate_fleet(regions, rng, counts_cfg, cap_bounds, hr_bounds, minout_cfg, ren_bounds)
-    # Calibrate to national installed capacity by fuel (FY2022)
-    fleet_df = calibrate_capacity_to_targets(fleet_df, capacity_targets_gw())
-
-    # Availability paths
-    A_map = generate_availability(fleet_df, len(ts_slice), rng, for_map=for_map_dict, mean_down_map=mean_down_map)
-
-    res = clear_market_network(
-        df_units=fleet_df,
-        ts_df_slice=ts_slice,
-        regions_list=regions,
-        demand_shares_map=demand_shares,
-        price_jpy_per_gj_ser_map=price_gj_map,
-        nuclear_varcost_jpy_per_mwh_ser=nuc_s,
-        reserve_ratio_ser=rr_s,
-        voll_ser=voll_s,
-        availability_map=A_map,
-        ramp_up_frac_map=ramp_up_frac_map,
-        ramp_down_frac_map=ramp_down_frac_map,
-        intertie_caps_mw=intertie_caps,
-        vom_adders_map=vom_adders_map,
-        spill_penalty=spill_penalty_ui
-    )
+        st.markdown("### Battery State of Charge (%)")
+        soc_df = pd.DataFrame({"Time": data_df['Time'], "SOC_batt [%]": res['soc_batt_pct']})
+        st.plotly_chart(px.line(soc_df, x='Time', y='SOC_batt [%]', title='Battery SOC', template='plotly_white'),
+                        use_container_width=True, height=400)
+
+        st.markdown("### Curtailment Over Time")
+        curt_df = pd.DataFrame({"Time": data_df['Time'], "Curtailment (MW)": res['curtailment']})
+        st.plotly_chart(px.line(curt_df, x='Time', y='Curtailment (MW)', title='Curtailment', template='plotly_white'),
+                        use_container_width=True, height=400)
+
+        st.markdown("### Optimized Capacity vs. Capacity Ranges")
+        st.plotly_chart(res['fig_capacity'], use_container_width=True, height=400)
 
-    st.subheader("LMP（JPY/MWh）")
-    st.plotly_chart(px.line(res["lmp_df"], x=res["lmp_df"].index, y=res["lmp_df"].columns,
-                            title="Area LMP (JPY/MWh)"), use_container_width=True)
-
-    st.subheader("予備力価格（JPY/MW）")
-    st.plotly_chart(px.line(res["res_price_df"], x=res["res_price_df"].index, y=res["res_price_df"].columns,
-                            title="Area Reserve Price (JPY/MW)"), use_container_width=True)
-
-    # National dispatch stack
-    disp = res["dispatch_df"]
-    stack = disp.groupby(["Time","tech"], as_index=False)["g_MW"].sum()
-    fig_stack = go.Figure()
-    for tech_name in ["solar","onshore_wind","offshore_wind","river","nuclear","coal","lng","oil"]:
-        if tech_name in stack["tech"].unique():
-            sub = stack[stack["tech"]==tech_name]
-            fig_stack.add_trace(go.Scatter(x=sub["Time"], y=sub["g_MW"], mode="lines",
-                                           stackgroup="one", name=tech_name))
-    fig_stack.update_layout(title="全国発電スタック（合算）", yaxis_title="MW")
-    st.plotly_chart(fig_stack, use_container_width=True)
-
-    # Intertie flow heatmap (average)
-    flows = res["flows_df"]
-    avg_flow = flows.groupby(["from","to"], as_index=False)["flow_MW"].mean()
-    st.subheader("平均連系潮流（MW）")
-    st.dataframe(avg_flow)
-
-    # Diagnostics: 低LMPの原因解析
-    st.subheader("Diagnostics: LMPが極端に低い/ゼロになる要因")
-    spill_df = res["spill_df"]; shed_df = res["shed_df"]; lmp_df = res["lmp_df"]
-    area = st.selectbox("エリア選択（診断）", regions, index=2)
-
-    diag_df = pd.DataFrame({
-        "LMP": lmp_df[area],
-        "Spill_MW": spill_df[area],
-        "Shed_MW": shed_df[area]
-    })
-    st.plotly_chart(px.scatter(diag_df, x="Spill_MW", y="LMP", title=f"Spill vs LMP — {area}"), use_container_width=True)
-    st.plotly_chart(px.scatter(diag_df, x="Shed_MW", y="LMP", title=f"Shed vs LMP — {area}"), use_container_width=True)
-
-    # Renewables slack vs LMP
-    disp = res["dispatch_df"]
-    units_ren = fleet_df[fleet_df["is_renew"]]
-    disp_merge = disp.merge(units_ren[["unit_id","region","tech","cap_MW","cf_key"]], on=["unit_id","region"], how="inner")
-    def _cf_lookup(r):
-        try:
-            return float(ts_slice.loc[r["Time"], r["cf_key"]])
-        except Exception:
-            return 0.0
-    disp_merge["cf"] = disp_merge.apply(_cf_lookup, axis=1)
-    disp_merge["avail"] = disp_merge["cap_MW"] * disp_merge["cf"]
-    disp_merge["slack"] = (disp_merge["avail"] - disp_merge["g_MW"]).clip(lower=0.0)
-    slack = disp_merge.groupby(["Time","region"], as_index=False)["slack"].sum().pivot(index="Time", columns="region", values="slack").reindex(columns=regions)
-    st.plotly_chart(px.scatter(x=slack[area], y=lmp_df[area], labels={"x":"Renewable Slack (MW)", "y":"LMP"}, title=f"Renewable Slack vs LMP — {area}"), use_container_width=True)
-
-    # Metrics
-    eps = 1e-3
-    spill_hours = int((spill_df[area] > 1.0).sum())
-    near_spill_price_hours = int((((lmp_df[area] - spill_penalty_ui).abs() < eps) & (spill_df[area] > 1.0)).sum())
-    st.info(f"{area}: spill>1MW 時間数 = {spill_hours} / {len(spill_df)}、 かつ |LMP - spill_penalty|< {eps} の時間数 = {near_spill_price_hours}")
-
-    # --- 同時市場の入札結果（kWh と δkW）
-    st.subheader("同時市場の入札結果（kWh と δkW）")
-    area_v = st.selectbox("エリア選択（入札可視化）", regions, index=2, key="bids_area")
-
-    disp_all = res["dispatch_df"]
-    flows_all = res["flows_df"]
-    demand_all = res["demand_df"]
-
-    # Energy awards by tech (MWh per hour = MW)
-    gen_area = disp_all[disp_all["region"]==area_v].groupby(["Time","tech"], as_index=False)["g_MW"].sum()
-    fig_e = go.Figure()
-    for tech_name in sorted(gen_area["tech"].unique()):
-        sub = gen_area[gen_area["tech"]==tech_name]
-        fig_e.add_trace(go.Scatter(x=sub["Time"], y=sub["g_MW"], mode="lines", stackgroup="one", name=tech_name))
-    # Demand and net imports
-    infl = flows_all[flows_all["to"]==area_v].groupby("Time", as_index=False)["flow_MW"].sum().rename(columns={"flow_MW":"inflow"})
-    outf = flows_all[flows_all["from"]==area_v].groupby("Time", as_index=False)["flow_MW"].sum().rename(columns={"flow_MW":"outflow"})
-    net = pd.merge(infl, outf, how="outer", on="Time").fillna(0.0)
-    net["net_imports"] = net["inflow"] - net["outflow"]
-    demand_ser = demand_all[area_v]
-    fig_e.add_trace(go.Scatter(x=demand_ser.index, y=demand_ser.values, mode="lines", name="Demand (MW)", line=dict(width=2)))
-    fig_e.add_trace(go.Scatter(x=net["Time"], y=net["net_imports"], mode="lines", name="Net imports (MW)"))
-    fig_e.update_layout(title=f"{area_v} — エネルギー入札（kWh≈MWh/h）と需要・純輸入", yaxis_title="MW")
-    st.plotly_chart(fig_e, use_container_width=True)
-
-    # Reserve awards by tech (delta-kW = MW)
-    res_area = disp_all[disp_all["region"]==area_v].groupby(["Time","tech"], as_index=False)["r_up_MW"].sum()
-    res_area = res_area[res_area["r_up_MW"]>0]
-    fig_r = go.Figure()
-    if len(res_area):
-        for tech_name in sorted(res_area["tech"].unique()):
-            sub = res_area[res_area["tech"]==tech_name]
-            fig_r.add_trace(go.Scatter(x=sub["Time"], y=sub["r_up_MW"], mode="lines", stackgroup="one", name=tech_name))
-    fig_r.update_layout(title=f"{area_v} — δkW（上方予備力）入札", yaxis_title="MW")
-    st.plotly_chart(fig_r, use_container_width=True)
-
-    # Supply-demand balance check
-    gen_tot = gen_area.groupby("Time", as_index=False)["g_MW"].sum().rename(columns={"g_MW":"gen_total"})
-    bal = pd.DataFrame({"Time": demand_ser.index})
-    bal = bal.merge(gen_tot, on="Time", how="left").merge(net[["Time","net_imports"]], on="Time", how="left")
-    bal["demand"] = demand_ser.values
-    bal = bal.fillna(0.0)
-    bal["gen_plus_net"] = bal["gen_total"] + bal["net_imports"]
-    bal["balance"] = bal["gen_plus_net"] - bal["demand"]
-    spill_area = res["spill_df"][area_v].reindex(bal["Time"]).values
-    shed_area = res["shed_df"][area_v].reindex(bal["Time"]).values
-
-    fig_bal = go.Figure()
-    fig_bal.add_trace(go.Scatter(x=bal["Time"], y=bal["demand"], mode="lines", name="Demand"))
-    fig_bal.add_trace(go.Scatter(x=bal["Time"], y=bal["gen_total"], mode="lines", name="Generation (local)"))
-    fig_bal.add_trace(go.Scatter(x=bal["Time"], y=bal["gen_plus_net"], mode="lines", name="Gen + Net imports"))
-    fig_bal.add_trace(go.Scatter(x=bal["Time"], y=spill_area, mode="lines", name="Spill (MW)"))
-    fig_bal.add_trace(go.Scatter(x=bal["Time"], y=shed_area, mode="lines", name="Shed (MW)"))
-    fig_bal.update_layout(title=f"{area_v} — 需給バランス（検算）", yaxis_title="MW")
-    st.plotly_chart(fig_bal, use_container_width=True)
-
-    err = float(np.max(np.abs(bal["balance"].to_numpy() - (spill_area - shed_area)))) if len(bal) else 0.0
-    st.caption(f"最大バランス誤差 |(Gen+Net)-Demand - (Spill-Shed)| = {err:.6f} MW (数値誤差目安)")
+        st.markdown("### Electricity Pseudo-LMP (ε-perturbation)")
+        st.plotly_chart(res['fig_price'], use_container_width=True, height=400)
 
+        st.success("Solved. 設備容量（抜粋）: " + ", ".join([f"{k}={v:.2f}" for k,v in res['caps'].items()]))