# app.py import streamlit as st import pandas as pd import pulp import plotly.graph_objs as go import plotly.express as px import numpy as np import json from copy import deepcopy # ------------------------------ # Data loader # ------------------------------ def get_json(): """ Open ./data.json and return a tidy DataFrame with columns: Time, {carrier} hourly capacity factor Returns ------- pd.DataFrame """ with open('data.json', encoding='utf-8') as f: data = json.load(f) if not data: return None 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') result_df = result_df.fillna(0) return result_df # ------------------------------ # Core LP builder/solver # ------------------------------ def build_and_solve_lp(params, data_df): """ Build and solve the single-region LP with electricity, H2 (P2X), CH4 (methanation), battery storage, and H2 storage. Returns solved objects & key series. Parameters ---------- params : dict Model parameters incl. costs, ranges, efficiencies, yearly_demand_TWh, etc. data_df : pd.DataFrame DataFrame from get_json(). Returns ------- dict Results including dispatch time series, capacities, SOCs, and figures. """ # 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 # 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] # 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), } # 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') 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 } # ------------------------------ # 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)') 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('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.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.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.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()]))