Upload 5 files

app.py

@@ -0,0 +1,264 @@
+"""
+Streamlit App for PVD Consolidation Analysis
+Shows settlement vs time curve
+"""
+
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+from pvd_consolidation import PVDConsolidation, SoilLayer, PVDProperties
+
+# Page configuration
+st.set_page_config(
+    page_title="PVD Consolidation Analysis", page_icon="📊", layout="wide"
+)
+
+# Title
+st.title("🏗️ PVD Consolidation Analysis")
+st.markdown("### Settlement vs Time Calculator")
+
+# Sidebar for inputs
+st.sidebar.header("Input Parameters")
+
+# Soil Layer Inputs
+st.sidebar.subheader("Soil Properties")
+n_layers = st.sidebar.number_input(
+    "Number of Layers", min_value=1, max_value=10, value=1
+)
+
+layers = []
+for i in range(n_layers):
+    st.sidebar.markdown(f"**Layer {i + 1}**")
+    col1, col2 = st.sidebar.columns(2)
+
+    with col1:
+        thickness = st.number_input(
+            f"Thickness (m)", min_value=0.1, value=10.0, step=0.5, key=f"thick_{i}"
+        )
+        Cv = st.number_input(
+            f"Cv (m²/yr)", min_value=0.01, value=0.5, step=0.1, key=f"cv_{i}"
+        )
+        Ch = st.number_input(
+            f"Ch (m²/yr)", min_value=0.01, value=2.0, step=0.1, key=f"ch_{i}"
+        )
+        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}"
+        )
+        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}"
+        )
+
+    layers.append(
+        SoilLayer(
+            thickness=thickness,
+            Cv=Cv,
+            Ch=Ch,
+            RR=RR,
+            CR=CR,
+            sigma_ini=sigma_ini,
+            sigma_p=sigma_p,
+        )
+    )
+
+    st.sidebar.markdown("---")
+
+# 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)
+
+    well_resistance = st.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
+
+pvd = PVDProperties(dw=dw, ds=ds, De=De, L_drain=L_drain, kh=kh, ks=ks, qw=qw)
+
+# Analysis Parameters
+st.sidebar.subheader("Analysis Parameters")
+surcharge = st.sidebar.number_input(
+    "Surcharge (kPa)", min_value=1.0, value=100.0, step=10.0
+)
+t_max = st.sidebar.number_input("Max Time (years)", min_value=0.1, value=2.0, step=0.1)
+dt = st.sidebar.number_input(
+    "Time Step (years)", min_value=0.001, value=0.01, step=0.001, format="%.3f"
+)
+
+# Run Analysis Button
+if st.sidebar.button("🚀 Run Analysis", type="primary"):
+    with st.spinner("Calculating consolidation..."):
+        try:
+            # Create analysis
+            analysis = PVDConsolidation(layers, pvd, surcharge, dt)
+
+            # Calculate settlement vs time
+            time, settlement = analysis.settlement_vs_time(t_max=t_max, n_points=200)
+            settlement_mm = settlement * 1000  # Convert to mm
+
+            # Get PVD factors
+            Fn, Fs, Fr = analysis.calculate_pvd_factors()
+            F_total = Fn + Fs + Fr
+
+            # Store results in session state
+            st.session_state.time = time
+            st.session_state.settlement = settlement_mm
+            st.session_state.Fn = Fn
+            st.session_state.Fs = Fs
+            st.session_state.Fr = Fr
+            st.session_state.F_total = F_total
+            st.session_state.analysis_done = True
+
+        except Exception as e:
+            st.error(f"Error in analysis: {str(e)}")
+            st.session_state.analysis_done = False
+
+# Display Results
+if hasattr(st.session_state, "analysis_done") and st.session_state.analysis_done:
+    # Main plot - Settlement vs Time
+    st.subheader("Settlement vs Time")
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+    ax.plot(st.session_state.time, st.session_state.settlement, "b-", linewidth=2.5)
+    ax.set_xlabel("Time (years)", fontsize=14, fontweight="bold")
+    ax.set_ylabel("Settlement (mm)", fontsize=14, fontweight="bold")
+    ax.set_title(
+        "PVD Consolidation - Settlement vs Time", fontsize=16, fontweight="bold"
+    )
+    ax.grid(True, alpha=0.3, linestyle="--")
+    ax.tick_params(labelsize=12)
+
+    # Add final settlement annotation
+    final_settlement = st.session_state.settlement[-1]
+    ax.axhline(
+        y=final_settlement,
+        color="r",
+        linestyle="--",
+        alpha=0.5,
+        label=f"Final Settlement = {final_settlement:.1f} mm",
+    )
+    ax.legend(fontsize=12)
+
+    st.pyplot(fig)
+
+    # Summary statistics
+    st.subheader("Analysis Summary")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric("Final Settlement", f"{final_settlement:.1f} mm")
+
+    with col2:
+        # Find time to 90% consolidation
+        target_settlement = 0.9 * final_settlement
+        idx_90 = np.argmax(st.session_state.settlement >= target_settlement)
+        t_90 = (
+            st.session_state.time[idx_90] if idx_90 > 0 else st.session_state.time[-1]
+        )
+        st.metric("Time to 90% U", f"{t_90:.2f} years")
+
+    with col3:
+        # Find time to 50% consolidation
+        target_settlement = 0.5 * final_settlement
+        idx_50 = np.argmax(st.session_state.settlement >= target_settlement)
+        t_50 = (
+            st.session_state.time[idx_50] if idx_50 > 0 else st.session_state.time[-1]
+        )
+        st.metric("Time to 50% U", f"{t_50:.2f} years")
+
+    with col4:
+        st.metric("Total Resistance F", f"{st.session_state.F_total:.2f}")
+
+    # PVD Factors
+    st.subheader("PVD Influence Factors")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.metric("Geometric Factor (Fn)", f"{st.session_state.Fn:.3f}")
+
+    with col2:
+        st.metric("Smear Factor (Fs)", f"{st.session_state.Fs:.3f}")
+
+    with col3:
+        st.metric("Well Resistance (Fr)", f"{st.session_state.Fr:.3f}")
+
+    # Download data
+    st.subheader("Download Results")
+
+    # Prepare CSV data
+    csv_data = "Time (years),Settlement (mm)\n"
+    for t, s in zip(st.session_state.time, st.session_state.settlement):
+        csv_data += f"{t:.4f},{s:.2f}\n"
+
+    st.download_button(
+        label="📥 Download Settlement Data (CSV)",
+        data=csv_data,
+        file_name="settlement_data.csv",
+        mime="text/csv",
+    )
+
+else:
+    # Initial instructions
+    st.info(
+        "👈 Configure your parameters in the sidebar and click **Run Analysis** to see results"
+    )
+
+    st.markdown("""
+    ### Instructions:
+
+    1. **Soil Properties**: Enter the properties for each soil layer
+       - Thickness (m)
+       - Cv: Vertical coefficient of consolidation (m²/year)
+       - Ch: Horizontal coefficient of consolidation (m²/year)
+       - RR: Recompression ratio
+       - CR: Compression ratio
+       - σ'ini: Initial effective stress (kPa)
+       - σ'p: Preconsolidation pressure (kPa)
+
+    2. **PVD Properties**: Configure the drain installation
+       - dw: Equivalent drain diameter (m)
+       - ds: Smear zone diameter (m)
+       - De: Equivalent unit cell diameter (m)
+       - L: Drain length (m)
+       - kh: Horizontal permeability (m/year)
+       - ks: Smear zone permeability (m/year)
+       - qw: Well discharge capacity (m³/year)
+
+    3. **Analysis Parameters**:
+       - Surcharge: Applied load (kPa)
+       - Max Time: Analysis duration (years)
+       - Time Step: Calculation step size (years)
+
+    4. Click **Run Analysis** to calculate and visualize results
+    """)
+
+# Footer
+st.sidebar.markdown("---")
+st.sidebar.markdown("**PVD Consolidation Calculator**")
+st.sidebar.markdown("Version 1.0")

example_input.yaml

@@ -0,0 +1,70 @@
+# PVD Consolidation Analysis Input File
+# All units: m, kPa, years
+
+# Soil layers (from top to bottom)
+soil_layers:
+  - thickness: 5.0 # Layer thickness (m)
+    Cv: 0.5 # Vertical coefficient of consolidation (m²/year)
+    Ch: 1.5 # Horizontal coefficient of consolidation (m²/year)
+    RR: 0.05 # Recompression ratio
+    CR: 0.30 # Compression ratio
+    sigma_ini: 50.0 # Initial effective stress (kPa)
+    sigma_p: 80.0 # Preconsolidation pressure (kPa)
+
+  - thickness: 8.0
+    Cv: 0.3
+    Ch: 1.0
+    RR: 0.04
+    CR: 0.35
+    sigma_ini: 90.0
+    sigma_p: 90.0
+
+  - thickness: 7.0
+    Cv: 0.4
+    Ch: 1.2
+    RR: 0.045
+    CR: 0.32
+    sigma_ini: 140.0
+    sigma_p: 150.0
+
+# PVD installation properties
+pvd:
+  dw: 0.05 # Equivalent diameter of drain (m) - typically 50-100 mm
+  ds: 0.15 # Smear zone diameter (m) - typically 2-4 times dw
+  De:
+    1.5 # Equivalent diameter of unit cell (m)
+    # For triangular pattern: De = 1.05 × S
+    # For square pattern: De = 1.13 × S
+    # where S = drain spacing
+  L_drain:
+    20.0 # Total drain length (m)
+    # For two-way drainage: actual drain length
+    # For one-way drainage: 2 × actual drain length
+  kh: 2.0 # Horizontal permeability (m/year)
+  ks: 1.0 # Smear zone permeability (m/year) - typically 0.5-0.67 × kh
+  qw:
+    100.0 # Well discharge capacity (m³/year)
+    # For negligible well resistance, use very large value (1e12)
+
+# Analysis parameters
+analysis:
+  surcharge: 100.0 # Applied surcharge load (kPa)
+  dt: 0.01 # Time step for finite difference (years)
+  t_max: 20.0 # Maximum time for analysis (years)
+  n_points: 200 # Number of points in settlement vs time curve
+
+  # Time points to check in report (years)
+  t_check:
+    - 0.1
+    - 0.5
+    - 1.0
+    - 2.0
+    - 5.0
+    - 10.0
+    - 20.0
+
+  # Times to generate consolidation profiles (years)
+  t_profiles:
+    - 0.5
+    - 2.0
+    - 10.0

pvd_consolidation.py

@@ -0,0 +1,762 @@
+"""
+Multilayer Prefabricated Vertical Drain (PVD) Consolidation Analysis
+Calculates settlement vs time using finite difference method
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import yaml
+import argparse
+import os
+from dataclasses import dataclass
+from typing import List, Tuple, Dict, Any
+
+
+@dataclass
+class SoilLayer:
+    """Soil layer properties"""
+
+    thickness: float  # Layer thickness (m)
+    Cv: float  # Vertical coefficient of consolidation (m²/year)
+    Ch: float  # Horizontal coefficient of consolidation (m²/year)
+    RR: float  # Recompression ratio
+    CR: float  # Compression ratio
+    sigma_ini: float  # Initial effective stress (kPa)
+    sigma_p: float  # Preconsolidation pressure (kPa)
+
+
+@dataclass
+class PVDProperties:
+    """PVD installation properties"""
+
+    dw: float  # Equivalent diameter of drain (m)
+    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)
+
+
+class PVDConsolidation:
+    """
+    Multilayer PVD consolidation analysis using finite difference method
+    """
+
+    def __init__(
+        self,
+        soil_layers: List[SoilLayer],
+        pvd: PVDProperties,
+        surcharge: float,
+        dt: float = 0.01,
+    ):
+        """
+        Initialize PVD consolidation analysis
+
+        Parameters:
+        -----------
+        soil_layers : List[SoilLayer]
+            List of soil layers from top to bottom
+        pvd : PVDProperties
+            PVD installation properties
+        surcharge : float
+            Applied surcharge load (kPa)
+        dt : float
+            Time step for finite difference (years)
+        """
+        self.layers = soil_layers
+        self.pvd = pvd
+        self.surcharge = surcharge
+        self.dt = dt
+
+        # Calculate total thickness
+        self.total_thickness = sum(layer.thickness for layer in soil_layers)
+
+        # Initialize mesh
+        self._setup_mesh()
+
+    def _setup_mesh(self, nodes_per_meter: int = 10):
+        """Setup finite difference mesh"""
+        self.nodes_per_meter = nodes_per_meter
+
+        # Create mesh for each layer
+        self.z_coords = []
+        self.layer_indices = []
+        self.Cv_profile = []
+        self.Ch_profile = []
+
+        z = 0
+        for i, layer in enumerate(self.layers):
+            n_nodes = max(int(layer.thickness * nodes_per_meter), 2)
+            z_layer = np.linspace(z, z + layer.thickness, n_nodes, endpoint=False)
+
+            self.z_coords.extend(z_layer)
+            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))
+
+            z += layer.thickness
+
+        # Add final node
+        self.z_coords.append(self.total_thickness)
+        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.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.n_nodes = len(self.z_coords)
+        self.dz = np.diff(self.z_coords)
+
+    def calculate_pvd_factors(self) -> Tuple[float, float, float]:
+        """
+        Calculate PVD influence factors
+
+        Returns:
+        --------
+        Fn, Fs, Fr : float
+            Geometric, smear, and well resistance factors
+        """
+        # Geometric factor (n ratio)
+        n = self.pvd.De / self.pvd.dw
+
+        # Fn - Geometric factor
+        Fn = (n**2 / (n**2 - 1)) * np.log(n) - 3 / 4 + 1 / n**2
+
+        # Fs - Smear effect factor
+        s = self.pvd.ds / self.pvd.dw
+        Fs = ((self.pvd.kh / self.pvd.ks) - 1) * np.log(s)
+
+        # Fr - Well resistance factor
+        # For typical band drains: Fr = π(2L-l)l/(qw·kh) where l = L/2
+        # Simplified for two-way drainage
+        L = self.pvd.L_drain
+        if self.pvd.qw > 1e10:  # If qw is very large, assume negligible well resistance
+            Fr = 0.0
+        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)
+
+        return Fn, Fs, Fr
+
+    def calculate_Uh(self, t: float) -> np.ndarray:
+        """
+        Calculate degree of consolidation in horizontal direction
+        using finite difference method
+
+        Parameters:
+        -----------
+        t : float
+            Time (years)
+
+        Returns:
+        --------
+        Uh : ndarray
+            Degree of horizontal consolidation at each node
+        """
+        # Calculate PVD factors
+        Fn, Fs, Fr = self.calculate_pvd_factors()
+        F_total = Fn + Fs + Fr
+
+        # Initialize excess pore pressure (normalized)
+        u = np.ones(self.n_nodes)  # Initially all excess pore pressure = surcharge
+        u_history = [u.copy()]
+
+        # Time stepping
+        n_steps = int(t / self.dt)
+
+        for step in range(n_steps):
+            u_new = u.copy()
+
+            # Finite difference for radial consolidation
+            # ∂u/∂t = Ch * [∂²u/∂r² + (1/r)(∂u/∂r)]
+            # 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)
+
+            # Boundary conditions
+            u_new[0] = 0  # Top drainage
+            u_new[-1] = 0  # Bottom drainage (if two-way)
+
+            u = u_new
+
+            if step % max(1, n_steps // 100) == 0:
+                u_history.append(u.copy())
+
+        # Calculate Uh (degree of consolidation)
+        Uh = 1 - u
+
+        return Uh
+
+    def calculate_Uv(self, t: float) -> np.ndarray:
+        """
+        Calculate degree of consolidation in vertical direction
+
+        Parameters:
+        -----------
+        t : float
+            Time (years)
+
+        Returns:
+        --------
+        Uv : ndarray
+            Degree of vertical consolidation at each node
+        """
+        Uv = np.zeros(self.n_nodes)
+
+        for i in range(self.n_nodes):
+            z = self.z_coords[i]
+            Cv = self.Cv_profile[i]
+            H = self.total_thickness
+
+            # Time factor
+            Tv = Cv * t / H**2
+
+            # Calculate Uv using Terzaghi's solution
+            if Tv < 0.217:
+                Uv[i] = np.sqrt(4 * Tv / np.pi)
+            else:
+                Uv[i] = 1 - (8 / np.pi**2) * np.exp(-(np.pi**2) * Tv / 4)
+
+            Uv[i] = min(Uv[i], 1.0)
+
+        return Uv
+
+    def calculate_total_U(self, t: float) -> np.ndarray:
+        """
+        Calculate total degree of consolidation (combined vertical and horizontal)
+
+        U = 1 - (1 - Uh)(1 - Uv)
+
+        Parameters:
+        -----------
+        t : float
+            Time (years)
+
+        Returns:
+        --------
+        U : ndarray
+            Total degree of consolidation at each node
+        """
+        Uh = self.calculate_Uh(t)
+        Uv = self.calculate_Uv(t)
+
+        U = 1 - (1 - Uh) * (1 - Uv)
+
+        return U
+
+    def calculate_settlement(self, t: float) -> Tuple[float, np.ndarray]:
+        """
+        Calculate total settlement at time t
+
+        Parameters:
+        -----------
+        t : float
+            Time (years)
+
+        Returns:
+        --------
+        total_settlement : float
+            Total settlement (m)
+        layer_settlements : ndarray
+            Settlement for each layer (m)
+        """
+        U = self.calculate_total_U(t)
+
+        layer_settlements = np.zeros(len(self.layers))
+
+        for i, layer in enumerate(self.layers):
+            # Find nodes in this layer
+            layer_mask = self.layer_indices == i
+            U_layer = np.mean(U[layer_mask])
+
+            # Calculate final settlement for this layer
+            sigma_final = layer.sigma_ini + self.surcharge
+
+            # Settlement components
+            if sigma_final <= layer.sigma_p:
+                # Recompression only
+                Sc_final = (
+                    layer.RR * np.log10(sigma_final / layer.sigma_ini) * layer.thickness
+                )
+            else:
+                if layer.sigma_ini >= layer.sigma_p:
+                    # Virgin compression only
+                    Sc_final = (
+                        layer.CR
+                        * np.log10(sigma_final / layer.sigma_ini)
+                        * layer.thickness
+                    )
+                else:
+                    # Both recompression and virgin compression
+                    Sc_recomp = (
+                        layer.RR
+                        * np.log10(layer.sigma_p / layer.sigma_ini)
+                        * layer.thickness
+                    )
+                    Sc_virgin = (
+                        layer.CR
+                        * np.log10(sigma_final / layer.sigma_p)
+                        * layer.thickness
+                    )
+                    Sc_final = Sc_recomp + Sc_virgin
+
+            # Settlement at time t
+            layer_settlements[i] = U_layer * Sc_final
+
+        total_settlement = np.sum(layer_settlements)
+
+        return total_settlement, layer_settlements
+
+    def settlement_vs_time(
+        self, t_max: float, n_points: int = 100
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Calculate settlement vs time curve
+
+        Parameters:
+        -----------
+        t_max : float
+            Maximum time (years)
+        n_points : int
+            Number of time points
+
+        Returns:
+        --------
+        time : ndarray
+            Time array (years)
+        settlement : ndarray
+            Settlement array (m)
+        """
+        time = np.linspace(0, t_max, n_points)
+        settlement = np.zeros(n_points)
+
+        for i, t in enumerate(time):
+            if t == 0:
+                settlement[i] = 0
+            else:
+                settlement[i], _ = self.calculate_settlement(t)
+
+        return time, settlement
+
+    def plot_settlement_vs_time(
+        self, t_max: float, n_points: int = 100, save_path: str = None
+    ):
+        """
+        Plot settlement vs time curve
+
+        Parameters:
+        -----------
+        t_max : float
+            Maximum time (years)
+        n_points : int
+            Number of time points
+        save_path : str, optional
+            Path to save the plot
+        """
+        time, settlement = self.settlement_vs_time(t_max, n_points)
+
+        # Convert to mm
+        settlement_mm = settlement * 1000
+
+        plt.figure(figsize=(10, 6))
+        plt.plot(time, settlement_mm, "b-", linewidth=2)
+        plt.xlabel("Time (years)", fontsize=12)
+        plt.ylabel("Settlement (mm)", fontsize=12)
+        plt.title(
+            "Settlement vs Time - PVD Consolidation", fontsize=14, fontweight="bold"
+        )
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches="tight")
+
+        plt.show()
+
+        return time, settlement_mm
+
+    def plot_degree_of_consolidation(self, t: float, save_path: str = None):
+        """
+        Plot degree of consolidation profile at time t
+
+        Parameters:
+        -----------
+        t : float
+            Time (years)
+        save_path : str, optional
+            Path to save the plot
+        """
+        Uh = self.calculate_Uh(t)
+        Uv = self.calculate_Uv(t)
+        U = self.calculate_total_U(t)
+
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+        # Plot 1: Degree of consolidation profiles
+        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)")
+        ax1.set_xlabel("Degree of Consolidation (%)", fontsize=12)
+        ax1.set_ylabel("Depth (m)", fontsize=12)
+        ax1.set_title(
+            f"Consolidation Profile at t = {t:.2f} years",
+            fontsize=12,
+            fontweight="bold",
+        )
+        ax1.invert_yaxis()
+        ax1.grid(True, alpha=0.3)
+        ax1.legend()
+
+        # Plot 2: Excess pore pressure
+        u = 1 - U
+        ax2.plot(u * self.surcharge, self.z_coords, "k-", linewidth=2)
+        ax2.set_xlabel("Excess Pore Pressure (kPa)", fontsize=12)
+        ax2.set_ylabel("Depth (m)", fontsize=12)
+        ax2.set_title(
+            f"Excess Pore Pressure at t = {t:.2f} years", fontsize=12, fontweight="bold"
+        )
+        ax2.invert_yaxis()
+        ax2.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches="tight")
+
+        plt.show()
+
+    def get_summary_report(self, t_check: List[float]) -> str:
+        """
+        Generate summary report for specified time points
+
+        Parameters:
+        -----------
+        t_check : List[float]
+            Time points to check (years)
+
+        Returns:
+        --------
+        report : str
+            Summary report
+        """
+        Fn, Fs, Fr = self.calculate_pvd_factors()
+
+        report = "=" * 70 + "\n"
+        report += "PVD CONSOLIDATION ANALYSIS SUMMARY\n"
+        report += "=" * 70 + "\n\n"
+
+        report += "PVD PARAMETERS:\n"
+        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 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 += "SOIL PROFILE:\n"
+        for i, layer in enumerate(self.layers):
+            report += f"  Layer {i + 1}:\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"    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"
+
+        report += f"Applied surcharge: {self.surcharge:.1f} kPa\n\n"
+        report += "=" * 70 + "\n"
+        report += "SETTLEMENT vs TIME:\n"
+        report += "=" * 70 + "\n"
+        report += f"{'Time (years)':<15} {'Settlement (mm)':<20} {'U (%)':<15}\n"
+        report += "-" * 70 + "\n"
+
+        for t in t_check:
+            settlement, _ = self.calculate_settlement(t)
+            U = self.calculate_total_U(t)
+            U_avg = np.mean(U)
+            report += f"{t:<15.2f} {settlement * 1000:<20.2f} {U_avg * 100:<15.1f}\n"
+
+        report += "=" * 70 + "\n"
+
+        return report
+
+
+def example_usage():
+    """Example usage of PVD consolidation analysis"""
+
+    # Define soil layers (from top to bottom)
+    layers = [
+        SoilLayer(
+            thickness=5.0,  # 5 m thick
+            Cv=0.5,  # 0.5 m²/year vertical consolidation
+            Ch=1.5,  # 1.5 m²/year horizontal consolidation
+            RR=0.05,  # Recompression ratio
+            CR=0.30,  # Compression ratio
+            sigma_ini=50.0,  # Initial effective stress 50 kPa
+            sigma_p=80.0,  # Preconsolidation pressure 80 kPa
+        ),
+        SoilLayer(
+            thickness=8.0,  # 8 m thick
+            Cv=0.3,
+            Ch=1.0,
+            RR=0.04,
+            CR=0.35,
+            sigma_ini=90.0,
+            sigma_p=90.0,
+        ),
+        SoilLayer(
+            thickness=7.0,  # 7 m thick
+            Cv=0.4,
+            Ch=1.2,
+            RR=0.045,
+            CR=0.32,
+            sigma_ini=140.0,
+            sigma_p=150.0,
+        ),
+    ]
+
+    # Define PVD properties
+    pvd = PVDProperties(
+        dw=0.05,  # 50 mm equivalent drain diameter
+        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
+    )
+
+    # Applied surcharge
+    surcharge = 100.0  # 100 kPa
+
+    # Create analysis object
+    analysis = PVDConsolidation(layers, pvd, surcharge, dt=0.01)
+
+    # Generate summary report
+    t_check = [0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0]
+    print(analysis.get_summary_report(t_check))
+
+    # Plot settlement vs time
+    print("\nGenerating settlement vs time plot...")
+    time, settlement = analysis.plot_settlement_vs_time(
+        t_max=20.0, n_points=200, save_path="settlement_vs_time.png"
+    )
+
+    # Plot consolidation profiles at different times
+    print("Generating consolidation profile plots...")
+    for t in [0.5, 2.0, 10.0]:
+        analysis.plot_degree_of_consolidation(
+            t, save_path=f"consolidation_profile_t{t:.1f}.png"
+        )
+
+    print("\nAnalysis complete!")
+
+
+def load_yaml_data(yaml_file: str) -> Dict[str, Any]:
+    """
+    Load PVD analysis data from YAML file
+
+    Parameters:
+    -----------
+    yaml_file : str
+        Path to YAML file
+
+    Returns:
+    --------
+    data : dict
+        Dictionary containing analysis parameters
+    """
+    with open(yaml_file, "r") as f:
+        data = yaml.safe_load(f)
+    return data
+
+
+def create_analysis_from_yaml(yaml_file: str) -> PVDConsolidation:
+    """
+    Create PVDConsolidation object from YAML file
+
+    Parameters:
+    -----------
+    yaml_file : str
+        Path to YAML file
+
+    Returns:
+    --------
+    analysis : PVDConsolidation
+        PVD consolidation analysis object
+    """
+    data = load_yaml_data(yaml_file)
+
+    # Create soil layers
+    layers = []
+    for layer_data in data["soil_layers"]:
+        layer = SoilLayer(
+            thickness=layer_data["thickness"],
+            Cv=layer_data["Cv"],
+            Ch=layer_data["Ch"],
+            RR=layer_data["RR"],
+            CR=layer_data["CR"],
+            sigma_ini=layer_data["sigma_ini"],
+            sigma_p=layer_data["sigma_p"],
+        )
+        layers.append(layer)
+
+    # Create PVD properties
+    pvd_data = data["pvd"]
+    pvd = PVDProperties(
+        dw=pvd_data["dw"],
+        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"],
+    )
+
+    # Get analysis parameters
+    surcharge = data["analysis"]["surcharge"]
+    dt = data["analysis"].get("dt", 0.01)
+
+    # Create analysis object
+    analysis = PVDConsolidation(layers, pvd, surcharge, dt)
+
+    return analysis, data
+
+
+def run_analysis_from_yaml(yaml_file: str, output_dir: str = None):
+    """
+    Run complete PVD analysis from YAML file
+
+    Parameters:
+    -----------
+    yaml_file : str
+        Path to YAML input file
+    output_dir : str, optional
+        Directory to save output files
+    """
+    print(f"Loading data from: {yaml_file}")
+    analysis, data = create_analysis_from_yaml(yaml_file)
+
+    # Create output directory
+    if output_dir is None:
+        output_dir = os.path.dirname(yaml_file) or "."
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Get analysis parameters
+    analysis_params = data["analysis"]
+    t_max = analysis_params.get("t_max", 20.0)
+    n_points = analysis_params.get("n_points", 200)
+    t_check = analysis_params.get("t_check", [0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0])
+    t_profiles = analysis_params.get("t_profiles", [0.5, 2.0, 10.0])
+
+    # Generate summary report
+    print("\n" + "=" * 70)
+    print("RUNNING PVD CONSOLIDATION ANALYSIS")
+    print("=" * 70 + "\n")
+
+    report = analysis.get_summary_report(t_check)
+    print(report)
+
+    # Save report to file
+    report_file = os.path.join(output_dir, "pvd_analysis_report.txt")
+    with open(report_file, "w") as f:
+        f.write(report)
+    print(f"\nReport saved to: {report_file}")
+
+    # Plot settlement vs time
+    print("\nGenerating settlement vs time plot...")
+    settlement_plot = os.path.join(output_dir, "settlement_vs_time.png")
+    time, settlement = analysis.plot_settlement_vs_time(
+        t_max=t_max, n_points=n_points, save_path=settlement_plot
+    )
+    print(f"Plot saved to: {settlement_plot}")
+
+    # Save settlement data to CSV
+    csv_file = os.path.join(output_dir, "settlement_data.csv")
+    np.savetxt(
+        csv_file,
+        np.column_stack((time, settlement * 1000)),
+        delimiter=",",
+        header="Time (years),Settlement (mm)",
+        comments="",
+    )
+    print(f"Data saved to: {csv_file}")
+
+    # Plot consolidation profiles at different times
+    print("\nGenerating consolidation profile plots...")
+    for t in t_profiles:
+        profile_plot = os.path.join(output_dir, f"consolidation_profile_t{t:.1f}y.png")
+        analysis.plot_degree_of_consolidation(t, save_path=profile_plot)
+        print(f"Profile at t={t:.1f} years saved to: {profile_plot}")
+
+    print("\n" + "=" * 70)
+    print("ANALYSIS COMPLETE!")
+    print("=" * 70)
+
+
+def main():
+    """Main CLI interface"""
+    parser = argparse.ArgumentParser(
+        description="PVD Consolidation Analysis - Settlement vs Time Calculator",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Run analysis from YAML file
+  python pvd_consolidation.py --data input.yaml
+
+  # Specify output directory
+  python pvd_consolidation.py --data input.yaml --output results/
+
+  # Run example analysis
+  python pvd_consolidation.py --example
+        """,
+    )
+
+    parser.add_argument("--data", type=str, help="Path to YAML input file")
+    parser.add_argument(
+        "--output",
+        type=str,
+        default=None,
+        help="Output directory for results (default: same as input file)",
+    )
+    parser.add_argument(
+        "--example",
+        action="store_true",
+        help="Run example analysis with default parameters",
+    )
+
+    args = parser.parse_args()
+
+    if args.example:
+        print("Running example analysis...")
+        example_usage()
+    elif args.data:
+        if not os.path.exists(args.data):
+            print(f"Error: Input file '{args.data}' not found!")
+            return
+        run_analysis_from_yaml(args.data, args.output)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,4 @@
-altair
-pandas
-streamlit
+numpy>=1.21.0
+matplotlib>=3.4.0
+pyyaml>=5.4.0
+streamlit>=1.28.0

test_input.yaml

@@ -0,0 +1,33 @@
+# Quick test input for PVD consolidation
+soil_layers:
+  - thickness: 10.0
+    Cv: 0.5
+    Ch: 2.0
+    RR: 0.05
+    CR: 0.30
+    sigma_ini: 50.0
+    sigma_p: 80.0
+
+pvd:
+  dw: 0.05
+  ds: 0.15
+  De: 1.5
+  L_drain: 10.0
+  kh: 2.0
+  ks: 1.0
+  qw: 1000000000000.0 # Negligible well resistance (1e12)
+
+analysis:
+  surcharge: 100.0
+  dt: 0.005
+  t_max: 2.0
+  n_points: 50
+
+  t_check:
+    - 0.1
+    - 0.25
+    - 0.5
+    - 1.0
+
+  t_profiles:
+    - 0.5