Upload 2 files

app.py

@@ -44,17 +44,23 @@ for i in range(n_layers):
         RR = st.number_input(
             f"RR", min_value=0.001, value=0.05, step=0.01, format="%.3f", key=f"rr_{i}"
         )
-
-    with col2:
         CR = st.number_input(
             f"CR", min_value=0.001, value=0.30, step=0.01, format="%.3f", key=f"cr_{i}"
         )
+
+    with col2:
         sigma_ini = st.number_input(
             f"σ'ini (kPa)", min_value=1.0, value=50.0, step=5.0, key=f"sini_{i}"
         )
         sigma_p = st.number_input(
             f"σ'p (kPa)", min_value=1.0, value=80.0, step=5.0, key=f"sp_{i}"
         )
+        kh = st.number_input(
+            f"kh (m/yr)", min_value=0.1, value=2.0, step=0.1, key=f"kh_{i}"
+        )
+        ks = st.number_input(
+            f"ks (m/yr)", min_value=0.1, value=1.0, step=0.1, key=f"ks_{i}"
+        )
 
     layers.append(
         SoilLayer(
@@ -65,6 +71,8 @@ for i in range(n_layers):
             CR=CR,
             sigma_ini=sigma_ini,
             sigma_p=sigma_p,
+            kh=kh,
+            ks=ks,
         )
     )
 
@@ -72,32 +80,28 @@ for i in range(n_layers):
 
 # PVD Properties
 st.sidebar.subheader("PVD Properties")
-col1, col2 = st.sidebar.columns(2)
-
-with col1:
-    dw = st.number_input(
-        "Drain diameter dw (m)", min_value=0.01, value=0.05, step=0.01, format="%.3f"
-    )
-    ds = st.number_input(
-        "Smear zone ds (m)", min_value=0.01, value=0.15, step=0.01, format="%.3f"
-    )
-    De = st.number_input("Unit cell De (m)", min_value=0.1, value=1.5, step=0.1)
-    L_drain = st.number_input("Drain length L (m)", min_value=1.0, value=10.0, step=1.0)
 
-with col2:
-    kh = st.number_input("kh (m/yr)", min_value=0.1, value=2.0, step=0.1)
-    ks = st.number_input("ks (m/yr)", min_value=0.1, value=1.0, step=0.1)
+dw = st.sidebar.number_input(
+    "Drain diameter dw (m)", min_value=0.01, value=0.05, step=0.01, format="%.3f"
+)
+ds = st.sidebar.number_input(
+    "Smear zone ds (m)", min_value=0.01, value=0.15, step=0.01, format="%.3f"
+)
+De = st.sidebar.number_input("Unit cell De (m)", min_value=0.1, value=1.5, step=0.1)
+L_drain = st.sidebar.number_input(
+    "Drain length L (m)", min_value=1.0, value=10.0, step=1.0
+)
 
-    well_resistance = st.selectbox(
-        "Well Resistance", ["Negligible (qw → ∞)", "Custom qw"]
-    )
+well_resistance = st.sidebar.selectbox(
+    "Well Resistance", ["Negligible (qw → ∞)", "Custom qw"]
+)
 
-    if well_resistance == "Custom qw":
-        qw = st.number_input("qw (m³/yr)", min_value=1.0, value=100.0, step=10.0)
-    else:
-        qw = 1e12  # Very large value for negligible resistance
+if well_resistance == "Custom qw":
+    qw = st.sidebar.number_input("qw (m³/yr)", min_value=1.0, value=100.0, step=10.0)
+else:
+    qw = 1e12  # Very large value for negligible resistance
 
-pvd = PVDProperties(dw=dw, ds=ds, De=De, L_drain=L_drain, kh=kh, ks=ks, qw=qw)
+pvd = PVDProperties(dw=dw, ds=ds, De=De, L_drain=L_drain, qw=qw)
 
 # Analysis Parameters
 st.sidebar.subheader("Analysis Parameters")
@@ -152,6 +156,9 @@ if hasattr(st.session_state, "analysis_done") and st.session_state.analysis_done
     ax.grid(True, alpha=0.3, linestyle="--")
     ax.tick_params(labelsize=12)
 
+    # Invert y-axis (settlement goes down)
+    ax.invert_yaxis()
+
     # Add final settlement annotation
     final_settlement = st.session_state.settlement[-1]
     ax.axhline(

pvd_consolidation.py

@@ -23,6 +23,8 @@ class SoilLayer:
     CR: float  # Compression ratio
     sigma_ini: float  # Initial effective stress (kPa)
     sigma_p: float  # Preconsolidation pressure (kPa)
+    kh: float  # Horizontal permeability (m/year)
+    ks: float  # Smear zone permeability (m/year)
 
 
 @dataclass
@@ -33,8 +35,6 @@ class PVDProperties:
     ds: float  # Smear zone diameter (m)
     De: float  # Equivalent diameter of unit cell (m)
     L_drain: float  # Total drain spacing for two-way drainage (m)
-    kh: float  # Horizontal permeability (m/year)
-    ks: float  # Smear zone permeability (m/year)
     qw: float  # Well discharge capacity (m³/year)
 
 
@@ -84,6 +84,8 @@ class PVDConsolidation:
         self.layer_indices = []
         self.Cv_profile = []
         self.Ch_profile = []
+        self.kh_profile = []
+        self.ks_profile = []
 
         z = 0
         for i, layer in enumerate(self.layers):
@@ -94,6 +96,8 @@ class PVDConsolidation:
             self.layer_indices.extend([i] * len(z_layer))
             self.Cv_profile.extend([layer.Cv] * len(z_layer))
             self.Ch_profile.extend([layer.Ch] * len(z_layer))
+            self.kh_profile.extend([layer.kh] * len(z_layer))
+            self.ks_profile.extend([layer.ks] * len(z_layer))
 
             z += layer.thickness
 
@@ -102,24 +106,65 @@ class PVDConsolidation:
         self.layer_indices.append(len(self.layers) - 1)
         self.Cv_profile.append(self.layers[-1].Cv)
         self.Ch_profile.append(self.layers[-1].Ch)
+        self.kh_profile.append(self.layers[-1].kh)
+        self.ks_profile.append(self.layers[-1].ks)
 
         self.z_coords = np.array(self.z_coords)
         self.layer_indices = np.array(self.layer_indices)
         self.Cv_profile = np.array(self.Cv_profile)
         self.Ch_profile = np.array(self.Ch_profile)
+        self.kh_profile = np.array(self.kh_profile)
+        self.ks_profile = np.array(self.ks_profile)
 
         self.n_nodes = len(self.z_coords)
         self.dz = np.diff(self.z_coords)
 
+    def calculate_pvd_factors_layer(self, layer_idx: int) -> Tuple[float, float, float]:
+        """
+        Calculate PVD influence factors for a specific layer
+
+        Parameters:
+        -----------
+        layer_idx : int
+            Layer index
+
+        Returns:
+        --------
+        Fn, Fs, Fr : float
+            Geometric, smear, and well resistance factors for the layer
+        """
+        layer = self.layers[layer_idx]
+
+        # Geometric factor (n ratio) - same for all layers
+        n = self.pvd.De / self.pvd.dw
+        Fn = (n**2 / (n**2 - 1)) * np.log(n) - 3 / 4 + 1 / n**2
+
+        # Fs - Smear effect factor (layer-specific)
+        s = self.pvd.ds / self.pvd.dw
+        Fs = ((layer.kh / layer.ks) - 1) * np.log(s)
+
+        # Fr - Well resistance factor (layer-specific)
+        L = self.pvd.L_drain
+        if self.pvd.qw > 1e10:  # If qw is very large, assume negligible well resistance
+            Fr = 0.0
+        else:
+            Fr = (np.pi * L**2 * layer.kh) / (8 * self.pvd.qw)
+
+        return Fn, Fs, Fr
+
     def calculate_pvd_factors(self) -> Tuple[float, float, float]:
         """
-        Calculate PVD influence factors
+        Calculate PVD influence factors using weighted average permeabilities
 
         Returns:
         --------
         Fn, Fs, Fr : float
             Geometric, smear, and well resistance factors
         """
+        # Use thickness-weighted average kh and ks
+        kh_avg = np.average(self.kh_profile, weights=np.ones(len(self.kh_profile)))
+        ks_avg = np.average(self.ks_profile, weights=np.ones(len(self.ks_profile)))
+
         # Geometric factor (n ratio)
         n = self.pvd.De / self.pvd.dw
 
@@ -128,7 +173,7 @@ class PVDConsolidation:
 
         # Fs - Smear effect factor
         s = self.pvd.ds / self.pvd.dw
-        Fs = ((self.pvd.kh / self.pvd.ks) - 1) * np.log(s)
+        Fs = ((kh_avg / ks_avg) - 1) * np.log(s)
 
         # Fr - Well resistance factor
         # For typical band drains: Fr = π(2L-l)l/(qw·kh) where l = L/2
@@ -139,14 +184,15 @@ class PVDConsolidation:
         else:
             # Using Hansbo formula: Fr = (L²/(8·qw))·(kh)
             # More typical: Fr = π·L²·kh/(8·qw) for two-way drainage
-            Fr = (np.pi * L**2 * self.pvd.kh) / (8 * self.pvd.qw)
+            Fr = (np.pi * L**2 * kh_avg) / (8 * self.pvd.qw)
 
         return Fn, Fs, Fr
 
     def calculate_Uh(self, t: float) -> np.ndarray:
         """
         Calculate degree of consolidation in horizontal direction
-        using finite difference method
+        using finite difference method with layer-specific PVD factors
+        Only applies to layers within drain length L
 
         Parameters:
         -----------
@@ -157,10 +203,13 @@ class PVDConsolidation:
         --------
         Uh : ndarray
             Degree of horizontal consolidation at each node
+            (0 for nodes beyond drain length)
         """
-        # Calculate PVD factors
-        Fn, Fs, Fr = self.calculate_pvd_factors()
-        F_total = Fn + Fs + Fr
+        # Pre-calculate F_total for each layer
+        F_total_layers = []
+        for layer_idx in range(len(self.layers)):
+            Fn, Fs, Fr = self.calculate_pvd_factors_layer(layer_idx)
+            F_total_layers.append(Fn + Fs + Fr)
 
         # Initialize excess pore pressure (normalized)
         u = np.ones(self.n_nodes)  # Initially all excess pore pressure = surcharge
@@ -177,15 +226,26 @@ class PVDConsolidation:
             # Simplified for radial drainage with PVD
 
             for i in range(1, self.n_nodes - 1):
-                Ch = self.Ch_profile[i]
-
-                # Radial drainage term (simplified)
-                # Using equivalent time factor approach
-                Th = Ch * self.dt / (self.pvd.De**2 / 4)
-
-                # Update excess pore pressure
-                decay_rate = 8 * Th / F_total
-                u_new[i] = u[i] * np.exp(-decay_rate)
+                # Check if this node is within drain length
+                depth = self.z_coords[i]
+
+                if depth <= self.pvd.L_drain:
+                    # Within drain length - apply horizontal consolidation
+                    Ch = self.Ch_profile[i]
+                    layer_idx = self.layer_indices[i]
+                    F_total = F_total_layers[layer_idx]
+
+                    # Radial drainage term (simplified)
+                    # Using equivalent time factor approach
+                    Th = Ch * self.dt / (self.pvd.De**2 / 4)
+
+                    # Update excess pore pressure
+                    decay_rate = 8 * Th / F_total
+                    u_new[i] = u[i] * np.exp(-decay_rate)
+                else:
+                    # Beyond drain length - no horizontal consolidation
+                    # u remains unchanged (Uh = 0)
+                    pass
 
             # Boundary conditions
             u_new[0] = 0  # Top drainage
@@ -239,7 +299,8 @@ class PVDConsolidation:
         """
         Calculate total degree of consolidation (combined vertical and horizontal)
 
-        U = 1 - (1 - Uh)(1 - Uv)
+        For nodes within drain length: U = 1 - (1 - Uh)(1 - Uv)
+        For nodes beyond drain length: U = Uv (only vertical consolidation)
 
         Parameters:
         -----------
@@ -254,7 +315,17 @@ class PVDConsolidation:
         Uh = self.calculate_Uh(t)
         Uv = self.calculate_Uv(t)
 
-        U = 1 - (1 - Uh) * (1 - Uv)
+        U = np.zeros(self.n_nodes)
+
+        for i in range(self.n_nodes):
+            depth = self.z_coords[i]
+
+            if depth <= self.pvd.L_drain:
+                # Within drain length - combined vertical and horizontal
+                U[i] = 1 - (1 - Uh[i]) * (1 - Uv[i])
+            else:
+                # Beyond drain length - only vertical consolidation
+                U[i] = Uv[i]
 
         return U
 
@@ -410,6 +481,17 @@ class PVDConsolidation:
         ax1.plot(Uh * 100, self.z_coords, "r-", linewidth=2, label="Horizontal (Uh)")
         ax1.plot(Uv * 100, self.z_coords, "b-", linewidth=2, label="Vertical (Uv)")
         ax1.plot(U * 100, self.z_coords, "g-", linewidth=2, label="Total (U)")
+
+        # Add drain length line
+        ax1.axhline(
+            y=self.pvd.L_drain,
+            color="orange",
+            linestyle="--",
+            linewidth=1.5,
+            alpha=0.7,
+            label=f"Drain Length = {self.pvd.L_drain:.1f} m",
+        )
+
         ax1.set_xlabel("Degree of Consolidation (%)", fontsize=12)
         ax1.set_ylabel("Depth (m)", fontsize=12)
         ax1.set_title(
@@ -463,25 +545,42 @@ class PVDConsolidation:
         report += f"  Equivalent drain diameter (dw): {self.pvd.dw:.3f} m\n"
         report += f"  Smear zone diameter (ds): {self.pvd.ds:.3f} m\n"
         report += f"  Unit cell diameter (De): {self.pvd.De:.3f} m\n"
+        report += f"  Drain length (L): {self.pvd.L_drain:.2f} m\n"
         report += (
             f"  Drain spacing ratio (n = De/dw): {self.pvd.De / self.pvd.dw:.2f}\n"
         )
         report += f"  Geometric factor (Fn): {Fn:.4f}\n"
-        report += f"  Smear factor (Fs): {Fs:.4f}\n"
-        report += f"  Well resistance (Fr): {Fr:.4f}\n"
-        report += f"  Total resistance (F): {Fn + Fs + Fr:.4f}\n\n"
+        report += f"  Smear factor (Fs - avg): {Fs:.4f}\n"
+        report += f"  Well resistance (Fr - avg): {Fr:.4f}\n"
+        report += f"  Total resistance (F - avg): {Fn + Fs + Fr:.4f}\n\n"
 
         report += "SOIL PROFILE:\n"
+        cumulative_depth = 0
         for i, layer in enumerate(self.layers):
-            report += f"  Layer {i + 1}:\n"
+            depth_top = cumulative_depth
+            depth_bottom = cumulative_depth + layer.thickness
+
+            # Check if layer is within drain length
+            if depth_bottom <= self.pvd.L_drain:
+                drain_status = "Full PVD effect (Uh + Uv)"
+            elif depth_top >= self.pvd.L_drain:
+                drain_status = "No PVD effect (Uv only)"
+            else:
+                drain_status = "Partial PVD effect"
+
+            report += f"  Layer {i + 1} ({depth_top:.1f}m - {depth_bottom:.1f}m): {drain_status}\n"
             report += f"    Thickness: {layer.thickness:.2f} m\n"
             report += f"    Ch: {layer.Ch:.4f} m²/year\n"
             report += f"    Cv: {layer.Cv:.4f} m²/year\n"
+            report += f"    kh: {layer.kh:.4f} m/year\n"
+            report += f"    ks: {layer.ks:.4f} m/year\n"
             report += f"    RR: {layer.RR:.4f}\n"
             report += f"    CR: {layer.CR:.4f}\n"
             report += f"    σ'ini: {layer.sigma_ini:.1f} kPa\n"
             report += f"    σ'p: {layer.sigma_p:.1f} kPa\n\n"
 
+            cumulative_depth = depth_bottom
+
         report += f"Applied surcharge: {self.surcharge:.1f} kPa\n\n"
         report += "=" * 70 + "\n"
         report += "SETTLEMENT vs TIME:\n"
@@ -513,6 +612,8 @@ def example_usage():
             CR=0.30,  # Compression ratio
             sigma_ini=50.0,  # Initial effective stress 50 kPa
             sigma_p=80.0,  # Preconsolidation pressure 80 kPa
+            kh=2.0,  # 2 m/year horizontal permeability
+            ks=1.0,  # 1 m/year smear zone permeability
         ),
         SoilLayer(
             thickness=8.0,  # 8 m thick
@@ -522,6 +623,8 @@ def example_usage():
             CR=0.35,
             sigma_ini=90.0,
             sigma_p=90.0,
+            kh=1.5,  # Lower permeability
+            ks=0.75,
         ),
         SoilLayer(
             thickness=7.0,  # 7 m thick
@@ -531,6 +634,8 @@ def example_usage():
             CR=0.32,
             sigma_ini=140.0,
             sigma_p=150.0,
+            kh=1.8,
+            ks=0.9,
         ),
     ]
 
@@ -540,9 +645,7 @@ def example_usage():
         ds=0.15,  # 150 mm smear zone diameter
         De=1.5,  # 1.5 m equivalent unit cell diameter (triangular spacing)
         L_drain=20.0,  # 20 m total drain length (two-way drainage)
-        kh=2.0,  # 2 m/year horizontal permeability
-        ks=0.5,  # 0.5 m/year smear zone permeability
-        qw=50.0,  # 50 m³/year well discharge capacity
+        qw=100.0,  # 100 m³/year well discharge capacity
     )
 
     # Applied surcharge
@@ -617,6 +720,8 @@ def create_analysis_from_yaml(yaml_file: str) -> PVDConsolidation:
             CR=layer_data["CR"],
             sigma_ini=layer_data["sigma_ini"],
             sigma_p=layer_data["sigma_p"],
+            kh=layer_data["kh"],
+            ks=layer_data["ks"],
         )
         layers.append(layer)
 
@@ -627,8 +732,6 @@ def create_analysis_from_yaml(yaml_file: str) -> PVDConsolidation:
         ds=pvd_data["ds"],
         De=pvd_data["De"],
         L_drain=pvd_data["L_drain"],
-        kh=pvd_data["kh"],
-        ks=pvd_data["ks"],
         qw=pvd_data["qw"],
     )