xslope 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

xslope/mesh.py

@@ -1305,6 +1305,12 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         proj_left_x = None
         proj_right_x = None
         bottom_cleaned = []
+        
+        # Initialize vertical edge points (used for intermediate points on vertical edges)
+        left_vertical_points = []  # Intermediate points on left vertical edge (bottom to top)
+        right_vertical_points = []  # Intermediate points on right vertical edge (top to bottom)
+        left_y_bot = -np.inf
+        right_y_bot = -np.inf
 
         if i < n - 1:
             # Use the immediate next line as the lower boundary
@@ -1356,21 +1362,112 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
             # Convert to sorted list
             bottom_cleaned = sorted([(orig_x, orig_y) for _, _, orig_x, orig_y in bottom_dict.values()])
             
+            # Helper function to check if a point already exists in a list
+            def point_exists(point_list, x, y, tol=1e-8):
+                """Check if a point (x, y) already exists in the point list within tolerance."""
+                for px, py in point_list:
+                    if abs(px - x) < tol and abs(py - y) < tol:
+                        return True
+                return False
+            
+            # Helper function to find the lowest y value at a given x by checking all segments
+            def find_lowest_y_at_x(line_points, x_query, tol=1e-8):
+                """
+                Find the lowest y value at x_query by checking all segments of the line.
+                Handles vertical segments properly by finding all y values at that x and returning the minimum.
+                
+                Returns:
+                    tuple: (y_value, is_at_endpoint) where is_at_endpoint indicates if x_query is at an endpoint
+                """
+                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])
+                
+                # Check if x_query is within the line's x-range
+                if xs[0] - tol > x_query or xs[-1] + tol < x_query:
+                    return None, False
+                
+                # Check if x_query is at an endpoint
+                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
+                
+                # Find all y values at x_query by checking all segments
+                y_values = []
+                
+                # Check all points that are exactly at x_query
+                for k in range(len(line_points)):
+                    if abs(xs[k] - x_query) < tol:
+                        y_values.append(ys[k])
+                
+                # Check all segments that contain x_query
+                for k in range(len(line_points) - 1):
+                    x1, y1 = line_points[k]
+                    x2, y2 = line_points[k + 1]
+                    
+                    # Check if segment is vertical and contains x_query
+                    if abs(x1 - x_query) < tol and abs(x2 - x_query) < tol:
+                        # Vertical segment - include both y values
+                        y_values.append(y1)
+                        y_values.append(y2)
+                    # Check if segment is horizontal or sloped and contains x_query
+                    elif min(x1, x2) - tol <= x_query <= max(x1, x2) + tol:
+                        # Interpolate y value
+                        if abs(x2 - x1) < tol:
+                            # Segment is vertical (should have been caught above, but just in case)
+                            y_values.append(y1)
+                            y_values.append(y2)
+                        else:
+                            # Linear interpolation
+                            t = (x_query - x1) / (x2 - x1)
+                            if 0 <= t <= 1:
+                                y_interp = y1 + t * (y2 - y1)
+                                y_values.append(y_interp)
+                
+                if not y_values:
+                    return None, False
+                
+                # Return the lowest y value
+                y_min = min(y_values)
+                return y_min, is_at_endpoint
+            
             # Project endpoints - find highest lower profile or use max_depth
-            left_y_bot = -np.inf
-            right_y_bot = -np.inf
+            # When projecting right side: if intersection is at left end of lower line,
+            # add that point but continue projecting down
+            # When projecting left side: if intersection is at right end of lower line,
+            # add that point but continue projecting down
             for j in range(i + 1, n):
                 lower_candidate = lines[j]
                 xs_cand = np.array([x for x, y in lower_candidate])
                 ys_cand = np.array([y for x, y in lower_candidate])
+                
+                # Check left endpoint projection
                 if xs_cand[0] - tol <= left_x <= xs_cand[-1] + tol:
-                    y_cand = np.interp(left_x, xs_cand, ys_cand)
-                    if y_cand > left_y_bot:
-                        left_y_bot = y_cand
+                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, left_x, 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
+                            # Only add if not duplicate of the endpoint being projected and not already in list
+                            if abs(y_cand - left_y) > tol and not point_exists(left_vertical_points, left_x, y_cand, tol):
+                                left_vertical_points.append((left_x, y_cand))
+                        else:  # Not at endpoint, use as stopping point
+                            if y_cand > left_y_bot:
+                                left_y_bot = y_cand
+                
+                # Check right endpoint projection
                 if xs_cand[0] - tol <= right_x <= xs_cand[-1] + tol:
-                    y_cand = np.interp(right_x, xs_cand, ys_cand)
-                    if y_cand > right_y_bot:
-                        right_y_bot = y_cand
+                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, right_x, 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
+                            # Only add if not duplicate of the endpoint being projected and not already in list
+                            if abs(y_cand - right_y) > tol and not point_exists(right_vertical_points, right_x, y_cand, tol):
+                                right_vertical_points.append((right_x, y_cand))
+                        else:  # Not at endpoint, use as stopping point
+                            if y_cand > right_y_bot:
+                                right_y_bot = y_cand
             
             # If no lower profile at endpoints, use max_depth
             if left_y_bot == -np.inf:
@@ -1378,6 +1475,30 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
             if right_y_bot == -np.inf:
                 right_y_bot = max_depth if max_depth is not None else -np.inf
             
+            # Deduplicate vertical points (remove points that are too close to each other)
+            def deduplicate_points(points, tol=1e-8):
+                """Remove duplicate points within tolerance."""
+                if not points:
+                    return []
+                unique_points = [points[0]]
+                for p in points[1:]:
+                    # Check if this point is too close to any existing unique point
+                    is_duplicate = False
+                    for up in unique_points:
+                        if abs(p[0] - up[0]) < tol and abs(p[1] - up[1]) < tol:
+                            is_duplicate = True
+                            break
+                    if not is_duplicate:
+                        unique_points.append(p)
+                return unique_points
+            
+            right_vertical_points = deduplicate_points(right_vertical_points, tol)
+            left_vertical_points = deduplicate_points(left_vertical_points, tol)
+            
+            # Sort vertical points: right edge top to bottom, left edge bottom to top
+            right_vertical_points.sort(key=lambda p: -p[1])  # Sort by y descending (top to bottom)
+            left_vertical_points.sort(key=lambda p: p[1])    # Sort by y ascending (bottom to top)
+            
             # Build bottom boundary: right projection, intermediate points (right to left), left projection
             # The bottom should go from right to left to close the polygon
             bottom = []
@@ -1402,16 +1523,42 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         else:
             # For the lowest polygon, bottom is at max_depth
             # Only need endpoints - no intermediate points
+            left_y_bot = max_depth if max_depth is not None else -np.inf
+            right_y_bot = max_depth if max_depth is not None else -np.inf
             bottom = []
             bottom.append((right_x, max_depth))
             bottom.append((left_x, max_depth))
 
-        # Build polygon: top left-to-right, bottom right-to-left
+        # Build polygon: top left-to-right, right vertical edge (with intermediate points),
+        # bottom right-to-left, left vertical edge (with intermediate points)
         poly = []
+        
+        # Top edge: left to right along profile line
         for x, y in zip(xs_top, ys_top):
             poly.append((round(x, 6), round(y, 6)))
+        
+        # Right vertical edge: from (right_x, right_y) down to (right_x, right_y_bot)
+        # Include intermediate points where we intersect left endpoints of lower lines
+        # Note: (right_x, right_y_bot) will be added as part of the bottom edge, so don't add it here
+        if i < n - 1:
+            for x, y in right_vertical_points:
+                # Only add if it's between top and bottom (not duplicate of endpoints)
+                if abs(y - right_y) > tol and abs(y - right_y_bot) > tol:
+                    poly.append((round(x, 6), round(y, 6)))
+        
+        # Bottom edge: right to left (already includes (right_x, right_y_bot) and (left_x, left_y_bot))
         for x, y in bottom:
             poly.append((round(x, 6), round(y, 6)))
+        
+        # Left vertical edge: from (left_x, left_y_bot) up to (left_x, left_y)
+        # Include intermediate points where we intersect right endpoints of lower lines
+        # Note: (left_x, left_y_bot) was already added as part of the bottom edge
+        if i < n - 1:
+            for x, y in reversed(left_vertical_points):  # Reverse to go bottom to top
+                # Only add if it's between bottom and top (not duplicate of endpoints)
+                if abs(y - left_y_bot) > tol and abs(y - left_y) > tol:
+                    poly.append((round(x, 6), round(y, 6)))
+        
         # Clean up polygon (should rarely do anything)
         poly = clean_polygon(poly)
         polygons.append(poly)

xslope/plot.py

@@ -86,8 +86,10 @@ def plot_max_depth(ax, profile_lines, max_depth):
     x_max = max(x_vals)
     ax.hlines(max_depth, x_min, x_max, colors='black', linewidth=1.5, label='Max Depth')
 
-    spacing = 5
-    length = 4
+    x_diff = x_max - x_min
+    spacing = x_diff / 100
+    length = x_diff / 80
+
     angle_rad = np.radians(60)
     dx = length * np.cos(angle_rad)
     dy = length * np.sin(angle_rad)

xslope/plot_seep.py

@@ -217,20 +217,73 @@ def plot_seep_data(seep_data, figsize=(14, 6), show_nodes=False, show_bc=False,
     plt.show()
 
 
-def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat=1, fill_contours=True, phreatic=True, alpha=0.4, pad_frac=0.05, show_mesh=True):
+def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat=1, fill_contours=True, phreatic=True, alpha=0.4, pad_frac=0.05, mesh=True, variable="head", vectors=False, vector_scale=0.05, flowlines=True):
     """
-    Plots head contours and optionally overlays flowlines (phi) based on flow function.
-    Fixed version that properly handles mesh aspect ratio and doesn't clip the plot.
-    Supports both triangular and quadrilateral elements.
-
-    Arguments:
-        seep_data: Dictionary containing seepage data from import_seep2d
-        solution: Dictionary containing solution results from run_analysis
-        levels: number of head contour levels
-        base_mat: material ID (1-based) used to compute k for flow function
-        fill_contours: bool, if True shows filled contours, if False only black solid lines
-        phreatic: bool, if True plots phreatic surface (pressure head = 0) as thick red line
-        show_mesh: bool, if True overlays element edges in light gray
+    Plot seepage analysis results including head contours, flowlines, and phreatic surface.
+    
+    This function visualizes the results of a seepage analysis by plotting contours of various
+    nodal variables (head, pore pressure, velocity magnitude, or gradient magnitude). When
+    plotting head, flowlines are also overlaid. The plot properly handles mesh aspect ratios
+    and supports both linear and quadratic triangular and quadrilateral elements.
+    
+    Parameters:
+    -----------
+    seep_data : dict
+        Dictionary containing seepage mesh data from import_seep2d. Required keys include:
+        'nodes', 'elements', 'element_materials', 'element_types' (optional), and
+        'k1_by_mat' (optional, for flowline calculation).
+    solution : dict
+        Dictionary containing solution results from run_seepage_analysis. Required keys include:
+        'head' (array of total head values at nodes), 'velocity' (array of velocity vectors),
+        'gradient' (array of hydraulic gradient vectors). Optional keys: 'phi' (stream function),
+        'flowrate' (total flow rate), 'u' (pore pressure), 'v_mag' (velocity magnitude),
+        'i_mag' (gradient magnitude).
+    figsize : tuple of float, optional
+        Figure size in inches (width, height). Default is (14, 6).
+    levels : int, optional
+        Number of contour levels to plot. Default is 20.
+    base_mat : int, optional
+        Material ID (1-based) used to compute hydraulic conductivity for flow function
+        calculation. Default is 1. Only used when variable="head".
+    fill_contours : bool, optional
+        If True, shows filled contours with color map. If False, only black solid
+        contour lines are shown. Default is True.
+    phreatic : bool, optional
+        If True, plots the phreatic surface (where pressure head = 0) as a thick red line.
+        Default is True. Only applicable when variable="head".
+    alpha : float, optional
+        Transparency level (0-1) for material zone fill colors. Default is 0.4.
+    pad_frac : float, optional
+        Fraction of mesh extent to add as padding around the plot boundaries. Default is 0.05.
+    mesh : bool, optional
+        If True, overlays element edges in light gray. Default is True.
+    variable : str, optional
+        Nodal variable to contour. Options: "head" (default), "u" (pore pressure),
+        "v_mag" (velocity magnitude), "i_mag" (gradient magnitude). When "head" is selected,
+        flowlines can be overlaid if flowlines=True. Other variables do not include flowlines.
+    vectors : bool, optional
+        If True, plots velocity vectors as arrows at each node. Default is False.
+    vector_scale : float, optional
+        Scale factor for vector lengths. Maximum vector length will be x_range * vector_scale,
+        where x_range is the x-extent of the mesh. Default is 0.05.
+    flowlines : bool, optional
+        If True and variable="head", overlays flowlines (stream function contours) on the plot.
+        Default is True. Only applicable when variable="head".
+    
+    Returns:
+    --------
+    None
+        Displays the plot using matplotlib.pyplot.show().
+    
+    Notes:
+    ------
+    - The function automatically subdivides quadratic elements (tri6, quad8, quad9) for
+      proper visualization and contouring.
+    - Flowlines are only plotted when variable="head" and if 'phi' and 'flowrate' are present
+      in solution and 'k1_by_mat' is present in seep_data.
+    - The plot includes a colorbar for contours when fill_contours=True.
+    - The title includes flowrate information if available in the solution dictionary and
+      variable="head".
     """
     import matplotlib.pyplot as plt
     import matplotlib.tri as tri
@@ -238,15 +291,30 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
     from matplotlib.patches import Polygon
     import numpy as np
 
+    # Validate variable parameter
+    valid_variables = ["head", "u", "v_mag", "i_mag"]
+    if variable not in valid_variables:
+        raise ValueError(f"variable must be one of {valid_variables}, got '{variable}'")
+    
     # Extract data from seep_data and solution
     nodes = seep_data["nodes"]
     elements = seep_data["elements"]
     element_materials = seep_data["element_materials"]
     element_types = seep_data.get("element_types", None)  # New field for element types
     k1_by_mat = seep_data.get("k1_by_mat")  # Use .get() in case it's not present
+    
+    # Extract the variable to plot
+    if variable not in solution:
+        raise ValueError(f"Variable '{variable}' not found in solution dictionary. Available keys: {list(solution.keys())}")
+    contour_data = solution[variable]
+    
+    # Extract head and flowline-related data (only needed for head plots)
     head = solution["head"]
     phi = solution.get("phi")
     flowrate = solution.get("flowrate")
+    
+    # Determine if we should plot flowlines (only for head and if flowlines=True)
+    plot_flowlines = (variable == "head" and flowlines)
 
 
     # Use constrained_layout for best layout
@@ -347,9 +415,9 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
                 for sub_quad in sub_quads:
                     ax.fill(*zip(*sub_quad), edgecolor='none', facecolor=color, alpha=alpha)
 
-    vmin = np.min(head)
-    vmax = np.max(head)
-    hdrop = vmax - vmin
+    # Set up contour levels
+    vmin = np.min(contour_data)
+    vmax = np.max(contour_data)
     contour_levels = np.linspace(vmin, vmax, levels)
 
     # For contouring, subdivide tri6 elements into 4 subtriangles
@@ -374,24 +442,41 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
             all_triangles_for_contouring.extend([tri1, tri2])
     triang = tri.Triangulation(nodes[:, 0], nodes[:, 1], all_triangles_for_contouring)
 
+    # Variable labels for colorbar and title
+    variable_labels = {
+        "head": "Total Head",
+        "u": "Pore Pressure",
+        "v_mag": "Velocity Magnitude",
+        "i_mag": "Hydraulic Gradient Magnitude"
+    }
+    variable_label = variable_labels[variable]
+
     # Filled contours (only if fill_contours=True)
     if fill_contours:
-        contourf = ax.tricontourf(triang, head, levels=contour_levels, cmap="Spectral_r", vmin=vmin, vmax=vmax, alpha=0.5)
-        cbar = plt.colorbar(contourf, ax=ax, label="Total Head", shrink=0.8, pad=0.02)
+        contourf = ax.tricontourf(triang, contour_data, levels=contour_levels, cmap="Spectral_r", vmin=vmin, vmax=vmax, alpha=0.5)
+        cbar = plt.colorbar(contourf, ax=ax, label=variable_label, shrink=0.8, pad=0.02)
         cbar.locator = MaxNLocator(nbins=10, steps=[1, 2, 5])
         cbar.update_ticks()
 
-    # Solid lines for head contours
-    ax.tricontour(triang, head, levels=contour_levels, colors="k", linewidths=0.5)
-
-    # Phreatic surface (pressure head = 0)
-    if phreatic:
-        elevation = nodes[:, 1]  # y-coordinate is elevation
-        pressure_head = head - elevation
-        ax.tricontour(triang, pressure_head, levels=[0], colors="red", linewidths=2.0)
-
-    # Overlay flowlines if phi is available
-    if phi is not None and flowrate is not None and k1_by_mat is not None:
+    # Solid lines for contours
+    ax.tricontour(triang, contour_data, levels=contour_levels, colors="k", linewidths=0.5)
+
+    # Phreatic surface (pressure head = 0) - only for head plots
+    # Check if phreatic surface exists (pore pressure must be negative somewhere)
+    has_phreatic = False
+    if phreatic and plot_flowlines:
+        # Check if pore pressure goes negative (indicating a phreatic surface exists)
+        u = solution.get("u")
+        if u is not None and np.min(u) < 0:
+            elevation = nodes[:, 1]  # y-coordinate is elevation
+            pressure_head = head - elevation
+            ax.tricontour(triang, pressure_head, levels=[0], colors="red", linewidths=2.0)
+            has_phreatic = True
+
+    # Overlay flowlines if variable is head and phi is available
+    if plot_flowlines and phi is not None and flowrate is not None and k1_by_mat is not None:
+        # Compute head drop for flowline calculation
+        hdrop = vmax - vmin
         if base_mat > len(k1_by_mat):
             print(f"Warning: base_mat={base_mat} is larger than number of materials ({len(k1_by_mat)}). Using material 1.")
             base_mat = 1
@@ -406,8 +491,39 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
         phi_contours = np.linspace(np.min(phi), np.max(phi), phi_levels)
         ax.tricontour(triang, phi, levels=phi_contours, colors="blue", linewidths=0.7, linestyles="solid")
 
+    # Plot velocity vectors if requested
+    if vectors:
+        velocity = solution.get("velocity")
+        if velocity is not None:
+            # Calculate x_range for scaling
+            x_min_vec = nodes[:, 0].min()
+            x_max_vec = nodes[:, 0].max()
+            x_range = x_max_vec - x_min_vec
+            max_vector_length = x_range * vector_scale
+            
+            # Get velocity magnitude
+            v_mag = solution.get("v_mag")
+            if v_mag is None:
+                # Calculate v_mag if not available
+                v_mag = np.linalg.norm(velocity, axis=1)
+            
+            # Find maximum velocity magnitude
+            max_v_mag = np.max(v_mag)
+            
+            # Scale vectors: if max_v_mag > 0, scale so max vector has length max_vector_length
+            if max_v_mag > 0:
+                scale_factor = max_vector_length / max_v_mag
+                velocity_scaled = velocity * scale_factor
+            else:
+                velocity_scaled = velocity
+            
+            # Plot vectors using quiver
+            ax.quiver(nodes[:, 0], nodes[:, 1], velocity_scaled[:, 0], velocity_scaled[:, 1],
+                     angles='xy', scale_units='xy', scale=1, width=0.002, headwidth=2.5,
+                     headlength=3, headaxislength=2.5, color='black', alpha=0.7)
+
     # Plot element edges if requested
-    if show_mesh:
+    if mesh:
         # Draw all element edges
         for element, elem_type in zip(elements, element_types if element_types is not None else [3]*len(elements)):
             if elem_type == 3:
@@ -444,13 +560,17 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
     ax.set_xlim(x_min - x_pad, x_max + x_pad)
     ax.set_ylim(y_min - y_pad, y_max + y_pad)
 
-    title = "Flow Net: Head Contours"
-    if phi is not None:
-        title += " and Flowlines"
-    if phreatic:
-        title += " with Phreatic Surface"
-    if flowrate is not None:
-        title += f" — Total Flowrate: {flowrate:.3f}"
+    # Build title based on variable
+    if variable == "head":
+        title = f"Flow Net: {variable_label} Contours"
+        if plot_flowlines and phi is not None:
+            title += " and Flowlines"
+        if has_phreatic:
+            title += " with Phreatic Surface"
+        if flowrate is not None:
+            title += f" — Total Flowrate: {flowrate:.3f}"
+    else:
+        title = f"{variable_label} Contours"
     ax.set_title(title)
 
     # Set equal aspect ratio AFTER setting limits