Fix caching: avoid rerunning inverse design during thermoforming

.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.ipynb_checkpoints/
+
+# OS/editor
+.DS_Store
+.vscode/
+.idea/

inverse_design_demo/app.py

@@ -200,6 +200,8 @@ if 'input_curve_button_clicked' not in st.session_state:
     st.session_state.input_curve_button_clicked= False
 def input_curve_click():
     st.session_state.input_curve_button_clicked = True
+    # allow repeated attempts: each click increments run id
+    st.session_state.input_curve_run_id = int(st.session_state.get("input_curve_run_id", 0)) + 1
     
 if 'material_design_button_clicked' not in st.session_state:
     st.session_state.material_design_button_clicked= False
@@ -217,6 +219,8 @@ if 'forming_design_button_clicked' not in st.session_state:
     st.session_state.forming_design_button_clicked= False
 def forming_design_click():
     st.session_state.forming_design_button_clicked = True
+    # allow repeated attempts: each click increments run id
+    st.session_state.forming_design_run_id = int(st.session_state.get("forming_design_run_id", 0)) + 1
       
 
 
@@ -236,6 +240,36 @@ angle=30
 #######################
 # Backend helpers (no UI changes)
 
+def _is_git_lfs_pointer_file(path: str) -> bool:
+    """
+    Hugging Face / git checkouts sometimes contain Git-LFS pointer files instead of real data.
+    Detect that case so we can fall back to a real dataset path (or raise a clearer error).
+    """
+    try:
+        if not os.path.isfile(path):
+            return False
+        # Pointer files are tiny (a few hundred bytes).
+        if os.path.getsize(path) > 2048:
+            return False
+        with open(path, "r") as f:
+            head = f.read(256)
+        return "git-lfs.github.com/spec/v1" in head
+    except Exception:
+        return False
+
+
+def _choose_first_real_data_dir(candidates: list[str]) -> str:
+    """
+    Pick the first candidate that contains a non-LFS metadata.json.
+    Returns the first candidate if none match (caller may still error later with a clear message).
+    """
+    for d in candidates:
+        meta = os.path.join(str(d), "metadata.json")
+        if os.path.exists(meta) and (not _is_git_lfs_pointer_file(meta)):
+            return str(d)
+    return str(candidates[0]) if candidates else ""
+
+
 DEFAULT_CHECKPOINT_DIR = os.environ.get(
     "MG_CHECKPOINT_DIR",
     os.path.join(
@@ -246,9 +280,14 @@ DEFAULT_CHECKPOINT_DIR = os.environ.get(
         "exp_20260114_164540",
     ),
 )
+
+# NOTE: The Space repo can contain LFS pointers for large datasets. Prefer a "real" dataset
+# if available (commonly checked out at the MaterialGeneration root alongside this repo).
+_default_data_dir_space = os.path.join(ROOT_DIR, "data_generation", "processed_dataset", "config_1")
+_default_data_dir_root = os.path.abspath(os.path.join(ROOT_DIR, "..", "data_generation", "processed_dataset", "config_1"))
 DEFAULT_DATA_DIR = os.environ.get(
     "MG_DATA_DIR",
-    os.path.join(ROOT_DIR, "data_generation", "processed_dataset", "config_1"),
+    _choose_first_real_data_dir([_default_data_dir_space, _default_data_dir_root]),
 )
 DEFAULT_CURVE_DIR = os.environ.get(
     "MG_CURVE_DIR",
@@ -463,6 +502,18 @@ def _load_poly_metadata_small(data_dir: str) -> dict:
     meta_path = os.path.join(str(data_dir), "metadata.json")
     if not os.path.exists(meta_path):
         raise FileNotFoundError(f"metadata.json not found in {data_dir}")
+    if _is_git_lfs_pointer_file(meta_path):
+        raise RuntimeError(
+            "\n".join(
+                [
+                    "metadata.json looks like a Git-LFS pointer file, not the actual dataset.",
+                    f"path: {meta_path}",
+                    "Fix options:",
+                    "  - Point MG_DATA_DIR to a real dataset folder that contains the full metadata.json, or",
+                    "  - If this repo was cloned with git-lfs available, run: git lfs pull",
+                ]
+            )
+        )
 
     # These keys live very early in the file (per grep): keep this small for Streamlit responsiveness.
     keys = [
@@ -475,16 +526,39 @@ def _load_poly_metadata_small(data_dir: str) -> dict:
         "angle_max",
     ]
 
+    # Start small for responsiveness, but grow if needed (some metadata.json variants have these keys later).
+    max_prefix_bytes = 8_000_000
     prefix_bytes = 256_000
+    prefix = ""
     with open(meta_path, "r") as f:
-        prefix = f.read(prefix_bytes)
-
-    out = {}
-    for k in keys:
-        raw = _extract_json_value_prefix(prefix, k)
-        # json.loads handles arrays and numeric scalars (including scientific notation)
-        out[k] = json.loads(raw)
-    return out
+        while True:
+            prefix = f.read(prefix_bytes)
+            try:
+                out = {}
+                for k in keys:
+                    raw = _extract_json_value_prefix(prefix, k)
+                    out[k] = json.loads(raw)
+                return out
+            except KeyError:
+                # Not all keys in the current prefix; try a larger read.
+                if prefix_bytes >= max_prefix_bytes:
+                    break
+                prefix_bytes = min(int(prefix_bytes * 2), max_prefix_bytes)
+                f.seek(0)
+
+    # Last resort: if we still couldn't find keys in a large prefix, try loading full JSON only
+    # when it won't explode memory.
+    try:
+        size = os.path.getsize(meta_path)
+    except Exception:
+        size = None
+    if size is not None and size <= 64_000_000:
+        with open(meta_path, "r") as f:
+            full = json.load(f)
+        return {k: full[k] for k in keys}
+    raise KeyError(
+        f"Could not locate required keys {keys} in the first {prefix_bytes} bytes of metadata.json at {meta_path}"
+    )
 
 
 @st.cache_resource(show_spinner=False)
@@ -819,43 +893,72 @@ if st.session_state.input_changed == True:
         del st.session_state["inverse_design_result"]
     if "material_design_last_run_id" in st.session_state:
         del st.session_state["material_design_last_run_id"]
+    if "input_curve_last_run_id" in st.session_state:
+        del st.session_state["input_curve_last_run_id"]
+    if "forming_design_result" in st.session_state:
+        del st.session_state["forming_design_result"]
+    if "forming_design_last_run_id" in st.session_state:
+        del st.session_state["forming_design_last_run_id"]
     st.session_state.input_changed = False
     
 st.button("Generate required stress-strain curves", use_container_width=True, on_click=input_curve_click)
  
 if  st.session_state.input_curve_button_clicked == True:
-    #st.write(E1aV)
-    #st.write(E1bV)
-    n_pts = int(max(4, N_INPUT_POINTS))
-    x = np.linspace(0, 0.1, n_pts)
-    A = np.array([[0.2, 0.03], [0.01, 0.001]])
-    b = np.array([E1bV-E1aV, S1bV-E1aV*0.1])
-    a = np.linalg.solve(A, b)
-    y1= E1aV*x + a[0]*x**2 + a[1]*x**3
-    b = np.array([E2bV-E2aV, S2bV-E2aV*0.1])
-    a = np.linalg.solve(A, b)
-    y2= E2aV*x + a[0]*x**2 + a[1]*x**3
-    b = np.array([G12bV-G12aV, S12bV-G12aV*0.1])
-    a = np.linalg.solve(A, b)
-    y3= G12aV*x + a[0]*x**2 + a[1]*x**3
-    
-    y4 = v12aV*x + (v12bV - v12aV)/0.2*x*x
-    y5 = v21aV*x + (v21bV - v21aV)/0.2*x*x
-
-    # Cache required curves for inverse design (model conditioning)
-    st.session_state.required_curves = {
-        "eps11": x.astype(np.float32),
-        "sig11_mpa": y1.astype(np.float32),
-        "eps22": x.astype(np.float32),
-        "sig22_mpa": y2.astype(np.float32),
-        "eps12": x.astype(np.float32),
-        "sig12_mpa": y3.astype(np.float32),
-        "eps22_from_eps11": (-y4).astype(np.float32),
-        "eps11_from_eps22": (-y5).astype(np.float32),
-    }
-    # New curves -> invalidate any previous inverse-design result
-    if "inverse_design_result" in st.session_state:
-        del st.session_state["inverse_design_result"]
+    # Only (re)generate curves when the user explicitly clicks the button again,
+    # or when curves don't exist yet. Otherwise keep cached curves to avoid
+    # invalidating material inverse design on unrelated reruns (e.g. thermoforming clicks).
+    current_curve_run_id = int(st.session_state.get("input_curve_run_id", 0))
+    last_curve_run_id = int(st.session_state.get("input_curve_last_run_id", -1))
+    if ("required_curves" not in st.session_state) or (current_curve_run_id != last_curve_run_id):
+        #st.write(E1aV)
+        #st.write(E1bV)
+        n_pts = int(max(4, N_INPUT_POINTS))
+        x = np.linspace(0, 0.1, n_pts)
+        A = np.array([[0.2, 0.03], [0.01, 0.001]])
+        b = np.array([E1bV-E1aV, S1bV-E1aV*0.1])
+        a = np.linalg.solve(A, b)
+        y1= E1aV*x + a[0]*x**2 + a[1]*x**3
+        b = np.array([E2bV-E2aV, S2bV-E2aV*0.1])
+        a = np.linalg.solve(A, b)
+        y2= E2aV*x + a[0]*x**2 + a[1]*x**3
+        b = np.array([G12bV-G12aV, S12bV-G12aV*0.1])
+        a = np.linalg.solve(A, b)
+        y3= G12aV*x + a[0]*x**2 + a[1]*x**3
+        
+        y4 = v12aV*x + (v12bV - v12aV)/0.2*x*x
+        y5 = v21aV*x + (v21bV - v21aV)/0.2*x*x
+
+        # Cache required curves for inverse design (model conditioning)
+        st.session_state.required_curves = {
+            "eps11": x.astype(np.float32),
+            "sig11_mpa": y1.astype(np.float32),
+            "eps22": x.astype(np.float32),
+            "sig22_mpa": y2.astype(np.float32),
+            "eps12": x.astype(np.float32),
+            "sig12_mpa": y3.astype(np.float32),
+            "eps22_from_eps11": (-y4).astype(np.float32),
+            "eps11_from_eps22": (-y5).astype(np.float32),
+        }
+        st.session_state.input_curve_last_run_id = current_curve_run_id
+
+        # New curves -> invalidate any previous inverse-design result
+        if "inverse_design_result" in st.session_state:
+            del st.session_state["inverse_design_result"]
+        if "material_design_last_run_id" in st.session_state:
+            del st.session_state["material_design_last_run_id"]
+        # ...and any downstream thermoforming process result (it depends on material design)
+        if "forming_design_result" in st.session_state:
+            del st.session_state["forming_design_result"]
+        if "forming_design_last_run_id" in st.session_state:
+            del st.session_state["forming_design_last_run_id"]
+    else:
+        curves = st.session_state.required_curves
+        x = np.asarray(curves["eps11"], dtype=np.float32)
+        y1 = np.asarray(curves["sig11_mpa"], dtype=np.float32)
+        y2 = np.asarray(curves["sig22_mpa"], dtype=np.float32)
+        y3 = np.asarray(curves["sig12_mpa"], dtype=np.float32)
+        y4 = -np.asarray(curves["eps22_from_eps11"], dtype=np.float32)
+        y5 = -np.asarray(curves["eps11_from_eps22"], dtype=np.float32)
 
  
     #ylimit=np.max([np.max(y1),np.max(y2), np.max(y3)])
@@ -1102,19 +1205,27 @@ if  st.session_state.input_curve_button_clicked == True:
         st.write("")
         st.button("Thermoforming Requirements", use_container_width=True, on_click=forming_input_click)
         if  st.session_state.forming_input_button_clicked == True:
+            # Safety: thermoforming steps require a material inverse design result.
+            if "inverse_design_result" not in st.session_state:
+                st.warning("Please run 'Material Inverse Design' first. Thermoforming steps reuse that result and will not recompute it.")
+                st.stop()
         #st.write("")
         # 4th row with 3 columns
             col1_row4, col2_row4, col3_row4, col4_row4, col5_row4 = st.columns([0.16,0.16,0.2,0.24,0.24])
             with col1_row4:
                 with st.container(border=False): # Container with a border
-                    st.write("Matrix material", "PEEK")
-                    st.write("Fiber material=", "Carbon")
-                    st.write("Number of layers=", nlayers)
-                    st.write("Volume fraction=", vf)
+                    # Reuse the cached material inverse design result (do not recompute)
+                    nlayers = int(len(res["full_angles"]))
+                    vf = float(res["vf"])
+                    st.write("Matrix material = ", res["matrix"])
+                    st.write("Fiber material = ", res["fiber"])
+                    st.write("Number of layers = ", nlayers)
+                    st.write("Volume fraction = ", f"{vf:.3f}")
             with col2_row4:
                 with st.container(border=False): # Container with a border
                     df = pd.DataFrame({'Ply': [], 'Orientation': []})
-                    plies = np.array([[1,90], [2,45], [3,-45], [4,-90]])
+                    # Use the designed stacking sequence
+                    plies = np.array([[i + 1, float(a)] for i, a in enumerate(res["full_angles"])], dtype=object)
                     plies_df=pd.DataFrame(plies, columns=df.columns)
                     df = pd.concat([df, plies_df], ignore_index=True)
                     st.dataframe(df, hide_index=True)
@@ -1139,15 +1250,28 @@ if  st.session_state.input_curve_button_clicked == True:
 
             st.write("")
             if st.session_state.forming_input_changed == True:
-                st.session_state.forming_design_button_clicked = False
+                # Any change to thermoforming requirements invalidates cached process design result
+                if "forming_design_result" in st.session_state:
+                    del st.session_state["forming_design_result"]
+                if "forming_design_last_run_id" in st.session_state:
+                    del st.session_state["forming_design_last_run_id"]
                 st.session_state.forming_input_changed = False
             st.button("Thermoforming process design", use_container_width=True, on_click=forming_design_click)
             if  st.session_state.forming_design_button_clicked == True:
-                best = inverse_design(ply_number=nlayers, 
-                        fiber_vf=vf, 
-                        y_target=[angleA, angleB, angleC, max_stress], 
-                        n_restarts=5,
-                        epochs=100)
+                # Cache thermoforming process design result so it doesn't rerun on every Streamlit rerender.
+                current_run_id = int(st.session_state.get("forming_design_run_id", 0))
+                last_run_id = int(st.session_state.get("forming_design_last_run_id", -1))
+                if ("forming_design_result" not in st.session_state) or (current_run_id != last_run_id):
+                    with st.spinner("Optimizing thermoforming process parameters..."):
+                        st.session_state.forming_design_result = inverse_design(
+                            ply_number=nlayers,
+                            fiber_vf=vf,
+                            y_target=[angleA, angleB, angleC, max_stress],
+                            n_restarts=5,
+                            epochs=100,
+                        )
+                        st.session_state.forming_design_last_run_id = current_run_id
+                best = st.session_state.forming_design_result
                 # 5th row with 3 columns
                 col1_row5, col2_row5,col3_row5 = st.columns([0.25,0.25,0.25])
                 with col1_row5: