[FEAT] scenario & input management: Excel/JSON/ZIP(csv) import, save/export, multi-scenario comparison, clear all data

app.py

@@ -5,6 +5,7 @@ from tabs import (tab0_welcome, tab1_inputs, tab2_constraints,
                   tab3_coefficients, tab4_optimization, tab5_sensitivity,
                   tab6_scenarios)
 from utils.data_utils import load_slider_data
+from config.config import method_order, secondary_resources
 
 st.set_page_config("Carbon Portfolio Optimizer", layout="wide")
 st.title("Toolkit: CDR Portfolio Optimization")
@@ -26,9 +27,24 @@ with st.sidebar:
         orientation="vertical"
     )
 
-# Dispatch to appropriate tab
-cost_sliders = load_slider_data()
+# Initialize data to default values
+# Initialize constraints state
+if "constraints" not in st.session_state:
+    st.session_state.constraints = {}
+for m in method_order:
+    if m not in st.session_state.constraints:
+        st.session_state.constraints[m] = {"active": True, "max_share": 1.0}
 
+# Initialize cost_sliders
+cost_sliders = load_slider_data()
+if "costs" not in st.session_state or st.session_state.costs == {}:
+    st.session_state.costs = {
+        m: {
+            r: (0.0 if (m, r) in secondary_resources else cost_sliders[m][r]["median"])
+            for r in cost_sliders[m]
+        }
+        for m in cost_sliders
+    }
 
 if selected == "Welcome":
     tab0_welcome.render_tab()

data/generate_input_template.py

@@ -0,0 +1,50 @@
+import json
+import sys
+import pandas as pd
+import openpyxl
+from openpyxl.styles import Font
+
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from config.config import (resource_order, method_order)
+
+# Data
+with open("data/cost_sliders.json") as f:
+    cost_sliders = json.load(f)
+
+secondary_df = pd.read_csv("data/secondary_resources.csv")
+secondary_resources = set(zip(secondary_df["method"], secondary_df["resource"]))
+
+wb = openpyxl.Workbook()
+
+# resource_caps
+ws1 = wb.active
+ws1.title = "resource_caps"
+ws1.append(["Resource", "Available Amount"])
+ws1["A1"].font = Font(bold=True)
+ws1["B1"].font = Font(bold=True)
+for r in resource_order:
+    ws1.append([r, float("nan")])
+
+# constraints
+ws2 = wb.create_sheet("constraints")
+ws2.append(["method", "active", "max_share"])
+ws2["A1"].font = Font(bold=True)
+ws2["B1"].font = Font(bold=True)
+ws2["C1"].font = Font(bold=True)
+for m in method_order:
+    ws2.append([m, True, 1.0])
+
+ws3 = wb.create_sheet("coefficients")
+ws3.append(["method", "resource", "value", "secondary"])
+ws3["A1"].font = Font(bold=True)
+ws3["B1"].font = Font(bold=True)
+ws3["C1"].font = Font(bold=True)
+ws3["D1"].font = Font(bold=True)
+for m in method_order:
+    for r, conf in cost_sliders.get(m, {}).items():
+        is_secondary = (m, r) in secondary_resources
+        ws3.append([m, r, conf["median"], True if is_secondary else False])
+
+wb.save("data/inputs_template.xlsx")
+print("Template generated: data/inputs_template.xlsx")

tabs/tab1_inputs.py

@@ -42,41 +42,57 @@ def render_tab():
         st.markdown("Use the template below to fill in your resource availability values and import them directly into the tool.")
         with open("data/resource_template.xlsx", "rb") as f:
             st.download_button(
-                label="📥 Download Excel Template",
+                label="Download Excel Template",
                 data=f,
                 file_name="resource_template.xlsx",
                 use_container_width= True,
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                icon=":material/download:"
             )
     with col_upload:
-        uploaded_file = st.file_uploader("Upload your Excel file", type="xlsx")
-        if uploaded_file is not None:
+        uploaded_file = st.file_uploader(
+            "Upload your Excel file", type="xlsx",
+            key=f"resource_uploader_{st.session_state.get('resource_uploader_key', 0)}"
+        )
+        
+        if uploaded_file is not None and uploaded_file.name != st.session_state.get("resource_last_loaded_file"):
             try:
                 df = pd.read_excel(uploaded_file)
                 required_cols = {"Resource", "Available Amount"}
                 if not required_cols.issubset(df.columns):
                     raise ValueError(f"Missing columns: {required_cols - set(df.columns)}")
+                
+                # Reset tout à 0 avant d'appliquer le fichier
+                for r in st.session_state.resource_caps:
+                    st.session_state.resource_caps[r] = 0.0
+                    st.session_state[f"cap_{r}"] = 0.0
+
                 for _, row in df.iterrows():
                     r = row["Resource"]
                     val = row["Available Amount"]
                     if r not in st.session_state.resource_caps:
                         continue
-                    if pd.isna(val):
-                        continue
                     try:
-                        val = float(val)
+                        val = 0.0 if pd.isna(val) else float(val)
                     except (ValueError, TypeError):
-                        continue
-                    if val == 0:
-                        continue
+                        val = 0.0
                     st.session_state.resource_caps[r] = val
-                st.success(f"Resource values imported successfully.", icon="✅")
+                    st.session_state[f"cap_{r}"] = val
 
-                for r, v in st.session_state.resource_caps.items():
-                    st.session_state[f"cap_{r}"] = v
+                st.session_state["resource_last_loaded_file"] = uploaded_file.name
+                st.success("Resource values imported successfully.", icon="✅")
+                st.session_state.pop("excel_loaded_file", None)
+                st.session_state.pop("scenario_name_suggestion", None)
+                st.session_state.pop("scenario_loaded_file", None)
+                st.session_state.pop("input_file_name_suggestion", None)
+                st.session_state.pop("latest_result", None)
+                st.rerun()
 
             except Exception as e:
                 st.error(f"Error importing resource values: {e}")
+
+        elif st.session_state.get("resource_last_loaded_file"):
+            st.success(f"Loaded: **{st.session_state['resource_last_loaded_file']}**", icon="✅")
             
     col_reset, _ = st.columns([1, 5])
 

tabs/tab2_constraints.py

@@ -20,13 +20,6 @@ def render_tab():
     - Set each method's **max share** (as % of the total portfolio)
     """)
 
-    # Initialize constraints state
-    if "constraints" not in st.session_state:
-        st.session_state.constraints = {}
-    for m in method_order:
-        if m not in st.session_state.constraints:
-            st.session_state.constraints[m] = {"active": True, "max_share": 1.0}
-
     # UI controls
     with st.expander("⚙️ Manage methods (Open/Close)", expanded=False):
         st.subheader("Activate/deactivate methods and set max allocation")

tabs/tab3_coefficients.py

@@ -9,16 +9,6 @@ from utils.ui_helpers import format_efficiency_summary
 def render_tab(cost_sliders):
     st.header("Resource efficiency coefficients")
 
-    # === Initialization ===
-    if "costs" not in st.session_state or st.session_state.costs == {}:
-        st.session_state.costs = {
-            m: {
-                r: (0.0 if (m, r) in secondary_resources else cost_sliders[m][r]["median"])
-                for r in cost_sliders[m]
-            }
-            for m in cost_sliders
-        }
-
     # === Info ===
     st.info("""
     **Objective:**

tabs/tab4_optimization.py

@@ -2,255 +2,505 @@ import io
 import json
 import unicodedata
 import zipfile
+import openpyxl
 
 import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn as sns
 import streamlit as st
+import plotly.graph_objects as go
 
-from config.config import method_order, resource_order, resource_units
+from config.config import method_order, resource_order, resource_units, secondary_resources
 from optimization.optimization import run_optimization
 from utils.ui_helpers import format_results_summary
-from utils.data_utils import is_valid_scenario
+from utils.data_utils import is_valid_scenario, load_inputs_from_excel
 
 
-def render_tab():
-    st.header("Portfolio generation")
-    st.caption("Tab 4 - Seaborn fallback for vertical histograms")
-
-    st.info("""
-    **Objective:**
-    Run the optimization tool, explore results, and save scenarios for comparison or export.
-    """)
-
-    # Initialize necessary session state variables if they don't exist
-    if "resource_caps" not in st.session_state:
-        st.session_state.resource_caps = {}
-    if "constraints" not in st.session_state:
-        st.session_state.constraints = {}
-    if "costs" not in st.session_state:
-        st.session_state.costs = {}
-    if "scenarios" not in st.session_state:
-        st.session_state.scenarios = {}
-    
-    # Run optimization
-    st.markdown("### Run optimization")
-    col_run, col_load = st.columns(2)
-
-    with col_run:
-        st.markdown("**From current input values**")
-        run_clicked = st.button("▶️ Run Optimization", use_container_width=False)
-
-    with col_load:
-        st.markdown("**From a saved JSON scenario**")
-        uploaded_scenario = st.file_uploader("Upload a saved JSON scenario", type="json", key="scenario_loader")
-        if uploaded_scenario is not None:
-            try:
-                data = json.load(uploaded_scenario)
-                if is_valid_scenario(data):
-                    if st.button("↩️ Reload this scenario into all tabs", use_container_width=True):
-                        st.session_state.resource_caps = data["resource_caps"].copy()
-                        st.session_state.constraints = data["method_constraints"].copy()
-                        st.session_state.costs = data["method_costs"].copy()
-                        keys_to_delete = [k for k in st.session_state if any(
-                            k.startswith(prefix) for prefix in ["slider_", "manual_", "toggle_"]
-                        )]
-                        for k in keys_to_delete:
-                            del st.session_state[k]
-                        st.session_state.latest_result = data
-                        st.success("Scenario loaded. All tabs have been updated.")
-                        st.rerun()
-                else:
-                    st.error("Invalid scenario format.")
-            except Exception as e:
-                st.error(f"Error loading scenario: {e}")
-
-    # Vérifications et exécution — uniquement si Run Optimization cliqué
-    if run_clicked:
-        if sum(st.session_state.resource_caps.values()) <= 0:
-            st.warning("⚠️ All resources are currently set to 0. Please increase availability or load a saved scenario.")
-        else:
-            success, result = run_optimization(
-                resource_caps=st.session_state.resource_caps,
-                method_constraints=st.session_state.constraints,
-                method_costs=st.session_state.costs,
+# ─── Input panels ────────────────────────────────────────────────────────────
+
+def panel_run_from_tabs():
+    """Left sub-panel: run optimization from manually filled tabs."""
+    st.markdown("**Option 1 - From current tab values**")
+    st.caption("Set resource availability and method constraints in the tabs above, then run.")
+    st.divider() 
+
+
+def panel_load_from_excel():
+    """Left sub-panel: load inputs from an Excel file, then run."""
+    col_markdown, col_upload = st.columns([1, 1], vertical_alignment="center")
+
+    with col_markdown:
+        st.markdown("**Option 2 - From an Excel file**")
+
+    with col_upload:
+        with open("data/inputs_template.xlsx", "rb") as f:
+            st.download_button(
+                label="Download Excel Template",
+                data=f,
+                file_name="crra_input_template.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                use_container_width=True,
+                icon=":material/download:",
             )
-            if success:
-                allocations = result["method_usage"]
-                total_removed = result["total_removed"]
-                if total_removed <= 0:
-                    st.warning("❌ Optimization removed 0 tCO₂. Relax constraints or increase resources.")
-                else:
-                    total_cost = sum(
-                        allocations[m] * sum(st.session_state.costs[m].values())
-                        for m in allocations
-                    )
-                    st.session_state.latest_result = {
-                        "summary": {"total_co2_removed": total_removed, "total_cost": total_cost},
-                        "allocations": allocations,
-                        "resource_caps": st.session_state.resource_caps.copy(),
-                        "method_constraints": st.session_state.constraints,
-                        "method_costs": st.session_state.costs,
-                    }
-                    st.success(f"✅ Optimization successful: {total_removed:,.0f} tCO₂ removed")
-            else:
-                st.error("❌ Optimization failed")
-                if "message" in result:
-                    st.error(result["message"])
 
-    if "latest_result" not in st.session_state:
+    st.caption("Fill in the template with your values, then import and run.")
+
+    if "excel_loaded_file" in st.session_state:
+        st.success(f"Loaded: **{st.session_state['excel_loaded_file']}** - All tabs updated.", icon="✅")
+
+    uploaded = st.file_uploader("Upload inputs (.xlsx)", type=["xlsx"], key=f"inputs_loader_{st.session_state.excel_uploader_key}")
+
+    if uploaded is None:
         return
-    latest = st.session_state.latest_result
-    allocations = latest["allocations"]
-    resource_caps = latest["resource_caps"]
-    method_costs = latest["method_costs"]
 
-    if not allocations or sum(allocations.values()) == 0:
+    default_name = uploaded.name.rsplit(".", 1)[0]
+
+    if st.button("↩️ Load inputs into all tabs", use_container_width=True):
+        st.session_state.setdefault("input_file_name_suggestion", default_name)
+        try:
+            resource_caps, constraints, costs = load_inputs_from_excel(uploaded)
+            st.session_state.resource_caps = resource_caps
+            st.session_state.constraints = constraints
+            st.session_state.costs = costs
+            clear_widget_keys()
+            st.session_state.pop("latest_result", None)
+            st.session_state.pop("scenario_loaded_file", None)
+            st.session_state.pop("scenario_name_suggestion", None)
+            st.session_state.pop("resource_last_loaded_file", None)
+            st.session_state["excel_loaded_file"] = uploaded.name
+            st.session_state["input_file_name"] = default_name
+            st.session_state["scenario_uploader_key"] += 1 # force reload in scenario uploader
+            st.rerun()
+        except Exception as e:
+            st.error(f"Error loading file: {e}")
+
+def parse_zip_scenario(uploaded) -> dict | None:
+    """Reconstruct a scenario dict from a ZIP containing the 4 CSVs."""
+    try:
+        with zipfile.ZipFile(io.BytesIO(uploaded.read())) as zf:
+            names = zf.namelist()
+ 
+            def _read(fname):
+                return pd.read_csv(io.BytesIO(zf.read(fname)), index_col=0)
+ 
+            required = {"resource_caps.csv", "method_constraints.csv",
+                        "allocations.csv", "method_costs.csv"}
+            if not required.issubset(names):
+                return None
+ 
+            resource_caps = _read("resource_caps.csv")["Available Amount"].to_dict()
+ 
+            df_c = _read("method_constraints.csv")
+            constraints = {
+                m: {"active": bool(row["active"]), "max_share": float(row["max_share"])}
+                for m, row in df_c.iterrows()
+            }
+ 
+            df_costs = _read("method_costs.csv")  # index=method, columns=resources
+            costs = {m: row.dropna().to_dict() for m, row in df_costs.iterrows()}
+ 
+            allocations = _read("allocations.csv")["tCO₂ removed"].to_dict()
+            total = sum(allocations.values())
+ 
+            return {
+                "summary": {"total_co2_removed": total, "total_cost": 0},
+                "allocations": allocations,
+                "resource_caps": resource_caps,
+                "method_constraints": constraints,
+                "method_costs": costs,
+            }
+    except Exception:
+        return None
+
+def panel_load_from_json_or_csv():
+    """Right column: reload a full scenario from JSON or ZIP."""
+    st.caption("Accepts `.json` or `.zip` (CSV export)")
+ 
+    if "scenario_loaded_file" in st.session_state:
+        st.success(
+            f"Scenario **{st.session_state['scenario_loaded_file']}** loaded :\n\nAll tabs updated - Optimization results displayed.",
+            icon="✅"
+        )
+    uploaded_json = st.file_uploader(
+        "Upload scenario (.json or .zip)", type=["json", "zip"], key=f"scenario_loader_{st.session_state.scenario_uploader_key}"
+    )
+
+    if uploaded_json is None:
         return
+ 
+    if uploaded_json.name.endswith(".json"):
+        try:
+            data = json.load(uploaded_json)
+        except Exception as e:
+            st.error(f"Cannot read JSON: {e}")
+            return
+        if not is_valid_scenario(data):
+            st.error("Invalid scenario format.")
+            return
+    else:
+        data = parse_zip_scenario(uploaded_json)
+        if data is None:
+            st.error(
+                "Invalid ZIP. Expected: resource_caps.csv, method_constraints.csv, "
+                "method_costs.csv, allocations.csv"
+            )
+            return
+    
+    default_name = uploaded_json.name.rsplit(".", 1)[0]
+ 
+    if st.button("↩️ Reload scenario and run optimization", use_container_width=True):
+        st.session_state.setdefault("scenario_name_suggestion", default_name)
+        st.session_state.pop("latest_result", None)
+        st.session_state.pop("excel_loaded_file", None)
+        st.session_state.pop("input_file_name_suggestion", None)
+        st.session_state.pop("resource_last_loaded_file", None)
+        st.session_state.resource_caps = data["resource_caps"].copy()
+        st.session_state.constraints = data["method_constraints"].copy()
+        st.session_state.costs = data["method_costs"].copy()
+        clear_widget_keys()
+        st.session_state["scenario_loaded_file"] = uploaded_json.name
+        st.session_state["scenario_name"] = default_name
+        st.session_state["latest_result"] = data
+        st.session_state["excel_uploader_key"] += 1 # force reload in excel uploader
+        st.rerun()
 
-    # Metrics
+def clear_widget_keys():
+    prefixes = ("slider_", "manual_", "toggle_")
+    for k in [k for k in st.session_state if k.startswith(prefixes)]:
+        del st.session_state[k]
+
+
+# ─── Optimization execution ──────────────────────────────────────────────────
+
+def run_and_store_result():
+    if sum(st.session_state.resource_caps.values()) <= 0:
+        st.warning("⚠️ All resources are set to 0. Please set resource availability or load a scenario / input data.")
+        return
+
+    success, result = run_optimization(
+        resource_caps=st.session_state.resource_caps,
+        method_constraints=st.session_state.constraints,
+        method_costs=st.session_state.costs,
+    )
+
+    if not success:
+        st.error("❌ Optimization failed")
+        if "message" in result:
+            st.error(result["message"])
+        return
+
+    allocations = result["method_usage"]
+    total_removed = result["total_removed"]
+
+    if total_removed <= 0:
+        st.warning("❌ Optimization removed 0 tCO₂. Relax constraints or increase resources.")
+        return
+
+    total_cost = sum(
+        allocations[m] * sum(st.session_state.costs[m].values())
+        for m in allocations
+    )
+    st.session_state.latest_result = {
+        "summary": {"total_co2_removed": total_removed, "total_cost": total_cost},
+        "allocations": allocations,
+        "resource_caps": st.session_state.resource_caps.copy(),
+        "method_constraints": st.session_state.constraints,
+        "method_costs": st.session_state.costs,
+    }
+    st.success(f"✅ {total_removed:,.0f} tCO₂ removed")
+
+
+# ─── Results display ─────────────────────────────────────────────────────────
+
+def show_metrics(latest):
     col1, col2 = st.columns(2)
     col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} t")
-    col2.metric("Methods Used", len(allocations))
+    col2.metric("Methods Used", len(latest["allocations"]))
 
-    # Summary table
-    st.subheader("Optimization Summary")
-    df_result = pd.DataFrame.from_dict(allocations, orient="index", columns=["tCO₂ removed"])
-    df_result["tCO₂ removed"] = pd.to_numeric(df_result["tCO₂ removed"], errors="coerce")
-    total = df_result["tCO₂ removed"].sum()
+
+def build_results_df(allocations):
+    df = pd.DataFrame.from_dict(allocations, orient="index", columns=["tCO₂ removed"])
+    df["tCO₂ removed"] = pd.to_numeric(df["tCO₂ removed"], errors="coerce")
+    total = df["tCO₂ removed"].sum()
     if total > 0:
-        df_result["Share (%)"] = (df_result["tCO₂ removed"] / total * 100).round(2)
-    df_result = df_result.sort_values(by="tCO₂ removed", ascending=False)
-    st.table(format_results_summary(df_result))
+        df["Share (%)"] = (df["tCO₂ removed"] / total * 100).round(2)
+    return df.sort_values("tCO₂ removed", ascending=False)
 
-    # Donut chart
-    st.markdown("### Method allocation breakdown")
-    labels = df_result.index.tolist()
-    values = df_result["tCO₂ removed"].tolist()
 
-    import plotly.graph_objects as go
-    fig_donut = go.Figure(data=[go.Pie(
-        labels=labels,
-        values=values,
+def show_donut(df_result):
+    fig = go.Figure(data=[go.Pie(
+        labels=df_result.index.tolist(),
+        values=df_result["tCO₂ removed"].tolist(),
         hole=0.4,
         textinfo="label+percent",
         textposition="outside",
         marker=dict(line=dict(color="#000000", width=1)),
-        showlegend=False
+        showlegend=False,
     )])
-    fig_donut.update_layout(margin=dict(t=10, b=10))
-    st.plotly_chart(fig_donut, use_container_width=True)
+    fig.update_layout(margin=dict(t=10, b=10))
+    st.plotly_chart(fig, use_container_width=True)
 
-    # Heatmap
-    st.markdown("### Resource usage heatmap (% of cap)")
-    heatmap_matrix, heatmap_y = [], []
-    available_resources = [r for r in resource_order if resource_caps.get(r, 0) > 0]
 
+def show_heatmap(df_result, resource_caps, method_costs):
+    available = [r for r in resource_order if resource_caps.get(r, 0) > 0]
+    matrix, y_labels = [], []
     for method in df_result.index:
-        row = []
-        for r in available_resources:
-            usage = method_costs.get(method, {}).get(r, 0.0) * allocations.get(method, 0.0)
-            row.append((usage / resource_caps[r]) * 100 if resource_caps[r] > 0 else 0)
-        heatmap_matrix.append(row)
-        heatmap_y.append(method)
-
-    fig_heatmap = go.Figure(data=go.Heatmap(
-        z=heatmap_matrix,
-        x=available_resources,
-        y=heatmap_y,
+        row = [
+            (method_costs.get(method, {}).get(r, 0.0) * df_result.at[method, "tCO₂ removed"]
+             / resource_caps[r] * 100) if resource_caps[r] > 0 else 0
+            for r in available
+        ]
+        matrix.append(row)
+        y_labels.append(method)
+
+    fig = go.Figure(data=go.Heatmap(
+        z=matrix, x=available, y=y_labels,
         colorscale="Blues",
         hovertemplate="Method: %{y}<br>Resource: %{x}<br>% Used: %{z:.2f}%<extra></extra>",
     ))
-    fig_heatmap.update_layout(
+    fig.update_layout(
         title="Resource Usage vs. Cap",
-        xaxis_title="Resource",
-        yaxis_title="Method",
-        height=400,
+        xaxis_title="Resource", yaxis_title="Method", height=400,
     )
-    st.plotly_chart(fig_heatmap, use_container_width=True)
-
-    # Absolute usage (fallback with seaborn)
-    st.markdown("### Absolute resource usage by unit (Seaborn)")
-    df_abs = []
-    for m, co2_removed in allocations.items():
-        for unit, resources in resource_units.items():
-            for r in resources:
-                if r in method_costs.get(m, {}):
-                    used = method_costs[m][r] * co2_removed
-                    if used > 0:
-                        df_abs.append({
-                            "Method": m,
-                            "Resource": r,
-                            "Used": used,
-                            "Unit": unit
-                        })
-
-    if df_abs:
-        df_abs = pd.DataFrame(df_abs)
-        for unit in df_abs["Unit"].unique():
-            st.markdown(f"#### Resources in {unit}")
-            df_unit = df_abs[df_abs["Unit"] == unit]
-
-            fig, ax = plt.subplots(figsize=(8, 4 + 0.3 * df_unit["Resource"].nunique()))
-            sns.barplot(data=df_unit, x="Resource", y="Used", hue="Method", ax=ax)
-            ax.set_ylabel(f"Used ({unit})")
-            ax.set_xlabel("Resource")
-            ax.tick_params(axis='x', rotation=45)
-            ax.legend(title="Method", bbox_to_anchor=(1.05, 1), loc='upper left')
-            st.pyplot(fig)
-
-    # Save scenario
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def show_absolute_usage(allocations, method_costs):
+    rows = [
+        {"Method": m, "Resource": r, "Used": method_costs[m][r] * co2, "Unit": unit}
+        for m, co2 in allocations.items()
+        for unit, resources in resource_units.items()
+        for r in resources
+        if r in method_costs.get(m, {}) and method_costs[m][r] * co2 > 0
+    ]
+    if not rows:
+        return
+
+    df = pd.DataFrame(rows)
+    for unit in df["Unit"].unique():
+        st.markdown(f"#### Resources in {unit}")
+        df_unit = df[df["Unit"] == unit]
+        fig, ax = plt.subplots(figsize=(8, 4 + 0.3 * df_unit["Resource"].nunique()))
+        sns.barplot(data=df_unit, x="Resource", y="Used", hue="Method", ax=ax)
+        ax.set_ylabel(f"Used ({unit})")
+        ax.tick_params(axis="x", rotation=45)
+        ax.legend(title="Method", bbox_to_anchor=(1.05, 1), loc="upper left")
+        st.pyplot(fig)
+
+
+# ─── Save / export / reset ───────────────────────────────────────────────────────────
+
+def save_scenario(latest):
     st.markdown("### Save scenario")
-    st.text_input("Scenario name", key="scenario_name")
-
-    if st.button("Save Scenario"):
-        name = st.session_state.get("scenario_name", "").strip()
-        if not name:
-            st.warning("Please enter a name before saving.")
-        elif name in st.session_state.scenarios:
-            st.warning("Scenario name already exists.")
-        else:
-            st.session_state.scenarios[name] = latest
-            st.success(f"Scenario '{name}' saved.")
-
-    # Preview saved scenario
-    current_name = st.session_state.get("scenario_name", "").strip()
-    if current_name and current_name in st.session_state.scenarios:
-        scenario = st.session_state.scenarios[current_name]
-        st.markdown(f"#### Scenario: {current_name}")
-        df_saved = pd.DataFrame.from_dict(
-            scenario["allocations"], orient="index", columns=["tCO₂ removed"]
+    st.caption("Save the current scenario with inputs and outputs for comparison and/or export.")
+
+    suggested = st.session_state.get("scenario_loaded_file", "").rsplit(".", 1)[0]
+    current = st.session_state.get("scenario_name", "").strip()
+
+    col_name, col_btn = st.columns([3, 1])
+    with col_name:
+        st.text_input(
+            "Scenario name", key="scenario_name",
+            value=current or suggested,
+            label_visibility="collapsed",
+            placeholder="Enter a scenario name"
         )
-        df_saved["tCO₂ removed"] = pd.to_numeric(df_saved["tCO₂ removed"], errors="coerce")
-        total = df_saved["tCO₂ removed"].sum()
-        if total > 0:
-            df_saved["Share (%)"] = (df_saved["tCO₂ removed"] / total * 100).round(2)
-        df_saved = df_saved.sort_values(by="tCO₂ removed", ascending=False)
-        st.table(format_results_summary(df_saved))
+    with col_btn:
+        if st.button("Save", use_container_width=True, icon=":material/save:"):
+            name = st.session_state.get("scenario_name", "").strip()
+            if not name:
+                st.warning("Please enter a name.")
+            elif name in st.session_state.scenarios:
+                st.warning("Name already exists.")
+            else:
+                st.session_state.scenarios[name] = latest
+                st.success(f"Scenario '{name}' saved for comparison.")
+
+def export_scenario():
+    name = st.session_state.get("scenario_name", "").strip()
+    if not name or name not in st.session_state.scenarios:
+        return
 
-        # Export buttons
-        safe_name = unicodedata.normalize("NFKD", current_name).encode("ascii", "ignore").decode("ascii")
+    scenario = st.session_state.scenarios[name]
+    st.markdown(f"#### Scenario: {name}")
+    df_saved = build_results_df(scenario["allocations"])
+    st.table(format_results_summary(df_saved))
 
+    safe = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
+    col_json, col_csv = st.columns(2)
+
+    with col_json:
+        st.download_button(
+            "Export JSON", data=json.dumps(scenario, indent=2),
+            file_name=f"{safe}.json", mime="application/json",
+            use_container_width=True,
+            icon=":material/download:"
+        )
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        zf.writestr("resource_caps.csv",
+                    pd.DataFrame.from_dict(scenario["resource_caps"], orient="index",
+                                           columns=["Available Amount"]).to_csv())
+        zf.writestr("method_constraints.csv",
+                    pd.DataFrame.from_dict(scenario["method_constraints"], orient="index",
+                                           columns=["active", "max_share"]).to_csv())
+        zf.writestr("method_costs.csv",                                      # ← nouveau
+                    pd.DataFrame.from_dict(scenario["method_costs"], orient="index").to_csv())
+        zf.writestr("allocations.csv",
+                    pd.DataFrame.from_dict(scenario["allocations"], orient="index",
+                                           columns=["tCO₂ removed"]).to_csv())
+    with col_csv:
         st.download_button(
-            label="Export JSON",
-            data=json.dumps(scenario, indent=2),
-            file_name=f"{safe_name}_scenario.json",
-            mime="application/json"
+            "Export CSV (zip)", data=buf.getvalue(),
+            file_name=f"{safe}.zip", mime="application/zip",
+            use_container_width=True,
+            icon=":material/download:"
+        )
+
+def export_inputs_only():
+    st.markdown("### Export inputs")
+    st.caption("Export only the resource capabilities, method constraints and coefficients — without results.")
+
+    suggested = st.session_state.get("excel_loaded_file", "").rsplit(".", 1)[0]
+    
+    col_text, col_button = st.columns([3,1])
+    with col_text:
+        st.text_input(
+            "File name", label_visibility="collapsed", key="input_file_name",
+            value=suggested,
+            placeholder="Enter a file name",
         )
 
-        inputs_df = pd.DataFrame.from_dict(scenario["resource_caps"], orient="index", columns=["Available"])
-        constraints_df = pd.DataFrame.from_dict({m: v.get("resources", {}) for m, v in scenario["method_constraints"].items()}, orient="index").fillna(0)
-        allocations_df = pd.DataFrame.from_dict(scenario["allocations"], orient="index", columns=["tCO₂ removed"])
+    wb = openpyxl.Workbook()
+    ws1 = wb.active
+    ws1.title = "resource_caps"
+    ws1.append(["Resource", "Available Amount"])
+    for r, v in st.session_state.resource_caps.items():
+        ws1.append([r, v])
+
+    ws2 = wb.create_sheet("constraints")
+    ws2.append(["method", "active", "max_share"])
+    for m, c in st.session_state.constraints.items():
+        ws2.append([m, c.get("active", True), c.get("max_share", 1.0)])
 
-        csv_buffer = io.BytesIO()
-        with zipfile.ZipFile(csv_buffer, "w") as zipf:
-            zipf.writestr("resource_caps.csv", inputs_df.to_csv())
-            zipf.writestr("method_constraints.csv", constraints_df.to_csv())
-            zipf.writestr("allocations.csv", allocations_df.to_csv())
+    ws3 = wb.create_sheet("coefficients")
+    ws3.append(["method", "resource", "value", "secondary"])
+    for m, resources in st.session_state.costs.items():
+        for r, v in resources.items():
+            ws3.append([m, r, v, (m, r) in secondary_resources])
 
+    buf = io.BytesIO()
+    wb.save(buf)
+    buf.seek(0)
+
+    safe = st.session_state.get("input_file_name", "").strip() or suggested or "crra_inputs"
+    with col_button:        
         st.download_button(
-            label="Export CSV",
-            data=csv_buffer.getvalue(),
-            file_name=f"{safe_name}_scenario.zip",
-            mime="application/zip"
+            f"Export Excel",
+            data=buf,
+            file_name=f"{safe}.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            icon=":material/download:",
+            use_container_width=True
         )
+
+def clear_all_data():
+    for key in ["resource_caps", "constraints", "costs", "scenarios", 
+                "latest_result", "scenario_loaded_file", "scenario_name", 
+                "excel_loaded_file", "input_file_name", "resource_last_loaded_file", "resource_uploader_key"]:
+        st.session_state.pop(key, None)
+
+    for uploader_key in ["resource_uploader_key", "excel_uploader_key", "scenario_uploader_key"]:
+        st.session_state[uploader_key] = st.session_state.get(uploader_key, 0) + 1
+
+    clear_widget_keys()
+    st.success("All data cleared.")
+    st.rerun()
+
+@st.dialog("Confirm deletion")
+def confirm_clear_all():
+    st.error("This action will delete all data from the current scenario(s).", icon=":material/warning:")
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        if st.button("Yes, delete everything", type="primary", use_container_width=True, icon=":material/delete:"):
+            clear_all_data()
+            st.rerun()
+    with col2:
+        if st.button("Cancel",use_container_width=True):
+            st.rerun()
+
+def reset_scenario():
+    st.divider()
+    st.markdown("### Reset")
+    st.caption("Clear all current inputs, results and saved scenarios from the session.")
+    if st.button("Clear all data", key="reset_scenario", use_container_width=False, type="primary", icon=":material/delete:"):
+        confirm_clear_all()
+
+# ─── Main tab entry point ─────────────────────────────────────────────────────
+
+def render_tab():
+    st.header("Portfolio generation")
+    st.info(
+        "Run the optimization tool, explore results and save scenarios for comparison or export."
+    )
+
+    # Session state defaults
+    for key, default in [
+        ("resource_caps", {}), ("constraints", {}),
+        ("costs", {}), ("scenarios", {}),
+        ("excel_uploader_key", 0),
+        ("scenario_uploader_key", 0)
+    ]:
+        st.session_state.setdefault(key, default)
+
+    # ── Two-column input area ──────────────────────────────────────────────
+    st.markdown("### Run optimization")
+    col_inputs, col_scenario = st.columns(2, gap="large")
+
+    with col_inputs:
+        st.markdown("#### From inputs")
+        run_clicked = st.button("▶️ Run Optimization", use_container_width=True)
+        panel_run_from_tabs()
+        panel_load_from_excel()
+
+    with col_scenario:
+        st.markdown("#### From a saved scenario")
+        panel_load_from_json_or_csv()
+
+    # ── Execute if button pressed ──────────────────────────────────────────
+    if run_clicked:
+        run_and_store_result()
+
+    if "latest_result" not in st.session_state:
+        return
+
+    latest = st.session_state.latest_result
+    allocations = latest["allocations"]
+    resource_caps = latest["resource_caps"]
+    method_costs = latest["method_costs"]
+
+    if not allocations or sum(allocations.values()) == 0:
+        return
+
+    # ── Results ────────────────────────────────────────────────────────────
+    show_metrics(latest)
+    df_result = build_results_df(allocations)
+
+    st.subheader("Optimization Summary")
+    st.table(format_results_summary(df_result))
+
+    st.markdown("### Method allocation breakdown")
+    show_donut(df_result)
+
+    st.markdown("### Resource usage heatmap (% of cap)")
+    show_heatmap(df_result, resource_caps, method_costs)
+
+    st.markdown("### Absolute resource usage by unit")
+    show_absolute_usage(allocations, method_costs)
+
+    # ── Save & export & reset ───────────────────────────────────────────────────────
+    save_scenario(latest)
+    export_scenario()
+    export_inputs_only()
+    reset_scenario()

tabs/tab6_scenarios.py

@@ -5,125 +5,167 @@ import pandas as pd
 import seaborn as sns
 import streamlit as st
 from utils.data_utils import is_valid_scenario
+from tabs.tab4_optimization import parse_zip_scenario
 
-def render_tab():
-    st.header("Scenario Comparison")
 
-    # Load scenario from JSON
-    uploaded_file = st.file_uploader("Load scenario(s) from JSON", type="json")
-    if uploaded_file is not None:
-        try:
-            data = json.load(uploaded_file)
-            if isinstance(data, dict) and all(is_valid_scenario(s) for s in data.values()):
-                st.session_state.scenarios.update(data)
-                st.success("Scenarios loaded successfully.")
-            else:
-                st.error("Invalid file format.")
-        except Exception as e:
-            st.error(f"Error loading file: {e}")
-
-    if "scenarios" not in st.session_state:
-        st.session_state.scenarios = {}
-
-    if not st.session_state.scenarios:
-        st.info("No scenarios have been saved yet.")
-        return
+# ─── Load from file ───────────────────────────────────────────────────────────
 
-    # Select scenarios from current workspace
-    st.markdown("### Select Scenarios to Compare")
-    scenario_names = list(st.session_state.scenarios.keys())
-    selected = st.multiselect("Select scenarios", scenario_names, default=scenario_names)
+def panel_load_scenario():
+    st.markdown("### Load a scenario from file")
+    st.caption("Accepts `.json` or `.zip` (CSV export)")
 
-    if not selected:
-        st.warning("Please select at least one scenario to display the comparison.")
+    uploaded = st.file_uploader("Upload scenario", type=["json", "zip"], key="comparison_loader", accept_multiple_files=True)
+    if uploaded is None:
         return
+    for uploaded_file in uploaded:
+        if uploaded_file is not None:
+            try:
+                if uploaded_file.name.endswith(".json"):
+                    data = json.load(uploaded_file)
+                    if not is_valid_scenario(data):
+                        st.error(f"Invalid scenario format in {uploaded_file.name}.")
+                        continue
+                else:
+                    data = parse_zip_scenario(uploaded_file)
+                    if data is None:
+                        st.error(f"Invalid ZIP format in {uploaded_file.name}. Expected: resource_caps.csv, method_constraints.csv, method_costs.csv, allocations.csv")
+                        continue
+                st.session_state.scenarios[uploaded_file.name] = data
+            except Exception as e:
+                st.error(f"Error loading {uploaded_file.name}: {e}")
+
+# ─── Data preparation ─────────────────────────────────────────────────────────
+
+def _prepare_comparison_data(selected):
+    all_methods = sorted({
+        m for name in selected
+        for m in st.session_state.scenarios[name].get("allocations", {})
+    })
+    all_resources = sorted({
+        r for name in selected
+        for r in st.session_state.scenarios[name].get("resource_caps", {})
+    })
+
+    summary_rows, method_alloc_rows, resource_usage_rows = [], [], []
 
-    # Remove buttons
-    for name in selected:
-        col1, col2 = st.columns([10, 1])
-        with col1:
-            st.markdown(f"**{name}**")
-        with col2:
-            if st.button("❌", key=f"remove_{name}"):
-                st.session_state.scenarios.pop(name, None)
-                st.rerun()
-
-    # Prepare data
-    all_methods, all_resources = set(), set()
     for name in selected:
         scenario = st.session_state.scenarios[name]
-        all_methods.update(scenario.get("allocations", {}).keys())
-        all_resources.update(scenario.get("resource_caps", {}).keys())
-    all_methods, all_resources = sorted(all_methods), sorted(all_resources)
-
-    summary_rows, method_alloc_df, resource_usage_df = [], [], []
-    for name in selected:
-        data = st.session_state.scenarios[name]
-        allocations = data.get("allocations", {})
-        resource_caps = data.get("resource_caps", {})
-        constraints = data.get("method_constraints", {})
+        allocations = scenario.get("allocations", {})
+        method_costs = scenario.get("method_costs", {})  # ← fix: was using method_constraints
 
         row = {
             "Scenario": name,
-            "CO₂ Removed (t)": data.get("summary", {}).get("total_co2_removed", 0),
+            "CO₂ Removed (t)": scenario.get("summary", {}).get("total_co2_removed", 0),
         }
 
         for method in all_methods:
             val = allocations.get(method, 0)
             row[f"{method} (tCO₂)"] = val
-            method_alloc_df.append({"Scenario": name, "Method": method, "tCO₂": val})
+            method_alloc_rows.append({"Scenario": name, "Method": method, "tCO₂": val})
 
         for resource in all_resources:
             total_used = 0
             for method, tco2 in allocations.items():
-                coeffs = constraints.get(method, {}).get("resources", {})
-                if not isinstance(coeffs, dict):
-                    continue
-                unit_use = coeffs.get(resource, 0)
-                used = unit_use * tco2
+                used = method_costs.get(method, {}).get(resource, 0) * tco2
                 total_used += used
                 if used > 0:
-                    resource_usage_df.append({"Scenario": name, "Method": method, "Resource": resource, "Used": used})
+                    resource_usage_rows.append({
+                        "Scenario": name, "Method": method,
+                        "Resource": resource, "Used": used,
+                    })
             row[f"{resource} used"] = total_used
 
         summary_rows.append(row)
 
-    # Comparison table
-    df_summary = pd.DataFrame(summary_rows)
+    return (
+        pd.DataFrame(summary_rows),
+        pd.DataFrame(method_alloc_rows),
+        pd.DataFrame(resource_usage_rows),
+    )
+
+
+# ─── Charts ───────────────────────────────────────────────────────────────────
+
+def _show_method_allocations(df):
+    if df.empty:
+        return
+    st.subheader("Method Allocations")
+    fig, ax = plt.subplots(figsize=(10, 4))
+    sns.barplot(data=df, x="Method", y="tCO₂", hue="Scenario", ax=ax)
+    ax.set_xlabel("Method")
+    ax.set_ylabel("tCO₂")
+    plt.xticks(rotation=45, ha="right")
+    st.pyplot(fig)
+
+
+def _show_resource_usage(df):
+    if df.empty:
+        st.info("No resource usage data available (method_costs missing from scenarios?).")
+        return
+
+    st.subheader("Resource Use per Method")
+    for method in df["Method"].unique():
+        df_m = df[df["Method"] == method]
+        fig, ax = plt.subplots(figsize=(8, 3))
+        sns.barplot(data=df_m, x="Resource", y="Used", hue="Scenario", ax=ax)
+        ax.set_title(method)
+        ax.set_xlabel("Resource")
+        ax.set_ylabel("Used")
+        plt.xticks(rotation=45, ha="right")
+        st.pyplot(fig)
+
+    st.subheader("Total Resource Use per Scenario")
+    df_total = df.groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
+    fig, ax = plt.subplots(figsize=(10, 4))
+    sns.barplot(data=df_total, x="Scenario", y="Used", hue="Resource", ax=ax)
+    ax.set_xlabel("Scenario")
+    ax.set_ylabel("Total Used")
+    plt.xticks(rotation=45, ha="right")
+    st.pyplot(fig)
+
+
+# ─── Main tab entry point ─────────────────────────────────────────────────────
+
+def render_tab():
+    st.header("Scenario Comparison")
+
+    st.session_state.setdefault("scenarios", {})
+
+    panel_load_scenario()
+
+    if not st.session_state.scenarios:
+        st.info("No scenarios saved yet. Run an optimization in tab 4 or load a file above.")
+        return
+
+    # Select & manage scenarios
+    st.markdown("### Select Scenarios to Compare")
+    scenario_names = list(st.session_state.scenarios.keys())
+    selected = st.multiselect("Select scenarios", scenario_names, default=scenario_names)
+
+    for name in selected:
+        col1, col2 = st.columns([10, 1])
+        with col1:
+            st.markdown(f"**{name}**")
+        with col2:
+            if st.button("❌", key=f"remove_{name}"):
+                st.session_state.scenarios.pop(name, None)
+                st.rerun()
+
+    if not selected:
+        st.warning("Please select at least one scenario.")
+        return
+
+    # Comparison
+    df_summary, df_methods, df_resources = _prepare_comparison_data(selected)
+
     st.subheader("Summary Table")
     st.dataframe(df_summary.style.format(na_rep="-", thousands=","), use_container_width=True)
-    st.download_button("Download Comparison CSV", df_summary.to_csv(index=False).encode("utf-8"), "scenario_comparison.csv", "text/csv")
-
-    # Charts
-    if method_alloc_df:
-        st.subheader("Method Allocations")
-        df1 = pd.DataFrame(method_alloc_df)
-        fig1, ax1 = plt.subplots(figsize=(10, 4))
-        sns.barplot(data=df1, x="Method", y="tCO₂", hue="Scenario", ax=ax1)
-        ax1.set_xlabel("Method")
-        ax1.set_ylabel("tCO₂")
-        plt.xticks(rotation=45, ha="right")
-        st.pyplot(fig1)
-
-    if resource_usage_df:
-        st.subheader("Resource Use per Method")
-        df2 = pd.DataFrame(resource_usage_df)
-        methods = df2["Method"].unique()
-        for method in methods:
-            df_method = df2[df2["Method"] == method]
-            fig2, ax2 = plt.subplots(figsize=(8, 3))
-            sns.barplot(data=df_method, x="Resource", y="Used", hue="Scenario", ax=ax2)
-            ax2.set_title(method)
-            ax2.set_xlabel("Resource")
-            ax2.set_ylabel("Used")
-            plt.xticks(rotation=45, ha="right")
-            st.pyplot(fig2)
-
-        st.subheader("Total Resource Use per Scenario")
-        df_total = df2.groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
-        fig3, ax3 = plt.subplots(figsize=(10, 4))
-        sns.barplot(data=df_total, x="Scenario", y="Used", hue="Resource", ax=ax3)
-        ax3.set_xlabel("Scenario")
-        ax3.set_ylabel("Total Used")
-        plt.xticks(rotation=45, ha="right")
-        st.pyplot(fig3)
+    st.download_button(
+        "Export Comparison CSV",
+        df_summary.to_csv(index=False).encode("utf-8"),
+        "scenario_comparison.csv", "text/csv",
+        icon=":material/download:"
+    )
+
+    _show_method_allocations(df_methods)
+    _show_resource_usage(df_resources)

utils/data_utils.py

@@ -1,7 +1,10 @@
+import io
 import json
 import pandas as pd
 import streamlit as st
-
+import openpyxl
+from openpyxl.styles import PatternFill, Font
+from config.config import resource_order, method_order, secondary_resources
 
 @st.cache_data
 def load_slider_data():
@@ -42,4 +45,29 @@ def is_valid_scenario(scenario):
         and "method_costs" in scenario
         and "method_constraints" in scenario
         and "summary" in scenario
-    )
+    )
+
+def load_inputs_from_excel(file):
+    xl = pd.read_excel(file, sheet_name=None)
+
+    resource_caps = {}
+    if "resource_caps" in xl:
+        for _, row in xl["resource_caps"].iterrows():
+            resource_caps[row["Resource"]] = float(row["Available Amount"])
+
+    constraints = {}
+    if "constraints" in xl:
+        for _, row in xl["constraints"].iterrows():
+            constraints[row["method"]] = {
+                "active": bool(row["active"]),
+                "max_share": float(row["max_share"])
+            }
+
+    costs = {}
+    if "coefficients" in xl:
+        for _, row in xl["coefficients"].iterrows():
+            m, r, v = row["method"], row["resource"], float(row["value"])
+            costs.setdefault(m, {})[r] = v
+
+    return resource_caps, constraints, costs
+