Update src/streamlit_app.py

src/streamlit_app.py

@@ -1182,29 +1182,6 @@ def show_data_processing():
         format_func=lambda x: f"Dataset {x + 1}"
     )
 
-    # Pre-compute this dataset's actual time span (in 0.1 ms units) so we can
-    # default the interpolation range sensibly and avoid extrapolation.
-    def _dataset_time_max(idx):
-        try:
-            t_nd = np.array(st.session_state.t_nondim_all[0, idx]).flatten()
-            zc = np.where(np.abs(t_nd) < 1e-10)[0]
-            z = zc[0] if len(zc) else int(np.argmin(np.abs(t_nd)))
-            tc = st.session_state.physical_params['tc_exp']
-            t_ph = (t_nd * tc)[z:]
-            return float(np.max(t_ph) * 1e4)  # scale_exp = 1e4
-        except Exception:
-            return 1.0
-
-    data_t_max = _dataset_time_max(dataset_idx)
-    # Round up to a clean step so the default fully covers the data
-    default_range = float(np.ceil(data_t_max * 10) / 10) if data_t_max > 0 else 1.0
-    default_range = min(max(default_range, 0.1), 2.0)
-
-    st.caption(
-        f"📏 This dataset spans **t = 0 → {data_t_max:.3f}** (0.1 ms units). "
-        f"Set the Interpolation Range at or below this value to avoid extrapolation."
-    )
-
     # Processing parameters
     col1, col2 = st.columns(2)
     with col1:
@@ -1212,10 +1189,9 @@ def show_data_processing():
             "Interpolation Range",
             min_value=0.1,
             max_value=2.0,
-            value=default_range,
+            value=1.0,
             step=0.1,
-            help="Time range for interpolation. Keep it ≤ the dataset's actual span "
-                 "(shown above) so the curve is not extrapolated."
+            help="Time range for interpolation"
         )
 
     with col2:
@@ -1264,23 +1240,31 @@ def show_data_processing():
                 t_newunit_exp = t_newunit_exp[sort_indices]
                 R_newunit_exp = R_newunit_exp[sort_indices]
 
-                # Interpolate — NEVER extrapolate beyond the measured data.
-                # Extrapolating an exponential-like R-t tail blows up to huge,
-                # unphysical values, so clamp the grid to the data's actual span.
-                t_data_max = float(t_newunit_exp.max())
-                requested_range = float(interp_range)
-                effective_range = min(requested_range, t_data_max)
-
-                t_interp_newunit = np.arange(0, effective_range + time_step, time_step)
+                # Interpolate over the full requested range (default 1.0).
+                # PchipInterpolator with extrapolate=False returns NaN beyond the
+                # measured data; instead of extrapolating (which explodes), we hold
+                # the last valid value constant (forward-fill).
+                t_interp_newunit = np.arange(0, interp_range + time_step, time_step)
                 pchip_interpolator = PchipInterpolator(
                     t_newunit_exp, R_newunit_exp, extrapolate=False
                 )
                 R_interp_newunit = pchip_interpolator(t_interp_newunit)
 
-                # Drop any points that fell outside the data support (safety net)
-                valid = ~np.isnan(R_interp_newunit)
-                t_interp_newunit = t_interp_newunit[valid]
-                R_interp_newunit = R_interp_newunit[valid]
+                # Forward-fill NaNs (points beyond the data) with the previous valid value
+                nan_mask = np.isnan(R_interp_newunit)
+                if nan_mask.any():
+                    valid_idx = np.where(~nan_mask)[0]
+                    if len(valid_idx) > 0:
+                        # Standard numpy forward-fill
+                        fill_idx = np.where(~nan_mask, np.arange(len(nan_mask)), 0)
+                        np.maximum.accumulate(fill_idx, out=fill_idx)
+                        R_interp_newunit = R_interp_newunit[fill_idx]
+                        # Guard against any leading NaNs (use first valid value)
+                        first_valid = valid_idx[0]
+                        if first_valid > 0:
+                            R_interp_newunit[:first_valid] = R_interp_newunit[first_valid]
+                    else:
+                        R_interp_newunit = np.zeros_like(R_interp_newunit)
 
                 # Store results
                 st.session_state.t_interp_newunit = t_interp_newunit
@@ -1292,14 +1276,6 @@ def show_data_processing():
 
                 st.success(f"✅ Data processed successfully! {len(R_interp_newunit)} interpolated points created.")
 
-                if requested_range > t_data_max + 1e-9:
-                    st.warning(
-                        f"⚠️ The Interpolation Range you set ({requested_range:.2f}) is larger than "
-                        f"this dataset's measured span (t ends at {t_data_max:.3f} in 0.1 ms units). "
-                        f"It was automatically clamped to {effective_range:.3f} so the curve is not "
-                        f"extrapolated. For best results, set the Interpolation Range to ≈ {t_data_max:.3f}."
-                    )
-
             except Exception as e:
                 st.error(f"Processing failed: {str(e)}")