pypsa-cl 0.1.0__py3-none-any.whl

pypsa_cl/GUI.py

@@ -0,0 +1,848 @@
+"""Graphical configuration interface for the PyPSA-CL expansion model.
+
+Builds the scenario/epoch configuration returned to ``main.py``. A run may
+queue several global scenarios, each with one or more investment epochs, and
+execute them sequentially. Preset scenario packages (E1-N3) auto-fill and lock
+the six component selectors; the "Otro" option unlocks free configuration.
+
+``run_gui`` returns a dictionary with a ``scenarios`` list and a flattened
+``epochs`` list, where each epoch carries the ``global_scenario`` label and the
+``_scenario_index`` / ``_epoch_in_scenario`` / ``_global_epoch`` markers used by
+the export routines.
+"""
+
+import tkinter as tk
+from tkinter import ttk, messagebox
+from tkcalendar import DateEntry
+from PIL import Image, ImageTk
+from datetime import datetime, timedelta
+import os
+import pandas as pd
+
+from pypsa_cl._data import get_data_file
+from pypsa_cl._paths import ASSETS_DIR, get_project_root
+
+ordinal_english = [
+    "first", "second", "third", "fourth", "fifth", "sixth", "seventh",
+    "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth",
+    "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth",
+    "nineteenth", "twentieth"
+]
+
+class Epoch:
+    def __init__(self, name, start_date, end_date, rep_years, rep_months, rep_days, settings=None):
+        self.name = name
+        self.start_date = start_date
+        self.end_date = end_date
+        self.rep_years = rep_years
+        self.rep_months = rep_months
+        self.rep_days = rep_days
+        self.settings = settings or {}
+
+def run_gui():
+    def get_scenarios_names():
+        current_dir = os.path.dirname(__file__)
+        parent_dir = get_project_root()
+        scenario_types = ["demand", "climate", "hydrology", "fuel_price",
+                          "generation_investment_cost", "storage_investment_cost"]
+        scenario_names_path = {
+            "demand": [get_data_file("Loads.xlsx"), "loads"],
+            "climate": [get_data_file("Profiles.xlsx"), "profiles"],
+            "hydrology": [get_data_file("Water time series.xlsx"), "Inflow"],
+            "fuel_price": [get_data_file("Costs.xlsx"), "Fuel price"],
+            "generation_investment_cost": [get_data_file("Costs.xlsx"), "Generation investment cost"],
+            "storage_investment_cost": [get_data_file("Costs.xlsx"), "Storage investment cost"],
+        }
+        scenario_names = {}
+        for s in scenario_types:
+            file_path, sheet_name = scenario_names_path[s]
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+            scenario_names[s] = df["scenario"].unique().tolist()
+        return scenario_names
+
+    scenario_map = {}
+    scenario_map['E1 - Exploratorio desfavorable'] = {
+        'demand': 'Baja - E1', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Alto',
+        'generation_investment_cost': 'Alto', 'storage_investment_cost': 'Alto'}
+    scenario_map['E2 - Exploratorio BAU'] = {
+        'demand': 'Media - E2', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Medio',
+        'generation_investment_cost': 'Medio', 'storage_investment_cost': 'Medio'}
+    scenario_map['E3 - Exploratorio favorable'] = {
+        'demand': 'Alta - E3', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Bajo',
+        'generation_investment_cost': 'Bajo', 'storage_investment_cost': 'Bajo'}
+    scenario_map['N1 - Normativo desfavorable'] = {
+        'demand': 'Baja - N1', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Alto',
+        'generation_investment_cost': 'Alto', 'storage_investment_cost': 'Alto'}
+    scenario_map['N2 - Normativo BAU'] = {
+        'demand': 'Media - N2', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Medio',
+        'generation_investment_cost': 'Medio', 'storage_investment_cost': 'Medio'}
+    scenario_map['N3 - Normativo favorable'] = {
+        'demand': 'Alta - N3', 'climate': 'current_projections',
+        'hydrology': 'MIROC-ESM-CHEM r1i1p1', 'fuel_price': 'Bajo',
+        'generation_investment_cost': 'Bajo', 'storage_investment_cost': 'Bajo'}
+    scenario_map['Otro'] = {}
+
+    PRESET_NAMES = [k for k in scenario_map if k != 'Otro']
+    ALL_GLOBAL_NAMES = PRESET_NAMES + ['Otro']
+
+    scenario_names = {
+        'demand': ['Alta - E3', 'Media - E2', 'Baja - E1', 'Alta - N3', 'Media - N2', 'Baja - N1'],
+        'climate': ['current_projections'],
+        'hydrology': ['H_1982', 'H_1986', 'H_1998', 'MIROC-ESM-CHEM r1i1p1', 'NorESM1-M r1i1p1'],
+        'fuel_price': ['Alto', 'Medio', 'Bajo'],
+        'generation_investment_cost': ['Alto', 'Medio', 'Bajo'],
+        'storage_investment_cost': ['Alto', 'Medio', 'Bajo'],
+    }
+
+    BASE_COLORS = {
+        "fondo_azul_oscuro": "#081889",
+        "cyan": "#18ADE5",
+        "gray": "#8093AD",
+        "orange": "#F7A823",
+        "green": "#7DB928",
+        "mint": "#99D0C1",
+        "dark_green": "#397831",
+        "white": "#FFFFFF",
+        "black": "#000000",
+        "section_bg": "#0a20a8",
+        "section_border": "#2a40c8",
+    }
+
+    THEME = {
+        "fondo_principal": "fondo_azul_oscuro",
+        "titulo": "cyan",
+        "texto_principal": "white",
+        "campo_activo": "mint",
+        "boton_principal": "orange",
+        "boton_hover": "green",
+    }
+
+    def color(role):
+        return BASE_COLORS[THEME[role]]
+
+    SBG   = BASE_COLORS["section_bg"]
+    WHITE = BASE_COLORS["white"]
+    CYAN  = BASE_COLORS["cyan"]
+    MINT  = BASE_COLORS["mint"]
+    DARK  = BASE_COLORS["fondo_azul_oscuro"]
+    ORANGE = BASE_COLORS["orange"]
+
+    result = {}
+    epochs = []
+    scenarios = []
+
+    def get_current_epoch_settings():
+        gs = global_scenario_var.get()
+        if gs == 'Otro':
+            global_label = custom_scenario_name_var.get().strip() or 'Otro'
+        else:
+            global_label = gs
+
+        return {
+            "global_scenario": global_label,
+            "demand_scenario": demand_scenario.get(),
+            "climate_scenario": climate_scenario.get(),
+            "hydrology_scenario": hydrology_scenario.get(),
+            "generation_investment_cost_scenario": generation_investment_cost_scenario.get(),
+            "storage_investment_cost_scenario": storage_investment_cost_scenario.get(),
+            "fuel_price_scenario": fuel_price_scenario.get(),
+            "solver_name": solver_name.get(),
+            "solver_threads": int(entry_threads.get()),
+            "solver_mip_gap": float(entry_mip_gap.get()),
+            "linearized_unit_commitment": linearized_uc_var.get(),
+            # Restriccion de emisiones maximas deshabilitada.
+            # "constraint_max_emissions": cb_emissions.get(),
+            # "max_emissions_MtCO2_year": float(entry_emissions.get()),
+            "constraint_max_emissions": False,
+            "max_emissions_MtCO2_year": 0.0,
+            "constraint_max_load_lost": cb_load_lost.get(),
+            "max_load_lost_GWh_year": float(entry_load_lost.get()),
+            "constraint_discrete_transmission_expansion": cb_discrete_transmission.get(),
+        }
+
+    def build_epoch_dicts():
+        """Serializa las épocas actualmente añadidas a dicts exportables."""
+        return [
+            {
+                "name": ep.name,
+                "start_date": ep.start_date.strftime("%Y-%m-%d"),
+                "end_date": ep.end_date.strftime("%Y-%m-%d"),
+                "representative_years": ep.rep_years,
+                "representative_months": ep.rep_months,
+                "representative_days": ep.rep_days,
+                **ep.settings,
+            }
+            for ep in epochs
+        ]
+
+    def add_scenario_to_queue():
+        """Guarda el escenario global actual (con sus épocas) en la cola y deja
+        la GUI lista para configurar el siguiente escenario global."""
+        if not epochs:
+            messagebox.showerror("Error", "Debe añadir al menos una época antes de agregar el escenario a la cola.")
+            return False
+        label = epochs[0].settings.get("global_scenario", "")
+        if label in [s["global_scenario"] for s in scenarios]:
+            messagebox.showerror(
+                "Error",
+                f'Ya hay un escenario "{label}" en la cola.\n'
+                'Para agregar una variante use "Otro" con un nombre distinto.'
+            )
+            return False
+        scenarios.append({"global_scenario": label, "epochs": build_epoch_dicts()})
+        epochs.clear()
+        update_epoch_listbox()
+        update_scenario_listbox()
+        global_scenario_combo.config(state="readonly")
+        _update_global_lock_label(locked=False)
+        custom_scenario_name_var.set("")
+        cal_inicio.set_date("2026-01-01")
+        years_var.set("2")
+        months_var.set("6")
+        days_var.set("1")
+        try:
+            sync_end_date_with_years()
+        except Exception:
+            pass
+        suggest_epoch_name()
+        return True
+
+    def confirmar():
+        if epochs:
+            if not add_scenario_to_queue():
+                return
+        if not scenarios:
+            messagebox.showerror("Error", "Debe agregar al menos un escenario (con al menos una época) antes de ejecutar.")
+            return
+        try:
+            _max_workers = max(1, int(entry_max_workers.get()))
+            _ram_limit = float(entry_ram_limit.get())
+            if not (10 <= _ram_limit <= 100):
+                raise ValueError
+        except ValueError:
+            messagebox.showerror("Error", "Revise la configuracion de ejecucion:\n"
+                                          "- Max parallel scenarios debe ser un entero >= 1\n"
+                                          "- RAM limit debe ser un porcentaje entre 10 y 100")
+            return
+        result["run_config"] = {
+            "execution_mode": "parallel" if execution_mode_var.get() == "Paralelo" else "sequential",
+            "max_parallel_scenarios": _max_workers,
+            "ram_limit_pct": _ram_limit,
+        }
+        flat = []
+        for s_idx, sc in enumerate(scenarios):
+            for e_idx, ep in enumerate(sc["epochs"]):
+                d = dict(ep)
+                d["_scenario_index"] = s_idx
+                d["_epoch_in_scenario"] = e_idx
+                d["_global_epoch"] = len(flat)
+                flat.append(d)
+        result["scenarios"] = scenarios
+        result["epochs"] = flat
+        result["n_scenarios"] = len(scenarios)
+        root.destroy()
+
+    root = tk.Tk()
+    root.title("PyPSA-CL - a tool for Long-term Power Systems Planning in Chile")
+    root.configure(bg=color("fondo_principal"))
+    root.geometry("1350x900")
+    root.resizable(True, True)
+
+    def _on_callback_error(exc, val, tb):
+        import traceback
+        traceback.print_exception(exc, val, tb)
+        try:
+            root.destroy()
+        except Exception:
+            pass
+
+    root.report_callback_exception = _on_callback_error
+
+    outer_frame = tk.Frame(root, bg=color("fondo_principal"))
+    outer_frame.pack(fill="both", expand=True)
+
+    canvas = tk.Canvas(outer_frame, bg=color("fondo_principal"), highlightthickness=0)
+    vscrollbar = ttk.Scrollbar(outer_frame, orient="vertical", command=canvas.yview)
+    hscrollbar = ttk.Scrollbar(outer_frame, orient="horizontal", command=canvas.xview)
+    canvas.configure(yscrollcommand=vscrollbar.set, xscrollcommand=hscrollbar.set)
+
+    canvas.grid(row=0, column=0, sticky="nsew")
+    vscrollbar.grid(row=0, column=1, sticky="ns")
+    hscrollbar.grid(row=1, column=0, sticky="ew")
+    outer_frame.rowconfigure(0, weight=1)
+    outer_frame.columnconfigure(0, weight=1)
+
+    container = tk.Frame(canvas, bg=color("fondo_principal"))
+    canvas_window = canvas.create_window((0, 0), window=container, anchor="nw")
+
+    def on_frame_configure(event):
+        canvas.configure(scrollregion=canvas.bbox("all"))
+
+    def on_canvas_configure(event):
+        content_width = container.winfo_reqwidth()
+        canvas.itemconfig(canvas_window, width=max(event.width, content_width))
+
+    container.bind("<Configure>", on_frame_configure)
+    canvas.bind("<Configure>", on_canvas_configure)
+
+    def _on_mousewheel(event):
+        canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
+
+    def _on_shift_mousewheel(event):
+        canvas.xview_scroll(int(-1 * (event.delta / 120)), "units")
+
+    canvas.bind_all("<MouseWheel>", _on_mousewheel)
+    canvas.bind_all("<Shift-MouseWheel>", _on_shift_mousewheel)
+
+    inner = tk.Frame(container, bg=color("fondo_principal"))
+    inner.pack(padx=20, pady=10)
+
+    style = ttk.Style(root)
+    style.theme_use("default")
+    style.configure("TLabel", background=color("fondo_principal"), foreground=color("texto_principal"), font=("Verdana", 10))
+    style.configure("TCombobox", fieldbackground=MINT, background=MINT, foreground=BASE_COLORS["black"], font=("Verdana", 9))
+    style.configure("TButton", background=color("boton_principal"), foreground=BASE_COLORS["black"], font=("Verdana", 10, "bold"), padding=6)
+    style.map("TButton", background=[("active", color("boton_hover"))])
+    style.configure("Section.TLabelframe", background=SBG, foreground=CYAN, font=("Verdana", 9, "bold"), relief="groove", bordercolor=BASE_COLORS["section_border"])
+    style.configure("Section.TLabelframe.Label", background=SBG, foreground=CYAN, font=("Verdana", 9, "bold"))
+
+    # Imágenes de la GUI: primero data/ de la carpeta de trabajo (permite reemplazarlas),
+    # luego las incluidas en el paquete.
+    _src_dir = ASSETS_DIR
+    _data_dir = os.path.join(get_project_root(), "data")
+
+    header_frame = tk.Frame(inner, bg=color("fondo_principal"))
+    header_frame.grid(row=0, column=0, columnspan=4, sticky="ew", pady=(0, 4))
+    header_frame.columnconfigure(0, weight=1)
+
+    header_inner = tk.Frame(header_frame, bg=color("fondo_principal"))
+    header_inner.grid(row=0, column=0)
+
+    for _logo_dir in (_data_dir, _src_dir):
+        _logo_path = os.path.join(_logo_dir, "logo_PELP.png")
+        if os.path.exists(_logo_path):
+            try:
+                _logo_raw = Image.open(_logo_path)
+                _logo_w = 200
+                _logo_h = int(_logo_w * _logo_raw.height / _logo_raw.width)
+                _logo_res = _logo_raw.resize((_logo_w, _logo_h), Image.LANCZOS)
+                logo_photo = ImageTk.PhotoImage(_logo_res)
+                logo_label = tk.Label(header_inner, image=logo_photo,
+                                      bg=color("fondo_principal"))
+                logo_label.image = logo_photo
+                logo_label.grid(row=0, column=0, padx=(0, 24), sticky="w")
+            except Exception as e:
+                print(f"No se pudo cargar el logo: {e}")
+            break
+
+    title = tk.Label(
+        header_inner,
+        text="PyPSA-CL - a tool for Long-term Power Systems Planning in Chile",
+        bg=color("fondo_principal"), fg=color("titulo"),
+        font=("Verdana", 15, "bold"),
+    )
+    title.grid(row=0, column=1, sticky="w")
+
+    header_sep = tk.Frame(header_frame, bg=CYAN, height=2)
+    header_sep.grid(row=1, column=0, sticky="ew", pady=(8, 10))
+
+    def add_row_in(frame, label_text, widget, row, bg):
+        lbl = tk.Label(frame, text=label_text, bg=bg, fg=WHITE, font=("Verdana", 9))
+        lbl.grid(row=row, column=0, padx=(6, 8), pady=4, sticky="e")
+        widget.grid(row=row, column=1, padx=(0, 6), pady=4, sticky="w")
+
+    def add_entry_row(frame, label_text, default, row, width=8):
+        lbl = tk.Label(frame, text=label_text, bg=SBG, fg=MINT, font=("Verdana", 9))
+        lbl.grid(row=row, column=0, padx=(6, 8), pady=4, sticky="e")
+        var = tk.StringVar(value=str(default))
+        ent = tk.Entry(frame, textvariable=var, bg=MINT, fg=DARK, font=("Verdana", 9),
+                       width=width, relief="flat", bd=2)
+        ent.grid(row=row, column=1, padx=(0, 6), pady=4, sticky="w")
+        return var
+
+    left_col = tk.Frame(inner, bg=color("fondo_principal"))
+    left_col.grid(row=1, column=0, padx=(0, 10), sticky="n")
+
+    mid_col = tk.Frame(inner, bg=color("fondo_principal"))
+    mid_col.grid(row=1, column=1, padx=(0, 10), sticky="n")
+
+    frame_temporal = ttk.LabelFrame(left_col, text="Configuracion temporal",
+                                     style="Section.TLabelframe", padding=(12, 8))
+    frame_temporal.pack(fill="x", pady=(0, 10))
+
+    epoch_name_var = tk.StringVar()
+
+    def suggest_epoch_name():
+        idx = len(epochs)
+        name = ordinal_english[idx] + " epoch" if idx < len(ordinal_english) else f"{idx+1}th epoch"
+        epoch_name_var.set(name)
+
+    suggest_epoch_name()
+
+    lbl_epoch = tk.Label(frame_temporal, text="Epoch name:", bg=SBG, fg=WHITE, font=("Verdana", 9))
+    lbl_epoch.grid(row=0, column=0, padx=(6, 8), pady=4, sticky="e")
+    entry_epoch_name = tk.Entry(frame_temporal, textvariable=epoch_name_var, bg=MINT, fg=DARK,
+                                font=("Verdana", 9), width=22, relief="flat", bd=2)
+    entry_epoch_name.grid(row=0, column=1, padx=(0, 6), pady=4, sticky="w")
+
+    cal_inicio = DateEntry(frame_temporal, date_pattern="yyyy-mm-dd")
+    cal_inicio.set_date("2026-01-01")
+    add_row_in(frame_temporal, "Start date", cal_inicio, 1, SBG)
+
+    cal_final = DateEntry(frame_temporal, date_pattern="yyyy-mm-dd")
+    cal_final.set_date("2027-12-31")
+    add_row_in(frame_temporal, "End date", cal_final, 2, SBG)
+
+    years_var = tk.StringVar(value="2")
+    years_combo = ttk.Combobox(frame_temporal, textvariable=years_var, values=list(range(1, 6)), state="readonly", width=12)
+    add_row_in(frame_temporal, "Representative years", years_combo, 3, SBG)
+
+    months_var = tk.StringVar(value="6")
+    months_combo = ttk.Combobox(frame_temporal, textvariable=months_var, values=[1, 2, 3, 4, 6, 12], state="readonly", width=12)
+    add_row_in(frame_temporal, "Representative months", months_combo, 4, SBG)
+
+    days_var = tk.StringVar(value="1")
+    days_combo = ttk.Combobox(frame_temporal, textvariable=days_var, values=[1, 4], state="readonly", width=12)
+    add_row_in(frame_temporal, "Representative days", days_combo, 5, SBG)
+
+    def suggested_end_date(start_date, rep_years):
+        return datetime(start_date.year + rep_years - 1, 12, 31).date()
+
+    def sync_end_date_with_years(event=None):
+        try:
+            start_date = cal_inicio.get_date()
+            rep_years = int(years_var.get())
+            cal_final.set_date(suggested_end_date(start_date, rep_years))
+        except Exception:
+            pass
+
+    years_combo.bind("<<ComboboxSelected>>", sync_end_date_with_years)
+    cal_inicio.bind("<<DateEntrySelected>>", sync_end_date_with_years)
+    try:
+        sync_end_date_with_years()
+    except Exception as e:
+        print(f"Warning syncing end date: {e}")
+
+    def add_epoch():
+        name = epoch_name_var.get().strip()
+        if not name:
+            messagebox.showerror("Error", "Por favor ingrese un nombre para la época.")
+            return
+
+        if global_scenario_var.get() == 'Otro':
+            if not custom_scenario_name_var.get().strip():
+                messagebox.showerror("Error", 'Debe ingresar un nombre para el escenario "Otro".')
+                return
+
+        if len(epochs) == 0:
+            start_date = cal_inicio.get_date()
+        else:
+            start_date = epochs[-1].end_date + timedelta(days=1)
+            cal_inicio.set_date(start_date)
+
+        rep_years = int(years_var.get())
+        end_date = suggested_end_date(start_date, rep_years)
+        cal_final.set_date(end_date)
+
+        if start_date > end_date:
+            messagebox.showerror("Error", "La fecha de inicio no puede ser posterior a la fecha de fin.")
+            return
+
+        ep = Epoch(
+            name=name,
+            start_date=start_date,
+            end_date=end_date,
+            rep_years=rep_years,
+            rep_months=int(months_var.get()),
+            rep_days=int(days_var.get()),
+            settings=get_current_epoch_settings(),
+        )
+        epochs.append(ep)
+
+        if len(epochs) == 1:
+            global_scenario_combo.config(state="disabled")
+            _update_global_lock_label(locked=True)
+
+        next_date = end_date + timedelta(days=1)
+        cal_inicio.set_date(next_date)
+        _next_yrs = 5 if len(epochs) >= 1 else 1
+        _next_mos = 6 if len(epochs) >= 1 else 1
+        cal_final.set_date(suggested_end_date(next_date, _next_yrs))
+        years_var.set(str(_next_yrs))
+        months_var.set(str(_next_mos))
+        days_var.set("1")
+        suggest_epoch_name()
+        update_epoch_listbox()
+
+    lbl_epochs_list = tk.Label(frame_temporal, text="Added epochs:", bg=SBG, fg=CYAN,
+                                font=("Verdana", 9, "bold"))
+    lbl_epochs_list.grid(row=6, column=0, columnspan=2, padx=6, pady=(6, 2), sticky="w")
+
+    epoch_listbox = tk.Listbox(
+        frame_temporal, width=52, height=4,
+        bg="#061260", fg=WHITE, font=("Verdana", 8),
+        selectbackground=BASE_COLORS["cyan"], selectforeground=DARK,
+        relief="flat", bd=2
+    )
+    epoch_listbox.grid(row=7, column=0, columnspan=2, padx=6, pady=(0, 6), sticky="ew")
+
+    def update_epoch_listbox():
+        epoch_listbox.delete(0, tk.END)
+        for i, ep in enumerate(epochs, 1):
+            epoch_listbox.insert(
+                tk.END,
+                f"{i}. {ep.name} | {ep.start_date.strftime('%Y-%m-%d')} - "
+                f"{ep.end_date.strftime('%Y-%m-%d')} | "
+                f"{ep.rep_years} rep.yrs | {ep.rep_months} rep.months | {ep.rep_days} rep.days"
+            )
+
+    def remove_epoch():
+        sel = epoch_listbox.curselection()
+        if not sel:
+            messagebox.showwarning("Aviso", "Seleccione una época para eliminar.")
+            return
+        idx = sel[0]
+        epochs.pop(idx)
+        update_epoch_listbox()
+        suggest_epoch_name()
+        if epochs:
+            next_date = epochs[-1].end_date + timedelta(days=1)
+            cal_inicio.set_date(next_date)
+            cal_final.set_date(next_date)
+        else:
+            global_scenario_combo.config(state="readonly")
+            _update_global_lock_label(locked=False)
+            cal_inicio.set_date("2025-01-01")
+            cal_final.set_date(suggested_end_date(cal_inicio.get_date(), int(years_var.get())))
+
+    btns_epoch = tk.Frame(frame_temporal, bg=SBG)
+    btns_epoch.grid(row=8, column=0, columnspan=2, pady=(4, 4))
+
+    add_epoch_btn = tk.Button(
+        btns_epoch, text="Add Epoch", command=add_epoch,
+        bg=ORANGE, fg=DARK, font=("Verdana", 9, "bold"),
+        relief="flat", padx=8, pady=4,
+        activebackground=BASE_COLORS["green"], activeforeground=DARK,
+        cursor="hand2"
+    )
+    add_epoch_btn.grid(row=0, column=0, padx=(0, 6))
+
+    remove_epoch_btn = tk.Button(
+        btns_epoch, text="Remove Selected", command=remove_epoch,
+        bg=BASE_COLORS["green"], fg=DARK, font=("Verdana", 8, "bold"),
+        relief="flat", padx=6, pady=3,
+        activebackground=BASE_COLORS["mint"], activeforeground=DARK,
+        cursor="hand2"
+    )
+    remove_epoch_btn.grid(row=0, column=1, padx=(6, 0))
+
+    frame_scenario = ttk.LabelFrame(mid_col, text="Configuracion de escenario",
+                                     style="Section.TLabelframe", padding=(12, 8))
+    frame_scenario.pack(fill="x", pady=(0, 10))
+
+    global_scenario_var = tk.StringVar(value=PRESET_NAMES[0])
+
+    lbl_global = tk.Label(frame_scenario, text="Global scenario:", bg=SBG, fg=CYAN,
+                           font=("Verdana", 9, "bold"))
+    lbl_global.grid(row=0, column=0, padx=(6, 8), pady=(6, 2), sticky="e")
+
+    global_scenario_combo = ttk.Combobox(
+        frame_scenario, textvariable=global_scenario_var,
+        values=ALL_GLOBAL_NAMES, state="readonly", width=32
+    )
+    global_scenario_combo.grid(row=0, column=1, padx=(0, 6), pady=(6, 2), sticky="w")
+
+    lbl_global_lock = tk.Label(frame_scenario, text="", bg=SBG, fg=BASE_COLORS["orange"],
+                                font=("Verdana", 7, "italic"))
+    lbl_global_lock.grid(row=1, column=0, columnspan=2, padx=(6, 6), pady=(0, 2), sticky="e")
+
+    def _update_global_lock_label(locked: bool):
+        if locked:
+            lbl_global_lock.config(text="⚠  Locked after first epoch – add scenario to queue or remove all epochs to change")
+        else:
+            lbl_global_lock.config(text="")
+
+    custom_scenario_name_var = tk.StringVar(value="")
+
+    lbl_custom_name = tk.Label(frame_scenario, text="Custom name:", bg=SBG, fg=ORANGE,
+                                font=("Verdana", 9, "italic"))
+    entry_custom_name = tk.Entry(frame_scenario, textvariable=custom_scenario_name_var,
+                                  bg=MINT, fg=DARK, font=("Verdana", 9), width=30,
+                                  relief="flat", bd=2)
+
+    sep = tk.Frame(frame_scenario, bg=BASE_COLORS["section_border"], height=1)
+    sep.grid(row=3, column=0, columnspan=2, sticky="ew", padx=6, pady=(4, 4))
+
+    demand_scenario = tk.StringVar()
+    hydrology_scenario = tk.StringVar()
+    climate_scenario = tk.StringVar()
+    generation_investment_cost_scenario = tk.StringVar()
+    storage_investment_cost_scenario = tk.StringVar()
+    fuel_price_scenario = tk.StringVar()
+
+    demand_combo = ttk.Combobox(frame_scenario, textvariable=demand_scenario,
+                                 values=scenario_names["demand"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Demand scenario", demand_combo, 4, SBG)
+
+    hydrology_combo = ttk.Combobox(frame_scenario, textvariable=hydrology_scenario,
+                                    values=scenario_names["hydrology"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Hydrology scenario", hydrology_combo, 5, SBG)
+
+    climate_combo = ttk.Combobox(frame_scenario, textvariable=climate_scenario,
+                                  values=scenario_names["climate"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Climate scenario", climate_combo, 6, SBG)
+
+    gen_cost_combo = ttk.Combobox(frame_scenario, textvariable=generation_investment_cost_scenario,
+                                   values=scenario_names["generation_investment_cost"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Generation investment cost", gen_cost_combo, 7, SBG)
+
+    sto_cost_combo = ttk.Combobox(frame_scenario, textvariable=storage_investment_cost_scenario,
+                                   values=scenario_names["storage_investment_cost"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Storage investment cost", sto_cost_combo, 8, SBG)
+
+    fuel_combo = ttk.Combobox(frame_scenario, textvariable=fuel_price_scenario,
+                               values=scenario_names["fuel_price"], state="disabled", width=28)
+    add_row_in(frame_scenario, "Fuel price scenario", fuel_combo, 9, SBG)
+
+    _component_combos = [demand_combo, hydrology_combo, climate_combo,
+                          gen_cost_combo, sto_cost_combo, fuel_combo]
+
+    def on_global_scenario_change(event=None):
+        sel = global_scenario_var.get()
+        if sel == 'Otro':
+            lbl_custom_name.grid(row=2, column=0, padx=(6, 8), pady=(2, 2), sticky="e")
+            entry_custom_name.grid(row=2, column=1, padx=(0, 6), pady=(2, 2), sticky="w")
+            for cb in _component_combos:
+                cb.config(state="readonly")
+        else:
+            lbl_custom_name.grid_remove()
+            entry_custom_name.grid_remove()
+            vals = scenario_map[sel]
+            demand_scenario.set(vals['demand'])
+            climate_scenario.set(vals['climate'])
+            hydrology_scenario.set(vals['hydrology'])
+            generation_investment_cost_scenario.set(vals['generation_investment_cost'])
+            storage_investment_cost_scenario.set(vals['storage_investment_cost'])
+            fuel_price_scenario.set(vals['fuel_price'])
+            for cb in _component_combos:
+                cb.config(state="disabled")
+
+    global_scenario_combo.bind("<<ComboboxSelected>>", on_global_scenario_change)
+
+    on_global_scenario_change()
+
+    frame_queue = ttk.LabelFrame(mid_col, text="Cola de escenarios a ejecutar",
+                                  style="Section.TLabelframe", padding=(12, 8))
+    frame_queue.pack(fill="x", pady=(0, 10))
+
+    lbl_scenarios_list = tk.Label(frame_queue, text="Queued scenarios:", bg=SBG, fg=CYAN,
+                                   font=("Verdana", 9, "bold"))
+    lbl_scenarios_list.grid(row=0, column=0, columnspan=2, padx=6, pady=(4, 2), sticky="w")
+
+    scenario_listbox = tk.Listbox(
+        frame_queue, width=52, height=4,
+        bg="#061260", fg=WHITE, font=("Verdana", 8),
+        selectbackground=BASE_COLORS["cyan"], selectforeground=DARK,
+        relief="flat", bd=2
+    )
+    scenario_listbox.grid(row=1, column=0, columnspan=2, padx=6, pady=(0, 6), sticky="ew")
+
+    def update_scenario_listbox():
+        scenario_listbox.delete(0, tk.END)
+        for i, sc in enumerate(scenarios, 1):
+            n_ep = len(sc["epochs"])
+            first = sc["epochs"][0]["start_date"]
+            last = sc["epochs"][-1]["end_date"]
+            scenario_listbox.insert(
+                tk.END,
+                f"{i}. {sc['global_scenario']} | {n_ep} epoch(s) | {first} - {last}"
+            )
+
+    def remove_scenario():
+        sel = scenario_listbox.curselection()
+        if not sel:
+            messagebox.showwarning("Aviso", "Seleccione un escenario para eliminar de la cola.")
+            return
+        scenarios.pop(sel[0])
+        update_scenario_listbox()
+
+    btns_queue = tk.Frame(frame_queue, bg=SBG)
+    btns_queue.grid(row=2, column=0, columnspan=2, pady=(4, 4))
+
+    add_scenario_btn = tk.Button(
+        btns_queue, text="Add scenario to queue", command=add_scenario_to_queue,
+        bg=ORANGE, fg=DARK, font=("Verdana", 9, "bold"),
+        relief="flat", padx=8, pady=4,
+        activebackground=BASE_COLORS["green"], activeforeground=DARK,
+        cursor="hand2"
+    )
+    add_scenario_btn.grid(row=0, column=0, padx=(0, 6))
+
+    remove_scenario_btn = tk.Button(
+        btns_queue, text="Remove Selected", command=remove_scenario,
+        bg=BASE_COLORS["green"], fg=DARK, font=("Verdana", 8, "bold"),
+        relief="flat", padx=6, pady=3,
+        activebackground=BASE_COLORS["mint"], activeforeground=DARK,
+        cursor="hand2"
+    )
+    remove_scenario_btn.grid(row=0, column=1, padx=(6, 0))
+
+    right_col = tk.Frame(inner, bg=color("fondo_principal"))
+    right_col.grid(row=1, column=2, padx=(10, 0), sticky="n")
+
+    frame_restricciones = ttk.LabelFrame(left_col, text="Restricciones adicionales",
+                                          style="Section.TLabelframe", padding=(14, 10))
+    frame_restricciones.pack(fill="x", pady=(0, 10))
+
+    def make_compact_constraint(parent, text, var, row, fields):
+        cb = tk.Checkbutton(
+            parent, text=text, variable=var,
+            bg=SBG, fg=WHITE, selectcolor=DARK,
+            activebackground=SBG, activeforeground=CYAN,
+            font=("Verdana", 10, "bold"), anchor="w",
+            wraplength=185, justify="left",
+        )
+        cb.grid(row=row, column=0, padx=(8, 8), pady=(10, 6), sticky="w")
+
+        fields_frame = tk.Frame(parent, bg=SBG)
+        fields_frame.grid(row=row, column=1, padx=(0, 8), pady=(10, 6), sticky="e")
+
+        vars_out = []
+        for i, (label, default) in enumerate(fields):
+            lbl = tk.Label(fields_frame, text=label, bg=SBG, fg=MINT, font=("Verdana", 9))
+            lbl.grid(row=i, column=0, padx=(0, 4), pady=2, sticky="e")
+            var_field = tk.StringVar(value=str(default))
+            ent = tk.Entry(fields_frame, textvariable=var_field, bg=MINT, fg=DARK,
+                           font=("Verdana", 9), width=9, relief="flat", bd=2)
+            ent.grid(row=i, column=1, padx=(0, 0), pady=2, sticky="w")
+            vars_out.append(var_field)
+        return vars_out
+
+    def make_separator(parent, row):
+        sep2 = tk.Frame(parent, bg=BASE_COLORS["section_border"], height=1)
+        sep2.grid(row=row, column=0, columnspan=2, sticky="ew", padx=8, pady=4)
+
+    frame_restricciones.grid_columnconfigure(0, weight=1)
+    frame_restricciones.grid_columnconfigure(1, weight=0)
+
+    r = 0
+    # Restriccion de emisiones maximas deshabilitada.
+    # cb_emissions = tk.BooleanVar(value=False)
+    # (entry_emissions,) = make_compact_constraint(
+    #     frame_restricciones,
+    #     "Maximum emissions [MtCO2/year]",
+    #     cb_emissions, r, [("MtCO2/year:", 30)]
+    # )
+    # r += 1
+    # make_separator(frame_restricciones, r); r += 1
+
+    cb_load_lost = tk.BooleanVar(value=False)
+    (entry_load_lost,) = make_compact_constraint(
+        frame_restricciones,
+        "Maximum load lost [MWh/year]",
+        cb_load_lost, r, [("MWh/year:", 2000)]
+    )
+    r += 1
+    make_separator(frame_restricciones, r); r += 1
+
+    cb_discrete_transmission = tk.BooleanVar(value=False)
+    cb_dt = tk.Checkbutton(
+        frame_restricciones,
+        text="Discrete transmission expansion",
+        variable=cb_discrete_transmission,
+        bg=SBG, fg=WHITE, selectcolor=DARK,
+        activebackground=SBG, activeforeground=CYAN,
+        font=("Verdana", 10, "bold"),
+        anchor="w", wraplength=185, justify="left",
+    )
+    cb_dt.grid(row=r, column=0, columnspan=2, padx=8, pady=(10, 6), sticky="w")
+
+    frame_optimizer = ttk.LabelFrame(left_col, text="Configuracion de optimizacion",
+                                      style="Section.TLabelframe", padding=(12, 8))
+    frame_optimizer.pack(fill="x", pady=(0, 10))
+
+    solver_name = tk.StringVar(value="highs")
+    solver_name_combo = ttk.Combobox(frame_optimizer, textvariable=solver_name,
+                                      values=["cbc", "highs", "gurobi", "cplex"],
+                                      state="readonly", width=12)
+    add_row_in(frame_optimizer, "Solver name", solver_name_combo, 0, SBG)
+
+    entry_threads = add_entry_row(frame_optimizer, "Threads",   os.cpu_count(), 1, width=8)
+    entry_mip_gap = add_entry_row(frame_optimizer, "MIP gap",   0.1,            2, width=8)
+
+    linearized_uc_var = tk.BooleanVar(value=True)
+    cb_lin_uc = tk.Checkbutton(
+        frame_optimizer, text="Linearized unit commitment",
+        variable=linearized_uc_var,
+        bg=SBG, fg=WHITE, selectcolor=DARK,
+        activebackground=SBG, activeforeground=CYAN,
+        font=("Verdana", 9), anchor="w",
+    )
+    cb_lin_uc.grid(row=3, column=0, columnspan=2, padx=(6, 6), pady=(4, 6), sticky="w")
+
+    frame_exec = ttk.LabelFrame(mid_col, text="Configuracion de ejecucion",
+                                 style="Section.TLabelframe", padding=(12, 8))
+    frame_exec.pack(fill="x", pady=(0, 10))
+
+    execution_mode_var = tk.StringVar(value="Secuencial")
+    execution_mode_combo = ttk.Combobox(frame_exec, textvariable=execution_mode_var,
+                                         values=["Secuencial", "Paralelo"],
+                                         state="readonly", width=12)
+    add_row_in(frame_exec, "Execution mode", execution_mode_combo, 0, SBG)
+
+    entry_max_workers = add_entry_row(frame_exec, "Max parallel scenarios", 2, 1, width=8)
+    entry_ram_limit   = add_entry_row(frame_exec, "RAM limit [% of total]", 85, 2, width=8)
+
+    lbl_exec_note = tk.Label(
+        frame_exec,
+        text=("Paralelo: cada escenario corre en un proceso propio y los CSVs\n"
+              "se fusionan en orden al final. El siguiente escenario no se lanza\n"
+              "si la RAM supera el límite. Ajuste Threads del solver para no\n"
+              "sobresuscribir la CPU (ej: nucleos / escenarios simultaneos)."),
+        bg=SBG, fg=MINT, font=("Verdana", 7, "italic"), justify="left",
+    )
+    lbl_exec_note.grid(row=3, column=0, columnspan=2, padx=6, pady=(4, 2), sticky="w")
+
+    confirm_btn = tk.Button(
+        mid_col,
+        text="Run all scenarios",
+        command=confirmar,
+        bg=ORANGE, fg=DARK,
+        font=("Verdana", 10, "bold"),
+        relief="flat", bd=0,
+        padx=20, pady=10,
+        activebackground=BASE_COLORS["green"],
+        activeforeground=DARK,
+        cursor="hand2",
+        width=30
+    )
+    confirm_btn.pack(fill="x", pady=(10, 0))
+
+    _net_path = os.path.join(_data_dir, "sen_network.png")
+    if not os.path.exists(_net_path):
+        _net_path = os.path.join(_src_dir, "sen_network.png")
+    if os.path.exists(_net_path):
+        try:
+            _net_raw = Image.open(_net_path).convert("RGBA").rotate(-90, expand=True)
+            _net_h = 650
+            _net_w = int(_net_h * _net_raw.width / _net_raw.height)
+            _net_res = _net_raw.resize((_net_w, _net_h), Image.LANCZOS)
+            net_photo = ImageTk.PhotoImage(_net_res)
+            net_label = tk.Label(right_col, image=net_photo, bg=color("fondo_principal"))
+            net_label.image = net_photo
+            net_label.pack(fill="both", expand=True)
+        except Exception as e:
+            print(f"No se pudo cargar el mapa del SEN: {e}")
+
+    root.after(0, lambda: root.state("zoomed"))
+    root.mainloop()
+    return result
+
+if __name__ == "__main__":
+    r = run_gui()
+    print(r)