[FEAT] objective 2: More flexible resources input

app.py

@@ -35,7 +35,33 @@ with st.sidebar:
         ],
         icons=["house", "upload", "gear", "sliders", "graph-up-arrow", "card-checklist", "search"],
         default_index=0,
-        orientation="vertical"
+        orientation="vertical",
+        key="crra-menu",
+        styles={
+            "container":{
+                "border-radius":"0px",
+            },
+            "menu-title":{
+                "font-family": "Segoe UI, sans-serif",
+                "font-weight":"bold",
+                "color": "#ff5f4d",
+                "text-transform": "uppercase",
+                "font-style": "italic",
+            },
+            "nav-link": {
+                "font-family": "Segoe UI, sans-serif",
+                "margin": "4px 0",
+                "--hover-color": "#F5F5F5",
+                "text-transform": "uppercase",
+                "font-weight":"600",
+                "font-style": "italic",
+            },
+            "nav-link-selected": {
+                "background-color": "#eae9d8",
+                "color": "#298231",
+                "font-weight": "900",
+            },
+        }
     )
 
 # Initialize data to default values
@@ -44,7 +70,7 @@ 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, "cap_type": "percent", "cap_value": 1.0}
+        st.session_state.constraints[m] = {"active": True, "cap_type": "percent", "cap_value": 100}
 
 # Initialize cost_sliders
 cost_sliders = load_slider_data()
@@ -60,7 +86,7 @@ if "costs" not in st.session_state or st.session_state.costs == {}:
 if selected == "Welcome":
     tab0_welcome.render_tab()
 elif selected == "Resource inputs":
-    tab1_inputs.render_tab()
+    tab1_inputs.render_tab(cost_sliders)
 elif selected == "Method constraints":
     tab2_constraints.render_tab()
 elif selected == "Resource coefficients":

assets/styles.css

@@ -1,13 +1,28 @@
+:root {
+    --off-white: #eae9d8;
+    --red: #ff5f4d;
+    --green-dark: #298231;
+    --green: #55c95b;
+    --green-light: #92ef9b;
+    --yellow: #d9e210;
+    --white: #ffffff;
+    --brown-grey: #665d5b;
+    --grey: #a0a0a0;
+    --black: #000000;
+    --font: 'Segoe UI', sans-serif;
+}
+
 .cdr-table, .cdr-table-res, .resources-summary {
     width: 100%;
     border-collapse: separate;
     border-spacing: 0;
     border-radius: 10px;
     overflow: hidden;
+    font-family: var(--font);
 }
 
 .cdr-table thead th, .cdr-table-res thead th, .resources-summary thead th{
-    background-color: #3d86e9;
+    background-color: var(--green);
     color: white;
     font-weight: bold;
     padding: 8px 12px;
@@ -16,7 +31,7 @@
 
 .cdr-table tbody th, .cdr-table-res tbody th, .resources-summary tbody th{
     text-align: center;
-    color: #949393;
+    color: var(--grey);
     font-weight: 100;
 }
 
@@ -35,24 +50,40 @@
 /* tab2 */
 [class*="st-key-toggle_type_"] p {
     font-weight: 600;
+    font-family: var(--font);
+    text-transform: uppercase;
+    letter-spacing: 1.25px;
+    color: var(--brown-grey);
+}
+
+[class*="cap_type_"] p {
+    font-family: var(--font);
+}
+
+[class*="slider_"] p, [class*="manual_"] p{
+    font-family: var(--font);
+    font-style: italic;
+    color: var(--grey);
 }
 
+/* tab2 end */
+
 h1.custom-title {
-    font-family: "Segoe UI", sans-serif;
+    font-family: var(--font);
     font-size: 60px;
     font-style: italic;
     line-height: 0.95em;
 }
 
 .crra-hl {
-    background: linear-gradient(90deg, #D9E210 0%, #92EF9B 99%);
+    background: linear-gradient(90deg, var(--yellow) 0%, var(--green-light) 99%);
     -webkit-text-fill-color: transparent;
     background-clip: text;
     padding-right: 6px;
 }
 
 div.custom-corps {
-    font-family: "Segoe UI", sans-serif;
+    font-family: var(--font);
     font-size: 18px;
 }
 
@@ -61,17 +92,15 @@ div.custom-corps {
 }
 
 .text_with_border {
-    border-left: 3px solid #FF5F4D;
+    border-left: 3px solid var(--red);
     padding-left: 16px;
-    font-family: "Segoe UI", sans-serif;
-    /* font-style: italic; */
-    font-weight: 600;
+    font-family: var(--font);
     font-size: 18px !important;
 }
 
 .objective_title {
-    color: #FF5F4D;
-    font-family: "Segoe UI", sans-serif;
+    color: var(--red);
+    font-family: var(--font);
     font-size: 14px;
     font-weight: 700;
     text-transform: uppercase;
@@ -80,25 +109,27 @@ div.custom-corps {
 }
 
 .st-key-warning_resources [data-testid="stAlert"] {
-    background-color: #EAE9D8!important;
+    /* background-color: var(--off-white)!important; */
     clip-path: polygon(1.5% 0, 100% 0, 98.5% 100%, 0 100%);
 }
 
 .st-key-warning_resources p{
-    font-family: 'Segoe UI', sans-serif;
+    font-family: var(--font);
     font-style: italic;
     font-size: 16px;
-    font-weight: 600;
-    color: #665d5b;
+    line-height: 1.5;
+    letter-spacing: 0.01em;
+    /* font-weight: 600; */
+    /* color: #var(--brown-grey); */
 }
 
 .st-key-warning_resources span{
     font-style: italic;
-    color: #665d5b;
+    /* color: #var(--brown-grey); */
 }
 
 .crra-heading {
-    font-family: 'Segoe UI', sans-serif !important;
+    font-family: var(--font) !important;
     font-weight: 700;
     font-style: italic;
     font-size: clamp(32px, 2.5vw, 55px) !important;
@@ -112,41 +143,275 @@ div.custom-corps {
 }
 
 .crra-sub-heading {
-    font-family: 'Segoe UI', sans-serif !important;
+    font-family: var(--font) !important;
     font-weight: 700;
     font-style: italic;
     font-size: clamp(25px, 2vw, 32px) !important;
     line-height: 1.25em;
-    color: #665D5B !important;
+    color: var(--brown-grey) !important;
     margin-bottom: 15px;
     margin-top: 30px !important;
 }
 
+.dialog-title {
+    font-family: var(--font) !important;
+    font-weight: 600;
+    font-size: clamp(20px, 1vw, 30px) !important;
+    line-height: 1.25em;
+    margin-bottom: 15px;
+    margin-top: 10px !important;
+}
+
+.crra-sub-sub-heading {
+    font-family: var(--font) !important;
+    font-weight: 600;
+    font-style: italic;
+    font-size: clamp(20px, 1.5vw, 30px) !important;
+    line-height: 1.25em;
+    color: var(--grey) !important;
+    margin-bottom: 15px;
+    margin-top: 20px !important;
+}
+
+.crra-group-name{
+    font-family: var(--font) !important;
+    font-weight: 600;
+    font-style: italic;
+    font-size: clamp(20px, 1.5vw, 30px) !important;
+    line-height: 1.25em;
+}
 
 /* buttons */
-.st-key-btn-reset button {
+.st-key-btn-reset button, [class*="btn-reset-"] button {
     border-width: 0px !important;
     border-radius: 0px;
-    color: #FFFFFF;
-    background: #FF5F4D;
-    display: inline-flex;
-    align-items: center;
+    color: var(--white);
+    background: var(--red);
     height: clamp(52px, 3.125vw, 74px);
-    padding: 0 clamp(20px, 2.625vw, 42px);
+    padding: 0 clamp(20px, 2vw, 42px);
     clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%);
     transition: background 0.25s ease;
 }
 
-.st-key-btn-reset button p{
+.st-key-btn-reset button p, [class*="btn-reset-"] button p{
     font-weight: 700 !important;
-    font-family: "Segoe UI", sans-serif;
-    font-size: clamp(14px, 0.900vw, 18px);
+    font-family: var(--font);
+    font-size: clamp(13px, 0.800vw, 18px);
     letter-spacing: 0.094444em;
     text-decoration: none;
     text-transform: uppercase;
+    line-height: 1.2;
 }
 
-.st-key-btn-reset button:hover{
+.st-key-btn-reset button:hover, [class*="btn-reset-"] button:hover{
     background: #E5503F;
     color: #FFFFFF;
-}
+}
+
+.st-key-btn-load button {
+    border-radius: 0px;
+    color: var(--off-white);
+    background: var(--green-dark);
+    height: clamp(52px, 3.125vw, 74px);
+    padding: 0 clamp(20px, 2vw, 42px);
+    clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%);
+    transition: background 0.25s ease;
+}
+.st-key-btn-load button p{
+    font-weight: 700 !important;
+    font-family: var(--font);
+    font-size: clamp(13px, 0.800vw, 18px);
+    letter-spacing: 0.094444em;
+    text-decoration: none;
+    text-transform: uppercase;
+    line-height: 1.2;
+}
+
+.st-key-btn-load button:hover{
+    background: #01740f;
+    color: var(--off-white);
+}
+
+[class*="btn-new-"] button {
+    border-radius: 0px;
+    border: 0px;
+    color: var(--red);
+    background: var(--off-white);
+    height: clamp(52px, 3.125vw, 74px);
+    padding: 0 clamp(20px, 2vw, 42px);
+    clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%);
+    transition: background 0.25s ease;
+}
+
+[class*="btn-new-"] button p{
+    font-weight: 700 !important;
+    font-family: var(--font);
+    font-size: clamp(13px, 0.800vw, 18px);
+    letter-spacing: 0.094444em;
+    text-decoration: none;
+    text-transform: uppercase;
+    line-height: 1.2;
+}
+
+[class*="btn-new-"] button:hover{
+    background: #D8D7C4;
+    color: var(--red);
+}
+
+.stSidebar {
+    background: var(--off-white) !important;
+}
+
+section[data-testid="stExpander"] summary {
+    font-family: var(--font);
+    font-weight: 600;
+    text-transform: uppercase;
+}
+
+[class*="crra-select"] [data-baseweb="select"], .st-key-crra-select p{
+    font-family: var(--font);
+    font-size: 16px;
+}
+
+[class*="crra-select"] p{
+    font-style: italic;
+    font-weight: bold;
+}
+
+/* .st-key-crra-select [data-baseweb="select"] div{
+    background-color: var(--off-white);
+} */
+
+/* tab1 */
+[class*="_dlg_edit_existing_"] p {
+    font-family: var(--font);
+    color: var(--red);
+    font-weight: bold;
+    font-style: italic;
+}
+
+.caption {
+    font-family: var(--font);
+    color:#a0a0a0;
+    font-size: 0.88rem !important;
+    letter-spacing: 0.05rem;
+}
+
+[class*="_dlg_existing_enable_"] p, [class*="label-input-"] p {
+    font-family: var(--font);
+}
+
+.st-key-container-btn {
+    display: flex;
+    flex-direction: row;
+    gap: 1.125%;
+}
+
+[class*="cap_"] p {
+    font-family: var(--font);
+}
+
+/* .stDownloadButton {
+    place-self: center;
+} */
+
+[class*="st-key-download_button_"] button {
+    border-width: 0px !important;
+    border-radius: 0px;
+    color: var(--green-dark);
+    background: var(--off-white);
+    height: clamp(52px, 3.125vw, 74px);
+    padding: 0 clamp(20px, 2vw, 42px);
+    clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%);
+    transition: background 0.25s ease;
+}
+
+[class*="st-key-download_button_save_custom"] button {
+    float:inline-end;
+}
+
+[class*="st-key-download_button_"] button p{
+    font-weight: 700 !important;
+    font-family: var(--font);
+    font-size: clamp(13px, 0.800vw, 18px);
+    letter-spacing: 0.094444em;
+    text-decoration: none;
+    text-transform: uppercase;
+    line-height: 1.2;
+}
+
+[class*="st-key-download_button_"] button:hover{
+    background: #D8D7C4;
+    color: #FFFFFF;
+}
+
+[class*="resource_uploader_"], 
+[class*="inputs_loader_"],
+[class*="scenario_loader_"],
+.st-key-comparison_loader 
+{
+    font-family: var(--font);
+}
+
+[class*="resource_uploader_"] p, 
+[class*="inputs_loader_"] p,
+[class*="scenario_loader_"] p,
+.st-key-comparison_loader p
+{
+    font-family: var(--font);
+    color: var(--grey);
+    font-style: italic;
+}
+
+[class*="resource_uploader_"] [data-testid="stFileUploaderDropzone"], 
+[class*="inputs_loader_"] [data-testid="stFileUploaderDropzone"],
+[class*="scenario_loader_"] [data-testid="stFileUploaderDropzone"],
+.st-key-comparison_loader [data-testid="stFileUploaderDropzone"]
+{
+    background-color: var(--off-white);
+    /* clip-path: polygon(16px 0, 100% 0, calc(100% - 16px) 100%, 0 100%); */
+    /* border-radius: 0px; */
+    /* box-shadow: 0px 4px 20px 0px rgba(0, 0, 0, 0.20); */
+    color: var(--green-dark);
+    font-weight: 700 !important;
+    letter-spacing: 0.094444em;
+    text-decoration: none;
+    text-transform: uppercase;
+    /* justify-self: center; */
+    width: stretch;
+    font-size: 0.875rem;;
+}
+
+/* [class*="resource_uploader_"] [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"]{
+    padding-inline: 3rem;
+} */
+
+[class*="resource_uploader_"] [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"] span svg,
+[class*="inputs_loader_"] [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"] span svg,
+[class*="scenario_loader_"] [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"] span svg,
+.st-key-comparison_loader [data-testid="stFileUploaderDropzone"] [data-testid="stFileUploaderDropzoneInstructions"] span svg
+{
+    color: var(--green-dark);
+}
+
+[class*="resource_uploader_"] [data-testid="stBaseButton-secondary"],
+[class*="inputs_loader_"] [data-testid="stBaseButton-secondary"],
+[class*="scenario_loader_"] [data-testid="stBaseButton-secondary"]{
+    color: var(--off-white);
+    font-weight: 700 !important;
+    text-transform: uppercase;
+    font-style: italic;
+    background-color: var(--green-dark);
+    border: none;
+}
+
+div.custom-corps-light {
+    font-family: var(--font);
+    color: var(--grey);
+    font-style: italic;
+    font-weight: 400;
+    font-size: 0.875rem;
+    /* margin-bottom: 0.25rem; */
+}
+
+/* tab1 end */

data/generate_input_template.py

@@ -5,8 +5,10 @@ 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, resource_unit_map, resource_groups)
+from utils.data_utils import strip_unit_suffix
 
 # Data
 with open("data/cost_sliders.json") as f:
@@ -41,18 +43,19 @@ ws2["B1"].font = Font(bold=True)
 ws2["C1"].font = Font(bold=True)
 ws2["D1"].font = Font(bold=True)
 for m in method_order:
-    ws2.append([m, True, "percent", 1.0])
+    ws2.append([m, True, "percent", 100])
 
 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 cell in ws3[1]:
+    cell.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])
+        is_secondary = (m, strip_unit_suffix(r)) in secondary_resources
+        ws3.append([m, strip_unit_suffix(r), conf["median"], True if is_secondary else False])
+
+ws4 = wb.create_sheet("custom_resources")
+ws4.append(["name", "group", "amount", "method", "min", "median", "max"])
 
 wb.save("data/inputs_template.xlsx")
 print("Template generated: data/inputs_template.xlsx")

optimization/optimization.py

@@ -9,7 +9,7 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
     Args:
         resource_caps (dict): {resource: available_quantity}
         method_constraints (dict): {method: {"active": bool, "cap_type": str, "cap_value": float}}
-            cap_type: "percent" → cap_value is a fraction of total (0 to 1)
+            cap_type: "percent" → cap_value is a fraction of total (0 to 100)
             cap_type: "absolute" → cap_value is a hard upper bound in CO₂ units
         method_costs (dict): {method: {resource: usage_per_tCO2}}
         custom_resources (list | None): list of custom batch dicts: [{"name": str, "group": str, "amount": float, "methods": {method: {"min", "median", "max"}}}]
@@ -33,6 +33,19 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
             else:
                 method_costs[method] = {r_key: coefs["median"]}
 
+    # ── Debug custom resources ────────────────────────────────────────────────
+    print(f"\n{'='*50}")
+    print(f"custom_resources received: {len(custom_resources or [])} batch(es)")
+    for batch in (custom_resources or []):
+        r_key = batch["name"]
+        print(f"  → '{r_key}' | amount: {resource_caps.get(r_key)} | methods: {list(batch['methods'].keys())}")
+        for method in batch["methods"]:
+            coef = method_costs.get(method, {}).get(r_key)
+            print(f"      method_costs['{method}']['{r_key}'] = {coef}")
+    print(f"Total resources in matrix: {len(resource_caps)}")
+    print(f"Total resources in matrix: {resource_caps}")
+    print(f"Resources: {list(resource_caps.keys())}")
+    print(f"{'='*50}\n")
 
     # ── Standard optimisation setup ───────────────────────────────────────────
 
@@ -56,7 +69,7 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
     for i, m in enumerate(methods):
         constraint = method_constraints.get(m, {})
         cap_type = constraint.get("cap_type", "percent")
-        cap_value = constraint.get("cap_value", 1.0)
+        cap_value = constraint.get("cap_value", 100)
 
         # x_i <= cap_value
         if cap_type == "absolute":
@@ -64,10 +77,11 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
             row[i] = 1
             A_share.append(row)
             b_share.append(cap_value)
-        # x_i <= cap_value * sum(x)  →  x_i - cap_value * sum(x) <= 0
+        # x_i <= cap_value/100 * sum(x)  →  x_i - cap_value/100 * sum(x) <= 0
         else:
+            cap_ratio = cap_value / 100
             row = np.zeros(len(methods))
-            row += -cap_value
+            row += -cap_ratio
             row[i] += 1
             A_share.append(row)
             b_share.append(0)
@@ -83,9 +97,10 @@ def run_optimization(resource_caps, method_constraints, method_costs, custom_res
     try:
         result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
         if result.success:
-            x = np.floor(result.x).astype(int)
-            total_removed = int(x.sum())
-            method_usage = {m: int(x[i]) for i, m in enumerate(methods) if x[i] > 0}
+            # x = np.floor(result.x).astype(int)
+            x = result.x
+            total_removed = x.sum()
+            method_usage = {m: x[i] for i, m in enumerate(methods) if x[i] > 0}
             return True, {"total_removed": total_removed, "method_usage": method_usage}
         else:
             return False, {"message": result.message}

tabs/tab0_welcome.py

@@ -3,29 +3,33 @@ from config.config import CO2_UNIT
 from utils.ui_helpers import show_bar
 
 def render_tab():
-    st.markdown('<h1 class="crra-heading">Welcome!</h1>', unsafe_allow_html=True)
-    show_bar()
     st.markdown(f"""
     <div class='custom-corps'>
-    This tool helps you optimize your carbon direct removal portfolio by adjusting resource usage and constraints.
-
-    **Required:**
-    1. **Resource inputs**: provide the total available quantities of resources for 1 year.
-
-    **Optional:**
-
-    2. **Method constraints**: select which carbon removal methods are active and set their **maximum deployment cap** (as % of total potential or absolute value in {CO2_UNIT}/yr).
-    3. **Resource efficiency coefficients**: adjust the resource usage for each method.
 
-    **Outputs:**
-
-    4. **Portfolio generation**: run the optimization to find the best portfolio: how much CO₂ is removed, what methods are used, and in what proportions.
-
-    **Explore:**
-
-    5. **Sensitivity analysis**: analyze how changes in method caps or resource availability affect the portfolio.
-    6. **Scenario comparison**: compare different scenarios based on the optimization results.
+    This tool helps you optimize your carbon direct removal portfolio by adjusting resource usage and constraints.
 
-    Let's get started! Use the side tabs to navigate through the sections.
+    <b>Required:</b>
+    <ol>
+        <li><b>Resource inputs</b>: provide the total available quantities of resources for 1 year.</li>
+    </ol>
+
+    <b>Optional:</b>
+    <ol start="2">
+        <li><b>Method constraints</b>: select which carbon removal methods are active and set their <b>maximum deployment cap</b> (as % of total potential or absolute value in {CO2_UNIT}/yr).</li>
+        <li><b>Resource efficiency coefficients</b>: adjust the resource usage for each method.</li>
+    </ol>
+
+    <b>Outputs:</b>
+    <ol start="4">
+        <li><b>Portfolio generation</b>: run the optimization to find the best portfolio: how much CO₂ is removed, what methods are used, and in what proportions.</li>
+    </ol>
+
+    <b>Explore:</b>
+    <ol start="5">
+        <li><b>Sensitivity analysis</b>: analyze how changes in method caps or resource availability affect the portfolio.</li>
+        <li><b>Scenario comparison</b>: compare different scenarios based on the optimization results.</li>
+    </ol>
+
+    Let’s get started! Use the side tabs to navigate through the sections.
     </div>
     """, unsafe_allow_html=True)

tabs/tab1_inputs.py

@@ -3,117 +3,258 @@ import streamlit as st
 
 from config.config import (resource_groups, resource_order, resource_tooltips,
                            resource_unit_map, method_groups, method_order, CO2_UNIT)
-from utils.data_utils import render_resource_input
-from utils.ui_helpers import format_resource_summary, show_bar
+from utils.data_utils import render_resource_input, strip_unit_suffix
+from utils.ui_helpers import format_resource_summary, format_table_summary, show_bar
 from io import BytesIO
 
 # ─── Custom resource helpers ──────────────────────────────────────────────────
 
 def standard_resource_names():
-    """Flat set of all standard resource names (without unit suffixes)."""
     return {r for rlist in resource_groups.values() for r in rlist}
 
 
 def init_custom_resources():
     if "custom_resources" not in st.session_state:
         st.session_state.custom_resources = []
+    for batch in st.session_state.custom_resources:
+        try:
+            batch["amount"] = float(batch["amount"])
+        except (ValueError, TypeError):
+            batch["amount"] = 0.0
+        for m, coefs in batch.get("methods", {}).items():
+            for key in ("min", "median", "max"):
+                try:
+                    coefs[key] = float(coefs[key])
+                except (ValueError, TypeError):
+                    coefs[key] = 0.0
 
 
 # ─── Dialog: add / edit a custom resource batch ───────────────────────────────
 
-@st.dialog("Add a custom resource", width="large")
-def dialog_add_custom_resource(edit_index: int | None = None):
-    """
-    Full-screen dialog to create or edit a custom resource batch.
-    edit_index: index in st.session_state.custom_resources to edit (None = new).
-    """
+@st.dialog("Add a new resource", width="large")
+def dialog_add_custom_resource(cost_sliders, edit_index: int | None = None):
+
+    if edit_index is not None and not st.session_state.get(f"_dlg_initialized_{edit_index}"):
+        for key in list(st.session_state.keys()):
+            if key.startswith(("_dlg_existing_enable_", "_dlg_edit_existing_",
+                            "_dlg_min_existing_", "_dlg_med_existing_", "_dlg_max_existing_",
+                            "_dlg_new_chk_", "_dlg_new_min_", "_dlg_new_med_", "_dlg_new_max_")):
+                del st.session_state[key]
+        st.session_state[f"_dlg_initialized_{edit_index}"] = True
 
     standard_names = standard_resource_names()
     existing_names = {
         b["name"] for i, b in enumerate(st.session_state.custom_resources)
         if i != edit_index
     }
-
-    # Pre-fill values when editing
     existing = st.session_state.custom_resources[edit_index] if edit_index is not None else {}
 
-    st.markdown("### 1 — Name & group")
-    col_name, col_group = st.columns(2)
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+    
+    st.markdown('<p class="dialog-title">1 — Name & group</p>', unsafe_allow_html=True)
 
+    col_name, col_group = st.columns(2)
     with col_name:
         batch_name = st.text_input(
             "Resource name *",
             value=existing.get("name", ""),
             placeholder="e.g. Degraded forest lands – North",
             help="It can't match the name of an existing resource.",
+            key="label-input-name"
         )
-
     with col_group:
-        groups = list(resource_groups.keys())
-        default_group_idx = groups.index(existing["group"]) if existing.get("group") in groups else 0
+        default_group_idx = resource_order.index(existing["group"]) if existing.get("group") in resource_order else 0
         batch_group = st.selectbox(
             "Resource group *",
-            options=groups,
+            options=resource_order,
             index=default_group_idx,
             help="Determines the physical unit of this resource.",
+            key="label-input-group"
         )
 
-    unit = resource_unit_map.get(batch_group, "?")
-    st.caption(f"Unit for this group: **{unit}** (per MtCO₂ for coefficients)")
+    group = resource_to_group.get(batch_group)
+    unit = resource_unit_map.get(group, "?")
+
+    st.markdown(f'<p class="caption">Unit for this group: <strong>{unit}</strong> (per MtCO₂ for coefficients)</p>', unsafe_allow_html=True)
+
+    st.markdown('<p class="dialog-title">2 — Available quantity</p>', unsafe_allow_html=True)
 
-    st.markdown("### 2 — Available quantity")
     batch_amount = st.number_input(
         f"Available amount ({unit})",
         min_value=0.0,
         format="%.2f",
         value=float(existing.get("amount", 0.0)),
         help=f"Total quantity available for 1 year, in {unit}.",
+        key="label-input-amount"
     )
 
-    st.markdown("### 3 — Allowed CDR methods & coefficients")
-    st.caption(
-        f"Select which methods can use this resource and enter their resource consumption coefficients in **{unit}/{CO2_UNIT}**."
-    )
+    st.markdown('<p class="dialog-title">3 — Existing CDR methods for this resource</p>', unsafe_allow_html=True)
 
-    existing_methods = existing.get("methods", {})
     method_configs = {}
 
+    # Methods linked to this resource grouped by CDR group
+    related_methods = {}
+    for cdr_method, resource in cost_sliders.items():
+        for name, coeff in resource.items():
+            if batch_group == strip_unit_suffix(name):
+                related_methods[cdr_method] = {
+                    "min": coeff["min"],
+                    "median": coeff["median"],
+                    "max": coeff["max"],
+                }
+
+    # group_name -> methods
+    related_by_group = {}
+
+    for m, coeff in related_methods.items():
+        method_group = next(
+            (g for g, methods in method_groups.items() if m in methods),
+            "Other"
+        )
+        related_by_group.setdefault(method_group, {})[m] = coeff
+
+    for method_group, methods in related_by_group.items():
+        with st.expander(f"**{method_group}**", expanded=False):
+            for m, coeff in methods.items():
+
+                already_selected = m in existing.get("methods", {})
+
+                if f"_dlg_existing_enable_{m}" not in st.session_state:
+                    st.session_state[f"_dlg_existing_enable_{m}"] = already_selected
+
+                enabled = st.checkbox(
+                    f"{m}",
+                    key=f"_dlg_existing_enable_{m}",
+                )
+
+                if not enabled:
+                    continue
+
+                if f"_dlg_edit_existing_{m}" not in st.session_state:
+                    saved = existing.get("methods", {}).get(m, {})
+                    default = coeff
+                    coeffs_differ = any(
+                        abs(float(saved.get(k, default[k])) - float(default[k])) > 1e-9
+                        for k in ("min", "median", "max")
+                    ) if saved else False
+                    st.session_state[f"_dlg_edit_existing_{m}"] = coeffs_differ
+
+                edit = st.checkbox(
+                    "Edit coefficients (will overwrite default values)",
+                    key=f"_dlg_edit_existing_{m}",
+                )
+
+                if edit:
+                    saved = existing.get("methods", {}).get(m, coeff)
+                    st.warning(
+                        "Editing this method will overwrite the default coefficient values.",
+                        icon="⚠️"
+                    )
+                    col_min, col_med, col_max = st.columns(3)
+                    with col_min:
+                        v_min = st.number_input(
+                            "Min",
+                            min_value=0.0,
+                            value=float(saved.get("min", coeff["min"])),
+                            format="%.4f",
+                            key=f"_dlg_min_existing_{m}",
+                        )
+
+                    with col_med:
+                        v_med = st.number_input(
+                            "Median ★",
+                            min_value=0.0,
+                            value=float(saved.get("median", coeff["median"])),
+                            format="%.4f",
+                            key=f"_dlg_med_existing_{m}",
+                        )
+
+                    with col_max:
+                        v_max = st.number_input(
+                            "Max",
+                            min_value=0.0,
+                            value=float(saved.get("max", coeff["max"])),
+                            format="%.4f",
+                            key=f"_dlg_max_existing_{m}",
+                        )
+
+                    method_configs[m] = {
+                        "min": v_min,
+                        "median": v_med,
+                        "max": v_max,
+                    }
+
+                else:
+                    st.dataframe(
+                        pd.DataFrame([{
+                            "Min": coeff["min"],
+                            "Median": coeff["median"],
+                            "Max": coeff["max"],
+                        }]),
+                        hide_index=True,
+                        use_container_width=True,
+                    )
+
+                    method_configs[m] = coeff.copy()
+    # -------------------------------------------------
+    # Part 4 : new/custom methods only
+    # -------------------------------------------------
+
+    st.markdown('<p class="dialog-title">4 — Add additional CDR methods</p>', unsafe_allow_html=True)
+    st.markdown(f'<p class="caption">Select additional methods and enter their coefficients in {unit}/{CO2_UNIT}.</p>', unsafe_allow_html=True)
+
+    already_used = set(related_methods.keys())
+
     for group_name, methods in method_groups.items():
+        available_methods = [
+            m for m in methods
+            if m not in already_used
+        ]
+        if not available_methods:
+            continue
         with st.expander(f"**{group_name}**", expanded=False):
-            for m in methods:
-                prev = existing_methods.get(m)
-                enabled_default = prev is not None
-                enabled = st.checkbox(f"**{m}**", value=enabled_default, key=f"_dlg_chk_{m}")
-
+            for m in available_methods:
+                enabled = st.checkbox(
+                    f"**{m}**",
+                    key=f"_dlg_new_chk_{m}",
+                )
                 if enabled:
                     col_min, col_med, col_max = st.columns(3)
                     with col_min:
                         v_min = st.number_input(
-                            "Min", min_value=0.0, format="%.4f",
-                            value=float(prev["min"] if prev else 0.0),
-                            key=f"_dlg_min_{m}",
+                            "Min",
+                            min_value=0.0,
+                            format="%.4f",
+                            key=f"_dlg_new_min_{m}",
                         )
                     with col_med:
                         v_med = st.number_input(
-                            "Median ★", min_value=0.0, format="%.4f",
-                            value=float(prev["median"] if prev else 0.0),
-                            key=f"_dlg_med_{m}",
+                            "Median ★",
+                            min_value=0.0,
+                            format="%.4f",
+                            key=f"_dlg_new_med_{m}",
                         )
                     with col_max:
                         v_max = st.number_input(
-                            "Max", min_value=0.0, format="%.4f",
-                            value=float(prev["max"] if prev else 0.0),
-                            key=f"_dlg_max_{m}",
+                            "Max",
+                            min_value=0.0,
+                            format="%.4f",
+                            key=f"_dlg_new_max_{m}",
                         )
-                    method_configs[m] = {"min": v_min, "median": v_med, "max": v_max}
-
-    # ── Save / cancel ──────────────────────────────────────────────────────────
+                    method_configs[m] = {
+                        "min": v_min,
+                        "median": v_med,
+                        "max": v_max,
+                    }
     error_placeholder = st.empty()
-
     col_save, col_cancel = st.columns([2, 2])
 
     with col_cancel:
-        if st.button("Cancel", use_container_width=True):
+        if st.button("Cancel", use_container_width=True, key="btn-reset-cancel"):
             st.rerun()
 
     def _validate():
@@ -128,7 +269,6 @@ def dialog_add_custom_resource(edit_index: int | None = None):
             errors.append("Available amount must be greater than 0.")
         if not method_configs:
             errors.append("Select at least one CDR method.")
-        #consistency check min / median / max
         for m, c in method_configs.items():
             if c["min"] > c["max"]:
                 errors.append(f"**{m}**: min ({c['min']}) cannot be greater than max ({c['max']}).")
@@ -137,7 +277,7 @@ def dialog_add_custom_resource(edit_index: int | None = None):
         return errors
 
     with col_save:
-        if st.button("Add to session", type="primary", use_container_width=True, icon=":material/check:"):
+        if st.button("Add to session", type="tertiary", use_container_width=True, icon=":material/check:", key="btn-new-add"):
             errors = _validate()
             if errors:
                 with error_placeholder.container():
@@ -147,185 +287,234 @@ def dialog_add_custom_resource(edit_index: int | None = None):
                 batch = {
                     "name": batch_name.strip(),
                     "group": batch_group,
-                    "amount": batch_amount,
+                    "amount": float(batch_amount),   # always store as float
                     "methods": method_configs,
                 }
                 if edit_index is not None:
                     st.session_state.custom_resources[edit_index] = batch
                 else:
                     st.session_state.custom_resources.append(batch)
-                # Clear any cached optimization results since inputs changed
                 st.session_state.pop("latest_result", None)
                 st.rerun()
-    return method_configs
 
-# ─── Load custom resource from a saved Excel ────────────────────────────────────
 
-def to_excel_bytes(df: pd.DataFrame) -> bytes:
-    buffer = BytesIO()
-    with pd.ExcelWriter(buffer, engine="openpyxl") as writer:
-        df.to_excel(writer, index=False, sheet_name="custom_resources")
-    return buffer.getvalue()
+# ─── Excel helpers ────────────────────────────────────────────────────────────
+
+def to_excel_bytes(batches: list) -> bytes:
+    """Serialize all custom resource batches to an Excel file (one row per batch×method)."""
+    rows = []
+    for batch in batches:
+        for m, coefs in batch["methods"].items():
+            rows.append({
+                "name":   batch["name"],
+                "group":  batch["group"],
+                "amount": float(batch["amount"]),
+                "unit": batch["unit"],
+                "method": m,
+                "min":    float(coefs["min"]),
+                "median": float(coefs["median"]),
+                "max":    float(coefs["max"]),
+            })
+    buf = BytesIO()
+    with pd.ExcelWriter(buf, engine="openpyxl") as writer:
+        pd.DataFrame(rows).to_excel(writer, index=False, sheet_name="custom_resources")
+    return buf.getvalue()
+
+
+def _parse_custom_excel(file) -> list:
+    df = pd.read_excel(file, sheet_name=0)
+    required = {"name", "group", "amount", "method", "min", "median", "max"}
+    if not required.issubset(df.columns):
+        raise ValueError(f"Missing columns: {required - set(df.columns)}")
+    batches = []
+    for bname in df["name"].unique():
+        df_b = df[df["name"] == bname]
+        methods = {
+            row["method"]: {
+                "min":    float(row["min"]),
+                "median": float(row["median"]),
+                "max":    float(row["max"]),
+            }
+            for _, row in df_b.iterrows()
+        }
+        batches.append({
+            "name":    str(bname),
+            "group":   str(df_b["group"].iloc[0]),
+            "amount":  float(df_b["amount"].iloc[0]),
+            "methods": methods,
+        })
+    return batches
+
 
-@st.dialog("Load a saved resource batch", width="large")
+# ─── Load dialog ──────────────────────────────────────────────────────────────
+
+@st.dialog("Load custom resource batches", width="large")
 def dialog_load_custom_batch():
-    st.caption("Import a Excel file that you have previously exported from the ‘Custom resource’ section")
-    uploaded = st.file_uploader("Upload Excel file", type=["xlsx"])
+    st.markdown('<p class="caption">Import an Excel file previously exported from the <strong>Custom resource</strong> section.</p>', unsafe_allow_html=True)
+
+    uploaded = st.file_uploader("Upload Excel file", type=["xlsx"], key="inputs_loader_custom")
     if uploaded is None:
         return
 
     try:
-        df = pd.read_excel(uploaded, sheet_name=0)
-        required = {"name", "group", "amount", "method", "min", "median", "max"}
-        if not required.issubset(df.columns):
-            st.error(f"Missing columns: {required - set(df.columns)}")
-            return
-
-        standard_names = standard_resource_names()
-        existing_names = {b["name"] for b in st.session_state.custom_resources}
-
-        batches_in_file = df["name"].unique()
-        for bname in batches_in_file:
-            df_b = df[df["name"] == bname]
-            group = df_b["group"].iloc[0]
-            amount = float(df_b["amount"].iloc[0])
-            methods = {
-                row["method"]: {"min": row["min"], "median": row["median"], "max": row["max"]}
-                for _, row in df_b.iterrows()
-            }
-            batch = {"name": bname, "group": group, "amount": amount, "methods": methods}
+        new_batches = _parse_custom_excel(uploaded)
+    except Exception as e:
+        st.error(f"Error reading file: {e}")
+        return
 
-            st.markdown(f"**Batch:** {bname} | Group: {group} | Amount: {amount} | Methods: {len(methods)}")
+    standard_names = standard_resource_names()
+    existing_names = {b["name"] for b in st.session_state.custom_resources}
+
+    previews = []
+    for batch in new_batches:
+        if batch["name"] in standard_names:
+            status = "❌ Conflicts with standard resource — will be skipped"
+        elif batch["name"] in existing_names:
+            status = "⚠️ Already exists — will be overwritten"
+        else:
+            status = "✅ New"
+        previews.append({
+            "Resource name": batch["name"],
+            "Group": batch["group"],
+            "Amount": f"{batch["amount"]} {resource_unit_map.get(batch["group"], "")}",
+            "Methods": len(batch["methods"]),
+            "Status": status,
+        })
+    st.dataframe(pd.DataFrame(previews), use_container_width=True, hide_index=True)
 
-            if bname in standard_names:
-                st.error(f"'{bname}' matches a standard resource. Skipped.")
+    if st.button("↩️ Import all batches", type="primary", use_container_width=True):
+        imported = 0
+        for batch in new_batches:
+            if batch["name"] in standard_names:
                 continue
-            if bname in existing_names:
-                st.warning(f"'{bname}' already exists in session. It will be overwritten.")
-                idx = next(i for i, b in enumerate(st.session_state.custom_resources) if b["name"] == bname)
+            if batch["name"] in existing_names:
+                idx = next(i for i, b in enumerate(st.session_state.custom_resources)
+                           if b["name"] == batch["name"])
                 st.session_state.custom_resources[idx] = batch
             else:
                 st.session_state.custom_resources.append(batch)
-
-        st.success(f"Loaded {len(batches_in_file)} batch(es) from file.")
+            imported += 1
         st.session_state.pop("latest_result", None)
+        st.success(f"Imported {imported} batch(es).")
         st.rerun()
 
-    except Exception as e:
-        st.error(f"Error loading file: {e}")
-
 
-# ─── Custom resources management panel ────────────────────────────────────────
+# ─── Custom resources panel ───────────────────────────────────────────────────
 
-def panel_custom_resources():
-    """Panel displayed at the top of the inputs tab to manage custom batches."""
+def panel_custom_resources(cost_sliders):
     init_custom_resources()
 
-    st.markdown("### ➕ Custom resource")
-    st.caption(
-        "Add sub-batches for any resource group and manually assign them to specific CDR methods. "
-        "Standard resources above use the default taxonomy; custom batches give you full control."
-    )
+    st.markdown('<p class="crra-sub-heading">➕ Custom resource</p>', unsafe_allow_html=True)
+    st.markdown('<p class="caption"> Add sub-batches for any resource group and manually assign them to specific CDR methods.</p>', unsafe_allow_html=True)
 
-    col_add, col_load = st.columns([1, 1])
-    with col_add:
-        if st.button("New resource", use_container_width=True, type="primary", icon=":material/add:"):
-            dialog_add_custom_resource()
-    with col_load:
-        if st.button("Load from Excel", use_container_width=True, icon=":material/arrow_upload_progress:"):
+    col = st.container(key="container-btn")
+
+    with col:
+        if st.button("New resource", type="tertiary", icon=":material/add:", key="btn-new-resource"):
+            dialog_add_custom_resource(cost_sliders)
+        if st.button("Load from Excel", type="tertiary", icon=":material/arrow_upload_progress:", key="btn-load"):
             dialog_load_custom_batch()
 
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+        
     batches = st.session_state.custom_resources
     if not batches:
-        st.info("No custom batches defined yet. Click **+ New resource** to get started.")
+        st.info("No new resources have been defined yet. Click **+ New resource** to get started.")
         return
 
-    st.markdown(f"**{len(batches)} custom batch(es) active**")
-
+    st.markdown(f"**{len(batches)} new resource(s)**")
     for i, batch in enumerate(batches):
-        unit = resource_unit_map.get(batch["group"], "?")
+
+        group = resource_to_group.get(batch["group"])
+        unit = resource_unit_map.get(group, "?")
+    
+        batch["unit"] = unit
         n_methods = len(batch["methods"])
+        amount_val = float(batch["amount"])
 
         with st.expander(
-            f"🆕 {batch['group']} ({unit}) - CDR methods: **{n_methods}**",
+            f"🆕 **{batch['name']}** ({batch['group']}) — CDR methods: **{n_methods}**",
             expanded=False,
         ):
-            st.markdown(f"**{batch['name']}**")
+            st.markdown(f"**{batch['name']}** ({unit})")
+
+            key_amount = f"custom_amount_{i}"
+            # Initialise widget state only if not already set (avoids overwrite on rerun)
+            if key_amount not in st.session_state:
+                st.session_state[key_amount] = amount_val
 
             col_amount, _, _, _ = st.columns(4)
             with col_amount:
                 new_amount = st.number_input(
                     "Available amount",
-                    label_visibility= "collapsed",
+                    label_visibility="collapsed",
                     min_value=0.0,
-                    value=float(batch["amount"]),
                     format="%.2f",
-                    key=f"custom_amount_{i}",
+                    key=key_amount,
                 )
-
-            if new_amount != batch["amount"]:
-                batch["amount"] = new_amount
+            # Write back as float — never as a formatted string
+            if new_amount != amount_val:
+                st.session_state.custom_resources[i]["amount"] = float(new_amount)
                 st.session_state.pop("latest_result", None)
 
-            # Summary table
+            # Coefficients table
+            col_min = f"Min ({unit}/MtCO₂)"
+            col_med = f"Median ({unit}/MtCO₂)"
+            col_max = f"Max ({unit}/MtCO₂)"
             rows = [
                 {
                     "Method": m,
-                    f"Min ({unit}/MtCO₂)": f"{c['min']:.2f}",
-                    f"Median ({unit}/MtCO₂)": f"{c['median']:.2f}",
-                    f"Max ({unit}/MtCO₂)": f"{c['max']:.2f}",
+                    col_min: float(c["min"]),
+                    col_med: float(c["median"]),
+                    col_max: float(c["max"]),
                 }
                 for m, c in batch["methods"].items()
             ]
-
             st.dataframe(
                 pd.DataFrame(rows),
                 use_container_width=True,
                 hide_index=True,
+                key=f"batch_editor_{i}",
+                column_config={
+                    "Method": st.column_config.TextColumn(disabled=True),
+                    col_min: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                    col_med: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                    col_max: st.column_config.NumberColumn(format="%.4f", min_value=0.0),
+                },
             )
 
             col_edit, col_del = st.columns([1, 1])
             with col_edit:
                 if st.button("Edit", key=f"edit_batch_{i}", use_container_width=True, icon=":material/edit:"):
-                    method_configs = dialog_add_custom_resource(edit_index=i)
-                    print(method_configs)
+                    dialog_add_custom_resource(cost_sliders, edit_index=i)
             with col_del:
-                if st.button("Delete", key=f"del_batch_{i}", use_container_width=True, type="primary", icon=":material/delete:"):
+                if st.button("Delete", key=f"del_batch_{i}", use_container_width=True,
+                             type="primary", icon=":material/delete:"):
                     st.session_state.custom_resources.pop(i)
                     st.session_state.pop("latest_result", None)
                     st.rerun()
 
-    # ── Export all batches as a single Excel file ─────────────────────────────────────
-    _,_,col_save_custom = st.columns(3)
+    # Export all batches as a single Excel file
+    _, col_save_custom = st.columns(2)
     with col_save_custom:
-        all_rows = []
-
-        for batch in batches:
-            for m, coefs in batch["methods"].items():
-                all_rows.append({
-                    "name": batch["name"],
-                    "group": batch["group"],
-                    "amount": batch["amount"],
-                    "method": m,
-                    "min": coefs["min"],
-                    "median": coefs["median"],
-                    "max": coefs["max"],
-                })
-
-        df_export = pd.DataFrame(all_rows)
-
         st.download_button(
-            "Save all custom resources (Excel)",
-            data=to_excel_bytes(df_export),
-            file_name="custom_resources.xlsx",
+            "Download new resources",
+            data=to_excel_bytes(batches),
+            file_name="new_resources.xlsx",
             mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            icon=":material/save:",
+            icon=":material/download:",
+            # use_container_width=True,
+            key="download_button_save_custom"
         )
 
+
 # ─── Main render ──────────────────────────────────────────────────────────────
 
-def render_tab():
-    # Safe session init
+def render_tab(cost_sliders):
     if "resource_caps" not in st.session_state:
         st.session_state.resource_caps = {}
     for r in resource_order:
@@ -335,31 +524,21 @@ def render_tab():
 
     st.markdown('<h1 class="crra-heading">Resource inputs</h1>', unsafe_allow_html=True)
     show_bar()
-    
-    st.markdown(
-        """
-        <p class="objective_title">OBJECTIVE</p>
-        """,
-        unsafe_allow_html=True,
-    )
 
-    st.markdown("""
-    <p class="text_with_border"> This section lets you define the total available quantities of each resource for the optimization model.</p>
-    """,
+    st.markdown('<p class="objective_title">OBJECTIVE</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<p class="text_with_border">This section lets you define the <strong>total available '
+        'quantities of each resource</strong> for the optimization model.</p>',
         unsafe_allow_html=True,
     )
 
     with st.container(key="warning_resources"):
         st.warning(
             "Resources with zero availability will block portfolio feasibility if required by active methods.",
-            icon=":material/warning:"
+            icon=":material/warning:",
         )
 
-    # Reset button
-    st.markdown("""
-        <p class="crra-sub-heading">Controls</p>""",
-        unsafe_allow_html=True,
-    )
+    st.markdown('<p class="crra-sub-heading">Controls</p>', unsafe_allow_html=True)
 
     if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
         for r in st.session_state.resource_caps:
@@ -368,37 +547,36 @@ def render_tab():
         st.success("All resource values reset to 0.")
         st.rerun()
 
-    # Import / download template
-    st.markdown("##### Import resource values")
+    st.markdown('<p class="crra-sub-sub-heading">Import resource values</p>', unsafe_allow_html=True)
     col_template, col_upload = st.columns([1, 1])
     with col_template:
-        st.markdown("Use the template below to fill in your resource availability values and import them directly into the tool.")
+        st.markdown("<div class='caption'><p>Use the template below to fill in your resource "
+                    "availability values and import them directly into the tool.</p></div>",
+                    unsafe_allow_html=True)
         with open("data/resource_template.xlsx", "rb") as f:
             st.download_button(
                 label="Download Excel Template",
                 data=f,
                 file_name="resource_template.xlsx",
-                use_container_width=True,
+                # use_container_width=True,
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                 icon=":material/download:",
+                key="download_button_resource_template"
             )
     with col_upload:
         uploaded_file = st.file_uploader(
             "Upload your Excel file", type="xlsx",
-            key=f"resource_uploader_{st.session_state.get('resource_uploader_key', 0)}"
+            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)}")
-
                 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"]
@@ -410,24 +588,19 @@ def render_tab():
                         val = 0.0
                     st.session_state.resource_caps[r] = val
                     st.session_state[f"cap_{r}"] = val
-
                 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)
+                for key in ["excel_loaded_file", "scenario_name_suggestion",
+                            "scenario_loaded_file", "input_file_name_suggestion", "latest_result"]:
+                    st.session_state.pop(key, 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="✅")
 
-    # ── Standard resource inputs ───────────────────────────────────────────────
-    st.markdown("### Set available resources for one year")
+    # Standard resource inputs
+    st.markdown('<p class="crra-sub-heading">Set available resources for one year</p>', unsafe_allow_html=True)
     for group, rlist in resource_groups.items():
         unit = resource_unit_map.get(group, "")
         with st.expander(f"**{group}** ({unit})", expanded=True):
@@ -438,54 +611,54 @@ def render_tab():
                 with cols[i % 4]:
                     render_resource_input(name_clean, r, tooltip=tooltip)
 
-    # ── Custom resource batches panel ──────────────────────────────────────────
-    panel_custom_resources()
+    # Custom resource batches panel
+    panel_custom_resources(cost_sliders)
 
-    # ── Summary table ──────────────────────────────────────────────────────────
-    st.markdown("### Summary of available resources")
+    # Summary table
+    st.markdown('<p class="crra-sub-heading">Summary of available resources</p>', unsafe_allow_html=True)
+
+    resource_to_unit = {
+        r: resource_unit_map[group]
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
 
-    # Standard resources
     df_caps = pd.DataFrame.from_dict(
         {r: st.session_state.resource_caps[r] for r in resource_order
          if st.session_state.resource_caps.get(r, 0.0) > 0},
-        orient="index", columns=["Available Amount"]
+        orient="index", columns=["Available Amount"],
     ).reindex(resource_order).dropna()
-
-    # Custom resource rows
+    df_caps["Available Amount"] = [
+        f"{value:,.2f} {resource_to_unit.get(resource, '?')}"
+        for resource, value in df_caps["Available Amount"].items()
+    ]
+
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+    
     custom_rows = []
     for batch in st.session_state.get("custom_resources", []):
-        unit = resource_unit_map.get(batch["group"], "?")
+        group = resource_to_group.get(batch["group"])
+        unit = resource_unit_map.get(group, "?")
         custom_rows.append({
-            "Resource": f"{batch['name']}",
-            "Available Amount": batch["amount"],
+            "Resource": batch["name"],
+            "Available Amount": f"{float(batch['amount']):,.2f} {unit}",
         })
 
     if not df_caps.empty or custom_rows:
-
-        # --- Standard resources ---
         dfs = []
-
         if not df_caps.empty:
             df_std = df_caps.copy()
-            df_std = df_std.rename(columns={"Available Amount": "Available Amount"})
             df_std["Type"] = "Standard"
             dfs.append(df_std)
-
-        # --- Custom resources ---
         if custom_rows:
             df_custom = pd.DataFrame(custom_rows).set_index("Resource")
-            df_custom["Type"] = "Custom"
+            df_custom["Type"] = "New"
             dfs.append(df_custom)
-
-        # --- Merge ---
-        df_all = pd.concat(dfs)
-
-        # Optionnel : ordre des colonnes
-        cols = ["Type", "Available Amount"]
-        df_all = df_all[cols]
-
-        # Styling
+        df_all = pd.concat(dfs)[["Available Amount", "Type"]]
         st.markdown(format_resource_summary(df_all), unsafe_allow_html=True)
-
     else:
         st.error("No resources defined yet. Set availability above to populate the summary table.")

tabs/tab2_constraints.py

@@ -10,77 +10,91 @@ from utils.ui_helpers import format_table_summary, show_bar
 # ─── Helpers ─────────────────────────────────────────────────────────────────
 
 def default_constraint():
-    return {"active": True, "cap_type": "percent", "cap_value": 1.0}
+    return {"active": True, "cap_type": "percent", "cap_value": 100}
 
 
 def render_method(m, cols, i):
     with cols[i % 3]:
         tooltip = method_tooltips.get(m, None)
+
+        # ─────────────────────────────────────────
+        # INIT SAFE
+        # ─────────────────────────────────────────
+        if m not in st.session_state.constraints:
+            st.session_state.constraints[m] = default_constraint()
+
         constraint = st.session_state.constraints[m]
 
-        if f"toggle_type_{m}" not in st.session_state:
-            st.session_state[f"toggle_type_{m}"] = constraint.get("active", True)
+        toggle_key = f"toggle_{m}"
+        cap_type_key = f"cap_type_{m}"
+        slider_key = f"slider_{m}"
+        manual_key = f"manual_{m}"
+
+        # init widgets ONLY from constraint (not reverse)
+        st.session_state.setdefault(toggle_key, constraint["active"])
+        st.session_state.setdefault(cap_type_key, constraint["cap_type"])
+
+        if constraint["cap_type"] == "percent":
+            st.session_state.setdefault(slider_key, float(constraint["cap_value"]))
+        else:
+            st.session_state.setdefault(manual_key, float(constraint["cap_value"]))
 
-        is_active = st.toggle(m, key=f"toggle_type_{m}", help=tooltip)
+        # ─────────────────────────────────────────
+        # TOGGLE
+        # ─────────────────────────────────────────
+        is_active = st.toggle(m, key=toggle_key, help=tooltip)
+
+        st.session_state.constraints[m]["active"] = is_active
 
         if not is_active:
-            st.session_state.constraints[m] = {
-                "active": False,
-                "cap_type": constraint.get("cap_type", "percent"),
-                "cap_value": constraint.get("cap_value", 1.0),
-            }
             return
 
-        cap_type_index = 0 if constraint.get("cap_type", "percent") == "percent" else 1
+        # ─────────────────────────────────────────
+        # CAP TYPE
+        # ─────────────────────────────────────────
         cap_type = st.radio(
             "Cap value type",
-            label_visibility="collapsed",
-            options=["percent", "absolute"],
-            index=cap_type_index,
+            ["percent", "absolute"],
             horizontal=True,
-            key=f"cap_type_{m}",
-            format_func=lambda x: "% of total potential" if x == "percent" else f"Absolute ({CO2_UNIT}/yr)",
+            key=cap_type_key,
+            format_func=lambda x: "% of total potential"
+            if x == "percent"
+            else f"Absolute ({CO2_UNIT}/yr)",
         )
 
+        st.session_state.constraints[m]["cap_type"] = cap_type
+
+        # ─────────────────────────────────────────
+        # PERCENT
+        # ─────────────────────────────────────────
         if cap_type == "percent":
-            if constraint.get("cap_type") == "percent" and constraint.get("cap_value", 0) > 0:
-                current_pct = int(constraint["cap_value"] * 100)
-            else:
-                current_pct = 100
-
-            share_val = st.slider(
-                "Max share (%)", min_value=0, max_value=100, step=5,
-                value=current_pct,
-                key=f"slider_{m}_widget",
+
+            value = st.slider(
+                "Max share (%)",
+                0, 100, step=5,
+                key=slider_key,
             )
-            st.session_state.constraints[m] = {
-                "active": True,
-                "cap_type": "percent",
-                "cap_value": share_val / 100,
-            }
-            if share_val == 0:
-                st.warning("Cap is 0% but method is active.", icon="⚠️")
 
-        else:
-            if constraint.get("cap_type") == "absolute":
-                current_abs = float(constraint.get("cap_value") or 0.0)
-            else:
-                current_abs = 0.0
+            st.session_state.constraints[m]["cap_value"] = value
 
-            abs_val = st.number_input(
+            if value == 0:
+                st.warning("Cap is 0% but method is active.", icon=":material/warning:")
+
+        # ─────────────────────────────────────────
+        # ABSOLUTE
+        # ─────────────────────────────────────────
+        else:
+            value = st.number_input(
                 f"Max cap ({CO2_UNIT}/yr)",
                 min_value=0.0,
                 format="%.2f",
-                value=current_abs,
-                key=f"manual_{m}_widget",
+                key=manual_key,
             )
-            st.session_state.constraints[m] = {
-                "active": True,
-                "cap_type": "absolute",
-                "cap_value": abs_val,
-            }
-            if abs_val == 0:
-                st.warning(f"Cap is 0 {CO2_UNIT}/yr but method is active.", icon="⚠️")
+
+            st.session_state.constraints[m]["cap_value"] = float(value)
+
+            if value == 0:
+                st.warning(f"Cap is 0 {CO2_UNIT}/yr but method is active.", icon=":material/warning:")
 
 def reset_all_constraints():
     for m in method_order:
@@ -99,9 +113,9 @@ def build_summary_df():
         if not c["active"]:
             continue
         if c["cap_type"] == "percent":
-            rows[m] = {"Cap value": f"{int(c['cap_value'] * 100)}", "Unit": "%"}
+            rows[m] = {"Cap value": f"{c['cap_value']}%"}
         else:
-            rows[m] = {"Cap value": f"{c['cap_value']:,.2f}", "Unit": f"{CO2_UNIT}/yr"}
+            rows[m] = {"Cap value": f"{c['cap_value']:,.2f} {CO2_UNIT}/yr"}
     return pd.DataFrame.from_dict(rows, orient="index") if rows else None
 
 
@@ -111,28 +125,46 @@ def render_tab():
     st.markdown('<h1 class="crra-heading">Method constraints</h1>', unsafe_allow_html=True)
     show_bar()
     
-    st.info("""
-    **Objective:**
-
-    This section lets you control which CDR methods are included in the optimization
-    and set a **maximum deployment cap** per method.
-
-    - Activate or deactivate individual methods
-    - Cap each method by **% of its total potential** or by an **absolute value** in {CO2_UNIT}/yr
-    """.format(CO2_UNIT=CO2_UNIT))
-
-    with st.expander("⚙️ Manage methods", expanded=False):
+    st.markdown(
+        """
+        <p class="objective_title">OBJECTIVE</p>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <div class="text_with_border">
+            <p>
+            This section lets you control which CDR methods are included in the optimization
+            and set a <strong>maximum deployment cap</strong> per method.<br>
+            <li>Activate or deactivate individual methods</li>
+            <li>Cap each method by <strong>% of its total potential</strong> or by an
+            <strong>absolute value</strong> in {CO2_UNIT}/yr</li>
+            </p>
+        </div>
+        """.format(CO2_UNIT=CO2_UNIT),
+        unsafe_allow_html=True,
+    )
+
+    with st.expander("Manage methods", expanded=False, icon=":material/settings:"):
         for group, method_list in method_groups.items():
-            st.markdown(f"#### {group}")
+            st.markdown(f"""
+                <p class="crra-group-name">{group}</p>""",
+                unsafe_allow_html=True,
+            )
             cols = st.columns(3)
             for i, m in enumerate(method_list):
                 render_method(m, cols, i)
 
     st.divider()
-    if st.button("🔄 Reset All Method Constraints"):
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
         reset_all_constraints()
 
-    st.subheader("Summary — Active methods and caps")
+    st.markdown("""
+        <p class="crra-sub-heading">Summary of Active methods and caps</p>""",
+        unsafe_allow_html=True,
+    )
     df = build_summary_df()
     if df is not None:
         st.markdown(format_table_summary(df,"cdr-table"), unsafe_allow_html=True)

tabs/tab3_coefficients.py

@@ -29,17 +29,32 @@ def render_tab(cost_sliders):
     st.markdown('<h1 class="crra-heading">Resource efficiency coefficients</h1>', unsafe_allow_html=True)
     show_bar()
     
-    st.info("""
-    **Objective:**
-
-    This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.
-
-    - 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**.")
-
+    st.markdown(
+        """
+        <p class="objective_title">OBJECTIVE</p>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <div class="text_with_border">
+            <p>
+            This section lets you adjust the resource usage coefficients for each CDR method to best fit your country conditions.<br>
+            <li>Primary resources are always active and initialized with default values.</li>
+            <li>Secondary resources are initialized at zero and toggled off by default.</li>
+            <li>Toggling on a secondary resource restores its default value.</li>
+            </p>
+        </div>
+        """.format(CO2_UNIT=CO2_UNIT),
+        unsafe_allow_html=True,
+    )
+
+    with st.container(key="warning_resources"):
+        st.warning(
+            "Blue cells in the table highlight coefficients modified from their **default median values**",
+            icon=":material/warning:"
+        )
     # Normalize cost_sliders once: strip unit suffixes from resource keys
     # cost_sliders_norm[method][resource_name] = {min, median, max}
     cost_sliders_norm = {
@@ -63,9 +78,9 @@ def render_tab(cost_sliders):
             method_choices.append(label)
             method_lookup[label] = method
 
-    selected_label = st.selectbox("Select a method:", method_choices)
+    selected_label = st.selectbox("Select a method:", method_choices, key="crra-select")
     
-    if st.button("🔄 Reset all methods"):
+    if st.button("RESET ALL", key="btn-reset", icon=":material/reset_settings:"):
         for m, sliders in cost_sliders_norm.items():
             for r, conf in sliders.items():
                 is_secondary = (m, r) in secondary_resources
@@ -86,9 +101,10 @@ def render_tab(cost_sliders):
             used = [r for r in rlist if r in method_sliders]
             if not used:
                 continue
-
-            st.markdown(f"### {group_name}")
-
+            st.markdown(f"""
+                <p class="crra-group-name">{group_name}</p>""",
+                unsafe_allow_html=True,
+            )
             for r in used:
                 conf = method_sliders[r]
                 display_label = resource_display.get(r, r)
@@ -139,7 +155,7 @@ def render_tab(cost_sliders):
                 st.session_state.costs[method][r] = manual_val if manual_val != slider_val else slider_val
 
         # ── Reset buttons ────────────────────────────────────────────────────
-        if st.button("🔄 Reset selected method"):
+        if st.button("Reset selected method", key="btn-reset-method", icon=":material/reset_settings:"):
             for r, conf in cost_sliders_norm.get(method, {}).items():
                 is_secondary = (method, r) in secondary_resources
                 st.session_state.costs[method][r] = 0.0 if is_secondary else conf["median"]
@@ -149,8 +165,10 @@ def render_tab(cost_sliders):
             st.rerun()
 
     # ── Summary table ─────────────────────────────────────────────────────────
-    st.subheader("Summary table: resource usage coefficients in the model")
-
+    st.markdown("""
+        <p class="crra-sub-heading">Summary of resource usage coefficients</p>""",
+        unsafe_allow_html=True,
+    )
     df_default = pd.DataFrame(index=method_order, columns=resource_order)
     df_current = pd.DataFrame(index=method_order, columns=resource_order)
 

tabs/tab4_optimization.py

@@ -22,8 +22,8 @@ from utils.data_utils import is_valid_scenario, load_inputs_from_excel, strip_un
 
 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.markdown("**Option 1 - From current tab values**", unsafe_allow_html=True)
+    st.markdown('<p class="caption">Set resource availability and method constraints in the tabs above, then run.</p>', unsafe_allow_html=True)
     st.divider() 
 
 
@@ -43,9 +43,10 @@ def panel_load_from_excel():
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                 use_container_width=True,
                 icon=":material/download:",
+                key="download_button_input_template"
             )
 
-    st.caption("Fill in the template with your values, then import and run.")
+    st.markdown('<p class="caption">Fill in the template with your values, then import and run.</p>', unsafe_allow_html=True)
 
     if "excel_loaded_file" in st.session_state:
         st.success(f"Loaded: **{st.session_state['excel_loaded_file']}** - All tabs updated.", icon="✅")
@@ -60,10 +61,12 @@ def panel_load_from_excel():
     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)
+            resource_caps, constraints, costs, custom_resources = load_inputs_from_excel(uploaded)
+            print(custom_resources)
             st.session_state.resource_caps = resource_caps
             st.session_state.constraints = constraints
             st.session_state.costs = costs
+            st.session_state.custom_resources = custom_resources
             clear_widget_keys()
             st.session_state.pop("latest_result", None)
             st.session_state.pop("scenario_loaded_file", None)
@@ -133,20 +136,45 @@ def parse_zip_scenario(uploaded) -> dict | None:
 
             total = sum(allocations.values())
 
+            # Load optional custom resource batches
+            custom_resources = []
+            if "custom_resources.csv" in names:
+                df_custom = pd.read_csv(io.BytesIO(zf.read("custom_resources.csv")))
+                required_custom = {"name", "group", "amount", "method", "min", "median", "max"}
+                if required_custom.issubset(df_custom.columns):
+                    for bname in df_custom["name"].unique():
+                        df_b = df_custom[df_custom["name"] == bname]
+                        methods = {
+                            row["method"]: {
+                                "min": float(row["min"]),
+                                "median": float(row["median"]),
+                                "max": float(row["max"]),
+                            }
+                            for _, row in df_b.iterrows()
+                        }
+                        custom_resources.append({
+                            "name": bname,
+                            "group": str(df_b["group"].iloc[0]),
+                            "amount": float(df_b["amount"].iloc[0]),
+                            "methods": methods,
+                        })
+
             return {
                 "summary": {"total_co2_removed": total, "total_cost": 0},
                 "allocations": allocations,
                 "resource_caps": resource_caps,
                 "method_constraints": constraints,
                 "method_costs": costs,
+                "custom_resources": custom_resources,
             }
+        
     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)")
- 
+    st.markdown('<p class="caption">Accepts `.json` or `.zip` (CSV export)</p>', unsafe_allow_html=True)
+
     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.",
@@ -188,11 +216,16 @@ def panel_load_from_json_or_csv():
         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()
+        # Restore custom resource batches if present in the scenario
+        st.session_state.custom_resources = data.get("custom_resources", [])
         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
+        if st.session_state.custom_resources:
+            n = len(st.session_state.custom_resources)
+            st.info(f"ℹ️ {n} new resource(s) restored from scenario.")
         st.rerun()
 
 def clear_widget_keys():
@@ -204,7 +237,13 @@ def clear_widget_keys():
 # ─── Optimization execution ──────────────────────────────────────────────────
 
 def run_and_store_result():
-    if sum(st.session_state.resource_caps.values()) <= 0:
+    custom_resources = st.session_state.get("custom_resources", [])
+
+    # Check that at least some resource is non-zero (standard OR custom)
+    std_total = sum(st.session_state.resource_caps.values())
+    print(custom_resources)
+    custom_total = sum(float(b["amount"]) for b in custom_resources)
+    if std_total <= 0 and custom_total <= 0:
         st.warning("⚠️ All resources are set to 0. Please set resource availability or load a scenario / input data.")
         return
 
@@ -212,6 +251,7 @@ def run_and_store_result():
         resource_caps=st.session_state.resource_caps,
         method_constraints=st.session_state.constraints,
         method_costs=st.session_state.costs,
+        custom_resources=custom_resources,
     )
 
     if not success:
@@ -237,20 +277,39 @@ def run_and_store_result():
         "resource_caps": st.session_state.resource_caps.copy(),
         "method_constraints": st.session_state.constraints,
         "method_costs": st.session_state.costs,
+        "custom_resources": custom_resources,
     }
-    st.success(f"✅ {total_removed:,.0f} {CO2_UNIT} removed")
+    if custom_resources:
+        st.info(f"ℹ️ {len(custom_resources)} new resource(s) included in optimisation.")
+    st.success(f"✅ {total_removed:,.4f} {CO2_UNIT} removed")
 
 
 # ─── Results display ─────────────────────────────────────────────────────────
 
 def show_metrics(latest):
-    col1, col2 = st.columns(2)
-    col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} {CO2_UNIT}")
-    col2.metric("Methods Used", len(latest["allocations"]))
+    custom_resources = latest.get("custom_resources", [])
+    cols = st.columns(3) if custom_resources else st.columns(2)
+    cols[0].metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.2f} {CO2_UNIT}")
+    cols[1].metric("Methods Used", len(latest["allocations"]))
+
+    # Show which custom batches were included and how much of each was available
+    if custom_resources:
+        with st.expander(f"✅ {len(custom_resources)} new resource(s) included in this optimisation", expanded=False):
+            rows = []
+            for batch in custom_resources:
+                unit = batch.get("group", "?")
+                rows.append({
+                    "Batch name": batch["name"],
+                    "Group": batch["group"],
+                    "Amount available": f"{float(batch['amount']):,.2f}",
+                    "Methods linked": ", ".join(batch["methods"].keys())
+                })
+            st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
 
 
 def build_results_df(allocations, method_constraints=None):
     df = pd.DataFrame.from_dict(allocations, orient="index", columns=[f"{CO2_UNIT} removed"])
+    print(df)
     df[f"{CO2_UNIT} removed"] = pd.to_numeric(df[f"{CO2_UNIT} removed"], errors="coerce")
     total = df[f"{CO2_UNIT} removed"].sum()
     if total > 0:
@@ -264,7 +323,7 @@ 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:
-                caps[m] = f"{int(c.get('cap_value', 1.0) * 100)}% of potential"
+                caps[m] = f"{int(c.get('cap_value', 100))}% of potential"
         df["Cap"] = pd.Series(caps)
     
     return df.sort_values(f"{CO2_UNIT} removed", ascending=False)
@@ -284,24 +343,44 @@ def show_donut(df_result):
     st.plotly_chart(fig, use_container_width=True)
 
 
-def show_heatmap(df_result, resource_caps, method_costs):
-    # Normalize method_costs keys for legacy scenarios
+def show_heatmap(df_result, resource_caps, method_costs, custom_resources=None):
+    # Normalize standard method_costs keys (strip legacy unit suffixes)
     normalized_costs = {
         m: {strip_unit_suffix(r): v for r, v in resources.items()}
         for m, resources in method_costs.items()
     }
 
-    available = [r for r in resource_order if resource_caps.get(r, 0) > 0]
+    # Inject custom resource coefficients (median)
+    for batch in (custom_resources or []):
+        for method, coefs in batch["methods"].items():
+            normalized_costs.setdefault(method, {})[batch["name"]] = coefs["median"]
+
+    # Build complete caps — resource_caps may not contain custom batches
+    # if latest_result was generated before the enriched_caps fix
+    full_caps = dict(resource_caps)
+    for batch in (custom_resources or []):
+        full_caps.setdefault(batch["name"], float(batch["amount"]))
+
+    standard_available = [r for r in resource_order if full_caps.get(r, 0) > 0]
+    extra_available = [b["name"] for b in (custom_resources or [])]
+    available = standard_available + extra_available
+
+    if not available:
+        st.info("No resources with non-zero availability to display.")
+        return
+
     matrix, y_labels = [], []
     for method in df_result.index:
         row = [
             (normalized_costs.get(method, {}).get(r, 0.0) * df_result.at[method, f"{CO2_UNIT} removed"]
-             / resource_caps[r] * 100) if resource_caps[r] > 0 else 0
+             / full_caps[r] * 100) if full_caps.get(r, 0) > 0 else 0
             for r in available
         ]
         matrix.append(row)
         y_labels.append(method)
 
+    height = max(400, 60 + 30 * len(y_labels))
+
     fig = go.Figure(data=go.Heatmap(
         z=matrix, x=available, y=y_labels,
         colorscale="Blues",
@@ -309,22 +388,43 @@ def show_heatmap(df_result, resource_caps, method_costs):
     ))
     fig.update_layout(
         title="Resource Usage vs. Cap",
-        xaxis_title="Resource", yaxis_title="Method", height=400,
+        xaxis_title="Resource", yaxis_title="Method", height=height,
+        xaxis=dict(tickangle=-35),
     )
     st.plotly_chart(fig, use_container_width=True)
 
-def show_absolute_usage(allocations, method_costs):
+def show_absolute_usage(allocations, method_costs, custom_resources=None):
     # Normalize method_costs keys: strip legacy unit suffixes
     normalized_costs = {
         m: {strip_unit_suffix(r): v for r, v in resources.items()}
         for m, resources in method_costs.items()
     }
 
-    # Build resource_units locally to avoid the overwrite bug when multiple categories share the same unit
+    # Build resource_units from standard groups
     _resource_units = defaultdict(list)
     for cat, resources in resource_groups.items():
         unit_key = f"{resource_unit_map[cat]}/MtCO2"
         _resource_units[unit_key].extend(resources)
+
+    resource_to_group = {
+        r: group
+        for group, resources in resource_groups.items()
+        for r in resources
+    }
+    
+    # Inject custom resource batches into the unit map
+    for batch in (custom_resources or []):
+        group = resource_to_group.get(batch["group"])
+        unit_key = f"{resource_unit_map.get(group, '?')}/MtCO2"
+        if batch["name"] not in _resource_units[unit_key]:
+            _resource_units[unit_key].append(batch["name"])
+        # Make sure the median coefficient is in normalized_costs
+        for method, coefs in batch["methods"].items():
+            if method in normalized_costs:
+                normalized_costs[method].setdefault(batch["name"], coefs["median"])
+            else:
+                normalized_costs[method] = {batch["name"]: coefs["median"]}
+
     local_resource_units = dict(_resource_units)
 
     rows = []
@@ -338,6 +438,7 @@ def show_absolute_usage(allocations, method_costs):
         return
 
     df = pd.DataFrame(rows)
+    print(df)
     for unit in df["Unit"].unique():
         st.markdown(f"#### Resources in {unit}")
         df_unit = df[df["Unit"] == unit]
@@ -353,7 +454,7 @@ def show_absolute_usage(allocations, method_costs):
 
 def save_scenario(latest):
     st.markdown("### Save scenario")
-    st.caption("Save the current scenario with inputs and outputs for comparison and/or export.")
+    st.markdown('<p class="caption">Save the current scenario with inputs and outputs for comparison and/or export.</p>', unsafe_allow_html=True)
 
     suggested = st.session_state.get("scenario_loaded_file", "").rsplit(".", 1)[0]
     
@@ -386,10 +487,10 @@ def export_scenario():
         return
 
     scenario = st.session_state.scenarios[name]
-    st.markdown(f"#### Scenario: {name}")
-    df_saved = build_results_df(scenario["allocations"], method_constraints=scenario.get("method_constraints"))
+    # st.markdown(f"#### Scenario: {name}")
+    # df_saved = build_results_df(scenario["allocations"], method_constraints=scenario.get("method_constraints"))
 
-    st.markdown(format_table_summary(df_saved,"cdr-table-res"), unsafe_allow_html=True)
+    # st.markdown(format_table_summary(df_saved,"cdr-table-res"), unsafe_allow_html=True)
 
     safe = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
     col_json, col_csv = st.columns(2)
@@ -407,13 +508,38 @@ def export_scenario():
         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", "cap_type (percent or absolute)", "cap_value"]).to_csv())
+        zf.writestr(
+            "method_constraints.csv",
+            pd.DataFrame.from_dict(
+                scenario["method_constraints"],
+                orient="index",
+                columns=["active", "cap_type", "cap_value"]
+            ).rename(columns={
+                "cap_type": "cap_type (percent or absolute)"
+            }).to_csv()
+        )
         zf.writestr("method_costs.csv",                      
                     pd.DataFrame.from_dict(scenario["method_costs"], orient="index").to_csv())
         zf.writestr("allocations.csv",
                     pd.DataFrame.from_dict(scenario["allocations"], orient="index",
                                            columns=[f"{CO2_UNIT} removed"]).to_csv())
+        # Custom resource batches — one row per (batch × method)
+        custom_batches = scenario.get("custom_resources", [])
+        if custom_batches:
+            custom_rows = []
+            for batch in custom_batches:
+                for method, coefs in batch["methods"].items():
+                    custom_rows.append({
+                        "name": batch["name"],
+                        "group": batch["group"],
+                        "amount": batch["amount"],
+                        "method": method,
+                        "min": coefs["min"],
+                        "median": coefs["median"],
+                        "max": coefs["max"],
+                    })
+            zf.writestr("custom_resources.csv", pd.DataFrame(custom_rows).to_csv(index=False))
+
     with col_csv:
         st.download_button(
             "Export CSV (zip)", data=buf.getvalue(),
@@ -429,7 +555,7 @@ def export_inputs_only():
         for r in resources
     }
     st.markdown("### Export inputs")
-    st.caption("Export only the resource capabilities, method constraints and coefficients — without results.")
+    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
@@ -461,7 +587,7 @@ def export_inputs_only():
         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", 1.0)])
+            ws2.append([m, c.get("active", True), c.get("cap_type", "percent"), c.get("cap_value", 100)])
 
         ws3 = wb.create_sheet("coefficients")
         ws3.append(["method", "resource", "value", "secondary"])
@@ -469,6 +595,21 @@ def export_inputs_only():
             for r, v in resources.items():
                 ws3.append([m, r, v, (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", []):
+            for method, c in batch["methods"].items():
+                ws4.append([
+                    batch["name"],
+                    batch["group"],
+                    batch["amount"],
+                    resource_unit_map.get(batch["group"]),
+                    method,
+                    c["min"],
+                    c["median"],
+                    c["max"],
+                ])
+
         buf = io.BytesIO()
         wb.save(buf)
 
@@ -513,7 +654,8 @@ def confirm_clear_all():
 def reset_scenario():
     st.divider()
     st.markdown("### Reset")
-    st.caption("Clear all current inputs, results and saved scenarios from the session.")
+    st.markdown('<p class="caption">Clear all current inputs, results and saved scenarios from the session.</p>', unsafe_allow_html=True)
+
     if st.button("Clear all data", key="reset_scenario", use_container_width=False, type="primary", icon=":material/delete:"):
         confirm_clear_all()
 
@@ -523,8 +665,20 @@ def render_tab():
     st.markdown('<h1 class="crra-heading">Portfolio generation</h1>', unsafe_allow_html=True)
     show_bar()
 
-    st.info(
-        "Run the optimization tool, explore results and save scenarios for comparison or export."
+    st.markdown(
+        """
+        <p class="objective_title">OBJECTIVE</p>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <div class="text_with_border">
+            <p>Run the optimization tool, explore results and save scenarios for comparison or export.</p>
+        </div>
+        """,
+        unsafe_allow_html=True
     )
 
     # Session state defaults
@@ -537,17 +691,26 @@ def render_tab():
         st.session_state.setdefault(key, default)
 
     # ── Two-column input area ─────────────────────���────────────────────────
-    st.markdown("### Run optimization")
+    st.markdown("""
+        <p class="crra-sub-heading">Run optimization</p>""",
+        unsafe_allow_html=True,
+    )
     col_inputs, col_scenario = st.columns(2, gap="large")
 
     with col_inputs:
-        st.markdown("#### From inputs")
+        st.markdown("""
+            <p class="crra-sub-sub-heading">From inputs</p>""",
+            unsafe_allow_html=True,
+        )
         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")
+        st.markdown("""
+            <p class="crra-sub-sub-heading">From a saved scenario</p>""",
+            unsafe_allow_html=True,
+        )
         panel_load_from_json_or_csv()
 
     # ── Execute if button pressed ──────────────────────────────────────────
@@ -567,20 +730,31 @@ def render_tab():
 
     # ── Results ────────────────────────────────────────────────────────────
     show_metrics(latest)
-    df_result = build_results_df(allocations, method_constraints=latest.get("method_constraints"))
+    df_result = build_results_df(
+        allocations,
+        method_constraints=latest.get("method_constraints")
+    )
+
+    df_display = df_result.copy()
+
+    df_display[f"{CO2_UNIT} removed"] = df_display[f"{CO2_UNIT} removed"].map(
+        lambda x: f"{x:,.2f}" if pd.notna(x) else x
+    )
 
     st.subheader("Optimization Summary")
-    # st.table(format_results_summary(df_result))
-    st.markdown(format_table_summary(df_result,"cdr-table-res"), unsafe_allow_html=True)
+    st.markdown(
+        format_table_summary(df_display, "cdr-table-res"),
+        unsafe_allow_html=True
+    )
 
     st.markdown("### Method allocation breakdown")
     show_donut(df_result)
 
     st.markdown("### Resource usage heatmap (% of cap)")
-    show_heatmap(df_result, resource_caps, method_costs)
+    show_heatmap(df_result, resource_caps, method_costs, custom_resources=latest.get("custom_resources", []))
 
     st.markdown("### Absolute resource usage by unit")
-    show_absolute_usage(allocations, method_costs)
+    show_absolute_usage(allocations, method_costs, custom_resources=latest.get("custom_resources", []))
 
     # ── Save & export & reset ───────────────────────────────────────────────────────
     save_scenario(latest)

tabs/tab5_sensitivity.py

@@ -12,11 +12,21 @@ def render_tab():
     st.markdown('<h1 class="crra-heading">Sensitivity analysis</h1>', unsafe_allow_html=True)
     show_bar()
 
-    st.info("""
-        **Objective**:
-        
-        - Explore how varying **one or multiple resources' availability** or **methods' maximum allocation** affects total CO₂ removed.
-    """)
+    st.markdown(
+        """
+        <p class="objective_title">OBJECTIVE</p>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <div class="text_with_border">
+            <p>Explore how varying <strong>one or multiple resources' availability</strong> or <strong>methods' maximum allocation</strong> affects total CO₂ removed.</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
 
     if "resource_caps" not in st.session_state or "constraints" not in st.session_state or "costs" not in st.session_state:
         st.warning("Please complete the setup in previous tabs before running sensitivity analysis.")
@@ -27,14 +37,18 @@ def render_tab():
         resource_caps=st.session_state.resource_caps,
         method_constraints=st.session_state.constraints,
         method_costs=st.session_state.costs,
+        custom_resources=st.session_state.get("custom_resources", []),
     )
     baseline_removed = baseline_result["total_removed"] if baseline_success else 0
 
     tab1, tab2 = st.tabs(["🔁 Resource sensitivity", "🔁 Method sensitivity"])
 
     with tab1:
-        st.subheader("Impact of resource availability")
-        selected_resources = st.multiselect("Select one or more resources:", resource_order)
+        st.markdown("""
+            <p class="crra-sub-heading">Impact of resource availability</p>""",
+            unsafe_allow_html=True,
+        )
+        selected_resources = st.multiselect("Select one or more resources:", resource_order,key="crra-select-resource")
 
         if not selected_resources:
             st.warning("Please select at least one resource to run the sensitivity analysis.")
@@ -52,6 +66,7 @@ def render_tab():
                         resource_caps=temp_caps,
                         method_constraints=st.session_state.constraints,
                         method_costs=st.session_state.costs,
+                        custom_resources=st.session_state.get("custom_resources", []),
                     )
 
                     co2_removed = result["total_removed"] if success else 0
@@ -71,7 +86,7 @@ def render_tab():
 
     with tab2:
         st.subheader("Impact of max allocation per method")
-        selected_methods = st.multiselect("Select one or more methods:", method_order)
+        selected_methods = st.multiselect("Select one or more methods:", method_order, key="crra-select-method")
 
         if not selected_methods:
             st.warning("Please select at least one method to run the sensitivity analysis.")
@@ -88,12 +103,13 @@ def render_tab():
                     for pct in percentages:
                         temp_constraints = st.session_state.constraints.copy()
                         temp_constraints[method]["cap_type"] = "percent"
-                        temp_constraints[method]["cap_value"] = pct / 100
+                        temp_constraints[method]["cap_value"] = pct
 
                         success, result = run_optimization(
                             resource_caps=st.session_state.resource_caps,
                             method_constraints=temp_constraints,
                             method_costs=st.session_state.costs,
+                            custom_resources=st.session_state.get("custom_resources", []),
                         )
                         co2_removed = result["total_removed"] if success else 0
                         all_data.append({
@@ -131,6 +147,7 @@ def render_tab():
                             resource_caps=st.session_state.resource_caps,
                             method_constraints=temp_constraints,
                             method_costs=st.session_state.costs,
+                            custom_resources=st.session_state.get("custom_resources", []),
                         )
                         co2_removed = result["total_removed"] if success else 0
                         all_data.append({
@@ -145,4 +162,4 @@ def render_tab():
                     sns.lineplot(data=df, x=f"Cap ({CO2_UNIT}/yr)", y=f"CO₂ removed ({CO2_UNIT})", hue="Input", ax=ax)
                     ax.axhline(y=baseline_removed, linestyle="--", color="gray", label=f"Baseline: {baseline_removed:,} {CO2_UNIT}")
                     ax.legend()
-                    st.pyplot(fig)
+                    st.pyplot(fig)

tabs/tab6_scenarios.py

@@ -13,8 +13,11 @@ from utils.ui_helpers import show_bar
 # ─── Load from file ───────────────────────────────────────────────────────────
 
 def panel_load_scenario():
-    st.markdown("### Load a scenario from file")
-    st.caption("Accepts `.json` or `.zip` (CSV export)")
+    st.markdown("""
+        <p class="crra-sub-heading">Load a scenario from file</p>""",
+        unsafe_allow_html=True,
+    )
+    st.markdown('<p class="caption">Accepts `.json` or `.zip` (CSV export)</p>', unsafe_allow_html=True)
 
     uploaded = st.file_uploader("Upload scenario", type=["json", "zip"], key="comparison_loader", accept_multiple_files=True)
     if uploaded is None:

utils/data_utils.py

@@ -5,7 +5,7 @@ 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
+from config.config import resource_unit_map
 
 @st.cache_data
 def load_slider_data():
@@ -53,18 +53,18 @@ def load_inputs_from_excel(file):
     if "constraints" in xl:
         for _, row in xl["constraints"].iterrows():
             # Compatibility with older files that used `max_share`
-            if "cap_type (percent or absolute)" in xl["constraints"].columns:
+            # if "cap_type (percent or absolute)" in xl["constraints"].columns:
                 constraints[row["method"]] = {
                     "active": bool(row["active"]),
                     "cap_type": str(row["cap_type (percent or absolute)"]),
                     "cap_value": float(row["cap_value"])
                 }
-            else:
-                constraints[row["method"]] = {
-                    "active": bool(row["active"]),
-                    "cap_type": "percent",
-                    "cap_value": float(row["max_share"])
-                }
+            # else:
+            #     constraints[row["method"]] = {
+            #         "active": bool(row["active"]),
+            #         "cap_type": "percent",
+            #         "cap_value": float(row["max_share"])
+            #     }
 
     costs = {}
     if "coefficients" in xl:
@@ -72,7 +72,33 @@ def load_inputs_from_excel(file):
             m, r, v = row["method"], row["resource"], float(row["value"])
             costs.setdefault(m, {})[r] = v
 
-    return resource_caps, constraints, costs
+    custom_resources = []
+    print("--------------------------------")
+    if "custom_resources" in xl:
+        df_custom = xl["custom_resources"]
+        if not df_custom.empty:
+            for name in df_custom["name"].unique():
+                df_b = df_custom[df_custom["name"] == name]
+                batch = {
+                    "name": name,
+                    "group": df_b["group"].iloc[0],
+                    "amount": float(df_b["amount"].iloc[0]),
+                    "unit": resource_unit_map.get(
+                        df_b["group"].iloc[0],
+                        ""
+                    ),
+                    "methods": {}
+                }
+
+                for _, row in df_b.iterrows():
+                    batch["methods"][row["method"]] = {
+                        "min": float(row["min"]),
+                        "median": float(row["median"]),
+                        "max": float(row["max"]),
+                    }
+                custom_resources.append(batch)
+
+    return resource_caps, constraints, costs, custom_resources
 
 def strip_unit_suffix(resource_name: str) -> str:
     """Remove legacy unit suffix from resource name, e.g. 'Unspecified land (ha/tCO2)' -> 'Unspecified land'"""

utils/ui_helpers.py

@@ -183,15 +183,22 @@ def format_results_table(df, highlight_changes=False, precision=2):
     return styled
 
 def format_resource_summary(df: pd.DataFrame):
-    """
-    Format a resource availability summary table with styling and column width control.
-    """
     df = df.copy()
     df.index.name = "Resource"
     df = df.reset_index()
-    
-    html = df.to_html(index=True, classes="resources-summary", border=0)
-    return html
+
+    def highlight_new(row):
+        if row.get("Type") == "New":
+            return ["color: #ff5f4d; font-weight: bold"] * len(row)
+        return [""] * len(row)
+
+    styled = (
+        df.style
+        .apply(highlight_new, axis=1)
+        .set_table_attributes('class="resources-summary"')
+    )
+
+    return styled.to_html()
 
 def smart_display_format(val):
     if abs(val) < 1e-8: