plot3d 1.7.0__tar.gz → 1.7.1__tar.gz

{plot3d-1.7.0 → plot3d-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: plot3d
-Version: 1.7.0
+Version: 1.7.1
 Summary: Plot3D python utilities for reading and writing and also finding connectivity between blocks
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -8,8 +8,10 @@ Requires-Python: >=3.10.12,<4.0.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: pandas
+Requires-Dist: pymetis
 Requires-Dist: scipy
 Requires-Dist: tqdm

{plot3d-1.7.0 → plot3d-1.7.1}/plot3d/__init__.py

@@ -7,7 +7,7 @@ from .blockfunctions import rotate_block, get_outer_bounds, block_connection_mat
 from .block_merging_mixed_facepairs import combine_nxnxn_cubes_mixed_pairs
 from .connectivity import find_matching_blocks, get_face_intersection, connectivity_fast, face_matches_to_dict
 from .face import Face
-from .facefunctions import create_face_from_diagonals, get_outer_faces, find_connected_faces, find_bounding_faces,split_face,find_face_nearest_point,match_faces_dict_to_list,outer_face_dict_to_list,find_closest_block
+from .facefunctions import create_face_from_diagonals, get_outer_faces, find_bounding_faces,split_face,find_face_nearest_point,match_faces_dict_to_list,outer_face_dict_to_list,find_closest_block
 from .read import read_plot3D, read_ap_nasa
 from .write import write_plot3D
 from .differencing import find_edges, find_face_edges
@@ -16,10 +16,4 @@ from .point_match import point_match
 from .split_block import split_blocks, Direction
 from .listfunctions import unique_pairs
 
-# Try importing metis
-if os.getenv('METIS_DLL') is not None:
-    if import_module('metis') is not None:
-        import metis
-        from .graph import block_to_graph,get_face_vertex_indices,get_starting_vertex,add_connectivity_to_graph, block_connectivity_to_graph
-else:
-    print("METIS_DLL is not set. metis may not be configured. plot3D will function without metis")
+from .graph import write_ddcmp, build_weighted_graph_from_face_matches,csr_from_adj_and_weights,partition_from_face_matches

{plot3d-1.7.0 → plot3d-1.7.1}/plot3d/blockfunctions.py

@@ -91,81 +91,124 @@ def get_outer_bounds(blocks:List[Block]):
     
     return tuple(xbounds),tuple(ybounds),tuple(zbounds)
 
-def block_connection_matrix(blocks:List[Block],outer_faces:List[Dict[str,int]]=[],tol:float=1E-8):
-    """Creates a matrix representing how block edges are connected to each other 
 
-    Args:
-        blocks (List[Block]): List of blocks that describe the Plot3D mesh
-        outer_faces (List[Dict[str,int]], optional): List of outer faces remaining from connectivity. Useful if you are interested in finding faces that are exterior to the block. Also useful if you combine outerfaces with match faces, this will help identify connections by looking at split faces. Defaults to [].
-        tol (float, optional): Matching tolerance to look for when comparing face centroids.
-    
-    Returns:
-        (Tuple): containing
+def block_connection_matrix(
+    blocks: List[Block],
+    outer_faces: List[Dict[str, int]] = [],
+    tol: float = 1e-8,
+    *,
+    node_tol_xyz: float = 1e-7,
+    min_shared_frac: float = 0.02,
+    min_shared_abs: int = 4,
+    stride_u: int = 1,
+    stride_v: int = 1,
+    use_area_fallback: bool = True,
+    area_min_overlap_frac: float = 0.01
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Creates matrices representing how blocks are connected.
 
-            *connectivity* (np.ndarray): integer matrix defining how the blocks are connected to each other
-            *connectivity_i* (np.ndarray): integer matrix defining connectivity of all blocks where IMAX=IMIN
-            *connectivity_j* (np.ndarray): integer matrix defining connectivity of all blocks where JMAX=JMIN
-            *connectivity_k* (np.ndarray): integer matrix defining connectivity of all blocks where KMAX=KMIN
-            
+    Returns:
+        connectivity     : (n,n) overall connectivity (1 = connected, -1 = not)
+        connectivity_i   : (n,n) connections where both faces are I-constant
+        connectivity_j   : (n,n) connections where both faces are J-constant
+        connectivity_k   : (n,n) connections where both faces are K-constant
     """
-    # Reduce the size of the blocks by the GCD 
-    gcd_array = list()    
+    # Reduce the size of the blocks by the minimum GCD so index grids line up
+    gcd_array = []
     for block_indx in range(len(blocks)):
         block = blocks[block_indx]
-        gcd_array.append(math.gcd(block.IMAX-1, math.gcd(block.JMAX-1, block.KMAX-1)))
-    gcd_to_use = min(gcd_array) # You need to use the minimum gcd otherwise 1 block may not exactly match the next block. They all have to be scaled the same way.
-    blocks = reduce_blocks(deepcopy(blocks),gcd_to_use)
+        gcd_array.append(math.gcd(block.IMAX - 1, math.gcd(block.JMAX - 1, block.KMAX - 1)))
+    gcd_to_use = min(gcd_array)
+    blocks = reduce_blocks(deepcopy(blocks), gcd_to_use)
 
-    # Face to List 
-    outer_faces_all = list()
+    # Convert dict outer faces (if provided) to Face objects at the reduced resolution
+    outer_faces_all: List[Face] = []
     for o in outer_faces:
-        face = create_face_from_diagonals(blocks[o['block_index']], int(o['IMIN']/gcd_to_use), int(o['JMIN']/gcd_to_use), 
-            int(o['KMIN']/gcd_to_use), int(o['IMAX']/gcd_to_use), int(o['JMAX']/gcd_to_use), int(o['KMAX']/gcd_to_use))
-        face.set_block_index(o['block_index'])
+        face = create_face_from_diagonals(
+            blocks[o["block_index"]],
+            int(o["IMIN"] / gcd_to_use), int(o["JMIN"] / gcd_to_use), int(o["KMIN"] / gcd_to_use),
+            int(o["IMAX"] / gcd_to_use), int(o["JMAX"] / gcd_to_use), int(o["KMAX"] / gcd_to_use)
+        )
+        face.set_block_index(o["block_index"])
         if "id" in o:
-            face.id = o['id']
+            face.id = o["id"]
         outer_faces_all.append(face)
-
-    outer_faces = outer_faces_all
+    outer_faces = outer_faces_all # type: ignore
 
     n = len(blocks)
-    connectivity = np.eye(n,dtype=np.int8)
-    combos = list(combinations(range(n),2))    
-    for indx in (pbar:=trange(len(combos))):
-        i,j = combos[indx]
-        pbar.set_description(f"Building block to block connectivity matrix: checking {i}")
+    connectivity   = np.eye(n, dtype=np.int8)
+    connectivity_i = np.eye(n, dtype=np.int8)
+    connectivity_j = np.eye(n, dtype=np.int8)
+    connectivity_k = np.eye(n, dtype=np.int8)
+
+    combos = list(combinations(range(n), 2))
+    for idx in (pbar := trange(len(combos))):
+        i, j = combos[idx]
+        pbar.set_description(f"Building connectivity: checking block {i}")
         b1 = blocks[i]
 
-        if len(outer_faces)==0:                     # Get the outerfaces to search
-            b1_outer_faces,_ = get_outer_faces(b1)
+        # Gather outer faces for block i
+        if len(outer_faces) == 0:
+            b1_outer_faces, _ = get_outer_faces(b1)
         else:
-            b1_outer_faces = [o for o in outer_faces if o.BlockIndex == i] # type: ignore
-        
-        if i != j and connectivity[i,j]!=-1:
-            b2 = blocks[j]
+            b1_outer_faces = [o for o in outer_faces if o.BlockIndex == i]
 
-            if len(outer_faces)==0:                 # Get the outerfaces to search
-                b2_outer_faces,_ = get_outer_faces(b2)
+        if i != j and connectivity[i, j] != -1:
+            b2 = blocks[j]
+            if len(outer_faces) == 0:
+                b2_outer_faces, _ = get_outer_faces(b2)
             else:
-                b2_outer_faces = [o for o in outer_faces if o.BlockIndex == j]                 # type: ignore
+                b2_outer_faces = [o for o in outer_faces if o.BlockIndex == j]
+
+            connection_found = False
 
-            # Check to see if any of the outer faces of the blocks match   
-            connection_found=False             
             for f1 in b1_outer_faces:
                 for f2 in b2_outer_faces:
-                    if (f1.is_connected(f2,tol)):   # type: ignore # Check if face centroid is the same
-                        connectivity[i,j] = 1       # Default block to block connection matrix 
-                        connectivity[j,i] = 1
-                        connection_found=True
-                        # c = np.sum(connectivity[i,:]==1)
-                        # print(f"block {i} connections {c}")
+                    # 1) Primary: node-sharing (exact common grid nodes)
+                    if f1.touches_by_nodes(
+                        f2, b1, b2,
+                        tol_xyz=node_tol_xyz,
+                        min_shared_frac=min_shared_frac,
+                        min_shared_abs=min_shared_abs,
+                        stride_u=stride_u,
+                        stride_v=stride_v
+                    ):
+                        connectivity[i, j] = connectivity[j, i] = 1
+                        if f1.const_type == 0 and f2.const_type == 0:
+                            connectivity_i[i, j] = connectivity_i[j, i] = 1
+                        if f1.const_type == 1 and f2.const_type == 1:
+                            connectivity_j[i, j] = connectivity_j[j, i] = 1
+                        if f1.const_type == 2 and f2.const_type == 2:
+                            connectivity_k[i, j] = connectivity_k[j, i] = 1
+
+                        # Debug message to see what matched
+                        print(f"[nodes] blocks {i} and {j} connected via {f1} <-> {f2}")
+                        connection_found = True
                         break
+
+                    # 2) Optional fallback: polygon overlap for non-conforming interfaces
+                    if (not connection_found) and use_area_fallback:
+                        if f1.touches(f2, min_overlap_frac=area_min_overlap_frac):
+                            connectivity[i, j] = connectivity[j, i] = 1
+                            if f1.const_type == 0 and f2.const_type == 0:
+                                connectivity_i[i, j] = connectivity_i[j, i] = 1
+                            if f1.const_type == 1 and f2.const_type == 1:
+                                connectivity_j[i, j] = connectivity_j[j, i] = 1
+                            if f1.const_type == 2 and f2.const_type == 2:
+                                connectivity_k[i, j] = connectivity_k[j, i] = 1
+
+                            print(f"[area ] blocks {i} and {j} connected via {f1} <-> {f2}")
+                            connection_found = True
+                            break
+
                 if connection_found:
                     break
+
             if not connection_found:
-                connectivity[i,j] = -1
-                connectivity[j,i] = -1      
-    return connectivity
+                connectivity[i, j] = connectivity[j, i] = -1
+
+    return connectivity, connectivity_i, connectivity_j, connectivity_k
 
 def plot_blocks(blocks):
     gcd_array = list()