Update app.py

app.py

@@ -1,477 +1,412 @@
+# app_market_sim.py
+# -*- coding: utf-8 -*-
 import streamlit as st
 import pandas as pd
 import numpy as np
 import json
+import pulp
 import plotly.express as px
 import plotly.graph_objs as go
-import pulp
+from io import StringIO
 
 # -----------------------------
-# Data I/O
+# Utility: load time-series
 # -----------------------------
 def load_timeseries():
     """
-    Load hourly capacity-factor and demand CF from data.json.
-    Returns a tidy DataFrame indexed by 'Time' with columns:
-    - solar hourly capacity factor
-    - onshore_wind hourly capacity factor
-    - offshore_wind hourly capacity factor
-    - river hourly capacity factor
-    - demand hourly capacity factor
+    Load data.json with keys:
+      { "<series>": {"x": [...timestamps...], "y": [...values...] }, ... }
+    Required series (national, used for all areas):
+      - 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", "r") as f:
-        data = json.load(f)
-    if not data:
-        raise ValueError("data.json is empty")
-
-    base_times = data[next(iter(data))]["x"]
-    df = pd.DataFrame({"Time": pd.to_datetime(base_times, errors="coerce")})
-    for k, v in data.items():
-        if "y" in v:
-            df[f"{k} hourly capacity factor"] = pd.to_numeric(v["y"], errors="coerce")
-    # sanitize
-    for c in df.columns:
-        if c != "Time":
-            df[c] = df[c].fillna(0.0).clip(lower=0.0)
-    return df.set_index("Time")
-
+    with open("data.json", "r", encoding="utf-8") as f_local:
+        data_local = json.load(f_local)
+    if not data_local:
+        raise RuntimeError("data.json is empty")
+
+    times_local = pd.to_datetime(data_local[next(iter(data_local))]["x"])
+    df_local = pd.DataFrame({"Time": times_local})
+    for k_local, v_local in data_local.items():
+        if isinstance(v_local, dict) and "y" in v_local:
+            df_local[f"{k_local} hourly capacity factor"] = pd.to_numeric(v_local["y"], errors="coerce").fillna(0.0)
+    return df_local.set_index("Time")
 
 # -----------------------------
-# Parameter helpers (units + conversions)
+# Variable cost calculator
 # -----------------------------
-def compute_var_costs_jpy_per_mwh(
-    usd_jpy_rate: float,
-    lng_usd_per_mmbtu: float,
-    coal_usd_per_ton: float,
-    oil_usd_per_bbl: float,
-    hr_gas_ccgt_gj_per_mwh: float,
-    hr_coal_gj_per_mwh: float,
-    hr_oil_gj_per_mwh: float,
-    hr_nuclear_gj_per_mwh: float,
-    coal_energy_gj_per_ton: float = 25.12,  # ~6000 kcal/kg -> 25.12 GJ/t
-):
+def var_costs_jpy_per_mwh(usd_jpy, lng_usd_per_mmbtu, coal_usd_per_ton, oil_usd_per_bbl,
+                           hr_gas_gj_per_mwh, hr_coal_gj_per_mwh, hr_oil_gj_per_mwh,
+                           nuc_varcost_override_jpy_per_mwh):
     """
-    Compute short-run variable cost [JPY/MWh] for thermal and nuclear from fuel prices + heat rates.
-    All variables are local by design.
-
-    Notes:
-    - LNG price input is in USD/MMBtu (Japan CIF), convert via 1 MMBtu = 1.055056 GJ.
-    - Coal price input is in USD/ton; convert using energy content [GJ/ton].
-    - Oil price input is in USD/bbl; convert using 1 bbl ≈ 6.12 GJ (typical crude reference).
-    - Nuclear: we do NOT price via hr*fuel_price (uranium path is different). Set a practical fuel+cycle variable cost baseline via UI (overrides), but we keep a fallback via hr*proxy if provided.
+    Compute JPY/MWh variable costs for thermal fuels.
+    1 MMBtu = 1.055056 GJ, 1 bbl ≈ 6.12 GJ, coal energy ≈ 25.12 GJ/t
     """
     mmbtu_to_gj = 1.055056
     bbl_to_gj = 6.12
+    coal_gj_per_ton = 25.12
 
-    # $/GJ
     gas_usd_per_gj = lng_usd_per_mmbtu / mmbtu_to_gj
-    coal_usd_per_gj = coal_usd_per_ton / coal_energy_gj_per_ton
+    coal_usd_per_gj = coal_usd_per_ton / coal_gj_per_ton
     oil_usd_per_gj = oil_usd_per_bbl / bbl_to_gj
 
-    # $/MWh
-    gas_usd_per_mwh = gas_usd_per_gj * hr_gas_ccgt_gj_per_mwh
-    coal_usd_per_mwh = coal_usd_per_gj * hr_coal_gj_per_mwh
-    oil_usd_per_mwh = oil_usd_per_gj * hr_oil_gj_per_mwh
+    gas_jpy_mwh = gas_usd_per_gj * hr_gas_gj_per_mwh * usd_jpy
+    coal_jpy_mwh = coal_usd_per_gj * hr_coal_gj_per_mwh * usd_jpy
+    oil_jpy_mwh = oil_usd_per_gj * hr_oil_gj_per_mwh * usd_jpy
+    nuc_jpy_mwh = nuc_varcost_override_jpy_per_mwh
 
-    # Convert to JPY
-    gas_jpy_per_mwh = gas_usd_per_mwh * usd_jpy_rate
-    coal_jpy_per_mwh = coal_usd_per_mwh * usd_jpy_rate
-    oil_jpy_per_mwh = oil_usd_per_mwh * usd_jpy_rate
+    return {"lng": gas_jpy_mwh, "coal": coal_jpy_mwh, "oil": oil_jpy_mwh, "nuclear": nuc_jpy_mwh}
 
-    # Nuclear variable cost baseline (JPY/MWh) left to UI; here return zero placeholder (overridden later)
-    nuclear_jpy_per_mwh = 0.0
-
-    return {
-        "lng_ccgt": gas_jpy_per_mwh,
-        "coal": coal_jpy_per_mwh,
-        "oil": oil_jpy_per_mwh,
-        "nuclear": nuclear_jpy_per_mwh,
-    }
+# -----------------------------
+# Random fleet generator
+# -----------------------------
+def generate_fleet(regions, rng, counts_cfg, caps_cfg, hr_cfg, min_output_cfg, ren_unit_caps):
+    """
+    Generate a unit-level fleet with realistic ranges.
 
+    Returns
+    -------
+    pandas.DataFrame columns:
+      ['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_local in regions:
+        for fuel_local in ["lng", "coal", "oil", "nuclear"]:
+            n_units = counts_cfg[(r_local, fuel_local)]
+            cap_min, cap_max = caps_cfg[fuel_local]
+            hr_min, hr_max = hr_cfg[fuel_local]
+            min_frac_rng = min_output_cfg[fuel_local]
+            for _ in range(n_units):
+                cap = rng.uniform(cap_min, cap_max)
+                hr = rng.uniform(hr_min, hr_max) if fuel_local != "nuclear" else np.nan
+                min_frac = rng.uniform(min_frac_rng[0], min_frac_rng[1])
+                rows_local.append({
+                    "unit_id": f"U{uid_local}",
+                    "region": r_local,
+                    "tech": fuel_local,
+                    "fuel": fuel_local,
+                    "cap_MW": float(cap),
+                    "hr_GJ_per_MWh": (float(hr) if fuel_local != "nuclear" else np.nan),
+                    "min_frac": float(min_frac),
+                    "is_renew": False,
+                    "cf_key": None
+                })
+                uid_local += 1
+
+    # Renewables (as unit blocks with zero var cost, output <= CF*cap)
+    for r_local in regions:
+        for ren_key, cf_key in [("solar","solar"), ("onshore_wind","onshore_wind"),
+                                ("offshore_wind","offshore_wind"), ("river","river")]:
+            n_units = counts_cfg[(r_local, ren_key)]
+            cap_min, cap_max = ren_unit_caps[ren_key]
+            for _ in range(n_units):
+                cap = rng.uniform(cap_min, cap_max)
+                rows_local.append({
+                    "unit_id": f"U{uid_local}",
+                    "region": r_local,
+                    "tech": ren_key,
+                    "fuel": None,
+                    "cap_MW": float(cap),
+                    "hr_GJ_per_MWh": np.nan,
+                    "min_frac": 0.0,
+                    "is_renew": True,
+                    "cf_key": f"{cf_key} hourly capacity factor"
+                })
+                uid_local += 1
+
+    df_units = pd.DataFrame(rows_local)
+    return df_units
 
 # -----------------------------
-# Core optimization
+# Simultaneous market clearing (energy + reserve)
 # -----------------------------
-def optimize_capacity_and_dispatch(
-    timeseries_df: pd.DataFrame,
-    regions: list,
-    region_load_shares: dict,
-    yearly_demand_twh: float,
-    # renewable CAPEX [JPY/MW]
-    solar_capex_jpy_per_mw: float,
-    onshore_capex_jpy_per_mw: float,
-    offshore_capex_jpy_per_mw: float,
-    river_capex_jpy_per_mw: float,
-    # renewable capacity bounds per region [MW] (min,max)
-    solar_bounds_mw: tuple,
-    onshore_bounds_mw: tuple,
-    offshore_bounds_mw: tuple,
-    river_bounds_mw: tuple,
-    # battery: cost per MWh energy (JPY/MWh), efficiency (0-1)
-    battery_cost_per_mwh: float,
-    battery_eff: float,
-    # thermal/nuclear: max capacities by region [MW] (user-editor table)
-    thermal_caps_mw: dict,  # {(region, tech): MW}
-    # variable costs [JPY/MWh]
-    var_costs_jpy_per_mwh: dict,  # keys: lng_ccgt, coal, oil, nuclear
-    # nuclear variable override (JPY/MWh)
-    nuclear_varcost_override: float,
-    # solver msg
-    solver_msg: bool = False,
-):
+def clear_market(df_units, ts_df_slice, regions, demand_shares, voll_jpy_per_mwh,
+                 reserve_ratio, varcost_map, battery_eff=0.9):
     """
-    Two-step solve:
-      Step-1 (capacity expansion): choose renewable & battery capacities (MW / MWh) to minimize total (CAPEX + variable costs) with thermal/nuclear capacities fixed (upper-bounded).
-      Step-2 (dispatch only, capacities fixed): compute LMPs from duals of each region-time balance constraint (short-run pricing).
-
-    Returns figures and key outputs.
+    Co-optimize energy and upward reserve simultaneously for each region and hour.
+
+    Decision variables:
+      g[u,t]         Generation (MW)
+      r[u,t]         Upward reserve (MW), eligible only for non-renew units
+      shed[r,t]      Load shedding (MW), penalized by VOLL
+    Constraints:
+      - Energy balance (per region, per hour): sum(g) + shed == demand
+      - Reserve requirement: sum(r) >= reserve_ratio * demand
+      - Unit limits:  min_frac*cap <= g <= cap (thermal/nuclear), g <= CF*cap (renew)
+                      0 <= r <= cap - g  (renew not eligible for r)
+    Objective:
+      Minimize sum(c_u * g + VOLL * shed)
+
+    Returns
+    -------
+    dict with:
+      lmp_df: DataFrame [Time x regions] LMP (JPY/MWh)
+      res_price_df: DataFrame [Time x regions] Reserve price (JPY/MW)
+      dispatch_df: long table with g[u,t]
     """
-    # Prepare demand (national hourly energy -> split by shares)
-    demand_cf = timeseries_df["demand hourly capacity factor"].values  # 0-1
-    nT = len(demand_cf)
-
-    # Compute national hourly demand in MW: scale yearly_demand_twh into hourly series
-    # Sum CF over hours -> annualized fraction of peak; we normalize such that sum(hourly_demand) = yearly_demand_twh * 1e6 MWh
-    # Let base_peak be 1 MW and scale to meet annual energy:
-    base_profile = demand_cf / demand_cf.max()  # normalized by peak=1
-    energy_norm = base_profile.sum()  # sum over hours with peak=1
-    # scale so that total energy equals yearly_demand_twh [TWh]
-    total_energy_mwh = yearly_demand_twh * 1e6
-    peak_mw_national = total_energy_mwh / energy_norm
-    national_demand_mw = base_profile * peak_mw_national
-
-    # Region-wise demand (MW)
-    region_demand = {}
+    times = ts_df_slice.index
+    T = len(times)
+
+    # Build regional demand
+    base_cf = ts_df_slice["demand hourly capacity factor"].values
+    # Normalize to peak=1 and scale so sum(base)=sum(base)  => here we just use proportional shares
+    base_profile = base_cf / base_cf.max()
+    # Set national energy (MWh) equal to sum(base_profile) [MW] so demand is in MW consistently
+    # We scale to an arbitrary national peak of 1 MW-equivalent then allocate shares; absolute levels cancel in prices if varcost scale holds.
+    national_demand = base_profile  # MW proxy
+    demand = {r: national_demand * demand_shares[r] for r in regions}
+
+    # Build model
+    mdl = pulp.LpProblem("CoOptim_Energy_Reserve", pulp.LpMinimize)
+
+    # Index maps
+    units_by_region = {r: df_units[df_units["region"] == r].index.tolist() for r in regions}
+
+    # Variables
+    g = pulp.LpVariable.dicts("g", ((u, t) for u in df_units.index for t in range(T)), lowBound=0, cat="Continuous")
+    r_up = pulp.LpVariable.dicts("r", ((u, t) for u in df_units.index for t in range(T)), lowBound=0, cat="Continuous")
+    shed = pulp.LpVariable.dicts("shed", ((r, t) for r in regions for t in range(T)), lowBound=0, cat="Continuous")
+
+    # Objective
+    cost_terms = []
+    for u in df_units.index:
+        row = df_units.loc[u]
+        vc = 0.0
+        if not row["is_renew"]:
+            fuel = row["fuel"]
+            if fuel == "nuclear":
+                vc = varcost_map["nuclear"]
+            else:
+                vc = varcost_map[fuel]
+        for t in range(T):
+            cost_terms.append(vc * g[(u, t)])
+    # VOLL penalty
     for r in regions:
-        region_demand[r] = national_demand_mw * float(region_load_shares[r])
-
-    # Renewable CFs
-    solar_cf = timeseries_df["solar hourly capacity factor"].values
-    onshore_cf = timeseries_df["onshore_wind hourly capacity factor"].values
-    offshore_cf = timeseries_df["offshore_wind hourly capacity factor"].values
-    river_cf = timeseries_df["river hourly capacity factor"].values
-
-    # Technologies
-    ren_techs = ["solar", "onshore_wind", "offshore_wind", "river"]
-    therm_techs = ["lng_ccgt", "oil", "coal", "nuclear"]
-
-    capex = {
-        "solar": solar_capex_jpy_per_mw,
-        "onshore_wind": onshore_capex_jpy_per_mw,
-        "offshore_wind": offshore_capex_jpy_per_mw,
-        "river": river_capex_jpy_per_mw,
-    }
-    cf_map = {
-        "solar": solar_cf,
-        "onshore_wind": onshore_cf,
-        "offshore_wind": offshore_cf,
-        "river": river_cf,
-    }
-    ren_bounds = {
-        "solar": solar_bounds_mw,
-        "onshore_wind": onshore_bounds_mw,
-        "offshore_wind": offshore_bounds_mw,
-        "river": river_bounds_mw,
-    }
-    varcost = var_costs_jpy_per_mwh.copy()
-    if nuclear_varcost_override is not None and nuclear_varcost_override > 0:
-        varcost["nuclear"] = nuclear_varcost_override
-
-    # -----------------
-    # Step-1: capacity + dispatch (coarse) to size renewables and battery
-    # -----------------
-    mdl1 = pulp.LpProblem("Japan_Capacity_Expansion", pulp.LpMinimize)
-
-    # Decision variables
-    ren_cap = pulp.LpVariable.dicts(
-        "ren_cap", ((r, g) for r in regions for g in ren_techs), lowBound=0, cat="Continuous"
-    )
-    # Battery per region (energy capacity MWh, charge/discharge power unconstrained except by energy window)
-    batt_energy_cap = pulp.LpVariable.dicts("batt_e_cap", (r for r in regions), lowBound=0, cat="Continuous")
-    ch = pulp.LpVariable.dicts("ch", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-    dis = pulp.LpVariable.dicts("dis", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-    soc = pulp.LpVariable.dicts("soc", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-
-    # Thermal/nuclear dispatch variables (capacity fixed via thermal_caps_mw)
-    gen = pulp.LpVariable.dicts(
-        "gen", ((r, g, t) for r in regions for g in therm_techs for t in range(nT)), lowBound=0, cat="Continuous"
-    )
-
-    # Curtailment
-    cur = pulp.LpVariable.dicts("cur", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-
-    # Objective: CAPEX(renewables + battery energy) + variable costs(thermal/nuclear)
-    mdl1 += (
-        pulp.lpSum(ren_cap[(r, g)] * capex[g] for r in regions for g in ren_techs)
-        + pulp.lpSum(batt_energy_cap[r] * battery_cost_per_mwh for r in regions)
-        + pulp.lpSum(gen[(r, g, t)] * varcost[g] for r in regions for g in therm_techs for t in range(nT))
-    )
+        for t in range(T):
+            cost_terms.append(voll_jpy_per_mwh * shed[(r, t)])
+    mdl += pulp.lpSum(cost_terms)
 
     # Constraints
-    for r in regions:
-        # Renewable bounds per region (uniform min/max applied to each region)
-        for g in ren_techs:
-            lo, hi = ren_bounds[g]
-            mdl1 += ren_cap[(r, g)] >= lo
-            mdl1 += ren_cap[(r, g)] <= hi
-
-        # Battery SoC and energy window
-        for t in range(nT):
-            ren_supply = (
-                ren_cap[(r, "solar")] * cf_map["solar"][t]
-                + ren_cap[(r, "onshore_wind")] * cf_map["onshore_wind"][t]
-                + ren_cap[(r, "offshore_wind")] * cf_map["offshore_wind"][t]
-                + ren_cap[(r, "river")] * cf_map["river"][t]
-            )
-
-            # Power balance with curtailment and storage
-            if t == 0:
-                mdl1 += (
-                    ren_supply
-                    + pulp.lpSum(gen[(r, g, t)] for g in therm_techs)
-                    + dis[(r, t)]
-                    == region_demand[r][t] + ch[(r, t)] + cur[(r, t)]
-                )
-                mdl1 += soc[(r, t)] == ch[(r, t)] * battery_eff - dis[(r, t)] / battery_eff
+    # Unit limits
+    for u in df_units.index:
+        row = df_units.loc[u]
+        cap = float(row["cap_MW"])
+        min_frac = float(row["min_frac"])
+        for t in range(T):
+            # Upper bound on generation
+            if row["is_renew"]:
+                cf_col = row["cf_key"]
+                cf_val = float(ts_df_slice.iloc[t][cf_col])
+                mdl += g[(u, t)] <= cap * cf_val, f"RenCap_{u}_{t}"
+                mdl += r_up[(u, t)] == 0.0, f"RenNoReserve_{u}_{t}"
             else:
-                mdl1 += (
-                    ren_supply
-                    + pulp.lpSum(gen[(r, g, t)] for g in therm_techs)
-                    + dis[(r, t)]
-                    == region_demand[r][t] + ch[(r, t)] + cur[(r, t)]
-                )
-                mdl1 += soc[(r, t)] == soc[(r, t - 1)] + ch[(r, t)] * battery_eff - dis[(r, t)] / battery_eff
-
-            # Battery energy limit
-            mdl1 += soc[(r, t)] <= batt_energy_cap[r]
-
-            # Thermal capacity limits
-            for g in therm_techs:
-                mdl1 += gen[(r, g, t)] <= thermal_caps_mw[(r, g)]
-
-    # Solve step-1
-    solver = pulp.PULP_CBC_CMD(msg=solver_msg)
-    mdl1.solve(solver)
-
-    # Fix capacities for step-2 (short-run dispatch → LMP)
-    ren_cap_star = {(r, g): ren_cap[(r, g)].value() for r in regions for g in ren_techs}
-    batt_e_star = {r: batt_energy_cap[r].value() for r in regions}
-
-    # -----------------
-    # Step-2: dispatch only with capacities fixed (dual → LMP)
-    # -----------------
-    mdl2 = pulp.LpProblem("Japan_Dispatch_LMP", pulp.LpMinimize)
-
-    ch2 = pulp.LpVariable.dicts("ch2", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-    dis2 = pulp.LpVariable.dicts("dis2", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-    soc2 = pulp.LpVariable.dicts("soc2", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-    gen2 = pulp.LpVariable.dicts(
-        "gen2", ((r, g, t) for r in regions for g in therm_techs for t in range(nT)), lowBound=0, cat="Continuous"
-    )
-    cur2 = pulp.LpVariable.dicts("cur2", ((r, t) for r in regions for t in range(nT)), lowBound=0, cat="Continuous")
-
-    # Objective: variable costs only
-    mdl2 += pulp.lpSum(gen2[(r, g, t)] * varcost[g] for r in regions for g in therm_techs for t in range(nT))
-
-    # Constraints with named balance for duals
-    for r in regions:
-        for t in range(nT):
-            ren_supply = (
-                ren_cap_star[(r, "solar")] * cf_map["solar"][t]
-                + ren_cap_star[(r, "onshore_wind")] * cf_map["onshore_wind"][t]
-                + ren_cap_star[(r, "offshore_wind")] * cf_map["offshore_wind"][t]
-                + ren_cap_star[(r, "river")] * cf_map["river"][t]
-            )
-            cname = f"Balance_{r}_{t}"
-            mdl2 += (
-                ren_supply + pulp.lpSum(gen2[(r, g, t)] for g in therm_techs) + dis2[(r, t)]
-                == region_demand[r][t] + ch2[(r, t)] + cur2[(r, t)]
-            ), cname
-
-            if t == 0:
-                mdl2 += soc2[(r, t)] == ch2[(r, t)] * battery_eff - dis2[(r, t)] / battery_eff
-            else:
-                mdl2 += soc2[(r, t)] == soc2[(r, t - 1)] + ch2[(r, t)] * battery_eff - dis2[(r, t)] / battery_eff
-
-            mdl2 += soc2[(r, t)] <= batt_e_star[r]
-            for g in therm_techs:
-                mdl2 += gen2[(r, g, t)] <= thermal_caps_mw[(r, g)]
-
-    mdl2.solve(solver)
-
-    # Extract LMPs from duals (JPY/MWh)
-    lmp = {r: np.zeros(nT) for r in regions}
-    for r in regions:
-        for t in range(nT):
-            cname = f"Balance_{r}_{t}"
-            lmp[r][t] = mdl2.constraints[cname].pi if cname in mdl2.constraints else np.nan
-
-    # Collect plots
-    # 1) LMP per area
-    lmp_df = pd.DataFrame(
-        {"Time": timeseries_df.index}
-        | {f"LMP {r} [JPY/MWh]": lmp[r] for r in regions}
-    )
-    fig_lmp = px.line(lmp_df, x="Time", y=lmp_df.columns[1:], title="Area LMP (JPY/MWh)")
-
-    # 2) Example dispatch stack (national sum for visualization)
-    # Sum generation across regions and techs at each hour (from mdl2)
-    gen_stack = {g: np.zeros(nT) for g in therm_techs}
-    ren_stack = {g: np.zeros(nT) for g in ren_techs}
-    for r in regions:
-        for t in range(nT):
-            ren_stack["solar"][t] += ren_cap_star[(r, "solar")] * cf_map["solar"][t]
-            ren_stack["onshore_wind"][t] += ren_cap_star[(r, "onshore_wind")] * cf_map["onshore_wind"][t]
-            ren_stack["offshore_wind"][t] += ren_cap_star[(r, "offshore_wind")] * cf_map["offshore_wind"][t]
-            ren_stack["river"][t] += ren_cap_star[(r, "river")] * cf_map["river"][t]
-            for g in therm_techs:
-                gen_stack[g][t] += gen2[(r, g, t)].value()
-
-    disp_df = pd.DataFrame({"Time": timeseries_df.index})
-    for g in ["solar", "onshore_wind", "offshore_wind", "river"]:
-        disp_df[g] = ren_stack[g]
-    for g in therm_techs:
-        disp_df[g] = gen_stack[g]
-    disp_df["demand_total"] = sum(region_demand[r] for r in regions)
-
-    fig_stack = go.Figure()
-    for col in ["solar", "onshore_wind", "offshore_wind", "river", "lng_ccgt", "coal", "oil", "nuclear"]:
-        fig_stack.add_trace(go.Scatter(x=disp_df["Time"], y=disp_df[col], mode="lines", stackgroup="one", name=col))
-    fig_stack.add_trace(go.Scatter(x=disp_df["Time"], y=disp_df["demand_total"], mode="lines", name="demand", line=dict(width=1)))
-
-    fig_stack.update_layout(title="National Dispatch Stack (sum of 10 areas)", yaxis_title="MW")
-
-    # 3) Capacity results
-    cap_tbl = []
-    for r in regions:
-        for g in ren_techs:
-            cap_tbl.append({"region": r, "tech": g, "optimal_capacity_MW": ren_cap_star[(r, g)]})
-        cap_tbl.append({"region": r, "tech": "battery_energy", "optimal_capacity_MWh": batt_e_star[r]})
-    cap_df = pd.DataFrame(cap_tbl)
-
-    return fig_lmp, fig_stack, cap_df, lmp_df
-
+                mdl += g[(u, t)] <= cap, f"Cap_{u}_{t}"
+                mdl += g[(u, t)] >= min_frac * cap, f"MinOut_{u}_{t}"
+                # Reserve headroom
+                mdl += r_up[(u, t)] <= cap - g[(u, t)], f"ReserveHeadroom_{u}_{t}"
+
+    # Energy balance & Reserve requirement
+    lmp_names = {}         # energy balance names to read duals
+    res_names = {}         # reserve names to read duals (use <= form for positive dual)
+    for ridx, r in enumerate(regions):
+        units_r = units_by_region[r]
+        for t in range(T):
+            # Energy balance: sum g + shed == demand[r,t]
+            cname = f"EnergyBal_{r}_{t}"
+            mdl += (pulp.lpSum([g[(u, t)] for u in units_r]) + shed[(r, t)] ==
+                    float(demand[r][t])), cname
+            lmp_names[(r, t)] = cname
+
+            # Reserve: -sum r <= - req  (so dual >= 0 at optimum)
+            req = reserve_ratio * float(demand[r][t])
+            rname = f"ReserveReq_{r}_{t}"
+            mdl += (-pulp.lpSum([r_up[(u, t)] for u in units_r]) <= -req), rname
+            res_names[(r, t)] = rname
+
+    # Solve
+    solver = pulp.PULP_CBC_CMD(msg=False)
+    mdl.solve(solver)
+
+    # Extract LMPs and reserve prices
+    lmp_mat = np.zeros((T, len(regions)))
+    res_mat = np.zeros((T, len(regions)))
+    for j, r in enumerate(regions):
+        for t in range(T):
+            lmp_mat[t, j] = mdl.constraints[lmp_names[(r, t)]].pi  # JPY/MWh
+            res_mat[t, j] = mdl.constraints[res_names[(r, t)]].pi  # JPY/MW
+
+    lmp_df = pd.DataFrame(lmp_mat, index=ts_df_slice.index, columns=regions)
+    res_price_df = pd.DataFrame(res_mat, index=ts_df_slice.index, columns=regions)
+
+    # Dispatch table
+    disp_rows = []
+    for u in df_units.index:
+        row = df_units.loc[u]
+        for t in range(T):
+            disp_rows.append({
+                "Time": ts_df_slice.index[t],
+                "unit_id": row["unit_id"],
+                "region": row["region"],
+                "tech": row["tech"],
+                "g_MW": g[(u, t)].value(),
+                "r_up_MW": r_up[(u, t)].value()
+            })
+    dispatch_df = pd.DataFrame(disp_rows)
+
+    return {"lmp_df": lmp_df, "res_price_df": res_price_df, "dispatch_df": dispatch_df}
 
 # -----------------------------
 # Streamlit UI
 # -----------------------------
-st.set_page_config(page_title="Japan LMP Tool (10 areas)", layout="wide")
-st.title("日本版 LMP ツール（10エリア・双対価格）")
+st.set_page_config(page_title="Simultaneous Market (JP-10) — Random Fleet", layout="wide")
+st.title("同時市場シミュレーション（日本10エリア・乱数フリート）")
 
-st.markdown(
-    "短期限界費用（燃料費）に基づく dispatch で各エリアの LMP（需給制約の双対変数）を算出します．"
-)
+# Regions
+REGIONS = ["Hokkaido","Tohoku","Tokyo","Chubu","Hokuriku","Kansai","Chugoku","Shikoku","Kyushu","Okinawa"]
 
-# Load data
+# Load time-series
 ts_df = load_timeseries()
 
-# Regions (10 T&D areas)
-regions = ["Hokkaido","Tohoku","Tokyo","Chubu","Hokuriku","Kansai","Chugoku","Shikoku","Kyushu","Okinawa"]
-
 with st.sidebar:
-    st.header("需要・配分")
-    y_demand = st.number_input("年間需要（TWh/年，国全体）", value=900.0, step=10.0, min_value=10.0)
+    st.header("乱数と時間範囲")
+    seed = st.number_input("Random seed", value=42, step=1)
+    hours = st.slider("Hours to simulate", min_value=24, max_value=min(168, len(ts_df)), value=24, step=24)
+    start_idx = st.slider("Start index", min_value=0, max_value=max(0, len(ts_df)-hours), value=0, step=1)
+    ts_slice = ts_df.iloc[start_idx:start_idx+hours]
 
-    st.caption("エリア需要の配分（合計=1.0）")
+    st.header("需要配分（∑=1.0）")
     default_share = 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]  # 実務上の目安（編集可）
+        "region": REGIONS,
+        "share": [0.03,0.09,0.32,0.14,0.03,0.17,0.07,0.03,0.11,0.01]
     })
     share_df = st.data_editor(default_share, num_rows="fixed", use_container_width=True)
-    share_sum = float(share_df["share"].sum())
-    if abs(share_sum - 1.0) > 1e-6:
-        st.warning(f"合計が {share_sum:.3f} です．1.0 に自動正規化します．")
-    region_shares = {row["region"]: float(row["share"]) / share_sum for _, row in share_df.iterrows()}
+    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("燃料価格・為替（編集可）")
+    st.header("燃料価格・為替（可変費）")
     usd_jpy = st.number_input("USD/JPY", value=148.21, step=0.5)
-    lng_price = st.number_input("LNG 価格（USD/MMBtu，CIF Japan）", value=11.27, step=0.1)
-    coal_price = st.number_input("石炭 価格（USD/ton，FOB/CIFの代表値）", value=130.0, step=1.0)
-    oil_price = st.number_input("原油（JCC想定）価格（USD/bbl）", value=80.0, step=1.0)
-
-    st.header("熱率（GJ/MWh）")
-    hr_gas = st.number_input("LNG-CCGT", value=6.6, step=0.1)
-    hr_coal = st.number_input("石炭（USC等）", value=8.3, step=0.1)
-    hr_oil = st.number_input("石油（効率39%想定→約9.23）", value=9.23, step=0.1)
-    hr_nuc = st.number_input("原子力（ダミー，UI用）", value=10.3, step=0.1)
-
-    vc_base = compute_var_costs_jpy_per_mwh(
-        usd_jpy_rate=usd_jpy,
-        lng_usd_per_mmbtu=lng_price,
-        coal_usd_per_ton=coal_price,
-        oil_usd_per_bbl=oil_price,
-        hr_gas_ccgt_gj_per_mwh=hr_gas,
-        hr_coal_gj_per_mwh=hr_coal,
-        hr_oil_gj_per_mwh=hr_oil,
-        hr_nuclear_gj_per_mwh=hr_nuc,
-    )
-    st.caption("短期限界費用（計算結果，JPY/MWh）")
-    st.write({k: round(v, 1) for k, v in vc_base.items()})
-
-    nuc_var = st.number_input("原子力の可変費（燃料＋サイクル, JPY/MWh）", value=2300.0, step=100.0)
-
-    st.header("CAPEX（JPY/MW）")
-    solar_capex = st.number_input("太陽光", value=102000.0, step=1000.0)
-    onshore_capex = st.number_input("陸上風力", value=222000.0, step=1000.0)
-    offshore_capex = st.number_input("洋上風力（着床）", value=348000.0, step=1000.0)
-    river_capex = st.number_input("流れ込み水力", value=620000.0, step=5000.0)
-
-    st.header("バッテリー")
-    batt_cost = st.number_input("コスト（JPY/MWh，エネルギー容量）", value=6_250_000.0, step=50_000.0)
-    batt_eta = st.slider("往復効率", min_value=0.70, max_value=0.98, value=0.90, step=0.01)
-
-    st.header("再エネ容量下限・上限（各エリア同一）")
-    solar_bounds = st.slider("太陽光 [MW]", 0, 50000, (0, 50000))
-    onshore_bounds = st.slider("陸上風力 [MW]", 0, 50000, (0, 50000))
-    offshore_bounds = st.slider("洋上風力 [MW]", 0, 50000, (0, 50000))
-    river_bounds = st.slider("流れ込み水力 [MW]", 0, 50000, (0, 50000))
-
-    st.header("火力・原子力の上限制約（各エリア）")
-    therm_df_default = pd.DataFrame({
-        "region": regions,
-        "lng_ccgt_MW": [3000, 9000, 25000, 9000, 2500, 18000, 6000, 2500, 9000, 1000],
-        "oil_MW":      [1000, 2000,  6000, 2000,  800,  3000, 1500,  800, 1500,  300],
-        "coal_MW":     [1500, 4000,  7000, 4000, 1500,  7000, 3000, 1000, 5000,  200],
-        "nuclear_MW":  [  0 , 2600,  6500, 3700, 1740,  4700,  820,  890,  3570,  0 ],
+    lng_px = st.number_input("LNG (USD/MMBtu)", value=11.27, step=0.1)
+    coal_px = st.number_input("Coal (USD/ton)", value=130.0, step=1.0)
+    oil_px = st.number_input("Oil (USD/bbl)", value=80.0, step=1.0)
+    # Heat-rate (GJ/MWh) ranges (for random draw, UI below sets min/max)
+    st.caption("熱率の代表値：Gas CCGT≈6.6, Coal≈8.3, Oil≈9.2（レンジ内で乱数生成）")
+    hr_gas_min = st.number_input("HR_gas_min (GJ/MWh)", value=6.2, step=0.1)
+    hr_gas_max = st.number_input("HR_gas_max (GJ/MWh)", value=6.9, step=0.1)
+    hr_coal_min = st.number_input("HR_coal_min (GJ/MWh)", value=7.8, step=0.1)
+    hr_coal_max = st.number_input("HR_coal_max (GJ/MWh)", value=9.0, step=0.1)
+    hr_oil_min = st.number_input("HR_oil_min (GJ/MWh)", value=8.8, step=0.1)
+    hr_oil_max = st.number_input("HR_oil_max (GJ/MWh)", value=10.0, step=0.1)
+    nuc_var = st.number_input("原子力の可変費（JPY/MWh）", value=2300.0, step=100.0)
+
+    vc = var_costs_jpy_per_mwh(usd_jpy, lng_px, coal_px, oil_px,
+                               (hr_gas_min+hr_gas_max)/2, (hr_coal_min+hr_coal_max)/2, (hr_oil_min+hr_oil_max)/2,
+                               nuc_var)
+    st.caption("参考：中庸熱率での短期限界費用（JPY/MWh）")
+    st.write({k: round(v,1) for k,v in vc.items()})
+
+    st.header("ユニット数（各エリア）")
+    units_df = pd.DataFrame({
+        "region": REGIONS,
+        "lng_units": [6,10,25,10,4,20,8,4,10,2],
+        "coal_units":[3,6,10,6,3,10,5,2,7,1],
+        "oil_units": [2,3,6,3,2,5,3,2,3,1],
+        "nuc_units": [0,2,4,2,1,3,1,1,2,0],
+        "solar_units":[20,30,60,30,12,40,20,12,30,8],
+        "on_units":  [10,15,25,15,6,20,10,6,15,4],
+        "off_units": [2,3,6,3,1,4,2,1,3,0],
+        "river_units":[5,8,12,8,4,12,6,3,8,2]
     })
-    therm_df = st.data_editor(therm_df_default, use_container_width=True)
+    units_df = st.data_editor(units_df, 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("最低出力（比率レンジ）")
+    minout_cfg = {
+        "lng": (0.0, 0.2),
+        "coal": (0.2, 0.6),
+        "oil": (0.0, 0.4),
+        "nuclear": (0.6, 0.9)
+    }
+
+    st.header("市場パラメータ")
+    reserve_ratio = st.slider("一次予備率（需要比）", min_value=0.0, max_value=0.20, value=0.03, step=0.01)
+    voll = st.number_input("VOLL（JPY/MWh）", value=300000.0, step=10000.0)
 
-# Build thermal capacity dict
-thermal_caps = {}
-for _, row in therm_df.iterrows():
+# Build counts config
+counts_cfg = {}
+for _, row in units_df.iterrows():
     r = row["region"]
-    thermal_caps[(r, "lng_ccgt")] = float(row["lng_ccgt_MW"])
-    thermal_caps[(r, "oil")] = float(row["oil_MW"])
-    thermal_caps[(r, "coal")] = float(row["coal_MW"])
-    thermal_caps[(r, "nuclear")] = float(row["nuclear_MW"])
-
-if st.button("最適化＆LMP計算"):
-    fig_lmp, fig_stack, cap_df, lmp_df = optimize_capacity_and_dispatch(
-        timeseries_df=ts_df,
-        regions=regions,
-        region_load_shares=region_shares,
-        yearly_demand_twh=y_demand,
-        solar_capex_jpy_per_mw=solar_capex,
-        onshore_capex_jpy_per_mw=onshore_capex,
-        offshore_capex_jpy_per_mw=offshore_capex,
-        river_capex_jpy_per_mw=river_capex,
-        solar_bounds_mw=solar_bounds,
-        onshore_bounds_mw=onshore_bounds,
-        offshore_bounds_mw=offshore_bounds,
-        river_bounds_mw=river_bounds,
-        battery_cost_per_mwh=batt_cost,
-        battery_eff=batt_eta,
-        thermal_caps_mw=thermal_caps,
-        var_costs_jpy_per_mwh=vc_base,
-        nuclear_varcost_override=nuc_var,
-        solver_msg=False,
-    )
-
-    st.subheader("LMP（10エリア）")
-    st.plotly_chart(fig_lmp, use_container_width=True)
-    st.subheader("全国ディスパッチ（合算スタック）")
-    st.plotly_chart(fig_stack, use_container_width=True)
-    st.subheader("最適化された容量（再エネ・蓄電）")
-    st.dataframe(cap_df)
-    st.subheader("LMP 出力（テーブル）")
-    st.dataframe(lmp_df)
+    counts_cfg[(r,"lng")] = int(row["lng_units"])
+    counts_cfg[(r,"coal")] = int(row["coal_units"])
+    counts_cfg[(r,"oil")] = int(row["oil_units"])
+    counts_cfg[(r,"nuclear")] = int(row["nuc_units"])
+    counts_cfg[(r,"solar")] = int(row["solar_units"])
+    counts_cfg[(r,"onshore_wind")] = int(row["on_units"])
+    counts_cfg[(r,"offshore_wind")] = int(row["off_units"])
+    counts_cfg[(r,"river")] = int(row["river_units"])
+
+# Heat-rate and min-output configs
+hr_cfg = {"lng": (hr_gas_min, hr_gas_max), "coal": (hr_coal_min, hr_coal_max),
+          "oil": (hr_oil_min, hr_oil_max), "nuclear": (np.nan, np.nan)}
+min_output_cfg = minout_cfg
+
+if st.button("シミュレーション実行（同時市���クリアリング）"):
+    rng = np.random.default_rng(seed)
+    df_units = generate_fleet(REGIONS, rng, counts_cfg, cap_bounds, hr_cfg, min_output_cfg, ren_bounds)
+
+    st.subheader("生成フリート（ユニット一覧）")
+    st.dataframe(df_units)
+
+    res = clear_market(df_units, ts_slice, REGIONS, demand_shares, voll,
+                       reserve_ratio, varcost_map=var_costs_jpy_per_mwh(
+                           usd_jpy, lng_px, coal_px, oil_px,
+                           (hr_gas_min+hr_gas_max)/2, (hr_coal_min+hr_coal_max)/2, (hr_oil_min+hr_oil_max)/2,
+                           nuc_var
+                       ))
+
+    # LMP & Reserve price plots
+    st.subheader("LMP（JPY/MWh）")
+    st.plotly_chart(px.line(res["lmp_df"], x=res["lmp_df"].index, y=res["lmp_df"].columns), 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), use_container_width=True)
+
+    # Simple national dispatch stack (sum by tech)
+    disp = res["dispatch_df"].merge(df_units[["unit_id","tech"]], on="unit_id")
+    stack = disp.groupby(["Time","tech"], as_index=False)["g_MW"].sum()
+    fig = go.Figure()
+    for tech in ["solar","onshore_wind","offshore_wind","river","nuclear","coal","lng","oil"]:
+        if tech in stack["tech"].unique():
+            sub = stack[stack["tech"]==tech]
+            fig.add_trace(go.Scatter(x=sub["Time"], y=sub["g_MW"], mode="lines", stackgroup="one", name=tech))
+    fig.update_layout(title="全国発電スタック（合算）", yaxis_title="MW")
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Downloads
+    csv_buf = StringIO()
+    df_units.to_csv(csv_buf, index=False, encoding="utf-8")
+    st.download_button("ユニット一覧CSVダウンロード", data=csv_buf.getvalue(), file_name="fleet_units.csv", mime="text/csv")
+
+    csv_buf2 = StringIO()
+    res["dispatch_df"].to_csv(csv_buf2, index=False, encoding="utf-8")
+    st.download_button("ディスパッチ結果CSVダウンロード", data=csv_buf2.getvalue(), file_name="dispatch.csv", mime="text/csv")