[FEAT] Expand Other-method variants in LP, fix scenario load widget sync and resource balance display

tabs/tab4_optimization.py

@@ -13,8 +13,9 @@ import plotly.express as px
 from config.config import CRRA_COLORS, PLOTLY_COLOR_SEQUENCE, PLOTLY_HEATMAP_SCALE, resource_order, resource_unit_map, resource_groups, secondary_resources, CO2_UNIT
 from optimization.optimization import run_optimization
 from utils.ui_helpers import apply_chart_style, register_chart_data, show_bar
-from utils.data_utils import is_valid_scenario, is_complete_scenario, load_inputs_from_excel, neutralize_zero_coefficient_methods, strip_unit_suffix, get_resource_to_group, get_resource_to_unit
-
+from utils.data_utils import is_valid_scenario, is_complete_scenario, load_inputs_from_excel, neutralize_zero_coefficient_methods, strip_unit_suffix, get_resource_to_group, get_resource_to_unit, is_other_method, get_other_method_variants, make_variant_name
+from config.config import hidden_resource_names as _hidden
+from tabs.tab2_constraints import default_constraint as _dc
 
 def to_json_safe(obj):
     """Recursively convert numpy/pandas types to plain Python so json.dumps works."""
@@ -84,7 +85,18 @@ def panel_load_from_excel():
             st.session_state.costs = costs
             st.session_state.custom_resources = custom_resources
             st.session_state.enabled_methods = enabled_methods
+            st.session_state.auto_disabled_methods = set()
             clear_widget_keys()
+            for _m, _c in constraints.items():
+                st.session_state[f"toggle_{_m}"] = bool(_c.get("active", True))
+                if _c.get("active", True):
+                    st.session_state[f"cap_type_{_m}"] = _c.get("cap_type", "percent")
+                    if _c.get("cap_type", "percent") == "percent":
+                        st.session_state[f"slider_{_m}"] = int(_c.get("cap_value", 100))
+                    else:
+                        st.session_state[f"manual_{_m}"] = float(_c.get("cap_value", 0.0))
+            # Signal tab2 to force-refresh all widget keys on next visit.
+            st.session_state["constraints_just_loaded"] = True
             st.session_state.pop("latest_result", None)
             st.session_state.pop("scenario_loaded_file", None)
             st.session_state.pop("scenario_name_suggestion", None)
@@ -129,18 +141,23 @@ def parse_zip_scenario(uploaded) -> dict | None:
 
             # Compatibility with older files that used `max_share`
             if "cap_type (percent or absolute)" in df_c.columns:
-                constraints = {
-                    m: {
-                        "active": bool(row["active"]),
-                        "cap_type": str(row["cap_type (percent or absolute)"]),
-                        "cap_value": float(row["cap_value"])
+                _VALID_CAP_TYPES = {"percent", "absolute"}
+                constraints = {}
+                for m, row in df_c.iterrows():
+                    raw_ct = str(row["cap_type (percent or absolute)"])
+                    raw_active = row["active"]
+                    constraints[m] = {
+                        "active": raw_active is True or str(raw_active).strip().lower() == "true",
+                        # Store the raw value even if invalid so the UI can display
+                        # a warning and let the user correct it without re-importing.
+                        "cap_type": raw_ct if raw_ct in _VALID_CAP_TYPES else raw_ct,
+                        "cap_value": float(row["cap_value"]),
+                        "_cap_type_invalid": raw_ct not in _VALID_CAP_TYPES,
                     }
-                    for m, row in df_c.iterrows()
-                }
             else:
                 constraints = {
                     m: {
-                        "active": bool(row["active"]),
+                        "active": row["active"] is True or str(row["active"]).strip().lower() == "true",
                         "cap_type": "percent",
                         "cap_value": float(row["max_share"])
                     }
@@ -218,8 +235,9 @@ def parse_zip_scenario(uploaded) -> dict | None:
 
             if neutralized:
                 st.info(
-                    f"ℹ️ {len(neutralized)} méthode(s) désactivée(s) automatiquement (aucune ressource active) : "
-                    + ", ".join(neutralized)
+                    f"{len(neutralized)} method(s) automatically deactivated (no active resource): "
+                    + ", ".join(neutralized),
+                    icon=":material/info:",
                 )
 
             if success:
@@ -319,7 +337,20 @@ def panel_load_from_json_or_csv():
         # Restore custom resource batches if present in the scenario
         st.session_state.custom_resources = data.get("custom_resources", [])
         st.session_state.enabled_methods = data.get("enabled_methods", {})
+        # Reset auto_disabled_methods so tab1's re-enable logic starts from a
+        # clean slate matching the loaded scenario (avoids stale entries that
+        # would prevent or incorrectly trigger re-enable on the next tab1 visit).
+        st.session_state.auto_disabled_methods = set()
         clear_widget_keys()
+        for _m, _c in st.session_state.constraints.items():
+            st.session_state[f"toggle_{_m}"] = bool(_c.get("active", True))
+            if _c.get("active", True):
+                st.session_state[f"cap_type_{_m}"] = _c.get("cap_type", "percent")
+                if _c.get("cap_type", "percent") == "percent":
+                    st.session_state[f"slider_{_m}"] = int(_c.get("cap_value", 100))
+                else:
+                    st.session_state[f"manual_{_m}"] = float(_c.get("cap_value", 0.0))
+        st.session_state["constraints_just_loaded"] = True
         st.session_state["scenario_loaded_file"] = uploaded_json.name
         st.session_state["scenario_name"] = filename_stem
         st.session_state["latest_result"] = data
@@ -338,7 +369,7 @@ def clear_widget_keys():
     Returns:
         None
     """
-    prefixes = ("slider_", "manual_", "toggle_")
+    prefixes = ("toggle_", "cap_type_", "slider_", "manual_")
     for k in [k for k in st.session_state if k.startswith(prefixes)]:
         del st.session_state[k]
 
@@ -385,20 +416,75 @@ def run_and_store_result():
             if method_name in applied_costs and applied_costs[method_name].get(batch_name, 0.0) == 0.0:
                 applied_costs[method_name][batch_name] = coefficients.get("median", 0.0)
 
-    safe_constraints = neutralize_zero_coefficient_methods(
-        applied_costs, st.session_state.constraints
-    )
+    # Only neutralize standard methods (those present in applied_costs).
+    # Variant names from previous runs may exist in st.session_state.constraints
+    # but are not in applied_costs yet — passing them would cause false positives
+    # (empty cost dict → all_zero → auto-deactivated before expansion runs).
+    standard_constraints = {
+        m: c for m, c in st.session_state.constraints.items()
+        if m in applied_costs
+    }
+    safe_constraints = neutralize_zero_coefficient_methods(applied_costs, standard_constraints)
     neutralized = [
         m for m in safe_constraints
         if safe_constraints[m].get("active") is False
         and st.session_state.constraints.get(m, {}).get("active") is True
     ]
 
+    # Expand "Other" methods: replace each with one variant per assigned batch.
+    # Each variant uses the batch as its primary resource (standard LP constraint)
+    # instead of the z-variable substitution mechanism.
+    resource_caps_for_lp = dict(st.session_state.resource_caps)
+    custom_resources_for_lp = []
+    expanded_batch_names: set[str] = set()
+
+    for m in list(applied_costs.keys()):
+        if not is_other_method(m):
+            continue
+        batches_for_m = get_other_method_variants(m, custom_resources)
+        if not batches_for_m:
+            continue
+        # All batch names for this "Other" method — must be excluded from each
+        # variant's base costs so variants don't inherit each other's batches.
+        all_batch_names_for_m = {b["name"] for b in batches_for_m}
+
+        for batch in batches_for_m:
+            vname = make_variant_name(m, batch["name"])
+            # Inherit only non-hidden, non-batch secondary resources from the
+            # original method, then add THIS batch as the sole primary resource.
+            variant_costs = {
+                r: coeff for r, coeff in applied_costs[m].items()
+                if r not in _hidden and r not in all_batch_names_for_m
+            }
+            variant_costs[batch["name"]] = applied_costs[m].get(
+                batch["name"],
+                batch["methods"][m]["median"],
+            )
+            applied_costs[vname] = variant_costs
+            # Variant constraint: prefer an explicit user-set value, else default.
+            safe_constraints[vname] = (
+                st.session_state.constraints.get(vname) or _dc()
+            )
+            # Batch becomes a standard capped resource for the LP.
+            resource_caps_for_lp[batch["name"]] = float(batch["amount"])
+            expanded_batch_names.add(batch["name"])
+        # Remove the original "Other" method — replaced by variants.
+        del applied_costs[m]
+        del safe_constraints[m]
+
+    # LP receives only non-expanded batches.  Expanded batches are now standard
+    # resources (in resource_caps_for_lp) so they get a type-A constraint — if
+    # they stayed in custom_resources they'd land in custom_batch_names, be
+    # excluded from standard_resources, and generate no constraint → unbounded LP.
+    custom_resources_for_lp = [b for b in custom_resources if b["name"] not in expanded_batch_names]
+    # Display functions keep the full list so group/unit info is available.
+    custom_resources_for_display = list(custom_resources)
+
     success, result = run_optimization(
-        resource_caps=st.session_state.resource_caps,
+        resource_caps=resource_caps_for_lp,
         method_constraints=safe_constraints,
-        method_costs=st.session_state.costs,
-        custom_resources=custom_resources,
+        method_costs=applied_costs,
+        custom_resources=custom_resources_for_lp,
         enabled_methods=enabled_methods,
     )
 
@@ -410,8 +496,9 @@ def run_and_store_result():
     
     if neutralized:
         st.info(
-            f"ℹ️ {len(neutralized)} méthode(s) désactivée(s) automatiquement (aucune ressource active) : "
-            + ", ".join(neutralized)
+            f"{len(neutralized)} method(s) automatically deactivated (no active resource): "
+            + ", ".join(neutralized),
+            icon=":material/info:",
         )
 
     allocations = result["method_usage"]
@@ -422,7 +509,7 @@ def run_and_store_result():
         return
 
     total_cost = sum(
-        allocations[m] * sum(st.session_state.costs[m].values())
+        allocations[m] * sum(applied_costs.get(m, st.session_state.costs.get(m, {})).values())
         for m in allocations
     )
     st.session_state.latest_result = {
@@ -432,14 +519,41 @@ def run_and_store_result():
         "resource_used_total": result["resource_used_total"],
         "resource_remaining": result["resource_remaining"],
         "resource_actual_gain": result.get("resource_actual_gain", {}),
-        "resource_caps": st.session_state.resource_caps.copy(),
-        "method_constraints": st.session_state.constraints,
-        "method_costs": st.session_state.costs,
-        "custom_resources": custom_resources,
+        "resource_caps": resource_caps_for_lp,
+        "method_constraints": safe_constraints,
+        "method_costs": applied_costs,
+        "custom_resources": custom_resources_for_display,
         "enabled_methods": enabled_methods,
     }
     if custom_resources:
         st.info(f"ℹ️ {len(custom_resources)} new resource(s) included in optimisation.")
+
+    # Warn when an active method has a primary resource whose coefficient is so
+    # small (< 1e-7) that it is effectively unconstrained — the LP will run the
+    # method freely regardless of how much of that resource is available.
+    _COEFF_WARN = 1e-7
+    near_zero_warnings = []
+    for m, qty in allocations.items():
+        if qty <= 0:
+            continue
+        for r, coeff in applied_costs.get(m, {}).items():
+            if (m, r) in secondary_resources:
+                continue
+            if r not in st.session_state.resource_caps:
+                continue
+            if 0 < coeff < _COEFF_WARN:
+                near_zero_warnings.append((m, r, coeff))
+    if near_zero_warnings:
+        lines = "\n".join(
+            f"- **{m}** \n {r}: coefficient = {coeff:.2e} (effectively 0 — resource not constraining)"
+            for m, r, coeff in near_zero_warnings
+        )
+        st.warning(
+            f"The following primary resources have near-zero coefficients and do **not** "
+            f"constrain the method: the method can run regardless of their availability:\n\n{lines}",
+            icon=":material/warning:",
+        )
+
     st.success(f"✅ {total_removed:,.4f} {CO2_UNIT} removed")
 
 
@@ -499,8 +613,10 @@ def build_results_df(allocations, method_constraints=None):
             
             if c.get("cap_type") == "absolute":
                 caps[m] = f"{c['cap_value']:,.2f} {CO2_UNIT}/yr"
-            else:
+            elif c.get("cap_type") == "percent":
                 caps[m] = f"{int(c.get('cap_value', 100))}% of potential"
+            else:
+                caps[m] = f"⚠️ Invalid type ({c.get('cap_type')!r}) — fix in Tab 2"
         df["Cap"] = pd.Series(caps)
     
     return df.sort_values(f"{CO2_UNIT} removed", ascending=False)
@@ -583,7 +699,7 @@ def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None,
         df_heat, color_continuous_scale=PLOTLY_HEATMAP_SCALE, text_auto=".1f",
         labels=dict(x="Resource", y="Method", color="% Used"),
     )
-    matrix_exact_fmt = [[f"{v:.4f}" for v in row] for row in matrix_exact]
+    matrix_exact_fmt = [[f"{v:.15f}".rstrip("0").rstrip(".") for v in row] for row in matrix_exact]
     fig.update_traces(
         customdata=matrix_exact_fmt,
         hovertemplate="<b>%{y}</b><br>%{x}<br>% of cap: %{z:.1f}%<br>Exact: %{customdata}<extra></extra>",
@@ -705,9 +821,15 @@ def show_resource_balance(latest):
     remaining = latest["resource_remaining"]
 
     resource_to_group = get_resource_to_group()
-        
+    # Custom batch names: their amounts come from resource_caps (expanded batches
+    # are also in resource_caps) but we display them via the custom_resources loop
+    # to retain group/unit info — skip them in the standard loop to avoid duplicates.
+    custom_names = {b["name"] for b in latest.get("custom_resources", [])}
+
     rows = []
     for r in resource_caps:
+        if r in custom_names:
+            continue  # handled in the custom_resources loop below
         group = resource_to_group.get(r)
         unit = resource_unit_map.get(group)
         cap = resource_caps[r]
@@ -718,22 +840,29 @@ def show_resource_balance(latest):
             "Resource": f"{r} ({unit})",
             "Available amount": cap,
             "Quantity used": used,
-            "Quantity remaining": remaining.get(r, cap),
-            "% used": round(used / cap * 100, 1) if cap > 0 else 0,
+            "Quantity remaining": max(0.0, cap - used),
+            "% used": (used / cap * 100) if cap > 0 else 0,
         })
 
     for batch in latest.get("custom_resources", []):
         r = batch["name"]
-        cap = float(batch["amount"])
+        # Use resource_caps for the cap (includes expanded batch amounts).
+        cap = resource_caps.get(r, float(batch.get("amount", 0)))
+        if cap <= 0:
+            continue
         used = used_total.get(r, 0.0)
+        resource_to_group_local = get_resource_to_group()
+        group_name = resource_to_group_local.get(batch.get("group", ""))
+        unit = resource_unit_map.get(group_name, "?")
         rows.append({
-            "Resource": r, "Available amount": cap, "Quantity used": used,
-            "Quantity remaining": remaining.get(r, cap),
-            "% used": round(used / cap * 100, 1) if cap > 0 else 0,
+            "Resource": f"{r} ({unit})",
+            "Available amount": cap,
+            "Quantity used": used,
+            "Quantity remaining": max(0.0, cap - used),
+            "% used": (used / cap * 100) if cap > 0 else 0,
         })
 
     df = pd.DataFrame(rows).sort_values("% used", ascending=False)
-
     fig = px.bar(
         df, x="Resource", y=["Quantity used", "Quantity remaining"], barmode="stack",
         color_discrete_map={"Quantity used": CRRA_COLORS["green"], "Quantity remaining": CRRA_COLORS["off_white"]},
@@ -779,8 +908,7 @@ def show_bottleneck_analysis(latest):
                 f"CDR gain for +1 unit ({CO2_UNIT})": round(gain, 4),
             })
         df_sp = pd.DataFrame(sp_rows)
-        with st.expander("📊 View / download resource sensitivity", expanded=True):
-            st.dataframe(df_sp, width='stretch', hide_index=True)
+        st.dataframe(df_sp, width='stretch', hide_index=True)
         register_chart_data("Resource sensitivity (CDR gain per +1 unit)", df_sp)
     else:
         st.info("No resources to analyse.")
@@ -812,15 +940,17 @@ def save_scenario(latest):
             placeholder="Enter a scenario name",
         )
     with col_btn:
-        if st.button("Save", width='stretch', 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.")
+        save_clicked = st.button("Save", width='stretch', icon=":material/save:")
+
+    if save_clicked:
+        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():
     """Render JSON and ZIP export download buttons for the currently saved scenario.
@@ -992,7 +1122,7 @@ def export_inputs_only():
     """
     resource_to_unit = get_resource_to_unit()
     st.markdown('<p class="crra-sub-heading">Export inputs</p>', unsafe_allow_html=True)
-    st.markdown('<p class="caption">Export only the resource capabilities, method constraints and coefficients — without results.</p>', unsafe_allow_html=True)
+    st.markdown('<p class="caption">Export only the resource capabilities, method constraints and coefficients without results.</p>', unsafe_allow_html=True)
 
     suggested = st.session_state.get("excel_loaded_file", "").rsplit(".", 1)[0]
     # Update when a new file is loaded
@@ -1002,86 +1132,75 @@ def export_inputs_only():
 
     resource_to_group = get_resource_to_group() 
 
-    col_text, col_btn = st.columns([3, 1])
-    with col_text:
-        st.text_input(
-            "File name",
-            label_visibility="collapsed",
-            key="input_file_name",
-            placeholder="Enter a file name",
-        )
-    with col_btn:
-        prepare = st.button("Prepare export", width='stretch', icon=":material/file_export:")
-
-    if prepare:
-        safe = st.session_state.get("input_file_name", "").strip() or suggested or "crra_inputs"
-
-        enabled_methods = st.session_state.get("enabled_methods", {})
-
-        def is_allowed(method, resource):
-            return enabled_methods.get(resource, {}).get(method, True)
-
-        wb = openpyxl.Workbook()
-        ws1 = wb.active
-        ws1.title = "resource_caps"
-        ws1.append(["Resource", "Unit", "Available Amount"])
-        for r, v in st.session_state.resource_caps.items():
-            ws1.append([r, resource_to_unit.get(r, ""), v])
-
-        ws2 = wb.create_sheet("constraints")
-        ws2.append(["method", "active", "cap_type (percent or absolute)", "cap_value"])
-        for m, c in st.session_state.constraints.items():
-            ws2.append([m, c.get("active", True), c.get("cap_type", "percent"), c.get("cap_value", 100)])
-
-        # Coefficients — a disabled (method, resource) pair is always exported
-        # as 0, regardless of whether the user ever opened it in tab3. This
-        # keeps the export consistent with what the optimizer actually uses.
-        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():
-                value = 0.0 if not is_allowed(m, r) else v
-                ws3.append([m, r, value, (m, r) in secondary_resources])
-
-        ws4 = wb.create_sheet("custom_resources")
-        ws4.append(["name", "group", "amount", "unit", "method", "min", "median", "max"])
-        for batch in st.session_state.get("custom_resources", []):
-            unit = resource_unit_map.get(resource_to_group.get(batch["group"]))
-            for method, c in batch["methods"].items():
-                ws4.append([
-                    batch["name"],
-                    batch["group"],
-                    batch["amount"],
-                    unit,
-                    method,
-                    c["min"],
-                    c["median"],
-                    c["max"],
-                ])
-
-        # Per-resource manual method allocation (objective 2) — which CDR
-        # methods are allowed to use each resource batch.
-        ws5 = wb.create_sheet("enabled_methods")
-        ws5.append(["resource", "method", "enabled"])
-        for r, methods in enabled_methods.items():
-            for m, ok in methods.items():
-                ws5.append([r, m, bool(ok)])
-
-        excel_buffer = io.BytesIO()
-        wb.save(excel_buffer)
-
-        st.session_state["_input_export_buf"] = excel_buffer.getvalue()
-        st.session_state["_input_export_name"] = safe
-
-    if "_input_export_buf" in st.session_state:
-        st.download_button(
-            f"Download **{st.session_state['_input_export_name']}.xlsx**",
-            data=st.session_state["_input_export_buf"],
-            file_name=f"{st.session_state['_input_export_name']}.xlsx",
-            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            width='stretch',
-            icon=":material/download:"
-        )
+    enabled_methods = st.session_state.get("enabled_methods", {})
+
+    def is_allowed(method, resource):
+        return enabled_methods.get(resource, {}).get(method, True)
+
+    wb = openpyxl.Workbook()
+    ws1 = wb.active
+    ws1.title = "resource_caps"
+    ws1.append(["Resource", "Unit", "Available Amount"])
+    for r, v in st.session_state.resource_caps.items():
+        ws1.append([r, resource_to_unit.get(r, ""), v])
+
+    ws2 = wb.create_sheet("constraints")
+    ws2.append(["method", "active", "cap_type (percent or absolute)", "cap_value"])
+    for m, c in st.session_state.constraints.items():
+        ws2.append([m, c.get("active", True), c.get("cap_type", "percent"), c.get("cap_value", 100)])
+
+    # Coefficients — a disabled (method, resource) pair is always exported
+    # as 0, regardless of whether the user ever opened it in tab3. This
+    # keeps the export consistent with what the optimizer actually uses.
+    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():
+            value = 0.0 if not is_allowed(m, r) else v
+            ws3.append([m, r, value, (m, r) in secondary_resources])
+
+    ws4 = wb.create_sheet("custom_resources")
+    ws4.append(["name", "group", "amount", "unit", "method", "min", "median", "max"])
+    for batch in st.session_state.get("custom_resources", []):
+        unit = resource_unit_map.get(resource_to_group.get(batch["group"]))
+        for method, c in batch["methods"].items():
+            ws4.append([
+                batch["name"],
+                batch["group"],
+                batch["amount"],
+                unit,
+                method,
+                c["min"],
+                c["median"],
+                c["max"],
+            ])
+
+    # Per-resource manual method allocation (objective 2) — which CDR
+    # methods are allowed to use each resource batch.
+    ws5 = wb.create_sheet("enabled_methods")
+    ws5.append(["resource", "method", "enabled"])
+    for r, methods in enabled_methods.items():
+        for m, ok in methods.items():
+            ws5.append([r, m, bool(ok)])
+
+    excel_buffer = io.BytesIO()
+    wb.save(excel_buffer)
+
+    st.text_input(
+        "File name",
+        label_visibility="collapsed",
+        key="input_file_name",
+        placeholder="Enter a file name",
+    )
+    safe = st.session_state.get("input_file_name", "").strip() or suggested or "crra_inputs"
+    st.download_button(
+        "Export excel",
+        data=excel_buffer.getvalue(),
+        file_name=f"{safe}.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        width='stretch',
+        icon=":material/download:",
+    )
 
 def export_all_charts():
     """Render a download widget for all chart data registered in this session.
@@ -1104,48 +1223,46 @@ def export_all_charts():
         st.info("No charts have been generated yet in this session.")
         return
 
-    col_name, col_fmt = st.columns([2, 1])
-    with col_name:
-        base_name = st.text_input(
-            "File name",
-            value="charts_data",
-            key="charts_export_name",
-            help="The extension (.xlsx or .zip) is added automatically.",
-        )
-    with col_fmt:
-        fmt = st.radio(
-            "Format", ["Excel (.xlsx, one sheet per chart)", "ZIP (one CSV per chart)"],
-            horizontal=True, key="chart_export_format",
-        )
+    base_name = st.text_input(
+        "File name",
+        value=None,
+        key="charts_export_name",
+        label_visibility="collapsed",
+        placeholder="File name",
+        help="The extension (.xlsx or .zip) is added automatically.",
+    )
 
-    safe_name = base_name.strip() or "charts_data"
+    safe_name = (base_name or "").strip() or "charts_data"
+
+    xlsx_buffer = io.BytesIO()
+    with pd.ExcelWriter(xlsx_buffer, engine="openpyxl") as writer:
+        for name, df in registry.items():
+            df.to_excel(writer, sheet_name=name[:31], index=False)
+
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w") as zf:
+        for name, df in registry.items():
+            safe_chart_name = name.replace(" ", "_").replace("/", "-").replace("(", "").replace(")", "")
+            zf.writestr(f"{safe_chart_name}.csv", df.to_csv(index=False))
 
-    if fmt.startswith("Excel"):
-        export_buffer = io.BytesIO()
-        with pd.ExcelWriter(export_buffer, engine="openpyxl") as writer:
-            for name, df in registry.items():
-                sheet_name = name[:31]  # limite Excel
-                df.to_excel(writer, sheet_name=sheet_name, index=False)
+    col_xlsx, col_zip = st.columns(2)
+    with col_xlsx:
         st.download_button(
-            f"Download {safe_name}.xlsx",
-            data=export_buffer.getvalue(),
+            "Export Excel",
+            data=xlsx_buffer.getvalue(),
             file_name=f"{safe_name}.xlsx",
             mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            icon=":material/download:"
+            width='stretch',
+            icon=":material/download:",
         )
-    else:
-        export_buffer = io.BytesIO()
-        with zipfile.ZipFile(export_buffer, "w") as zf:
-            for name, df in registry.items():
-                safe_chart_name = name.replace(" ", "_").replace("/", "-").replace("(", "").replace(")", "")
-                zf.writestr(f"{safe_chart_name}.csv", df.to_csv(index=False))
-
+    with col_zip:
         st.download_button(
-            f"Download {safe_name}.zip",
-            data=export_buffer.getvalue(),
+            "Export csv (ZIP)",
+            data=zip_buffer.getvalue(),
             file_name=f"{safe_name}.zip",
             mime="application/zip",
-            icon=":material/download:"
+            width='stretch',
+            icon=":material/download:",
         )
 
 def clear_all_data():
@@ -1274,6 +1391,7 @@ def render_tab():
                 unsafe_allow_html=True,
             )
             run_clicked = st.button("Run Optimization", icon=":material/play_arrow:", key="btn-run-optimization", type="primary")
+            run_msg_area = st.container()
             panel_run_from_tabs()
             panel_load_from_excel()
 
@@ -1285,7 +1403,8 @@ def render_tab():
             panel_load_from_json_or_csv()
 
         if run_clicked:
-            run_and_store_result()
+            with run_msg_area:
+                run_and_store_result()
 
     _no_results = '<p class="caption">Run the optimization first to see results here.</p>'