xslope 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

xslope/_version.py

@@ -1,4 +1,4 @@
 __all__ = ["__version__"]
-__version__ = "0.1.10"
+__version__ = "0.1.12"
 
 

xslope/fileio.py

@@ -142,7 +142,8 @@ def load_slope_data(filepath):
 
     profile_data_blocks = [
         {"header_row": 4, "data_start": 5, "data_end": 20},
-        {"header_row": 22, "data_start": 23, "data_end": 38}
+        {"header_row": 22, "data_start": 23, "data_end": 38},
+        {"header_row": 40, "data_start": 41, "data_end": 56},
     ]
     profile_block_width = 3
 
@@ -182,35 +183,62 @@ def load_slope_data(filepath):
     mat_df = xls.parse('mat', header=2)  # header=2 because the header row is row 3 in Excel
     materials = []
 
-    # Only process rows 4-15 (Excel), which are 0-indexed 0-11 in pandas 
-    for _, row in mat_df.iloc[0:12].iterrows():
-        # Check if the row is blank (columns 2-22, which are indices 1-21)
-        if row.iloc[1:22].isna().all():
-            continue
+    required_materials = len(profile_lines)
+
+    def _num(x):
+        v = pd.to_numeric(x, errors="coerce")
+        return float(v) if pd.notna(v) else 0.0
+
+    # Read exactly one material row per profile line.
+    # Materials are positional: Excel row 4 corresponds to profile line 1, row 5 to line 2, etc.
+    for i in range(required_materials):
+        # Excel row number: header is on row 3, first data row is row 4
+        excel_row = i + 4
+
+        if i >= len(mat_df):
+            raise ValueError(
+                "CRITICAL ERROR: Materials table ended early. "
+                f"Expected {required_materials} materials for {required_materials} profile lines, "
+                f"but ran out of rows at Excel row {excel_row}."
+            )
+
+        row = mat_df.iloc[i]
+        # For seepage workflows, 'g' (unit weight) and shear strength properties are not required.
+        # A material row is considered "missing" only if Excel columns C:X are empty.
+        # (Excel A:B are number and name; C:X contain the actual property fields.)
+        start_col = 2  # C
+        end_col = min(mat_df.shape[1], 24)  # X is column 24 (1-based) -> index 23, so slice end is 24
+        c_to_x_empty = True if start_col >= end_col else row.iloc[start_col:end_col].isna().all()
+        if c_to_x_empty:
+            raise ValueError(
+                "CRITICAL ERROR: Missing material row for a profile line. "
+                f"Material {i+1} of {required_materials} is blank in columns C:X (Excel row {excel_row})."
+            )
+
         materials.append({
             "name": row.get('name', ''),
-            "gamma": float(row.get('g', 0) or 0),
+            "gamma": _num(row.get("g", 0)),
             "option": str(row.get('option', '')).strip().lower(),
-            "c": float(row.get('c', 0) or 0),
-            "phi": float(row.get('f', 0) or 0),
-            "cp": float(row.get('cp', 0) or 0),
-            "r_elev": float(row.get('r-elev', 0) or 0),
-            "d": float(row.get('d', 0)) if pd.notna(row.get('d')) else 0,
-            "psi": float(row.get('ψ', 0)) if pd.notna(row.get('ψ')) else 0,
+            "c": _num(row.get('c', 0)),
+            "phi": _num(row.get('f', 0)),
+            "cp": _num(row.get('cp', 0)),
+            "r_elev": _num(row.get('r-elev', 0)),
+            "d": _num(row.get('d', 0)) if pd.notna(row.get('d')) else 0,
+            "psi": _num(row.get('ψ', 0)) if pd.notna(row.get('ψ')) else 0,
             "u": str(row.get('u', 'none')).strip().lower(),
-            "sigma_gamma": float(row.get('s(g)', 0) or 0),
-            "sigma_c": float(row.get('s(c)', 0) or 0),
-            "sigma_phi": float(row.get('s(f)', 0) or 0),
-            "sigma_cp": float(row.get('s(cp)', 0) or 0),
-            "sigma_d": float(row.get('s(d)', 0) or 0),
-            "sigma_psi": float(row.get('s(ψ)', 0) or 0),
-            "k1": float(row.get('k1', 0) or 0),
-            "k2": float(row.get('k2', 0) or 0),
-            "alpha": float(row.get('alpha', 0) or 0),
-            "kr0" : float(row.get('kr0', 0) or 0),
-            "h0" : float(row.get('h0', 0) or 0),
-            "E": float(row.get('E', 0) or 0),
-            "nu": float(row.get('n', 0) or 0)
+            "sigma_gamma": _num(row.get('s(g)', 0)),
+            "sigma_c": _num(row.get('s(c)', 0)),
+            "sigma_phi": _num(row.get('s(f)', 0)),
+            "sigma_cp": _num(row.get('s(cp)', 0)),
+            "sigma_d": _num(row.get('s(d)', 0)),
+            "sigma_psi": _num(row.get('s(ψ)', 0)),
+            "k1": _num(row.get('k1', 0)),
+            "k2": _num(row.get('k2', 0)),
+            "alpha": _num(row.get('alpha', 0)),
+            "kr0" : _num(row.get('kr0', 0)),
+            "h0" : _num(row.get('h0', 0)),
+            "E": _num(row.get('E', 0)),
+            "nu": _num(row.get('n', 0))
         })
 
     # === SEEPAGE ANALYSIS FILES ===
@@ -222,21 +250,21 @@ def load_slope_data(filepath):
     seep_u2 = None
     
     if has_seep_materials:
-        # Read seepage file names directly from Excel cells L19, L20, L21
+        # Read seepage file names directly from Excel cells L22, L23, L24
         try:
             # Read the 'mat' sheet directly without header parsing
             mat_raw_df = xls.parse('mat', header=None)
             
-            # L19 = row 18, column 11 (0-indexed)
-            mesh_filename = str(mat_raw_df.iloc[18, 11]).strip()  # L19
-            solution1_filename = str(mat_raw_df.iloc[19, 11]).strip()  # L20  
-            solution2_filename = str(mat_raw_df.iloc[20, 11]).strip()  # L21
+            # L22 = row 21, column 11 (0-indexed)
+            mesh_filename = str(mat_raw_df.iloc[21, 11]).strip()  # L22
+            solution1_filename = str(mat_raw_df.iloc[22, 11]).strip()  # L23
+            solution2_filename = str(mat_raw_df.iloc[23, 11]).strip()  # L24
             
             # Validate required files
             if not mesh_filename or mesh_filename.lower() == 'nan':
-                raise ValueError("CRITICAL ERROR: Mesh filename is required when using 'seep' pore pressure option but is blank in cell L19.")
+                raise ValueError("CRITICAL ERROR: Mesh filename is required when using 'seep' pore pressure option but is blank in cell L22.")
             if not solution1_filename or solution1_filename.lower() == 'nan':
-                raise ValueError("CRITICAL ERROR: Solution1 filename is required when using 'seep' pore pressure option but is blank in cell L20.")
+                raise ValueError("CRITICAL ERROR: Solution1 filename is required when using 'seep' pore pressure option but is blank in cell L23.")
             
             # Load mesh file
             if not os.path.exists(mesh_filename):
@@ -510,43 +538,51 @@ def load_slope_data(filepath):
     # === SEEPAGE ANALYSIS BOUNDARY CONDITIONS ===
     seep_df = xls.parse('seep bc', header=None)
     seepage_bc = {"specified_heads": [], "exit_face": []}
+    seepage_bc2 = {"specified_heads": [], "exit_face": []}
+
+    def _read_specified_head_block(
+        df,
+        head_row: int,
+        head_col: int,
+        x_col: int,
+        y_col: int,
+        data_start_row: int,
+        data_end_row: int,
+    ):
+        """Read a specified-head block; returns (head_value, coords_list)."""
+        head_val = (
+            df.iloc[head_row, head_col]
+            if df.shape[0] > head_row and df.shape[1] > head_col
+            else None
+        )
+        coords = []
+        for r in range(data_start_row, data_end_row):
+            if r >= df.shape[0]:
+                break
+            x = df.iloc[r, x_col] if df.shape[1] > x_col else None
+            y = df.iloc[r, y_col] if df.shape[1] > y_col else None
+            if pd.notna(x) and pd.notna(y):
+                coords.append((float(x), float(y)))
+        return head_val, coords
 
     # Specified Head #1
-    head1 = seep_df.iloc[2, 2] if seep_df.shape[1] > 2 and seep_df.shape[0] > 2 else None
-    coords1 = []
-    for i in range(4, 12):  # rows 5-12 (0-indexed 4-11)
-        if i >= seep_df.shape[0]:
-            break
-        x = seep_df.iloc[i, 1] if seep_df.shape[1] > 1 else None
-        y = seep_df.iloc[i, 2] if seep_df.shape[1] > 2 else None
-        if pd.notna(x) and pd.notna(y):
-            coords1.append((float(x), float(y)))
+    head1, coords1 = _read_specified_head_block(
+        seep_df, head_row=2, head_col=2, x_col=1, y_col=2, data_start_row=4, data_end_row=12
+    )
     if head1 is not None and coords1:
         seepage_bc["specified_heads"].append({"head": float(head1), "coords": coords1})
 
     # Specified Head #2
-    head2 = seep_df.iloc[2, 5] if seep_df.shape[1] > 5 and seep_df.shape[0] > 2 else None
-    coords2 = []
-    for i in range(4, 12):
-        if i >= seep_df.shape[0]:
-            break
-        x = seep_df.iloc[i, 4] if seep_df.shape[1] > 4 else None
-        y = seep_df.iloc[i, 5] if seep_df.shape[1] > 5 else None
-        if pd.notna(x) and pd.notna(y):
-            coords2.append((float(x), float(y)))
+    head2, coords2 = _read_specified_head_block(
+        seep_df, head_row=2, head_col=5, x_col=4, y_col=5, data_start_row=4, data_end_row=12
+    )
     if head2 is not None and coords2:
         seepage_bc["specified_heads"].append({"head": float(head2), "coords": coords2})
 
     # Specified Head #3
-    head3 = seep_df.iloc[2, 8] if seep_df.shape[1] > 8 and seep_df.shape[0] > 2 else None
-    coords3 = []
-    for i in range(4, 12):
-        if i >= seep_df.shape[0]:
-            break
-        x = seep_df.iloc[i, 7] if seep_df.shape[1] > 7 else None
-        y = seep_df.iloc[i, 8] if seep_df.shape[1] > 8 else None
-        if pd.notna(x) and pd.notna(y):
-            coords3.append((float(x), float(y)))
+    head3, coords3 = _read_specified_head_block(
+        seep_df, head_row=2, head_col=8, x_col=7, y_col=8, data_start_row=4, data_end_row=12
+    )
     if head3 is not None and coords3:
         seepage_bc["specified_heads"].append({"head": float(head3), "coords": coords3})
 
@@ -561,6 +597,39 @@ def load_slope_data(filepath):
             exit_coords.append((float(x), float(y)))
     seepage_bc["exit_face"] = exit_coords
 
+    # --- RAPID DRAWDOWN BCs (second set) ---
+    # User-added second set starts at:
+    # - Specified Head #1: head in C26, coords in B28:C35
+    head1b, coords1b = _read_specified_head_block(
+        seep_df, head_row=25, head_col=2, x_col=1, y_col=2, data_start_row=27, data_end_row=35
+    )
+    if head1b is not None and coords1b:
+        seepage_bc2["specified_heads"].append({"head": float(head1b), "coords": coords1b})
+
+    # Mirror the same layout for the other two specified-head blocks (same columns as the first set)
+    head2b, coords2b = _read_specified_head_block(
+        seep_df, head_row=25, head_col=5, x_col=4, y_col=5, data_start_row=27, data_end_row=35
+    )
+    if head2b is not None and coords2b:
+        seepage_bc2["specified_heads"].append({"head": float(head2b), "coords": coords2b})
+
+    head3b, coords3b = _read_specified_head_block(
+        seep_df, head_row=25, head_col=8, x_col=7, y_col=8, data_start_row=27, data_end_row=35
+    )
+    if head3b is not None and coords3b:
+        seepage_bc2["specified_heads"].append({"head": float(head3b), "coords": coords3b})
+
+    # Exit Face #2: positioned lower on the sheet (same columns as the first exit face block)
+    exit_coords2 = []
+    for i in range(38, 46):  # rows 39-46 (0-indexed 38-45)
+        if i >= seep_df.shape[0]:
+            break
+        x = seep_df.iloc[i, 1] if seep_df.shape[1] > 1 else None
+        y = seep_df.iloc[i, 2] if seep_df.shape[1] > 2 else None
+        if pd.notna(x) and pd.notna(y):
+            exit_coords2.append((float(x), float(y)))
+    seepage_bc2["exit_face"] = exit_coords2
+
     # === VALIDATION ===
  
     circular = len(circles) > 0
@@ -600,6 +669,7 @@ def load_slope_data(filepath):
     globals_data["dloads2"] = dloads2
     globals_data["reinforce_lines"] = reinforce_lines
     globals_data["seepage_bc"] = seepage_bc
+    globals_data["seepage_bc2"] = seepage_bc2
     
     # Add seepage data if available
     if has_seep_materials:

xslope/mesh.py

@@ -1206,7 +1206,7 @@ def get_quad_mesh_presets():
 
 
 
-def build_polygons(slope_data, reinf_lines=None, debug=False):
+def build_polygons(slope_data, reinf_lines=None, tol = 0.000001, debug=False):
     """
     Build material zone polygons from slope_data.
     
@@ -1237,7 +1237,6 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
 
     n = len(profile_lines)
     lines = [list(line) for line in copy.deepcopy(profile_lines)]
-    tol = 1e-8
 
     for i in range(n - 1):
         top = lines[i]
@@ -1432,6 +1431,93 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 # Return the lowest y value
                 y_min = min(y_values)
                 return y_min, is_at_endpoint
+
+            def find_projected_y_at_x(line_points, x_query, y_ref, side, tol=1e-8):
+                """
+                For vertical endpoint projections: choose the intersection y at x_query that is
+                closest *below* the point we're projecting from.
+
+                This fixes the case where a candidate profile has a vertical segment at x_query
+                (e.g., (260,229) then (260,202)). In that situation, using the "lowest y" (202)
+                is wrong; we want the first hit when projecting downward (229).
+
+                Behavior is intentionally conservative:
+                - If there is at least one intersection strictly below y_ref, return the highest of those.
+                - Otherwise fall back to the original behavior (lowest y), preserving legacy behavior
+                  in edge cases (e.g., coincident/above intersections).
+                """
+                # Reuse the exact same intersection enumeration logic as find_lowest_y_at_x,
+                # but keep the full set of y-values.
+                if not line_points:
+                    return None, False
+
+                xs = np.array([x for x, y in line_points])
+                ys = np.array([y for x, y in line_points])
+
+                if xs[0] - tol > x_query or xs[-1] + tol < x_query:
+                    return None, False
+
+                is_at_left_endpoint = abs(x_query - xs[0]) < tol
+                is_at_right_endpoint = abs(x_query - xs[-1]) < tol
+                is_at_endpoint = is_at_left_endpoint or is_at_right_endpoint
+
+                y_values = []
+                for k in range(len(line_points)):
+                    if abs(xs[k] - x_query) < tol:
+                        y_values.append(float(ys[k]))
+
+                for k in range(len(line_points) - 1):
+                    x1, y1 = line_points[k]
+                    x2, y2 = line_points[k + 1]
+
+                    if abs(x1 - x_query) < tol and abs(x2 - x_query) < tol:
+                        y_values.append(float(y1))
+                        y_values.append(float(y2))
+                    elif min(x1, x2) - tol <= x_query <= max(x1, x2) + tol:
+                        if abs(x2 - x1) < tol:
+                            y_values.append(float(y1))
+                            y_values.append(float(y2))
+                        else:
+                            t = (x_query - x1) / (x2 - x1)
+                            if 0 <= t <= 1:
+                                y_values.append(float(y1 + t * (y2 - y1)))
+
+                if not y_values:
+                    return None, False
+
+                # If the polyline has multiple *vertices* exactly at this x (vertical segment / duplicate-x),
+                # use a deterministic selection based on which side we are projecting from:
+                # - projecting from LEFT endpoint of the upper line: keep the LAST y encountered
+                # - projecting from RIGHT endpoint of the upper line: keep the FIRST y encountered
+                #
+                # This matches the intended "walk along the lower boundary" behavior and fixes cases like:
+                # - right projection at x=260 with vertices (260,229) then (260,202): choose 229 (first)
+                # - left projection at x=240 with vertices (240,140) then (240,190): choose 190 (last)
+                vertex_y_at_x = [float(y) for (x, y) in line_points if abs(x - x_query) < tol]
+                if len(vertex_y_at_x) >= 2:
+                    if side == "right":
+                        # first encountered vertex at this x
+                        y_pick = vertex_y_at_x[0]
+                        # If we are exactly on a vertex at y_ref, that is the first hit.
+                        if abs(y_pick - y_ref) < tol:
+                            return float(y_ref), is_at_endpoint
+                        if y_pick < (y_ref - tol):
+                            return y_pick, is_at_endpoint
+                    elif side == "left":
+                        # last encountered vertex at this x
+                        y_pick = vertex_y_at_x[-1]
+                        # If we are exactly on a vertex at y_ref, that is the first hit.
+                        if abs(y_pick - y_ref) < tol:
+                            return float(y_ref), is_at_endpoint
+                        if y_pick < (y_ref - tol):
+                            return y_pick, is_at_endpoint
+
+                y_below = [y for y in y_values if y < (y_ref - tol)]
+                if y_below:
+                    return max(y_below), is_at_endpoint
+
+                # Fall back to legacy behavior
+                return min(y_values), is_at_endpoint
             
             # Project endpoints - find highest lower profile or use max_depth
             # When projecting right side: if intersection is at left end of lower line,
@@ -1445,7 +1531,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 
                 # Check left endpoint projection
                 if xs_cand[0] - tol <= left_x <= xs_cand[-1] + tol:
-                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, left_x, tol)
+                    y_cand, is_at_endpoint = find_projected_y_at_x(lower_candidate, left_x, left_y, side="left", tol=tol)
                     if y_cand is not None:
                         # If intersection is at the right end of the lower line, add point but continue
                         if is_at_endpoint and abs(left_x - xs_cand[-1]) < tol:  # At right endpoint
@@ -1458,7 +1544,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 
                 # Check right endpoint projection
                 if xs_cand[0] - tol <= right_x <= xs_cand[-1] + tol:
-                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, right_x, tol)
+                    y_cand, is_at_endpoint = find_projected_y_at_x(lower_candidate, right_x, right_y, side="right", tol=tol)
                     if y_cand is not None:
                         # If intersection is at the left end of the lower line, add point but continue
                         if is_at_endpoint and abs(right_x - xs_cand[0]) < tol:  # At left endpoint
@@ -1474,6 +1560,25 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 left_y_bot = max_depth if max_depth is not None else -np.inf
             if right_y_bot == -np.inf:
                 right_y_bot = max_depth if max_depth is not None else -np.inf
+
+            # Filter vertical-edge "continue projecting" points so we only keep points that
+            # actually lie on the final vertical edge between the top and bottom of this zone.
+            #
+            # Without this, a deeper left-endpoint intersection (e.g., (240,190) at the left
+            # endpoint of some deeper line) can be appended to right_vertical_points even after
+            # we've already found the correct bottom (e.g., right_y_bot=229). That creates the
+            # dangling vertical segment you observed.
+            if right_y_bot != -np.inf:
+                right_vertical_points = [
+                    (x, y) for (x, y) in right_vertical_points
+                    if (y < right_y - tol) and (y > right_y_bot + tol)
+                ]
+            if left_y_bot != -np.inf:
+                # Left edge runs from bottom up to top; keep points strictly between bottom and top.
+                left_vertical_points = [
+                    (x, y) for (x, y) in left_vertical_points
+                    if (y > left_y_bot + tol) and (y < left_y - tol)
+                ]
             
             # Deduplicate vertical points (remove points that are too close to each other)
             def deduplicate_points(points, tol=1e-8):