Upload 47 files

.gitignore

@@ -0,0 +1,17 @@
+# Python and system files
+__pycache__/
+*.py[cod]
+*.DS_Store
+
+# Virtual environments
+.venv/
+env/
+.interface/
+
+# Streamlit & logs
+.streamlit/
+*.log
+
+# IDE & config
+.vscode/
+.env

config/config.py

@@ -38,6 +38,7 @@ resource_groups = {
     "Energy": ["Electrical energy (MWh/tCO2)", "Thermal energy unspecified grade (MWh/tCO2)", "Thermal energy low grade (MWh/tCO2)", "Thermal energy high grade (MWh/tCO2)"],
     "Water": ["Salt water (Liters/tCO2)", "Unspecified water (Liters/tCO2)"],
     "Shoreline": ["Shoreline (km/tCO2)"],
+    "Storage": ["Geologic storage (t/tCO2)"]
 }
 
 method_order = sum(method_groups.values(), [])
@@ -52,13 +53,14 @@ resource_unit_map = {
     "Minerals": "t",
     "Chemicals": "t",
     "Shoreline": "km",
-    "Water": "L"
+    "Water": "L",
+    "Storage": "t"
 }
 
 resource_units = {
     "ha/tCO2": ["Arable land (ha/tCO2)", "Non-arable land (ha/tCO2)", "Unspecified land (ha/tCO2)"],
     "MWh/tCO2": ["Electrical energy (MWh/tCO2)", "Thermal energy unspecified grade (MWh/tCO2)", "Thermal energy low grade (MWh/tCO2)", "Thermal energy high grade (MWh/tCO2)"],
-    "t/tCO2": ["Forest biomass (t/tCO2)", "Non-forest biomass (t/tCO2)", "Unspecified biomass (t/tCO2)", "Basalt mineral (t/tCO2)", "Olivine mineral (t/tCO2)", "Wollastonite mineral (t/tCO2)", "Unspecified mineral (t/tCO2)", "Unspecified chemical (t/tCO2)"],
+    "t/tCO2": ["Forest biomass (t/tCO2)", "Non-forest biomass (t/tCO2)", "Unspecified biomass (t/tCO2)", "Basalt mineral (t/tCO2)", "Olivine mineral (t/tCO2)", "Wollastonite mineral (t/tCO2)", "Unspecified mineral (t/tCO2)", "Unspecified chemical (t/tCO2)", "Geologic storage (t/tCO2)"],
     "km/tCO2": ["Shoreline (km/tCO2)"],
     "Liters/tCO2": ["Salt water (Liters/tCO2)", "Unspecified water (Liters/tCO2)"]
 }
@@ -70,7 +72,9 @@ resource_grouped = {
     "Minerals": ["Basalt mineral (t/tCO2)", "Olivine mineral (t/tCO2)", "Wollastonite mineral (t/tCO2)", "Unspecified mineral (t/tCO2)"],
     "Chemicals": ["Unspecified chemical (t/tCO2)"],
     "Shoreline": ["Shoreline (km/tCO2)"],
-    "Water": ["Salt water (Liters/tCO2)", "Unspecified water (Liters/tCO2)"]
+    "Water": ["Salt water (Liters/tCO2)", "Unspecified water (Liters/tCO2)"],
+    "Storage": ["Geologic storage (t/tCO2)"]
+    
 }
 
 # secondary resources

data/cost_sliders.json

@@ -33,6 +33,11 @@
       "min": 368182.0,
       "median": 565909.0,
       "max": 913636.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "BioCCS with combustion": {
@@ -65,6 +70,11 @@
       "min": 630.0,
       "median": 201625.2165,
       "max": 1296342.17
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Coastal revegetation (mangrove, seaweeds)": {
@@ -118,6 +128,11 @@
       "min": 1000.0,
       "median": 5000.0,
       "max": 27000.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Electrochemical OAE": {
@@ -169,6 +184,11 @@
       "min": 0.005,
       "median": 4700.0,
       "max": 50000.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Low-temp DACCS (solid-sorbent/liquid-solvent)": {
@@ -191,6 +211,11 @@
       "min": -2000.0,
       "median": 1008.17439,
       "max": 15000.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Mineral OAE / Ocean liming": {
@@ -245,6 +270,11 @@
       "min": 0.0,
       "median": 200.0,
       "max": 26714.00689
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Mineralization ex-situ": {
@@ -294,6 +324,11 @@
       "min": -146.0,
       "median": 427.0,
       "max": 1000.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Pasture management": {
@@ -330,6 +365,11 @@
       "min": 217391.304,
       "median": 6608695.652,
       "max": 13000000.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "Bio-char - Forest biomass": {
@@ -531,6 +571,11 @@
       "min": 630.0,
       "median": 201625.2165,
       "max": 1296342.17
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   },
   "BioCCS with anaerobic digestion/fermentation & growing biomass": {
@@ -543,6 +588,11 @@
       "min": 368182.0,
       "median": 565909.0,
       "max": 913636.0
+    },
+    "Geologic storage (t/tCO2)": {
+      "min": 1.0,
+      "median": 1.0,
+      "max": 1.0
     }
   }
 }

tabs/tab3_coefficients copy.py

@@ -0,0 +1,164 @@
+import pandas as pd
+import streamlit as st
+
+from config.config import (method_groups, method_order, resource_groups,
+                           resource_order, secondary_resources)
+from utils.ui_helpers import format_efficiency_summary
+
+
+def render_tab(cost_sliders):
+    # Initialize costs
+    if "costs" not in st.session_state:
+        st.session_state.costs = {}
+    for m in cost_sliders:
+        if m not in st.session_state.costs:
+            st.session_state.costs[m] = {}
+        for r in cost_sliders[m]:
+            if r not in st.session_state.costs[m]:
+                st.session_state.costs[m][r] = cost_sliders[m][r]["median"]
+
+    st.header("Resource efficiency coefficients")
+
+    st.info("""
+    **Objective:**
+
+    This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.
+
+    - Select a method using the dropdown
+    - Adjust the resource usage coefficients (e.g., land, energy) using sliders
+    - Optionally override the slider using a manual input (even outside bounds)
+    - Disable secondary resources (e.g., water, chemicals) if needed
+    - Reset a single method or all methods with the reset buttons
+    - View a summary table of coefficients used in the model
+    """)
+    st.info("""
+    **Information:**
+
+    Data used in this section is based on 
+    """)
+    st.warning("Blue cells in the table highlight coefficients modified from their **default median values**.")
+
+    # Combined dropdown for group + method
+    method_choices = []
+    method_lookup = {}
+    for group, methods in method_groups.items():
+        for method in methods:
+            label = f"{group} | {method}"
+            method_choices.append(label)
+            method_lookup[label] = method
+
+    selected_label = st.selectbox("Select a method:", method_choices)
+    method_selected = method_lookup[selected_label]
+
+    with st.expander(f"Manage resources for the {method_selected} method", expanded=True):
+        for group_name, rlist in resource_groups.items():
+            used = [r for r in rlist if r in cost_sliders[method_selected]]
+            if not used:
+                continue
+
+            st.markdown(f"### {group_name}")
+            for r in used:
+                conf = cost_sliders[method_selected][r]
+                default_val = conf["median"]
+                min_val = conf["min"]
+                max_val = conf["max"]
+                if min_val < 0.01:
+                    step = 0.0001
+                    fmt = "%.4f"
+                elif min_val < 1:
+                    step = 0.001
+                    fmt = "%.3f"
+                elif min_val < 100:
+                    step = 0.01
+                    fmt = "%.2f"
+                else:
+                    step = 1.0
+                    fmt = "%.0f"
+
+                slider_key = f"slider_{method_selected}_{r}".replace(" ", "_").lower()
+                manual_key = f"manual_{method_selected}_{r}".replace(" ", "_").lower()
+                toggle_key = f"toggle_{method_selected}_{r}".replace(" ", "_").lower()
+
+                is_secondary = (method_selected, r) in secondary_resources
+                if is_secondary and toggle_key not in st.session_state:
+                    st.session_state[toggle_key] = False
+
+                enabled = True
+                if is_secondary:
+                    enabled = st.checkbox(f"Use {r}", key=toggle_key)
+
+                if enabled:
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        slider_val = st.slider(
+                            label=r,
+                            min_value=min_val,
+                            max_value=max_val,
+                            value=st.session_state.costs[method_selected].get(r, default_val),
+                            step=step,
+                            format=fmt,
+                            key=slider_key
+                        )
+                    with col2:
+                        manual_val = st.number_input(
+                            label="",
+                            value=slider_val,
+                            key=manual_key,
+                            help="Manual override (optional, any value)"
+                        )
+
+                    # Manual overrides slider if changed
+                    final_val = manual_val if manual_val != slider_val else slider_val
+                    st.session_state.costs[method_selected][r] = final_val
+                else:
+                    st.session_state.costs[method_selected][r] = 0.0
+                    st.markdown("**DISABLED**")
+
+        # Reset buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("🔄 Reset selected method"):
+                for r in cost_sliders[method_selected]:
+                    default_val = cost_sliders[method_selected][r]["median"]
+                    st.session_state.costs[method_selected][r] = default_val
+
+                    # Clear UI state
+                    for suffix in ["slider", "manual", "toggle"]:
+                        key = f"{suffix}_{method_selected}_{r}".replace(" ", "_").lower()
+                        if key in st.session_state:
+                            del st.session_state[key]
+
+                st.success(f"{method_selected} reset to default values.")
+                st.rerun()
+
+        with col2:
+            if st.button("🔄 Reset all methods"):
+                for m in method_order:
+                    for r in cost_sliders.get(m, {}):
+                        default_val = cost_sliders[m][r]["median"]
+                        st.session_state.costs[m][r] = default_val
+
+                        for suffix in ["slider", "manual", "toggle"]:
+                            key = f"{suffix}_{m}_{r}".replace(" ", "_").lower()
+                            if key in st.session_state:
+                                del st.session_state[key]
+
+                st.success("All methods reset to default values.")
+                st.rerun()
+
+    # Summary table
+    st.subheader("Summary table: resource usage coefficients in the model")
+
+    df_default = pd.DataFrame(index=method_order, columns=resource_order)
+    df_current = pd.DataFrame(index=method_order, columns=resource_order)
+
+    for m in method_order:
+        for r in resource_order:
+            df_default.at[m, r] = cost_sliders.get(m, {}).get(r, {}).get("median", 0.0)
+            df_current.at[m, r] = st.session_state.costs.get(m, {}).get(r, 0.0)
+
+    df_default = df_default.astype(float)
+    df_current = df_current.astype(float)
+
+    styled = format_efficiency_summary(df_current, df_default)
+    st.table(styled)

tabs/tab3_coefficients.py

@@ -7,38 +7,31 @@ from utils.ui_helpers import format_efficiency_summary
 
 
 def render_tab(cost_sliders):
-    # Initialize costs
-    if "costs" not in st.session_state:
-        st.session_state.costs = {}
-    for m in cost_sliders:
-        if m not in st.session_state.costs:
-            st.session_state.costs[m] = {}
-        for r in cost_sliders[m]:
-            if r not in st.session_state.costs[m]:
-                st.session_state.costs[m][r] = cost_sliders[m][r]["median"]
-
     st.header("Resource efficiency coefficients")
 
+    # === Initialization ===
+    if "costs" not in st.session_state:
+        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:**
 
     This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.
 
-    - Select a method using the dropdown
-    - Adjust the resource usage coefficients (e.g., land, energy) using sliders
-    - Optionally override the slider using a manual input (even outside bounds)
-    - Disable secondary resources (e.g., water, chemicals) if needed
-    - Reset a single method or all methods with the reset buttons
-    - View a summary table of coefficients used in the model
-    """)
-    st.info("""
-    **Information:**
-
-    Data used in this section is based on 
+    - Primary resources are always active and initialized with default values.
+    - Secondary resources are initialized at zero and toggled off by default.
+    - Toggling on a secondary resource restores its default value.
     """)
     st.warning("Blue cells in the table highlight coefficients modified from their **default median values**.")
 
-    # Combined dropdown for group + method
+    # === Method selector ===
     method_choices = []
     method_lookup = {}
     for group, methods in method_groups.items():
@@ -50,6 +43,7 @@ def render_tab(cost_sliders):
     selected_label = st.selectbox("Select a method:", method_choices)
     method_selected = method_lookup[selected_label]
 
+    # === Resource sliders ===
     with st.expander(f"Manage resources for the {method_selected} method", expanded=True):
         for group_name, rlist in resource_groups.items():
             used = [r for r in rlist if r in cost_sliders[method_selected]]
@@ -62,6 +56,7 @@ def render_tab(cost_sliders):
                 default_val = conf["median"]
                 min_val = conf["min"]
                 max_val = conf["max"]
+
                 if min_val < 0.01:
                     step = 0.0001
                     fmt = "%.4f"
@@ -75,59 +70,58 @@ def render_tab(cost_sliders):
                     step = 1.0
                     fmt = "%.0f"
 
-                slider_key = f"slider_{method_selected}_{r}".replace(" ", "_").lower()
-                manual_key = f"manual_{method_selected}_{r}".replace(" ", "_").lower()
-                toggle_key = f"toggle_{method_selected}_{r}".replace(" ", "_").lower()
-
                 is_secondary = (method_selected, r) in secondary_resources
-                if is_secondary and toggle_key not in st.session_state:
-                    st.session_state[toggle_key] = False
+                toggle_key = f"toggle_{method_selected}_{r}".replace(" ", "_").lower()
 
-                enabled = True
                 if is_secondary:
+                    if toggle_key not in st.session_state:
+                        st.session_state[toggle_key] = st.session_state.costs[method_selected][r] != 0.0
                     enabled = st.checkbox(f"Use {r}", key=toggle_key)
 
-                if enabled:
-                    col1, col2 = st.columns([3, 1])
-                    with col1:
-                        slider_val = st.slider(
-                            label=r,
-                            min_value=min_val,
-                            max_value=max_val,
-                            value=st.session_state.costs[method_selected].get(r, default_val),
-                            step=step,
-                            format=fmt,
-                            key=slider_key
-                        )
-                    with col2:
-                        manual_val = st.number_input(
-                            label="",
-                            value=slider_val,
-                            key=manual_key,
-                            help="Manual override (optional, any value)"
-                        )
-
-                    # Manual overrides slider if changed
-                    final_val = manual_val if manual_val != slider_val else slider_val
-                    st.session_state.costs[method_selected][r] = final_val
-                else:
-                    st.session_state.costs[method_selected][r] = 0.0
-                    st.markdown("**DISABLED**")
+                    if not enabled:
+                        st.session_state.costs[method_selected][r] = 0.0
+                        st.markdown("**DISABLED**")
+                        continue
+                    elif st.session_state.costs[method_selected][r] == 0.0:
+                        st.session_state.costs[method_selected][r] = default_val
+
+                # Sliders and inputs
+                slider_key = f"slider_{method_selected}_{r}".replace(" ", "_").lower()
+                manual_key = f"manual_{method_selected}_{r}".replace(" ", "_").lower()
 
-        # Reset buttons
+                col1, col2 = st.columns([3, 1])
+                with col1:
+                    slider_val = st.slider(
+                        label=r,
+                        min_value=min_val,
+                        max_value=max_val,
+                        value=st.session_state.costs[method_selected][r],
+                        step=step,
+                        format=fmt,
+                        key=slider_key
+                    )
+                with col2:
+                    manual_val = st.number_input(
+                        label="",
+                        value=slider_val,
+                        key=manual_key,
+                        help="Manual override (optional, any value)"
+                    )
+
+                final_val = manual_val if manual_val != slider_val else slider_val
+                st.session_state.costs[method_selected][r] = final_val
+
+        # === Reset buttons ===
         col1, col2 = st.columns(2)
         with col1:
             if st.button("🔄 Reset selected method"):
                 for r in cost_sliders[method_selected]:
-                    default_val = cost_sliders[method_selected][r]["median"]
-                    st.session_state.costs[method_selected][r] = default_val
-
-                    # Clear UI state
+                    is_secondary = (method_selected, r) in secondary_resources
+                    st.session_state.costs[method_selected][r] = 0.0 if is_secondary else cost_sliders[method_selected][r]["median"]
                     for suffix in ["slider", "manual", "toggle"]:
                         key = f"{suffix}_{method_selected}_{r}".replace(" ", "_").lower()
                         if key in st.session_state:
                             del st.session_state[key]
-
                 st.success(f"{method_selected} reset to default values.")
                 st.rerun()
 
@@ -135,18 +129,16 @@ def render_tab(cost_sliders):
             if st.button("🔄 Reset all methods"):
                 for m in method_order:
                     for r in cost_sliders.get(m, {}):
-                        default_val = cost_sliders[m][r]["median"]
-                        st.session_state.costs[m][r] = default_val
-
+                        is_secondary = (m, r) in secondary_resources
+                        st.session_state.costs[m][r] = 0.0 if is_secondary else cost_sliders[m][r]["median"]
                         for suffix in ["slider", "manual", "toggle"]:
                             key = f"{suffix}_{m}_{r}".replace(" ", "_").lower()
                             if key in st.session_state:
                                 del st.session_state[key]
-
                 st.success("All methods reset to default values.")
                 st.rerun()
 
-    # Summary table
+    # === Summary table ===
     st.subheader("Summary table: resource usage coefficients in the model")
 
     df_default = pd.DataFrame(index=method_order, columns=resource_order)

tabs/tab4_optimization copy.py

@@ -0,0 +1,199 @@
+import io
+import json
+import zipfile
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import plotly.graph_objects as go
+import seaborn as sns
+import streamlit as st
+
+from config.config import method_order, resource_order, resource_units
+from optimization.optimization import run_optimization
+from utils.ui_helpers import format_results_summary
+
+
+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.
+    """)
+
+    if "constraints" not in st.session_state or "costs" not in st.session_state or "resource_caps" not in st.session_state:
+        st.error("Missing inputs. Please complete previous steps.")
+        return
+
+    if "scenarios" not in st.session_state:
+        st.session_state.scenarios = {}
+
+    if sum(st.session_state.resource_caps.values()) <= 0:
+        st.warning("\u26a0\ufe0f All resources are currently set to 0. Please increase availability.")
+        return
+
+    if st.button("Run Optimization"):
+        success, result = run_optimization(
+            resource_caps=st.session_state.resource_caps,
+            method_constraints=st.session_state.constraints,
+            method_costs=st.session_state.costs,
+        )
+
+        if success:
+            allocations = result["method_usage"]
+            total_removed = result["total_removed"]
+
+            if total_removed <= 0:
+                st.warning("\u274c 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"\u2705 Optimization successful: {total_removed:,.0f} tCO₂ removed")
+        else:
+            st.error("\u274c Optimization failed")
+            if "message" in result:
+                st.error(result["message"])
+
+    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
+
+    col1, col2 = st.columns(2)
+    col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} t")
+    col2.metric("Methods Used", len(allocations))
+
+    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()
+    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))
+
+    st.markdown("### Method allocation breakdown")
+    fig_donut = 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
+    )])
+    fig_donut.update_layout(margin=dict(t=10, b=10))
+    st.plotly_chart(fig_donut, use_container_width=True)
+
+    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]
+    for method in df_result.index:
+        row = [((method_costs.get(method, {}).get(r, 0.0) * allocations.get(method, 0.0)) / resource_caps[r]) * 100 if resource_caps[r] > 0 else 0 for r in available_resources]
+        heatmap_matrix.append(row)
+        heatmap_y.append(method)
+    fig_heatmap = go.Figure(data=go.Heatmap(
+        z=heatmap_matrix,
+        x=available_resources,
+        y=heatmap_y,
+        colorscale="Blues",
+        hovertemplate="Method: %{y}<br>Resource: %{x}<br>% Used: %{z:.2f}%<extra></extra>",
+    ))
+    fig_heatmap.update_layout(title="Resource Usage vs. Cap", xaxis_title="Resource", yaxis_title="Method", height=400)
+    st.plotly_chart(fig_heatmap, use_container_width=True)
+
+    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)
+
+    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.")
+
+    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"])
+        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))
+
+        # Export as JSON
+        json_data = json.dumps({current_name: scenario}, indent=2)
+        st.download_button("Download Scenario as JSON", data=json_data, file_name=f"{current_name}_scenario.json", mime="application/json")
+
+        # Export as CSV zip
+        df_alloc = pd.DataFrame.from_dict(scenario["allocations"], orient="index", columns=["tCO₂ removed"])
+        df_alloc.index.name = "Method"
+        df_alloc.reset_index(inplace=True)
+        df_caps = pd.DataFrame(list(scenario["resource_caps"].items()), columns=["Resource", "Cap"])
+        constraints_list = []
+        for method, values in scenario["method_constraints"].items():
+            entry = {"Method": method, "min_share": values.get("min_share", ""), "max_share": values.get("max_share", ""), "resources": values.get("resources", {})}
+            constraints_list.append(entry)
+        df_constraints = pd.json_normalize(constraints_list, sep=".").fillna("")
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr("allocations.csv", df_alloc.to_csv(index=False))
+            zf.writestr("resource_caps.csv", df_caps.to_csv(index=False))
+            zf.writestr("method_constraints.csv", df_constraints.to_csv(index=False))
+        st.download_button(
+            label="\ud83d\udcc5 Download Scenario as CSV (ZIP)",
+            data=zip_buffer.getvalue(),
+            file_name=f"{current_name}_scenario.zip",
+            mime="application/zip"
+        )

tabs/tab4_optimization.py

@@ -1,8 +1,11 @@
+import io
 import json
+import unicodedata
+import zipfile
 
+import matplotlib.pyplot as plt
 import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
+import seaborn as sns
 import streamlit as st
 
 from config.config import method_order, resource_order, resource_units
@@ -12,12 +15,14 @@ from utils.ui_helpers import format_results_summary
 
 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.
     """)
 
-    # Input check - ensure all required inputs are available
+    # Validate necessary inputs
     if "constraints" not in st.session_state or "costs" not in st.session_state or "resource_caps" not in st.session_state:
         st.error("Missing inputs. Please complete previous steps.")
         return
@@ -26,10 +31,10 @@ def render_tab():
         st.session_state.scenarios = {}
 
     if sum(st.session_state.resource_caps.values()) <= 0:
-        st.warning("⚠️ All resources are currently set to 0. Please increase availability.")
+        st.warning("\u26a0\ufe0f All resources are currently set to 0. Please increase availability.")
         return
 
-    # Optimization
+    # Run optimization
     if st.button("Run Optimization"):
         success, result = run_optimization(
             resource_caps=st.session_state.resource_caps,
@@ -42,7 +47,7 @@ def render_tab():
             total_removed = result["total_removed"]
 
             if total_removed <= 0:
-                st.warning("❌ Optimization removed 0 tCO₂. Relax constraints or increase resources.")
+                st.warning("\u274c Optimization removed 0 tCO₂. Relax constraints or increase resources.")
                 return
 
             total_cost = sum(
@@ -61,13 +66,12 @@ def render_tab():
                 "method_costs": st.session_state.costs,
             }
 
-            st.success(f"✅ Optimization successful: {total_removed:,.0f} tCO₂ removed")
+            st.success(f"\u2705 Optimization successful: {total_removed:,.0f} tCO₂ removed")
         else:
-            st.error("❌ Optimization failed")
+            st.error("\u274c Optimization failed")
             if "message" in result:
                 st.error(result["message"])
 
-    # --- Display Section ---
     if "latest_result" not in st.session_state:
         return
 
@@ -79,12 +83,12 @@ def render_tab():
     if not allocations or sum(allocations.values()) == 0:
         return
 
-    # --- Metrics ---
+    # Metrics
     col1, col2 = st.columns(2)
     col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} t")
     col2.metric("Methods Used", len(allocations))
 
-    # --- Summary Table ---
+    # 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")
@@ -94,25 +98,25 @@ def render_tab():
     df_result = df_result.sort_values(by="tCO₂ removed", ascending=False)
     st.table(format_results_summary(df_result))
 
-    # --- Donut Chart ---
+    # Donut chart
     st.markdown("### Method allocation breakdown")
-    fig_donut = px.pie(
-        df_result.reset_index(),
-        names="index",
-        values="tCO₂ removed",
+    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,
         hole=0.4,
-        labels={"index": "Method", "tCO₂ removed": "tCO₂ Removed"},
-    )
-    fig_donut.update_traces(
         textinfo="label+percent",
         textposition="outside",
-        pull=[0.02] * len(df_result),
         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)
 
-    # --- Heatmap of Resource Use ---
+    # 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]
@@ -140,8 +144,8 @@ def render_tab():
     )
     st.plotly_chart(fig_heatmap, use_container_width=True)
 
-    # --- Absolute Resource Use ---
-    st.markdown("### Absolute resource usage by unit")
+    # 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():
@@ -159,24 +163,18 @@ def render_tab():
     if df_abs:
         df_abs = pd.DataFrame(df_abs)
         for unit in df_abs["Unit"].unique():
-            df_unit = df_abs[df_abs["Unit"] == unit]
             st.markdown(f"#### Resources in {unit}")
-            fig = px.bar(
-                df_unit,
-                x="Resource",
-                y="Used",
-                color="Method",
-                barmode="group",
-                labels={"Used": f"Used ({unit})"},
-            )
-            fig.update_layout(
-                height=300 + 30 * df_unit["Resource"].nunique(),
-                margin=dict(t=30, b=30),
-                legend_title_text="",
-            )
-            st.plotly_chart(fig, use_container_width=True)
+            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 ---
+    # Save scenario
     st.markdown("### Save scenario")
     st.text_input("Scenario name", key="scenario_name")
 
@@ -190,7 +188,7 @@ def render_tab():
             st.session_state.scenarios[name] = latest
             st.success(f"Scenario '{name}' saved.")
 
-    # --- Preview Saved Scenario ---
+    # 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]
@@ -204,3 +202,30 @@ def render_tab():
             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))
+
+        # Export buttons
+        safe_name = unicodedata.normalize("NFKD", current_name).encode("ascii", "ignore").decode("ascii")
+
+        st.download_button(
+            label="Export JSON",
+            data=json.dumps(scenario, indent=2),
+            file_name=f"{safe_name}_scenario.json",
+            mime="application/json"
+        )
+
+        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"])
+
+        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())
+
+        st.download_button(
+            label="Export CSV",
+            data=csv_buffer.getvalue(),
+            file_name=f"{safe_name}_scenario.zip",
+            mime="application/zip"
+        )

tabs/tab5_sensitivity.py

@@ -1,5 +1,6 @@
+import matplotlib.pyplot as plt
 import pandas as pd
-import plotly.express as px
+import seaborn as sns
 import streamlit as st
 
 from config.config import method_order, resource_order
@@ -7,7 +8,7 @@ from optimization.optimization import run_optimization
 
 
 def render_tab():
-    st.header("Sensitivity Analysis")
+    st.header("Sensitivity analysis")
     st.info("""
         **Objective**:
         
@@ -26,7 +27,7 @@ def render_tab():
     )
     baseline_removed = baseline_result["total_removed"] if baseline_success else 0
 
-    tab1, tab2 = st.tabs(["🔁 Resource Sensitivity", "🔁 Method Sensitivity"])
+    tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
 
     with tab1:
         st.subheader("Impact of resource availability")
@@ -58,14 +59,12 @@ def render_tab():
                     })
 
             df = pd.DataFrame(all_data)
-            fig = px.line(df, x="% of cap", y="CO₂ removed (t)", color="Input",
-                          title="Sensitivity to Resource Availability")
-
-            fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
-                          annotation_text=f"Baseline: {baseline_removed:,} tCO₂",
-                          annotation_position="top left")
-
-            st.plotly_chart(fig, use_container_width=True)
+            st.markdown("#### Sensitivity to resource availability")
+            fig, ax = plt.subplots(figsize=(8, 5))
+            sns.lineplot(data=df, x="% of cap", y="CO₂ removed (t)", hue="Input", ax=ax)
+            ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} tCO₂")
+            ax.legend()
+            st.pyplot(fig)
 
     with tab2:
         st.subheader("Impact of max allocation per method")
@@ -97,11 +96,9 @@ def render_tab():
                     })
 
             df = pd.DataFrame(all_data)
-            fig = px.line(df, x="% max allocation", y="CO₂ removed (t)", color="Input",
-                          title="Sensitivity to Method Max Allocation")
-
-            fig.add_hline(y=baseline_removed, line_dash="dash", line_color="gray",
-                          annotation_text=f"Baseline: {baseline_removed:,} tCO₂",
-                          annotation_position="top left")
-
-            st.plotly_chart(fig, use_container_width=True)
+            st.markdown("#### Sensitivity to method max allocation in the portfolio")
+            fig, ax = plt.subplots(figsize=(8, 5))
+            sns.lineplot(data=df, x="% max allocation", y="CO₂ removed (t)", hue="Input", ax=ax)
+            ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} tCO₂")
+            ax.legend()
+            st.pyplot(fig)

tabs/tab6_scenarios.py

@@ -1,7 +1,8 @@
 import json
 
+import matplotlib.pyplot as plt
 import pandas as pd
-import plotly.express as px
+import seaborn as sns
 import streamlit as st
 
 
@@ -18,6 +19,19 @@ def is_valid_scenario(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 = {}
 
@@ -93,15 +107,33 @@ def render_tab():
     # Charts
     if method_alloc_df:
         st.subheader("Method Allocations")
-        fig1 = px.bar(pd.DataFrame(method_alloc_df), x="Method", y="tCO₂", color="Scenario", barmode="group")
-        st.plotly_chart(fig1, use_container_width=True)
+        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")
-        fig2 = px.bar(pd.DataFrame(resource_usage_df), x="Resource", y="Used", color="Scenario", facet_col="Method", facet_col_wrap=3)
-        st.plotly_chart(fig2, use_container_width=True)
+        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 = pd.DataFrame(resource_usage_df).groupby(["Scenario", "Resource"]).sum(numeric_only=True).reset_index()
-        fig3 = px.bar(df_total, x="Scenario", y="Used", color="Resource", barmode="stack")
-        st.plotly_chart(fig3, use_container_width=True)
+        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)