plot3d 1.7.14__tar.gz → 1.8.1__tar.gz

{plot3d-1.7.14 → plot3d-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: plot3d
-Version: 1.7.14
+Version: 1.8.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,6 +8,8 @@ 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
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: numpy

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/__init__.py

@@ -5,13 +5,13 @@ import os, warnings
 from .block import Block
 from .blockfunctions import rotate_block, get_outer_bounds, block_connection_matrix,split_blocks, plot_blocks, reduce_blocks, find_matching_faces
 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 .connectivity import find_matching_blocks, get_face_intersection, connectivity_fast, face_matches_to_dict, verify_connectivity
 from .face import Face
 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
-from .periodicity import periodicity, periodicity_fast, create_rotation_matrix, rotated_periodicity, translational_periodicity
+from .periodicity import periodicity, periodicity_fast, create_rotation_matrix, rotated_periodicity, translational_periodicity, verify_periodicity
 from .point_match import point_match
 from .split_block import split_blocks, Direction
 from .listfunctions import unique_pairs

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/blockfunctions.py

@@ -216,7 +216,7 @@ def plot_blocks(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),4)
+    blocks = reduce_blocks(deepcopy(blocks),gcd_to_use)
     
     fig = plt.figure(figsize=(10, 8))
     ax = fig.add_subplot(111, projection='3d')
@@ -327,7 +327,7 @@ def calculate_outward_normals(block:Block):
     z = [Z[0,0,0],Z[0,jmax,0],Z[0,0,kmax]]
     u = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]]) 
     v = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_imin = np.cross(v1,v2) # type: ignore
+    n_imin = np.cross(u,v)
     
     # Normals I direction: IMAX
     x = [X[imax,0,0],X[imax,jmax,0],X[imax,0,kmax]] 

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/connectivity.py

@@ -565,3 +565,159 @@ def face_matches_to_dict(face1:Face, face2:Face,block1:Block,block2:Block):
     match['block2']['JMAX'] = int(df.iloc[0]['J'])
     match['block2']['KMAX'] = int(df.iloc[0]['K'])
     return match
+
+
+def verify_connectivity(blocks: List[Block], face_matches: list, tol: float = 1E-6):
+    """Verifies that the diagonal corners of face_matches are spatially consistent.
+
+    For each face_match, checks that block1's lower corner coordinates match
+    block2's lower corner coordinates (and similarly for upper corners) within
+    the specified tolerance. If the stored diagonal doesn't match, tries all
+    permutations of block2's face corners. If a valid permutation is found,
+    the face_match is corrected and added to the verified list.
+
+    Uses GCD reduction (same as connectivity_fast) for efficient coordinate lookups.
+
+    Args:
+        blocks (List[Block]): List of all blocks (original full-resolution)
+        face_matches (list): List of face_match dicts from connectivity or periodicity
+        tol (float, optional): Euclidean distance tolerance. Defaults to 1E-6.
+
+    Returns:
+        (list): verified face_matches whose diagonals are confirmed or corrected
+        (list): mismatched face_matches where no corner permutation matched
+    """
+    # Compute GCD and reduce blocks (same pattern as connectivity_fast)
+    gcd_array = list()
+    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)
+    reduced_blocks = reduce_blocks(deepcopy(blocks), gcd_to_use)
+
+    # Scale down face_matches indices by GCD
+    scaled_matches = deepcopy(face_matches)
+    for fm in scaled_matches:
+        for side in ['block1', 'block2']:
+            for key in ['IMIN', 'JMIN', 'KMIN', 'IMAX', 'JMAX', 'KMAX']:
+                fm[side][key] = fm[side][key] // gcd_to_use
+
+    verified = list()
+    mismatched = list()
+
+    for idx in range(len(scaled_matches)):
+        fm = scaled_matches[idx]
+        b1 = fm['block1']
+        b2 = fm['block2']
+        b1_idx = b1['block_index']
+        b2_idx = b2['block_index']
+        block1 = reduced_blocks[b1_idx]
+        block2 = reduced_blocks[b2_idx]
+
+        # Block1 diagonal coordinates
+        x1_l = block1.X[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+        y1_l = block1.Y[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+        z1_l = block1.Z[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+
+        x1_u = block1.X[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+        y1_u = block1.Y[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+        z1_u = block1.Z[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+
+        # Enumerate unique corners of block2's face
+        I2 = [b2['IMIN'], b2['IMAX']]
+        J2 = [b2['JMIN'], b2['JMAX']]
+        K2 = [b2['KMIN'], b2['KMAX']]
+
+        unique_corners = list()
+        seen = set()
+        for i in I2:
+            for j in J2:
+                for k in K2:
+                    key = (i, j, k)
+                    if key not in seen:
+                        seen.add(key)
+                        unique_corners.append(key)
+
+        # Check stored diagonal first
+        x2_l = block2.X[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+        y2_l = block2.Y[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+        z2_l = block2.Z[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+
+        x2_u = block2.X[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+        y2_u = block2.Y[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+        z2_u = block2.Z[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+
+        dx = x2_l - x1_l; dy = y2_l - y1_l; dz = z2_l - z1_l
+        d_lower = math.sqrt(dx*dx + dy*dy + dz*dz)
+        dx = x2_u - x1_u; dy = y2_u - y1_u; dz = z2_u - z1_u
+        d_upper = math.sqrt(dx*dx + dy*dy + dz*dz)
+
+        if d_lower < tol and d_upper < tol:
+            verified.append(face_matches[idx])
+            continue
+
+        # Try all permutations of block2's corners
+        found = False
+        best_d_lower = d_lower
+        best_d_upper = d_upper
+
+        for corner_lower in unique_corners:
+            for corner_upper in unique_corners:
+                if corner_lower == corner_upper:
+                    continue
+
+                il, jl, kl = corner_lower
+                iu, ju, ku = corner_upper
+
+                x2_l = block2.X[il, jl, kl]
+                y2_l = block2.Y[il, jl, kl]
+                z2_l = block2.Z[il, jl, kl]
+
+                x2_u = block2.X[iu, ju, ku]
+                y2_u = block2.Y[iu, ju, ku]
+                z2_u = block2.Z[iu, ju, ku]
+
+                dx = x2_l - x1_l; dy = y2_l - y1_l; dz = z2_l - z1_l
+                dl = math.sqrt(dx*dx + dy*dy + dz*dz)
+                dx = x2_u - x1_u; dy = y2_u - y1_u; dz = z2_u - z1_u
+                du = math.sqrt(dx*dx + dy*dy + dz*dz)
+
+                if dl < best_d_lower:
+                    best_d_lower = dl
+                if du < best_d_upper:
+                    best_d_upper = du
+
+                if dl < tol and du < tol:
+                    corrected = deepcopy(face_matches[idx])
+                    corrected['block2']['IMIN'] = il * gcd_to_use
+                    corrected['block2']['JMIN'] = jl * gcd_to_use
+                    corrected['block2']['KMIN'] = kl * gcd_to_use
+                    corrected['block2']['IMAX'] = iu * gcd_to_use
+                    corrected['block2']['JMAX'] = ju * gcd_to_use
+                    corrected['block2']['KMAX'] = ku * gcd_to_use
+                    verified.append(corrected)
+                    if b1_idx == b2_idx:
+                        print("verify_connectivity: Self-match corrected for block index {0}".format(b1_idx))
+                    found = True
+                    break
+            if found:
+                break
+
+        if not found:
+            orig = face_matches[idx]
+            b1_orig = orig['block1']
+            b2_orig = orig['block2']
+            print(f"verify_connectivity: MISMATCH at face_match index {idx}")
+            print(f"  block1 (block_index={b1_orig['block_index']}): "
+                  f"lower=({b1_orig['IMIN']},{b1_orig['JMIN']},{b1_orig['KMIN']}) "
+                  f"upper=({b1_orig['IMAX']},{b1_orig['JMAX']},{b1_orig['KMAX']})")
+            print(f"  block2 (block_index={b2_orig['block_index']}): "
+                  f"lower=({b2_orig['IMIN']},{b2_orig['JMIN']},{b2_orig['KMIN']}) "
+                  f"upper=({b2_orig['IMAX']},{b2_orig['JMAX']},{b2_orig['KMAX']})")
+            print(f"  block1 lower xyz = ({x1_l:.6e}, {y1_l:.6e}, {z1_l:.6e})")
+            print(f"  block1 upper xyz = ({x1_u:.6e}, {y1_u:.6e}, {z1_u:.6e})")
+            print(f"  Closest block2 corner dist to block1 lower: {best_d_lower:.6e}")
+            print(f"  Closest block2 corner dist to block1 upper: {best_d_upper:.6e}")
+            mismatched.append(face_matches[idx])
+
+    return verified, mismatched

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/gridpro/import_functions.py

@@ -1,8 +1,7 @@
-from typing import Dict, List, Tuple, Optional, Union, Set
+from typing import Dict, List, Tuple, Optional, Union, Set, Any
 import numpy as np
 import pandas as pd
 from tqdm import tqdm
-from typing import List, Tuple, Optional, Any
 from plot3d import Block
 from collections import defaultdict
 
@@ -221,6 +220,8 @@ def read_gridpro_connectivity(
                 parse_patch(toks)
 
     patches_df = pd.DataFrame(patch_rows)
+    patches_to_connectivity = patches_df[(patches_df['sb1'] > 0) & (patches_df['sb2'] > 0) & (patches_df['pty'] > 1)]
+    
 
     # ---------------------------- helpers ----------------------------
     def face_dict(sb: int, imin: int, jmin: int, kmin: int, imax: int, jmax: int, kmax: int, pty:int=-1) -> Dict[str, int]:
@@ -253,6 +254,14 @@ def read_gridpro_connectivity(
                 )
             )
 
+    # These are patches that should be in connectivity but aren't 
+    connectivity_to_check: List[Dict[str, Dict[str, int]]] = [] 
+    for p in patches_to_connectivity.itertuples(index=False): 
+        connectivity_to_check.append(pair_dict(
+                    p.sb1, (p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k),
+                    p.sb2, (p.L2i, p.L2j, p.L2k, p.H2i, p.H2j, p.H2k),
+                ))
+   
     # Boundary-condition groups (by pty)
     def bc_faces_for(name: str, pty_vals: List[int], bc_type: str) -> List[Dict[str, int]]:
         targets = set(pty_vals)
@@ -384,6 +393,7 @@ def read_gridpro_connectivity(
         "periodic_faces": periodic_faces,
         "volume_zones": volume_zones,
         "blocksizes": superblock_sizes,
+        "connectivity_to_check": connectivity_to_check,
         "patches": patches_df,
     }
 

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/periodicity.py

@@ -6,19 +6,19 @@ from .blockfunctions import rotate_block, reduce_blocks
 from .face import Face
 from .facefunctions import outer_face_dict_to_list,match_faces_dict_to_list, create_face_from_diagonals, find_bounding_faces,get_outer_faces
 from .connectivity import get_face_intersection, face_matches_to_dict
-from math import cos, radians, sin, sqrt, acos, radians
+from math import cos, radians, sin, sqrt, acos
 from copy import deepcopy
 from tqdm import trange, tqdm
 import math 
 
-def periodicity_fast(blocks:List[Block],outer_faces:List[Face], matched_faces:List[Dict[str,int]], periodic_direction:str='k', rotation_axis:str='x',nblades:int=55):
+def periodicity_fast(blocks:List[Block],outer_faces:List[Dict[str,int]], matched_faces:List[Dict[str,int]], periodic_direction:str='k', rotation_axis:str='x',nblades:int=55):
     """Finds the connectivity of blocks when they are rotated by an angle defined by the number of blades. Only use this if your mesh is of an annulus. 
         This function reduces the size of the blocks by a factor of the minimum gcd. This speeds up finding the connectivity 
 
     Args:
         blocks (List[Block]): List of blocks that will be scanned for perodicity
         outer_faces (List[Dict[str,int]]): List of outer faces for each block as a dictionary format. You can get this from connectivity
-        matched_faces (ListList[Dict[str,int]]): List of matched faces from connectivity. Matched faces was added so that it's always removed from outer faces 
+        matched_faces (List[Dict[str,int]]): List of matched faces from connectivity. Matched faces was added so that it's always removed from outer faces
         periodic_direction (str): either i,j,k to look for
         rotation_axis (str): either x,y,z
         nblades (int): Number of blades to consider, this affects the rotation angle. 
@@ -132,8 +132,10 @@ def create_rotation_matrix(rotation_angle:float, rotation_axis:str="x"):
         rotation_matrix = np.array([[cos(rotation_angle),-sin(rotation_angle), 0],
                             [sin(rotation_angle),cos(rotation_angle), 0],
                             [0, 0, 1]])
+    else:
+        raise ValueError(f"rotation_axis must be 'x', 'y', or 'z', got '{rotation_axis}'")
 
-    return rotation_matrix 
+    return rotation_matrix
 
 def periodicity(blocks:List[Block],outer_faces:List[Dict[str,int]], matched_faces:List[Dict[str,int]], periodic_direction:str='k', rotation_axis:str='x',nblades:int=55):
     """This function is used to check for periodicity of the other faces rotated about an axis. Use periodicity_fast instead. Periodicity_fast calls this function after reducing the size of the mesh.
@@ -142,7 +144,7 @@ def periodicity(blocks:List[Block],outer_faces:List[Dict[str,int]], matched_face
     Args:
         blocks (List[Block]): List of blocks that will be scanned for perodicity
         outer_faces (List[Dict[str,int]]): List of outer faces for each block as a dictionary format. You can get this from connectivity
-        matched_faces (ListList[Dict[str,int]]): List of matched faces from connectivity. Matched faces was added so that it's always removed from outer faces 
+        matched_faces (List[Dict[str,int]]): List of matched faces from connectivity. Matched faces was added so that it's always removed from outer faces
         periodic_direction (str): either i,j,k to look for
         rotation_axis (str): either x,y,z
         nblades (int): Number of blades to consider, this affects the rotation angle. 
@@ -171,9 +173,10 @@ def periodicity(blocks:List[Block],outer_faces:List[Dict[str,int]], matched_face
     matched_faces_all = match_faces_dict_to_list(blocks,matched_faces)
 
     split_faces = list()         # List of split but free surfaces, this will be appended to outer_faces_to_remove list
+    outer_faces_to_remove = list()  # Integer list of which outer surfaces to remove
     while periodic_found:
-        periodic_found = False        
-        outer_faces_to_remove = list()  # Integer list of which outher surfaces to remove
+        periodic_found = False
+        outer_faces_to_remove = list()
         outer_face_combos = list(combinations_with_replacement(range(len(outer_faces_all)),2))
         t = trange(len(outer_face_combos))
         for i in t: 
@@ -204,7 +207,7 @@ def periodicity(blocks:List[Block],outer_faces:List[Dict[str,int]], matched_face
                             outer_faces_to_remove.append(periodic_faces_temp[0])    # Make sure periodic faces are also removed from outer faces during the loop
                             outer_faces_to_remove.append(periodic_faces_temp[1])
                             periodic_faces.append(periodic_faces_temp)
-                            periodic_faces_export.append((face1,face2,block1_rotated,block2))
+                            periodic_faces_export.append(face_matches_to_dict(face1,face2,block1_rotated,block2))
                             split_faces.extend(split_faces_temp)
                             periodic_found = True
                             break
@@ -339,7 +342,8 @@ def rotated_periodicity(blocks:List[Block], matched_faces:List[Dict[str,int]], o
         Rotates the set of blocks by an angle and checks the matching surfaces for R and L. 
 
     Args:
-        blocks (List[Block]): List of blocks for a particular geometry. Do not duplicate the geometry and pass it in! 
+        blocks (List[Block]): List of blocks for a particular geometry. Do not duplicate the geometry and pass it in!
+        matched_faces (List[Dict[str,int]]): List of matched faces from connectivity. Matched faces was added so that it's always removed from outer faces
         outer_faces (List[Dict[str,int]]): List of outer faces in dictionary form
         rotation_angle (float): rotation angle in between geometry in degrees.
         rotation_axis (str, Optional): "x", "y", or "z" 
@@ -364,7 +368,8 @@ def rotated_periodicity(blocks:List[Block], matched_faces:List[Dict[str,int]], o
             - **outer_faces_all** (List[Face]): This is a list of outer faces save as a list of Faces
     """
     gcd_array = list()
-    # Find the gcd of all the blocks 
+    gcd_to_use = 1
+    # Find the gcd of all the blocks
     if ReduceMesh:
         for block_indx in range(len(blocks)):
             block = blocks[block_indx]
@@ -388,29 +393,29 @@ def rotated_periodicity(blocks:List[Block], matched_faces:List[Dict[str,int]], o
 
     split_faces = list()         # List of split but free surfaces, this will be appended to outer_faces_to_remove list
     non_matching = list()
+    outer_faces_to_remove = list()  # Integer list of which outer surfaces to remove
     while periodic_found:
-        periodic_found = False        
-        outer_faces_to_remove = list()  # Integer list of which outer surfaces to remove
+        periodic_found = False
+        outer_faces_to_remove = list()
         outer_face_combos = list(permutations(range(len(outer_faces_all)),2))
         outer_face_combos = list(set(outer_face_combos) - set(non_matching)) # removes face combinations already checked
         t = trange(len(outer_face_combos))
-        for i in t: 
+        for i in t:
             # Check if surfaces are periodic with each other
             face1_indx = outer_face_combos[i][0]
             face2_indx = outer_face_combos[i][1]
             face1 = outer_faces_all[face1_indx]
             face2 = outer_faces_all[face2_indx]
-            t.set_description(f"Checking connections block {face1.blockIndex} with {face2.blockIndex}")
 
             if (face1.IMIN == face1.IMAX) and (face2.IMIN == face2.IMAX) or \
                 (face1.JMIN == face1.JMAX) and (face2.JMIN == face2.JMAX) or \
                 (face1.KMIN == face1.KMAX) and (face2.KMIN == face2.KMAX):
-                    
+
                 # Rotate Block 1 -> Check periodicity -> if not periodic -> Rotate Block 1 opposite direction -> Check periodicity
                 #   Rotate Block 1
                 block1_rotated = blocks_rotated[face1.blockIndex]
                 block2 = blocks[face2.blockIndex]
-                print(f'evaluating working blocks: a={face1.blockIndex} b={face2.blockIndex}')
+                t.set_description(f"Blk {face1.blockIndex} <-> {face2.blockIndex} | found {len(periodic_faces)}")
                 #   Check periodicity
                 df, periodic_faces_temp, split_faces_temp = __periodicity_check__(face1,face2,block1_rotated, block2)
                 
@@ -473,8 +478,6 @@ def rotated_periodicity(blocks:List[Block], matched_faces:List[Dict[str,int]], o
         periodic_faces_export[i]['block1']['JMAX'] *= gcd_to_use
         periodic_faces_export[i]['block1']['KMAX'] *= gcd_to_use
 
-        if (periodic_faces_export[i]['block2']['IMIN'] == 168):
-            print("check")
         periodic_faces_export[i]['block2']['IMIN'] *= gcd_to_use
         periodic_faces_export[i]['block2']['JMIN'] *= gcd_to_use
         periodic_faces_export[i]['block2']['KMIN'] *= gcd_to_use
@@ -904,3 +907,177 @@ def __periodicity_check__(face1:Face, face2:Face,block1:Block,block2:Block,tol:f
     return df,periodic_faces,split_faces
 
 
+def verify_periodicity(blocks: List[Block], face_matches: list, theta: float, rotation_axis: str = 'x', tol: float = 1E-6):
+    """Verifies that the diagonal corners of periodic face_matches are spatially
+    consistent after rotating block1 by ±theta about the given axis.
+
+    For each face_match, rotates block1 by +theta (and if needed -theta) and checks
+    that the rotated lower/upper corner coordinates match block2's lower/upper
+    corners within tolerance. If the stored diagonal doesn't match, tries all
+    permutations of block2's face corners. If a valid permutation is found,
+    the face_match is corrected and added to the verified list.
+
+    Uses GCD reduction (same as connectivity_fast / periodicity_fast) for
+    efficient coordinate lookups.
+
+    Args:
+        blocks (List[Block]): List of all blocks (original full-resolution)
+        face_matches (list): List of face_match dicts from periodicity or rotated_periodicity
+        theta (float): Rotation angle in degrees
+        rotation_axis (str, optional): Axis of rotation 'x', 'y', or 'z'. Defaults to 'x'.
+        tol (float, optional): Euclidean distance tolerance. Defaults to 1E-6.
+
+    Returns:
+        (list): verified face_matches whose diagonals are confirmed or corrected
+        (list): mismatched face_matches where no corner permutation matched
+    """
+    # Compute GCD and reduce blocks (same pattern as connectivity_fast)
+    gcd_array = list()
+    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)
+    reduced_blocks = reduce_blocks(deepcopy(blocks), gcd_to_use)
+
+    # Build rotation matrices for +theta and -theta
+    rotation_matrix_pos = create_rotation_matrix(radians(theta), rotation_axis)
+    rotation_matrix_neg = create_rotation_matrix(radians(-theta), rotation_axis)
+
+    # Pre-rotate all reduced blocks in both directions
+    rotated_blocks_pos = [rotate_block(b, rotation_matrix_pos) for b in reduced_blocks]
+    rotated_blocks_neg = [rotate_block(b, rotation_matrix_neg) for b in reduced_blocks]
+
+    # Scale down face_matches indices by GCD
+    scaled_matches = deepcopy(face_matches)
+    for fm in scaled_matches:
+        for side in ['block1', 'block2']:
+            for key in ['IMIN', 'JMIN', 'KMIN', 'IMAX', 'JMAX', 'KMAX']:
+                fm[side][key] = fm[side][key] // gcd_to_use
+
+    verified = list()
+    mismatched = list()
+
+    for idx in range(len(scaled_matches)):
+        fm = scaled_matches[idx]
+        b1 = fm['block1']
+        b2 = fm['block2']
+        b1_idx = b1['block_index']
+        b2_idx = b2['block_index']
+        block2 = reduced_blocks[b2_idx]
+
+        # Enumerate unique corners of block2's face
+        I2 = [b2['IMIN'], b2['IMAX']]
+        J2 = [b2['JMIN'], b2['JMAX']]
+        K2 = [b2['KMIN'], b2['KMAX']]
+
+        unique_corners = list()
+        seen = set()
+        for i in I2:
+            for j in J2:
+                for k in K2:
+                    key = (i, j, k)
+                    if key not in seen:
+                        seen.add(key)
+                        unique_corners.append(key)
+
+        found = False
+        best_d_lower = float('inf')
+        best_d_upper = float('inf')
+
+        # Try +theta rotation first, then -theta
+        for rotated_blocks in [rotated_blocks_pos, rotated_blocks_neg]:
+            if found:
+                break
+
+            block1_rotated = rotated_blocks[b1_idx]
+
+            # Block1 rotated diagonal coordinates
+            x1_l = block1_rotated.X[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+            y1_l = block1_rotated.Y[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+            z1_l = block1_rotated.Z[b1['IMIN'], b1['JMIN'], b1['KMIN']]
+
+            x1_u = block1_rotated.X[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+            y1_u = block1_rotated.Y[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+            z1_u = block1_rotated.Z[b1['IMAX'], b1['JMAX'], b1['KMAX']]
+
+            # Check stored diagonal first
+            x2_l = block2.X[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+            y2_l = block2.Y[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+            z2_l = block2.Z[b2['IMIN'], b2['JMIN'], b2['KMIN']]
+
+            x2_u = block2.X[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+            y2_u = block2.Y[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+            z2_u = block2.Z[b2['IMAX'], b2['JMAX'], b2['KMAX']]
+
+            dx = x2_l - x1_l; dy = y2_l - y1_l; dz = z2_l - z1_l
+            d_lower = math.sqrt(dx*dx + dy*dy + dz*dz)
+            dx = x2_u - x1_u; dy = y2_u - y1_u; dz = z2_u - z1_u
+            d_upper = math.sqrt(dx*dx + dy*dy + dz*dz)
+
+            if d_lower < best_d_lower:
+                best_d_lower = d_lower
+            if d_upper < best_d_upper:
+                best_d_upper = d_upper
+
+            if d_lower < tol and d_upper < tol:
+                verified.append(face_matches[idx])
+                found = True
+                break
+
+            # Try all permutations of block2's corners
+            for corner_lower in unique_corners:
+                for corner_upper in unique_corners:
+                    if corner_lower == corner_upper:
+                        continue
+
+                    il, jl, kl = corner_lower
+                    iu, ju, ku = corner_upper
+
+                    x2_l = block2.X[il, jl, kl]
+                    y2_l = block2.Y[il, jl, kl]
+                    z2_l = block2.Z[il, jl, kl]
+
+                    x2_u = block2.X[iu, ju, ku]
+                    y2_u = block2.Y[iu, ju, ku]
+                    z2_u = block2.Z[iu, ju, ku]
+
+                    dx = x2_l - x1_l; dy = y2_l - y1_l; dz = z2_l - z1_l
+                    dl = math.sqrt(dx*dx + dy*dy + dz*dz)
+                    dx = x2_u - x1_u; dy = y2_u - y1_u; dz = z2_u - z1_u
+                    du = math.sqrt(dx*dx + dy*dy + dz*dz)
+
+                    if dl < best_d_lower:
+                        best_d_lower = dl
+                    if du < best_d_upper:
+                        best_d_upper = du
+
+                    if dl < tol and du < tol:
+                        corrected = deepcopy(face_matches[idx])
+                        corrected['block2']['IMIN'] = il * gcd_to_use
+                        corrected['block2']['JMIN'] = jl * gcd_to_use
+                        corrected['block2']['KMIN'] = kl * gcd_to_use
+                        corrected['block2']['IMAX'] = iu * gcd_to_use
+                        corrected['block2']['JMAX'] = ju * gcd_to_use
+                        corrected['block2']['KMAX'] = ku * gcd_to_use
+                        verified.append(corrected)
+                        found = True
+                        break
+                if found:
+                    break
+
+        if not found:
+            orig = face_matches[idx]
+            b1_orig = orig['block1']
+            b2_orig = orig['block2']
+            print(f"verify_periodicity: MISMATCH at face_match index {idx}")
+            print(f"  block1 (block_index={b1_orig['block_index']}): "
+                  f"lower=({b1_orig['IMIN']},{b1_orig['JMIN']},{b1_orig['KMIN']}) "
+                  f"upper=({b1_orig['IMAX']},{b1_orig['JMAX']},{b1_orig['KMAX']})")
+            print(f"  block2 (block_index={b2_orig['block_index']}): "
+                  f"lower=({b2_orig['IMIN']},{b2_orig['JMIN']},{b2_orig['KMIN']}) "
+                  f"upper=({b2_orig['IMAX']},{b2_orig['JMAX']},{b2_orig['KMAX']})")
+            print(f"  Closest rotated block1 corner dist to block2 lower: {best_d_lower:.6e}")
+            print(f"  Closest rotated block1 corner dist to block2 upper: {best_d_upper:.6e}")
+            mismatched.append(face_matches[idx])
+
+    return verified, mismatched

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/split_block.py

@@ -50,17 +50,17 @@ def max_aspect_ratio(X:np.ndarray,Y:np.ndarray,Z:np.ndarray,ix:int,jx:int,kx:int
     
     ds = list()
     for n in range(len(i2)):
-        ds.append(sqrt((X(i2[n],j1[n],k1[n])-X(i1[n],j1[n],k1[n]))**2 +
-                    (Y(i2[n],j1[n],k1[n])-Y(i1[n],j1[n],k1[n]))**2 +  
-                    (Z(i2[n],j1[n],k1[n])-Z(i1[n],j1[n],k1[n]))**2)
+        ds.append(sqrt((X[i2[n],j1[n],k1[n]]-X[i1[n],j1[n],k1[n]])**2 +
+                    (Y[i2[n],j1[n],k1[n]]-Y[i1[n],j1[n],k1[n]])**2 +
+                    (Z[i2[n],j1[n],k1[n]]-Z[i1[n],j1[n],k1[n]])**2)
                 )
-        ds.append(sqrt((X(i1[n],j2[n],k1[n])-X(i1[n],j1[n],k1[n]))**2 +  
-                    (Y(i1[n],j2[n],k1[n])-Y(i1[n],j1[n],k1[n]))**2 +  
-                    (Z(i1[n],j2[n],k1[n])-Z(i1[n],j1[n],k1[n]))**2)
+        ds.append(sqrt((X[i1[n],j2[n],k1[n]]-X[i1[n],j1[n],k1[n]])**2 +
+                    (Y[i1[n],j2[n],k1[n]]-Y[i1[n],j1[n],k1[n]])**2 +
+                    (Z[i1[n],j2[n],k1[n]]-Z[i1[n],j1[n],k1[n]])**2)
                 )
-        ds.append(sqrt((X(i1[n],j1[n],k2[n])-X(i1[n],j1[n],k1[n]))**2 + 
-                    (Y(i1[n],j1[n],k2[n])-Y(i1[n],j1[n],k1[n]))**2 + 
-                    (Z(i1[n],j1[n],k2[n])-Z(i1[n],j1[n],k1[n]))**2)
+        ds.append(sqrt((X[i1[n],j1[n],k2[n]]-X[i1[n],j1[n],k1[n]])**2 +
+                    (Y[i1[n],j1[n],k2[n]]-Y[i1[n],j1[n],k1[n]])**2 +
+                    (Z[i1[n],j1[n],k2[n]]-Z[i1[n],j1[n],k1[n]])**2)
                 )
     aspect = [0,0,0]
     if ds[0]>0:
@@ -134,7 +134,7 @@ def split_blocks(blocks:List[Block], ncells_per_block:int,direction:Direction=No
         total_cells = block.IMAX*block.JMAX*block.KMAX
 
         if direction==None: 
-            indx = np.argmin(np.array([block.IMAX,block.JMAX,block.KMAX]))
+            indx = np.argmax(np.array([block.IMAX,block.JMAX,block.KMAX]))
             if indx == 0:
                 direction_to_use=Direction.i
             elif indx == 1:
@@ -153,7 +153,7 @@ def split_blocks(blocks:List[Block], ncells_per_block:int,direction:Direction=No
                 if step_size==-1:
                     step_size = __step_search(total_cells,greatest_common_divisor,ncells_per_block,denominator,direction='forward')
                 if step_size==-1:
-                    assert('no valid step size found, do you have multi-block? gcd > 1')
+                    raise ValueError('no valid step size found, do you have multi-block? gcd > 1')
                 # step_size-1 is the IMAX of the sub_blocks e.g. 0 to 92 this shows IMAX=93, (93-1) % 4 = 0 (good)
                 
                 iprev = 0
@@ -181,10 +181,10 @@ def split_blocks(blocks:List[Block], ncells_per_block:int,direction:Direction=No
                 if step_size==-1:
                     step_size = __step_search(total_cells,greatest_common_divisor,ncells_per_block,denominator,direction='forward')
                 if step_size==-1:
-                    assert('no valid step size found, do you have multi-block? gcd > 1')
+                    raise ValueError('no valid step size found, do you have multi-block? gcd > 1')
                 jprev = 0
                 for j in range(step_size,block.JMAX,step_size):
-                    if (j+1) > block.IMAX:
+                    if (j+1) > block.JMAX:
                         break
                     X = block.X[:,jprev:j,:]      # New X, Y, Z splits 
                     Y = block.Y[:,jprev:j,:]
@@ -205,7 +205,7 @@ def split_blocks(blocks:List[Block], ncells_per_block:int,direction:Direction=No
                 if step_size==-1:
                     step_size = __step_search(total_cells,greatest_common_divisor,ncells_per_block,denominator,direction='forward')
                 if step_size==-1:
-                    assert('no valid step size found, do you have multi-block? gcd > 1')
+                    raise ValueError('no valid step size found, do you have multi-block? gcd > 1')
                 kprev = 0
                 for k in range(step_size,block.KMAX,step_size):
                     if (k+1) > block.KMAX:

{plot3d-1.7.14 → plot3d-1.8.1}/plot3d/write.py

@@ -51,7 +51,7 @@ def __write_plot3D_block_ASCII(f, B:Block, double_precision:bool=True, columns:i
         batch_size (int, optional): number of lines to buffer before writing. Defaults to 100.
     """
     # Scientific notation format: width.precision E
-    fmt = '{0:23.15E}' if double_precision else '{0:15.8E}'
+    fmt = '{0:23.15f}' if double_precision else '{0:15.8f}'
 
     def write_var(V:np.ndarray):
         line_entries = []

{plot3d-1.7.14 → plot3d-1.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "plot3d"
-version = "1.7.14"
+version = "1.8.1"
 description = "Plot3D python utilities for reading and writing and also finding connectivity between blocks"
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]