xslope 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

xslope/_version.py

@@ -1,4 +1,4 @@
 __all__ = ["__version__"]
-__version__ = "0.1.13"
+__version__ = "0.1.15"
 
 

xslope/plot.py

@@ -466,22 +466,159 @@ def plot_seepage_bc_lines(ax, slope_data):
             label="Exit Face",
         )
 
-def plot_tcrack_surface(ax, tcrack_surface):
+def plot_tcrack_surface(ax, slope_data):
     """
-    Plots the tension crack surface as a thin dashed red line.
+    Plots the tension crack surface as a thin dashed red line, clipped to max_depth.
 
     Parameters:
         ax: matplotlib Axes object
-        tcrack_surface: Shapely LineString
+        slope_data: Dictionary containing tcrack_surface and max_depth
 
     Returns:
         None
     """
+    tcrack_surface = slope_data.get('tcrack_surface')
     if tcrack_surface is None:
         return
 
-    x_vals, y_vals = tcrack_surface.xy
-    ax.plot(x_vals, y_vals, linestyle='--', color='red', linewidth=1.0, label='Tension Crack Depth')
+    color = 'red'
+    linestyle = ':'
+    linewidth = 1.5
+
+    max_depth = slope_data.get('max_depth')
+    if max_depth is None:
+        # No clipping needed
+        x_vals, y_vals = tcrack_surface.xy
+        ax.plot(x_vals, y_vals, linestyle=linestyle, color=color, linewidth=linewidth, label='Tension Crack Depth')
+        return
+
+    # Get coordinates and clip to max_depth with interpolation
+    coords = list(tcrack_surface.coords)
+    x_clipped = []
+    y_clipped = []
+
+    for i in range(len(coords)):
+        x1, y1 = coords[i]
+
+        if y1 >= max_depth:
+            # Point is above max_depth, include it
+            x_clipped.append(x1)
+            y_clipped.append(y1)
+
+        # Check if segment crosses max_depth (need to interpolate)
+        if i < len(coords) - 1:
+            x2, y2 = coords[i + 1]
+            # Check if segment crosses max_depth
+            if (y1 < max_depth and y2 >= max_depth) or (y1 >= max_depth and y2 < max_depth):
+                # Interpolate to find crossing point
+                t = (max_depth - y1) / (y2 - y1)
+                x_cross = x1 + t * (x2 - x1)
+                x_clipped.append(x_cross)
+                y_clipped.append(max_depth)
+
+    if x_clipped:
+        ax.plot(x_clipped, y_clipped, linestyle=linestyle, color=color, linewidth=linewidth, label='Tension Crack Depth')
+
+
+def plot_tcrack_water_force(ax, slice_df, slope_data):
+    """
+    Plots the triangular water pressure distribution on the tension crack face.
+
+    The water in the tension crack creates a triangular pressure distribution
+    acting horizontally on the side of the top slice. Pressure is zero at the
+    water surface and maximum (gamma_w * water_depth) at the bottom.
+    The triangle is drawn on the outside of the slice, with arrows pointing
+    toward the slice to show force direction. The base of the triangle is
+    scaled to equal the water depth.
+
+    Parameters:
+        ax: matplotlib Axes object
+        slice_df: DataFrame containing slice data with 't' and 'y_t' columns
+        slope_data: Dictionary containing slope data including tcrack_water
+
+    Returns:
+        None
+    """
+    tcrack_water = slope_data.get('tcrack_water', 0)
+    if tcrack_water <= 0:
+        return
+
+    # Find the slice with the tension crack force
+    t_forces = slice_df['t'].abs()
+    if t_forces.max() == 0:
+        return
+
+    # Get the slice with the tension crack force
+    tcrack_slice_idx = t_forces.idxmax()
+    tcrack_slice = slice_df.loc[tcrack_slice_idx]
+
+    t_force = tcrack_slice['t']
+    y_rb = tcrack_slice['y_rb']
+    y_rt = tcrack_slice['y_rt']
+
+    # Determine if right-facing or left-facing based on sign of t
+    # Negative t means right-facing (force acts to the right, on left side of first slice)
+    # Positive t means left-facing (force acts to the left, on right side of last slice)
+    right_facing = t_force < 0
+
+    if right_facing:
+        # Water on left side of slice, triangle extends left (outside), arrows point right (into slice)
+        x_base = tcrack_slice['x_l']
+        triangle_direction = -1  # triangle extends left (outside the slice)
+        arrow_direction = 1      # arrows point right (into the slice)
+    else:
+        # Water on right side of slice, triangle extends right (outside), arrows point left (into slice)
+        x_base = tcrack_slice['x_r']
+        triangle_direction = 1   # triangle extends right (outside the slice)
+        arrow_direction = -1     # arrows point left (into the slice)
+
+    # Water surface is at ground level, bottom of water is at y_rb
+    y_water_top = y_rt  # top of water (at ground surface)
+    y_water_bottom = y_rb  # bottom of water (at failure surface)
+    water_depth = y_water_top - y_water_bottom
+
+    if water_depth <= 0:
+        return
+
+    # Scale so that the base of the triangle equals the water depth
+    max_length = tcrack_water  # base of triangle = water depth
+
+    # Arrow head dimensions (same style as distributed loads)
+    head_length = max_length / 8
+    head_width = head_length * 0.8
+
+    # Draw triangular pressure distribution (on outside of slice)
+    num_arrows = 5
+    y_positions = np.linspace(y_water_bottom, y_water_top, num_arrows + 1)[:-1]
+
+    for y_pos in y_positions:
+        # Arrow length proportional to depth (0 at top, max_length at bottom)
+        depth_from_surface = y_water_top - y_pos
+        arrow_length = max_length * (depth_from_surface / water_depth)
+
+        if arrow_length < 0.1:
+            continue  # Skip very short arrows
+
+        # Arrow starts from outside (triangle edge) and points toward slice
+        x_start = x_base + arrow_length * triangle_direction
+        dx = -arrow_length * triangle_direction  # direction toward slice
+
+        # Draw arrow using same style as distributed loads
+        if head_length > arrow_length:
+            # Draw a simple line without arrowhead for short arrows
+            ax.plot([x_start, x_base], [y_pos, y_pos],
+                   color='blue', linewidth=2, alpha=0.7)
+        else:
+            ax.arrow(x_start, y_pos, dx, 0,
+                    head_width=head_width, head_length=head_length,
+                    fc='blue', ec='blue', alpha=0.7,
+                    length_includes_head=True)
+
+    # Draw the triangular outline (pressure diagram) on outside of slice
+    triangle_x = [x_base, x_base + max_length * triangle_direction, x_base]
+    triangle_y = [y_water_top, y_water_bottom, y_water_bottom]
+    ax.fill(triangle_x, triangle_y, color='lightblue', alpha=0.3, edgecolor='blue', linewidth=1)
+
 
 def plot_dloads(ax, slope_data):
     """
@@ -635,7 +772,9 @@ def plot_circles(ax, slope_data):
         None
     """
     circles = slope_data['circles']
-    for circle in circles:
+    tcrack_depth = slope_data.get('tcrack_depth', 0)
+
+    for i, circle in enumerate(circles):
         Xo = circle['Xo']
         Yo = circle['Yo']
         R = circle['R']
@@ -644,11 +783,12 @@ def plot_circles(ax, slope_data):
         # y_circle = Yo + R * np.sin(theta)
         # ax.plot(x_circle, y_circle, 'r--', label='Circle')
 
-        # Plot the portion of the circle in the slope
+        # Plot the portion of the circle in the slope (clipped to tension crack if present)
         ground_surface = slope_data['ground_surface']
-        success, result = generate_failure_surface(ground_surface, circular=True, circle=circle)
+        success, result = generate_failure_surface(ground_surface, circular=True, circle=circle, tcrack_depth=tcrack_depth)
         if not success:
-            continue  # or handle error
+            print(f"Warning: Circle {i+1} (Xo={Xo:.2f}, Yo={Yo:.2f}, R={R:.2f}) could not be plotted: {result}")
+            continue
         # result = (x_min, x_max, y_left, y_right, clipped_surface)
         x_min, x_max, y_left, y_right, clipped_surface = result
         if not isinstance(clipped_surface, LineString):
@@ -673,11 +813,16 @@ def plot_circles(ax, slope_data):
             dx /= length
             dy /= length
 
-        # Shorten shaft length slightly
-        shaft_length = R - 5
-
-        ax.arrow(Xo, Yo, dx * shaft_length, dy * shaft_length,
-                 head_width=5, head_length=5, fc='red', ec='red')
+        # Draw arrow with pixel-based head size
+        ax.annotate('',
+                    xy=(Xo + dx * R, Yo + dy * R),  # arrow tip
+                    xytext=(Xo, Yo),                 # arrow start
+                    arrowprops=dict(
+                        arrowstyle='-|>',
+                        color='red',
+                        lw=1.0,            # shaft width in points
+                        mutation_scale=20  # head size in points
+                    ))
 
 def plot_non_circ(ax, non_circ):
     """
@@ -692,7 +837,12 @@ def plot_non_circ(ax, non_circ):
     """
     if not non_circ or len(non_circ) == 0:
         return
-    xs, ys = zip(*non_circ)
+    # Handle both dict format {'X': x, 'Y': y} and tuple format (x, y)
+    if isinstance(non_circ[0], dict):
+        xs = [p['X'] for p in non_circ]
+        ys = [p['Y'] for p in non_circ]
+    else:
+        xs, ys = zip(*non_circ)
     ax.plot(xs, ys, 'r--', label='Non-Circular Surface')
 
 def plot_lem_material_table(ax, materials, xloc=0.6, yloc=0.7):
@@ -1183,7 +1333,18 @@ def compute_ylim(data, slice_df, scale_frac=0.5, pad_fraction=0.1):
         y_min -= max_bar
         y_max += max_bar
 
-    # 4) add a final small pad
+    # 4) account for distributed loads extending above ground surface
+    gamma_w = data.get('gamma_water', 62.4)
+    for dloads in [data.get('dloads', []), data.get('dloads2', [])]:
+        if dloads:
+            for line in dloads:
+                for pt in line:
+                    # dload arrows extend above surface by load/gamma_w (water depth equivalent)
+                    load = pt.get('Normal', 0)
+                    if load > 0:
+                        y_max = max(y_max, pt.get('Y', 0) + load / gamma_w)
+
+    # 5) add a final small pad
     pad = (y_max - y_min) * pad_fraction
     return y_min - pad, y_max + pad
 
@@ -1231,11 +1392,11 @@ def plot_inputs(
     slope_data,
     title="Slope Geometry and Inputs",
     figsize=(12, 6),
-    mat_table=True,
+    mat_table=False,
     save_png=False,
     dpi=300,
     mode="lem",
-    tab_loc="upper left",
+    tab_loc="top",
     legend_ncol="auto",
     legend_max_cols=6,
     legend_max_rows=4,
@@ -1287,7 +1448,7 @@ def plot_inputs(
     if mode == "seep":
         plot_seepage_bc_lines(ax, slope_data)
     plot_dloads(ax, slope_data)
-    plot_tcrack_surface(ax, slope_data['tcrack_surface'])
+    plot_tcrack_surface(ax, slope_data)
     plot_reinforcement_lines(ax, slope_data)
 
     if slope_data['circular']:
@@ -1487,7 +1648,8 @@ def plot_solution(slope_data, slice_df, failure_surface, results, figsize=(12, 7
     plot_failure_surface(ax, failure_surface)
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
-    plot_tcrack_surface(ax, slope_data['tcrack_surface'])
+    plot_tcrack_surface(ax, slope_data)
+    plot_tcrack_water_force(ax, slice_df, slope_data)
     plot_reinforcement_lines(ax, slope_data)
     if slice_numbers:
         plot_slice_numbers(ax, slice_df)
@@ -1617,7 +1779,7 @@ def plot_search_path(ax, search_path):
         ax.arrow(start['x'], start['y'], dx, dy,
                  head_width=1, head_length=2, fc='green', ec='green', length_includes_head=True)
 
-def plot_circular_search_results(slope_data, fs_cache, search_path=None, highlight_fs=True, figsize=(12, 7), save_png=False, dpi=300):
+def plot_circular_search_results(slope_data, fs_cache, search_path=None, circle_cache=None, highlight_fs=True, figsize=(12, 7), save_png=False, dpi=300):
     """
     Creates a plot showing the results of a circular failure surface search.
 
@@ -1625,6 +1787,7 @@ def plot_circular_search_results(slope_data, fs_cache, search_path=None, highlig
         slope_data: Dictionary containing plot data
         fs_cache: List of dictionaries containing failure surface data and FS values
         search_path: List of dictionaries containing search path coordinates
+        circle_cache: List of dictionaries containing all tested circles (for plotting)
         highlight_fs: Boolean indicating whether to highlight the critical failure surface
         figsize: Tuple of (width, height) in inches for the plot
 
@@ -1637,10 +1800,33 @@ def plot_circular_search_results(slope_data, fs_cache, search_path=None, highlig
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
-    plot_tcrack_surface(ax, slope_data['tcrack_surface'])
-
-    plot_failure_surfaces(ax, fs_cache)
+    plot_tcrack_surface(ax, slope_data)
+
+    # Plot all tested circles from circle_cache (light gray)
+    if circle_cache:
+        first_plotted = True
+        for result in circle_cache:
+            surface = result.get('failure_surface')
+            if surface is None or surface.is_empty:
+                continue
+            x, y = zip(*surface.coords)
+            label = 'Tested Circle' if first_plotted else None
+            ax.plot(x, y, color='gray', linestyle='-', linewidth=0.5, alpha=0.5, label=label)
+            first_plotted = False
+
+    # Plot only the critical circle from fs_cache (red)
+    if fs_cache:
+        critical = fs_cache[0]
+        surface = critical.get('failure_surface')
+        if surface is not None and not surface.is_empty:
+            x, y = zip(*surface.coords)
+            ax.plot(x, y, color='red', linestyle='-', linewidth=2, label='Critical Circle')
+        # Plot critical circle center
+        ax.plot(critical['Xo'], critical['Yo'], 'ro', markersize=5)
+
+    # Plot all circle centers from fs_cache
     plot_circle_centers(ax, fs_cache)
+
     if search_path:
         plot_search_path(ax, search_path)
 
@@ -1683,17 +1869,23 @@ def plot_noncircular_search_results(slope_data, fs_cache, search_path=None, high
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
-    plot_tcrack_surface(ax, slope_data['tcrack_surface'])
+    plot_tcrack_surface(ax, slope_data)
 
     # Plot all failure surfaces from cache
+    first_tested = True
     for i, result in reversed(list(enumerate(fs_cache))):
         surface = result['failure_surface']
         if surface is None or surface.is_empty:
             continue
         x, y = zip(*surface.coords)
-        color = 'red' if i == 0 else 'gray'
-        lw = 2 if i == 0 else 1
-        ax.plot(x, y, color=color, linestyle='-', linewidth=lw, alpha=1.0 if i == 0 else 0.6)
+        if i == 0:
+            # Critical surface
+            ax.plot(x, y, color='red', linestyle='-', linewidth=2, alpha=1.0, label='Critical Surface')
+        else:
+            # Tested surfaces
+            label = 'Tested Surface' if first_tested else None
+            ax.plot(x, y, color='gray', linestyle='-', linewidth=1, alpha=0.6, label=label)
+            first_tested = False
 
     # Plot search path if provided
     if search_path:
@@ -1717,14 +1909,14 @@ def plot_noncircular_search_results(slope_data, fs_cache, search_path=None, high
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.grid(False)
-    ax.legend()
+    ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=4)
 
     if highlight_fs and fs_cache:
         critical_fs = fs_cache[0]['FS']
         ax.set_title(f"Critical Factor of Safety = {critical_fs:.3f}")
 
     plt.tight_layout()
-    
+
     if save_png:
         filename = 'plot_noncircular_search_results.png'
         plt.savefig(filename, dpi=dpi, bbox_inches='tight')
@@ -1750,7 +1942,7 @@ def plot_reliability_results(slope_data, reliability_data, figsize=(12, 7), save
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
-    plot_tcrack_surface(ax, slope_data['tcrack_surface'])
+    plot_tcrack_surface(ax, slope_data)
 
     # Plot reliability-specific failure surfaces
     fs_cache = reliability_data['fs_cache']

xslope/search.py

@@ -30,9 +30,11 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
         list of dict: sorted fs_cache by FS
         bool: convergence flag
         list of dict: search path
+        list of dict: circle_cache - all circles tested during search
     """
 
     solver = getattr(solve, method_name)
+    circle_cache = []  # Store ALL circles tested for plotting
 
     start_time = time.time()  # Start timing
 
@@ -46,7 +48,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
     circles = slope_data['circles']
     max_depth = slope_data['max_depth']
 
-    def optimize_depth(x, y, depth_guess, depth_step_init, depth_shrink_factor, tol_frac, fs_fail, diagnostic=False):
+    def optimize_depth(x, y, depth_guess, depth_step_init, depth_shrink_factor, tol_frac, fs_fail, circle_cache, diagnostic=False):
         depth_step = min(10.0, depth_step_init)
         best_depth = max(depth_guess, max_depth)
         best_fs = fs_fail
@@ -78,6 +80,17 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
                     FS = solver_result['FS'] if solver_success else fs_fail
                 fs_results.append((FS, d, df_slices, failure_surface, solver_result))
 
+                # Add to circle_cache for plotting all tested circles
+                if FS != fs_fail:
+                    circle_cache.append({
+                        "Xo": x,
+                        "Yo": y,
+                        "Depth": d,
+                        "R": y - d,
+                        "FS": FS,
+                        "failure_surface": failure_surface
+                    })
+
             fs_results.sort(key=lambda t: t[0])
             best_fs, best_depth, best_df, best_surface, best_solver_result = fs_results[0]
 
@@ -98,7 +111,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
 
         return best_depth, best_fs, best_df, best_surface, best_solver_result
 
-    def evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=False, fs_cache=None):
+    def evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=False, fs_cache=None, circle_cache=None):
         if fs_cache is None:
             fs_cache = {}
 
@@ -116,7 +129,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
             depth_step_init = grid_size * 0.75
             d, FS, df_slices, failure_surface, solver_result = optimize_depth(
                 x, y, depth_guess, depth_step_init, depth_shrink_factor=0.25, tol_frac=0.01, fs_fail=fs_fail,
-                diagnostic=diagnostic
+                circle_cache=circle_cache, diagnostic=diagnostic
             )
 
             fs_cache[(x, y)] = {
@@ -143,6 +156,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
 
     # === Step 1: Evaluate starting circles ===
     all_starts = []
+    fs_cache = {}  # Shared cache for all starting circles
     for i, start_circle in enumerate(circles):
         x0 = start_circle['Xo']
         y0 = start_circle['Yo']
@@ -151,11 +165,11 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
             print(f"\n[⏱ starting circle {i+1}] x={x0:.2f}, y={y0:.2f}, r={r0:.2f}")
         grid_size = r0 * 0.15
         depth_guess = start_circle['Depth']
-        fs_cache, best_point = evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=diagnostic)
-        all_starts.append((start_circle, best_point, fs_cache))
+        fs_cache, best_point = evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=diagnostic, fs_cache=fs_cache, circle_cache=circle_cache)
+        all_starts.append((start_circle, best_point))
 
     all_starts.sort(key=lambda t: t[1]['FS'])
-    start_circle, best_start, fs_cache = all_starts[0]
+    start_circle, best_start = all_starts[0]
     x0 = best_start['Xo']
     y0 = best_start['Yo']
     depth_guess = best_start['Depth']
@@ -174,7 +188,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
 
     for iteration in range(max_iter):
         print(f"[🔁 iteration {iteration+1}] center=({x0:.2f}, {y0:.2f}), FS={best_fs:.4f}, grid={grid_size:.4f}")
-        fs_cache, best_point = evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=diagnostic, fs_cache=fs_cache)
+        fs_cache, best_point = evaluate_grid(x0, y0, grid_size, depth_guess, slope_data, diagnostic=diagnostic, fs_cache=fs_cache, circle_cache=circle_cache)
 
         if best_point['FS'] < best_fs:
             best_fs = best_point['FS']
@@ -196,7 +210,7 @@ def circular_search(slope_data, method_name, rapid=False, tol=1e-2, max_iter=50,
         print(f"\n[❌ max iterations reached] FS={best_fs:.4f} at (x={x0:.2f}, y={y0:.2f})")
 
     sorted_fs_cache = sorted(fs_cache.values(), key=lambda d: d['FS'])
-    return sorted_fs_cache, converged, search_path
+    return sorted_fs_cache, converged, search_path, circle_cache
 
 def noncircular_search(slope_data, method_name, rapid=False, diagnostic=True, movement_distance=4.0, shrink_factor=0.8, fs_tol=0.001, max_iter=100, move_tol=0.1):
     """

xslope/slice.py

@@ -264,22 +264,6 @@ def get_sorted_intersections(failure_surface, ground_surface, circle_params=None
     return True, "", pruned
 
 
-def adjust_ground_for_tcrack(ground_surface, x_center, tcrack_depth, right_facing):
-    # helper function to adjust the ground surface for tension crack
-    if tcrack_depth <= 0:
-        return ground_surface
-
-    new_coords = []
-    for x, y in ground_surface.coords:
-        if right_facing and x < x_center:
-            new_coords.append((x, y - tcrack_depth))
-        elif not right_facing and x > x_center:
-            new_coords.append((x, y - tcrack_depth))
-        else:
-            new_coords.append((x, y))
-    return LineString(new_coords)
-
-
 def generate_failure_surface(ground_surface, circular, circle=None, non_circ=None, tcrack_depth=0):
     """
     Generates a failure surface based on either a circular or non-circular definition.
@@ -311,7 +295,7 @@ def generate_failure_surface(ground_surface, circular, circle=None, non_circ=Non
     else:
         return False, "Either a circular or non-circular failure surface must be provided."
 
-    # --- Step 2: Intersect with original ground surface to determine slope facing ---
+    # --- Step 2: Intersect with original ground surface to determine slope facing and toe ---
     if circular and circle:
         success, msg, points = get_sorted_intersections(failure_surface, ground_surface, circle_params=circle)
     else:
@@ -322,41 +306,64 @@ def generate_failure_surface(ground_surface, circular, circle=None, non_circ=Non
     x_min, x_max = points[0].x, points[1].x
     y_left, y_right = points[0].y, points[1].y
     right_facing = y_left > y_right
-    x_center = 0.5 * (x_min + x_max)
 
-    # --- Step 3: If tension crack exists, adjust surface and re-intersect ---
+    # --- Step 3: If tension crack exists, find intersection with tension crack surface ---
     if tcrack_depth > 0:
-        modified_surface = adjust_ground_for_tcrack(ground_surface, x_center, tcrack_depth, right_facing)
+        # Create tension crack surface as parallel offset of entire ground surface
+        tcrack_surface = LineString([(x, y - tcrack_depth) for x, y in ground_surface.coords])
+
+        # Find intersection of failure surface with tension crack surface
         if circular and circle:
-            success, msg, points = get_sorted_intersections(failure_surface, modified_surface, circle_params=circle)
+            tcrack_points = circle_polyline_intersections(Xo, Yo, R, tcrack_surface)
         else:
-            success, msg, points = get_sorted_intersections(failure_surface, modified_surface)
-        if not success:
-            return False, msg
-        x_min, x_max = points[0].x, points[1].x
-        y_left, y_right = points[0].y, points[1].y
+            tcrack_intersection = failure_surface.intersection(tcrack_surface)
+            if isinstance(tcrack_intersection, Point):
+                tcrack_points = [tcrack_intersection]
+            elif isinstance(tcrack_intersection, MultiPoint):
+                tcrack_points = list(tcrack_intersection.geoms)
+            elif isinstance(tcrack_intersection, GeometryCollection):
+                tcrack_points = [g for g in tcrack_intersection.geoms if isinstance(g, Point)]
+            else:
+                tcrack_points = []
+
+        if len(tcrack_points) >= 1:
+            # Sort tension crack intersection points by x
+            tcrack_points = sorted(tcrack_points, key=lambda p: p.x)
+
+            if right_facing:
+                # Right-facing slope: tension crack is on the left (upslope)
+                # Use leftmost tcrack intersection as new x_min
+                new_left = tcrack_points[0]
+                x_min = new_left.x
+                y_left = new_left.y
+            else:
+                # Left-facing slope: tension crack is on the right (upslope)
+                # Use rightmost tcrack intersection as new x_max
+                new_right = tcrack_points[-1]
+                x_max = new_right.x
+                y_right = new_right.y
 
     # --- Step 4: Clip the failure surface between intersection x-range ---
     # Filter coordinates within the x-range
     filtered_coords = [pt for pt in failure_coords if x_min <= pt[0] <= x_max]
-    
+
     # Add the exact intersection points if they're not already in the filtered list
     left_intersection = (x_min, y_left)
     right_intersection = (x_max, y_right)
-    
+
     # Check if intersection points are already in the filtered list (with tolerance)
     tol = 1e-6
     has_left = any(abs(pt[0] - x_min) < tol and abs(pt[1] - y_left) < tol for pt in filtered_coords)
     has_right = any(abs(pt[0] - x_max) < tol and abs(pt[1] - y_right) < tol for pt in filtered_coords)
-    
+
     if not has_left:
         filtered_coords.insert(0, left_intersection)
     if not has_right:
         filtered_coords.append(right_intersection)
-    
+
     # Sort by x-coordinate to ensure proper ordering
     filtered_coords.sort(key=lambda pt: pt[0])
-    
+
     clipped_surface = LineString(filtered_coords)
 
     return True, (x_min, x_max, y_left, y_right, clipped_surface)
@@ -600,10 +607,11 @@ def generate_slices(slope_data, circle=None, non_circ=None, num_slices=40, debug
             intersection = line_geom.intersection(circle_line)
             if not intersection.is_empty:
                 if hasattr(intersection, 'x'):
-                    fixed_xs.add(intersection.x)
+                    if x_min <= intersection.x <= x_max:
+                        fixed_xs.add(intersection.x)
                 elif hasattr(intersection, 'geoms'):
                     for geom in intersection.geoms:
-                        if hasattr(geom, 'x'):
+                        if hasattr(geom, 'x') and x_min <= geom.x <= x_max:
                             fixed_xs.add(geom.x)
     else:
         # For non-circular failure surfaces, use the original approach
@@ -611,10 +619,11 @@ def generate_slices(slope_data, circle=None, non_circ=None, num_slices=40, debug
             intersection = LineString(profile_lines[i]['coords']).intersection(clipped_surface)
             if not intersection.is_empty:
                 if hasattr(intersection, 'x'):
-                    fixed_xs.add(intersection.x)
+                    if x_min <= intersection.x <= x_max:
+                        fixed_xs.add(intersection.x)
                 elif hasattr(intersection, 'geoms'):
                     for geom in intersection.geoms:
-                        if hasattr(geom, 'x'):
+                        if hasattr(geom, 'x') and x_min <= geom.x <= x_max:
                             fixed_xs.add(geom.x)
 
     # Find intersections with piezometric lines

{xslope-0.1.13.dist-info → xslope-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xslope
-Version: 0.1.13
+Version: 0.1.15
 Summary: Slope stability analysis (limit equilibrium and FEM) in Python.
 Author: Norman L. Jones
 Project-URL: Homepage, https://github.com/njones61/xslope

{xslope-0.1.13.dist-info → xslope-0.1.15.dist-info}/RECORD

@@ -1,21 +1,21 @@
 xslope/__init__.py,sha256=ZygAIkX6Nbjag1czWdQa-yP-GM1mBE_9ss21Xh__JFc,34
-xslope/_version.py,sha256=XLyb183vl7CU3KttGJB7AeLEWBwd9veAWre8ysdY9ww,51
+xslope/_version.py,sha256=hD1GXFmGgqIG0Tc3NOuueq-3OtmJ--iS4ruDqHiw4gM,51
 xslope/advanced.py,sha256=-eL4-I36j6DfsheaGbOtclUHTFkkSn1k5k4YF9tOCvU,18278
 xslope/fem.py,sha256=x3BWHqxqJd-K78NzLquqr8eLXWVdFMzyA2cQXTNqLTk,115719
 xslope/fileio.py,sha256=BajiNljdwMMF2u2SqLpObZ-rimhgm3XyaFo14N6vZJI,38180
 xslope/global_config.py,sha256=Cj8mbPidIuj5Ty-5cZM-c8H12kNvyHsk5_ofNGez-3M,2253
 xslope/mesh copy.py,sha256=qtMH1yKFgHM4kNuIrxco7tKV86R3Dbf7Nok5j6MtlLY,131013
 xslope/mesh.py,sha256=Kn2Um1wz50EA4xd5xpxgxxegxWOlpL3Brks0_8JLWFQ,139382
-xslope/plot.py,sha256=VkItm3kASiNL3hha-W6PbjdJ7w2_yi2_4LcjH7GqokM,86265
+xslope/plot.py,sha256=P5M3kf4CFp6w2G4hugYdtA2bvyvbxd7gdVxJoSknyIU,94297
 xslope/plot_fem.py,sha256=z2FLPbIx6yNIKYcgC-LcZz2jfx0WLYFL3xJgNvQ1t-c,69488
 xslope/plot_seep.py,sha256=0s8R76c_34sUwA-L-_71Kt5BZSaIFbs-xV56M69XRU4,32960
-xslope/search.py,sha256=dvgKn8JCobuvyD7fClF5lcbeHESCvV8gZ_U_lQnYRok,16867
+xslope/search.py,sha256=ZY0Gw14l_V-ORg7HKNHVAGud-peVg4ASdNfv2h0-zoE,17587
 xslope/seep.py,sha256=AlZvp1kSPBfbNkpSZUNXqaefIRuT6BZPxhadmb5DFsk,93270
-xslope/slice.py,sha256=5zUl3qSF4PMt2d9y6jAX881aTcUWVMeVN87wt-BbIao,46380
+xslope/slice.py,sha256=zNbLtaMXdUMVGOgXLFJO-YvVWlsqPyHnDNHpAxzD0dQ,47100
 xslope/solve.py,sha256=_whlUuSsDqqe0wtgLowucc9dXmC8Q6J9zbViTQOmo-I,49337
-xslope-0.1.13.dist-info/LICENSE,sha256=NU5J88FUai_4Ixu5DqOQukA-gcXAyX8pXLhIg8OB3AM,10969
-xslope-0.1.13.dist-info/METADATA,sha256=gnmFMyTdek5oNE5MDHkb_WX6hiMKBJ9dP2DdG4OhHYI,2028
-xslope-0.1.13.dist-info/NOTICE,sha256=E-sbN0MWwvJC27Z-2_G4VUHIx4IsfvLDTmOstvY4-OQ,530
-xslope-0.1.13.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-xslope-0.1.13.dist-info/top_level.txt,sha256=5qHbWJ1R2pdTNIainFyrVtFk8R1tRcwIn0kzTuwuV1Q,7
-xslope-0.1.13.dist-info/RECORD,,
+xslope-0.1.15.dist-info/LICENSE,sha256=NU5J88FUai_4Ixu5DqOQukA-gcXAyX8pXLhIg8OB3AM,10969
+xslope-0.1.15.dist-info/METADATA,sha256=HM1g3oyEASm0o1LnHPfbUWbgHP89ej6NwLDd_pEOMG4,2028
+xslope-0.1.15.dist-info/NOTICE,sha256=E-sbN0MWwvJC27Z-2_G4VUHIx4IsfvLDTmOstvY4-OQ,530
+xslope-0.1.15.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+xslope-0.1.15.dist-info/top_level.txt,sha256=5qHbWJ1R2pdTNIainFyrVtFk8R1tRcwIn0kzTuwuV1Q,7
+xslope-0.1.15.dist-info/RECORD,,