Update app.py

app.py

@@ -522,4 +522,352 @@ def gsd_curve_ui():
 
     st.info("Upload a CSV (two columns: diameter_mm, percent_passing) or enter diameters and % passing manually. I will compute D10, D30, D60 and save them for the active site.")
 
-    col_up, col_manual = st.col
+    col_up, col_manual = st.columns([1,1])
+    uploaded = None
+    sieve = None; passing = None
+    with col_up:
+        uploaded = st.file_uploader("Upload CSV (diameter_mm, percent_passing)", type=["csv","txt"], key=f"gsd_upload_{site['Site Name']}")
+        if uploaded:
+            try:
+                df = pd.read_csv(uploaded)
+                # heuristic: first numeric column = diameter, second numeric = percent passing
+                numeric_cols = [c for c in df.columns if np.issubdtype(df[c].dtype, np.number)]
+                if len(numeric_cols) >= 2:
+                    sieve = df[numeric_cols[0]].values.astype(float)
+                    passing = df[numeric_cols[1]].values.astype(float)
+                else:
+                    # try to coerce
+                    sieve = df.iloc[:,0].astype(float).values
+                    passing = df.iloc[:,1].astype(float).values
+                st.success("CSV loaded.")
+            except Exception as e:
+                st.error(f"Error reading CSV: {e}")
+                sieve = passing = None
+
+    with col_manual:
+        diam_text = st.text_area("Diameters (mm) comma-separated (e.g. 75,50,37.5,...)", key=f"gsd_diams_{site['Site Name']}")
+        pass_text = st.text_area("% Passing comma-separated (same order)", key=f"gsd_pass_{site['Site Name']}")
+        if diam_text.strip() and pass_text.strip():
+            try:
+                sieve = np.array([float(x.strip()) for x in diam_text.split(",") if x.strip()])
+                passing = np.array([float(x.strip()) for x in pass_text.split(",") if x.strip()])
+            except Exception as e:
+                st.error(f"Invalid manual input: {e}")
+                sieve = passing = None
+
+    if sieve is None or passing is None:
+        st.info("Provide GSD data above to compute D-values.")
+        return
+
+    # Sort descending by sieve
+    order = np.argsort(-sieve)
+    sieve = sieve[order]; passing = passing[order]
+    # Ensure percent is in 0-100
+    if np.any(passing < 0) or np.any(passing > 100):
+        st.warning("Some % passing values are outside 0-100. Please verify.")
+    # Interpolate percent -> diameter (need percent increasing)
+    percent = passing.copy()
+    if not np.all(np.diff(percent) >= 0):
+        percent = percent[::-1]; sieve = sieve[::-1]
+    # Ensure arrays are floats
+    percent = percent.astype(float); sieve = sieve.astype(float)
+    # interpolation function (percent -> diameter)
+    def interp_d(pct: float) -> Optional[float]:
+        try:
+            # xp must be increasing
+            return float(np.interp(pct, percent, sieve))
+        except Exception:
+            return None
+    D10 = interp_d(10.0); D30 = interp_d(30.0); D60 = interp_d(60.0)
+    Cu = (D60 / D10) if (D10 and D60 and D10>0) else None
+    Cc = (D30**2)/(D10*D60) if (D10 and D30 and D60 and D10>0) else None
+
+    # Plot
+    fig, ax = plt.subplots(figsize=(7,4))
+    ax.plot(sieve, passing, marker='o', label="% Passing")
+    ax.set_xscale('log')
+    ax.invert_xaxis()
+    ax.set_xlabel("Particle diameter (mm) — log scale")
+    ax.set_ylabel("% Passing")
+    if D10: ax.axvline(D10, color='orange', linestyle='--', label=f"D10={D10:.4g} mm")
+    if D30: ax.axvline(D30, color='red', linestyle='--', label=f"D30={D30:.4g} mm")
+    if D60: ax.axvline(D60, color='blue', linestyle='--', label=f"D60={D60:.4g} mm")
+    ax.grid(True, which='both', linestyle='--', linewidth=0.4)
+    ax.legend()
+    st.pyplot(fig)
+
+    # Save to active site
+    idx, sdict = active_site()
+    sdict["GSD"] = {
+        "sieve_mm": sieve.tolist(),
+        "percent_passing": passing.tolist(),
+        "D10": float(D10) if D10 is not None else None,
+        "D30": float(D30) if D30 is not None else None,
+        "D60": float(D60) if D60 is not None else None,
+        "Cu": float(Cu) if Cu is not None else None,
+        "Cc": float(Cc) if Cc is not None else None
+    }
+    ss["site_descriptions"][idx] = sdict
+    st.success(f"Saved GSD to site: D10={D10}, D30={D30}, D60={D60}")
+    if st.button("Copy D-values to Soil Classifier inputs (for this site)", key=f"copy_d_to_cls_{sdict['Site Name']}"):
+        ss.setdefault("classifier_states", {})
+        ss["classifier_states"].setdefault(sdict["Site Name"], {"step":0, "inputs":{}})
+        ss["classifier_states"][sdict["Site Name"]]["inputs"]["D10"] = float(D10) if D10 is not None else 0.0
+        ss["classifier_states"][sdict["Site Name"]]["inputs"]["D30"] = float(D30) if D30 is not None else 0.0
+        ss["classifier_states"][sdict["Site Name"]]["inputs"]["D60"] = float(D60) if D60 is not None else 0.0
+        st.info("Copied. Go to Soil Classifier page and continue.")
+    st.markdown("---")
+    st.caption("Tip: If your classifier asks for D-values and you don't have them, compute them here and copy them back.")
+
+# -------------------------
+# Soil Classifier (chatbot-style; smart input flow)
+# -------------------------
+def soil_classifier_ui():
+    st.header("🧪 Soil Classifier — Chatbot-style (smart inputs)")
+    idx, sdict = active_site()
+    site_name = sdict["Site Name"]
+
+    # Prepare classifier state container per-site
+    ss.setdefault("classifier_states", {})
+    state = ss["classifier_states"].setdefault(site_name, {"step":0, "inputs":{}})
+
+    # Pre-populate inputs from site GSD if present
+    if sdict.get("GSD"):
+        g = sdict["GSD"]
+        state["inputs"].setdefault("D10", g.get("D10", 0.0))
+        state["inputs"].setdefault("D30", g.get("D30", 0.0))
+        state["inputs"].setdefault("D60", g.get("D60", 0.0))
+
+    # Dropdown exact strings mapping per your requested table
+    dil_options = [
+        "1. Quick to slow",
+        "2. None to very slow",
+        "3. Slow",
+        "4. Slow to none",
+        "5. None",
+        "6. Null?"
+    ]
+    tough_options = [
+        "1. None",
+        "2. Medium",
+        "3. Slight?",
+        "4. Slight to Medium?",
+        "5. High",
+        "6. Null?"
+    ]
+    dry_options = [
+        "1. None to slight",
+        "2. Medium to high",
+        "3. Slight to Medium",
+        "4. High to very high",
+        "5. Null?"
+    ]
+
+    # Mode selector: Both / USCS only / AASHTO only
+    if "classifier_mode" not in ss:
+        ss["classifier_mode"] = {}
+    ss["classifier_mode"].setdefault(site_name, "Both")
+    mode = st.selectbox("Classification mode", ["Both", "USCS only", "AASHTO only"], index=["Both","USCS only","AASHTO only"].index(ss["classifier_mode"][site_name]), key=f"mode_{site_name}")
+    ss["classifier_mode"][site_name] = mode
+
+    # Step machine:
+    step = state.get("step", 0)
+    inputs = state.setdefault("inputs", {})
+
+    def goto(n):
+        state["step"] = n
+        ss["classifier_states"][site_name] = state
+        safe_rerun()
+
+    def save_input(key, value):
+        inputs[key] = value
+        state["inputs"] = inputs
+        ss["classifier_states"][site_name] = state
+
+    # Chat style UI: show recent conversation history as simple list
+    st.markdown(f"**Active site:** {site_name}")
+    st.markdown("---")
+
+    if step == 0:
+        st.markdown("**GeoMate:** Hello! I'm the Soil Classifier bot. Shall we begin classification for this site?")
+        c1, c2 = st.columns(2)
+        if c1.button("Yes — Start", key=f"cls_start_{site_name}"):
+            goto(1)
+        if c2.button("Cancel", key=f"cls_cancel_{site_name}"):
+            st.info("Classifier cancelled.")
+
+    elif step == 1:
+        st.markdown("**GeoMate:** Is the soil organic (contains high organic matter, spongy, odour)?")
+        c1, c2 = st.columns(2)
+        if c1.button("No (inorganic)", key=f"org_no_{site_name}"):
+            save_input("opt", "n"); goto(2)
+        if c2.button("Yes (organic)", key=f"org_yes_{site_name}"):
+            save_input("opt", "y"); goto(12)  # skip to final classification for organic
+
+    elif step == 2:
+        st.markdown("**GeoMate:** What is the percentage passing the #200 sieve (0.075 mm)?")
+        val = st.number_input("Percentage passing #200 (P2)", value=float(inputs.get("P2",0.0)), min_value=0.0, max_value=100.0, key=f"P2_input_{site_name}", format="%.2f")
+        c1, c2, c3 = st.columns([1,1,1])
+        if c1.button("Next", key=f"P2_next_{site_name}"):
+            save_input("P2", float(val)); goto(3)
+        if c2.button("Skip", key=f"P2_skip_{site_name}"):
+            save_input("P2", 0.0); goto(3)
+        if c3.button("Back", key=f"P2_back_{site_name}"):
+            goto(0)
+
+    elif step == 3:
+        # decide path based on P2
+        P2 = float(inputs.get("P2", 0.0))
+        if P2 > 50:
+            st.markdown("**GeoMate:** P2 > 50 — fine-grained soil path selected.")
+            if st.button("Continue (fine-grained)", key=f"cont_fine_{site_name}"):
+                goto(4)
+        else:
+            st.markdown("**GeoMate:** P2 <= 50 — coarse-grained soil path selected.")
+            if st.button("Continue (coarse-grained)", key=f"cont_coarse_{site_name}"):
+                goto(6)
+
+    # Fine-grained branch
+    elif step == 4:
+        st.markdown("**GeoMate:** Enter Liquid Limit (LL).")
+        val = st.number_input("Liquid Limit (LL)", value=float(inputs.get("LL",0.0)), min_value=0.0, max_value=200.0, key=f"LL_{site_name}", format="%.2f")
+        col1, col2 = st.columns(2)
+        if col1.button("Next", key=f"LL_next_{site_name}"):
+            save_input("LL", float(val)); goto(5)
+        if col2.button("Back", key=f"LL_back_{site_name}"):
+            goto(3)
+
+    elif step == 5:
+        st.markdown("**GeoMate:** Enter Plastic Limit (PL).")
+        val = st.number_input("Plastic Limit (PL)", value=float(inputs.get("PL",0.0)), min_value=0.0, max_value=200.0, key=f"PL_{site_name}", format="%.2f")
+        col1, col2 = st.columns(2)
+        if col1.button("Next", key=f"PL_next_{site_name}"):
+            save_input("PL", float(val)); goto(11)  # go to descriptors step
+        if col2.button("Back", key=f"PL_back_{site_name}"):
+            goto(4)
+
+    # Coarse branch: ask % passing #4 and D-values option
+    elif step == 6:
+        st.markdown("**GeoMate:** What is the % passing sieve no. 4 (4.75 mm)?")
+        val = st.number_input("% passing #4 (P4)", value=float(inputs.get("P4",0.0)), min_value=0.0, max_value=100.0, key=f"P4_{site_name}", format="%.2f")
+        c1, c2, c3 = st.columns([1,1,1])
+        if c1.button("Next", key=f"P4_next_{site_name}"):
+            save_input("P4", float(val)); goto(7)
+        if c2.button("Compute D-values (GSD page)", key=f"P4_gsd_{site_name}"):
+            st.info("Please use GSD Curve page to compute D-values and then copy them back to classifier.")
+        if c3.button("Back", key=f"P4_back_{site_name}"):
+            goto(3)
+
+    elif step == 7:
+        st.markdown("**GeoMate:** Do you know D60, D30, D10 diameters (mm)?")
+        c1, c2, c3 = st.columns([1,1,1])
+        if c1.button("Yes — enter values", key=f"dvals_yes_{site_name}"):
+            goto(8)
+        if c2.button("No — compute from GSD", key=f"dvals_no_{site_name}"):
+            st.info("Use the GSD Curve page and then click 'Copy D-values to Soil Classifier' there.")
+        if c3.button("Skip", key=f"dvals_skip_{site_name}"):
+            save_input("D60", 0.0); save_input("D30", 0.0); save_input("D10", 0.0); goto(11)
+
+    elif step == 8:
+        st.markdown("**GeoMate:** Enter D60 (mm)")
+        val = st.number_input("D60 (mm)", value=float(inputs.get("D60",0.0)), min_value=0.0, key=f"D60_{site_name}")
+        if st.button("Next", key=f"D60_next_{site_name}"):
+            save_input("D60", float(val)); goto(9)
+        if st.button("Back", key=f"D60_back_{site_name}"):
+            goto(7)
+
+    elif step == 9:
+        st.markdown("**GeoMate:** Enter D30 (mm)")
+        val = st.number_input("D30 (mm)", value=float(inputs.get("D30",0.0)), min_value=0.0, key=f"D30_{site_name}")
+        if st.button("Next", key=f"D30_next_{site_name}"):
+            save_input("D30", float(val)); goto(10)
+        if st.button("Back", key=f"D30_back_{site_name}"):
+            goto(8)
+
+    elif step == 10:
+        st.markdown("**GeoMate:** Enter D10 (mm)")
+        val = st.number_input("D10 (mm)", value=float(inputs.get("D10",0.0)), min_value=0.0, key=f"D10_{site_name}")
+        if st.button("Next", key=f"D10_next_{site_name}"):
+            save_input("D10", float(val)); goto(11)
+        if st.button("Back", key=f"D10_back_{site_name}"):
+            goto(9)
+
+    # descriptors (for fine soils) and finishing
+    elif step == 11:
+        st.markdown("**GeoMate:** Fine soil descriptors (if applicable). You can skip.")
+        sel_dry = st.selectbox("Dry strength", dry_options, index=min(2, len(dry_options)-1), key=f"dry_{site_name}")
+        sel_dil = st.selectbox("Dilatancy", dil_options, index=0, key=f"dil_{site_name}")
+        sel_tg = st.selectbox("Toughness", tough_options, index=0, key=f"tough_{site_name}")
+        col1, col2, col3 = st.columns([1,1,1])
+        # map to numeric - map strings to numbers i+1
+        dry_map = {dry_options[i]: i+1 for i in range(len(dry_options))}
+        dil_map = {dil_options[i]: i+1 for i in range(len(dil_options))}
+        tough_map = {tough_options[i]: i+1 for i in range(len(tough_options))}
+        if col1.button("Save & Continue", key=f"desc_save_{site_name}"):
+            save_input("nDS", dry_map.get(sel_dry, 5))
+            save_input("nDIL", dil_map.get(sel_dil, 6))
+            save_input("nTG", tough_map.get(sel_tg, 6))
+            goto(12)
+        if col2.button("Skip descriptors", key=f"desc_skip_{site_name}"):
+            save_input("nDS", 5); save_input("nDIL", 6); save_input("nTG", 6); goto(12)
+        if col3.button("Back", key=f"desc_back_{site_name}"):
+            # go to previous appropriate step
+            # if LL in inputs, go to LL/PL steps else go to coarse branch
+            if inputs.get("LL") is not None and inputs.get("PL") is not None:
+                goto(5)
+            else:
+                goto(6)
+
+    elif step == 12:
+        st.markdown("**GeoMate:** Ready to classify. Review inputs and press **Classify**.")
+        st.json(inputs)
+        col1, col2 = st.columns([1,1])
+        if col1.button("Classify", key=f"classify_now_{site_name}"):
+            try:
+                res_text, uscs_sym, aashto_sym, GI, char_summary = uscs_aashto_from_inputs(inputs)
+                # Save to site dict
+                sdict["USCS"] = uscs_sym
+                sdict["AASHTO"] = aashto_sym
+                sdict["GI"] = GI
+                sdict["classifier_inputs"] = inputs
+                sdict["classifier_decision_path"] = res_text
+                # persist
+                ss["site_descriptions"][ss["active_site_index"]] = sdict
+                st.success("Classification complete and saved.")
+                st.markdown("### Result")
+                if mode == "USCS only":
+                    st.markdown(f"**USCS:** {uscs_sym}")
+                elif mode == "AASHTO only":
+                    st.markdown(f"**AASHTO:** {aashto_sym} (GI={GI})")
+                else:
+                    st.markdown(res_text)
+                # offer PDF export
+                if FPDF_OK and st.button("Export Classification PDF", key=f"exp_cls_pdf_{site_name}"):
+                    pdf = FPDF()
+                    pdf.add_page()
+                    pdf.set_font("Arial", "B", 14)
+                    pdf.cell(0, 8, f"GeoMate Classification — {site_name}", ln=1)
+                    pdf.ln(4)
+                    pdf.set_font("Arial", "", 11)
+                    pdf.multi_cell(0, 7, res_text)
+                    pdf.ln(4)
+                    pdf.set_font("Arial", "B", 12)
+                    pdf.cell(0, 6, "Inputs:", ln=1)
+                    pdf.set_font("Arial", "", 10)
+                    for k, v in inputs.items():
+                        pdf.cell(0,5, f"{k}: {v}", ln=1)
+                    fn = f"{site_name.replace(' ','_')}_classification.pdf"
+                    pdf.output(fn)
+                    with open(fn,"rb") as f:
+                        st.download_button("Download PDF", f, file_name=fn, mime="application/pdf")
+                # done
+            except Exception as e:
+                st.error(f"Classification failed: {e}\n{traceback.format_exc()}")
+        if col2.button("Back to edit", key=f"back_edit_{site_name}"):
+            goto(11)
+
+    else:
+        st.warning("Classifier state reset.")
+        state["step"] = 0
+        ss["classifier_states"][site_name] = state
+