plot3d 1.6.1__tar.gz → 1.6.3__tar.gz

{plot3d-1.6.1 → plot3d-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plot3d
-Version: 1.6.1
+Version: 1.6.3
 Summary: Plot3D python utilities for reading and writing and also finding connectivity between blocks
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: scipy

{plot3d-1.6.1 → plot3d-1.6.3}/plot3d/__init__.py

@@ -10,3 +10,4 @@ from .periodicity import periodicity, periodicity_fast, create_rotation_matrix,
 from .point_match import point_match
 from .split_block import split_blocks, Direction
 from .listfunctions import unique_pairs
+from .graph import block_to_graph,get_face_vertex_indices,get_starting_vertex,add_connectivity_to_graph

{plot3d-1.6.1 → plot3d-1.6.3}/plot3d/facefunctions.py

@@ -136,6 +136,7 @@ def find_connected_faces(face_to_search:Face,outer_faces:List[Face],connectivity
     Returns:
         List[Face]: list of all faces that connect with face_to_search and it's neighbors. Beware of duplicates.
     """
+    connectivity_matrix = connectivity_matrix.copy()
     all_matching_faces = [face_to_search]
     faces_to_search = [face_to_search]
     faces_searched = []
@@ -153,7 +154,8 @@ def find_connected_faces(face_to_search:Face,outer_faces:List[Face],connectivity
                     angle = abs(math.degrees(math.acos(np.dot(n1,n2)/(np.linalg.norm(n1)*np.linalg.norm(n2)))))
                     if angle>90:
                         angle = 180-angle
-                    if angle<50:
+
+                    if angle<30:
                         connectivity_matrix[selected_block_indx, f.BlockIndex] = 0
                         connectivity_matrix[f.BlockIndex, selected_block_indx] = 0
                         matching_faces.append(f)        

plot3d-1.6.3/plot3d/graph.py

@@ -0,0 +1,154 @@
+import numpy as np
+import numpy.typing as npt
+import networkx as nx 
+import itertools as it
+from typing import Dict, Tuple, List
+
+
+def block_to_graph(IMAX:int,JMAX:int,KMAX:int,offset:int = 0) -> nx.graph.Graph:
+    """Converts a block to a graph
+
+    Args:
+        IMAX (int): block.IMAX
+        JMAX (int): block.JMAX
+        KMAX (int): block.KMAX
+        offset (int): IMAX*JMAX*KMAX of previous block 
+
+    Returns:
+        nx.graph.Graph: networkx graph object 
+    """
+    G = nx.Graph()
+    irange = np.arange(IMAX)
+    jrange = np.arange(JMAX)
+    krange = np.arange(KMAX)
+    kshift = 0 
+    for k in range(KMAX): # K slices 
+        kshift = IMAX*JMAX*k
+
+        for j in range(JMAX):
+            nx.add_star(G, offset+ kshift + IMAX*j + irange,weight=1)
+
+        for i in range(IMAX):
+            nx.add_star(G, offset+kshift + i + IMAX*jrange,weight=1)
+
+    for p in range(IMAX*JMAX):
+        nx.add_star(G, offset + p + IMAX*JMAX*krange)
+    return G
+
+def get_face_vertex_indices(IMIN:int,JMIN:int,KMIN:int,IMAX:int,JMAX:int,KMAX:int,block_size:Tuple[int,int,int]) -> npt.NDArray:
+    """Returns an array containing the vertex number of a given face 
+
+    Args:
+        IMIN (int): starting I index
+        JMIN (int): starting J index
+        KMIN (int): starting K index
+        IMAX (int): ending I index
+        JMAX (int): ending J index
+        KMAX (int): ending K index
+        block_size (Tuple[int,int,int]): This is the actual IMAX,JMAX,KMAX of the block
+    
+    Returns:
+        npt.NDArray: an array containing all the vertices 
+    """
+
+    def create_range(indx1,indx2):
+        if indx1<indx2:
+            return np.arange(indx1,indx2)
+        else:
+            return np.arange(indx1-1,indx2-1,-1)
+        
+    indices = list()
+    if IMIN==IMAX:
+        jrange = create_range(JMIN,JMAX)
+        krange = create_range(KMIN,KMAX)
+        if IMIN==block_size[0]: # IMIN is really IMAX
+            for j in jrange:
+                j_offset = j*block_size[0]    # IMAX * JMAX
+                indices.append(j_offset + block_size[0]*block_size[1]*krange + IMAX-1)
+        else:
+            for j in jrange:
+                j_offset = j*block_size[0]
+                indices.append(j_offset + block_size[0]*block_size[1]*krange)
+        
+    elif JMIN == JMAX:
+        irange = create_range(IMIN,IMAX)
+        krange = create_range(KMIN,KMAX)
+        if JMIN==block_size[1]: # JMIN is really JMAX
+            for k in krange:
+                k_offset = k*block_size[0]*block_size[1] 
+                indices.append(k_offset + block_size[0]*(block_size[1]-1)+irange)
+        else:                   # JMIN
+            for k in krange:
+                k_offset = k*block_size[0]*block_size[1]
+                indices.append(k_offset + irange)
+    else:
+        irange = create_range(IMIN,IMAX)
+        jrange = create_range(JMIN,JMAX)
+        if KMIN == block_size[2]: # KMIN is really KMAX
+            offset = (KMIN-1)*block_size[0]*block_size[1] 
+        else:
+            offset = 0 
+        for j in jrange:
+            indices.append(offset+block_size[0]*j + irange)
+    return np.array(indices).flatten()
+
+def get_starting_vertex(blockIndex:int,block_sizes:List[Tuple[int,int,int]]) -> int:
+    """Gets the starting vertex index of the block
+
+    Args:
+        blockIndex (int): index of block
+        block_sizes (List[Tuple[int,int,int]]): List of all the [[IMAX,JMAX,KMAX]] 
+
+    Returns:
+        int: offset
+    """
+    offset = 0 
+    for i in range(blockIndex):
+        offset+=block_sizes[i][0]*block_sizes[i][1]*block_sizes[i][2]
+    return offset
+
+def add_connectivity_to_graph(G:nx.classes.graph.Graph,block_sizes:List[Tuple[int,int,int]],connectivities:List[Dict[str,int]]) -> nx.graph.Graph:
+    """Convert plot3d defined connectivity into additional graph edges 
+
+    Args:
+        G (nx.classes.graph.Graph): Giant graph 
+        block_sizes (List[Tuple[int,int,int]]): _description_
+        connectivity (List[Dict[str,int]]): _description_
+    
+    Returns:
+        nx.graph.Graph: networkx graph object with added edges 
+    """
+    
+    for con in connectivities: 
+        block1_index = con['block1']['index']
+        block2_index = con['block2']['index']
+        IMIN1,IMAX1 = con['block1']['IMIN'], con['block1']['IMAX']
+        JMIN1,JMAX1 = con['block1']['JMIN'], con['block1']['JMAX']
+        KMIN1,KMAX1 = con['block1']['KMIN'], con['block1']['KMAX']
+        
+        IMIN2,IMAX2 = con['block2']['IMIN'], con['block2']['IMAX']
+        JMIN2,JMAX2 = con['block2']['JMIN'], con['block2']['JMAX']
+        KMIN2,KMAX2 = con['block2']['KMIN'], con['block2']['KMAX']
+        
+        # Number of connectivities should match
+        face1 = get_face_vertex_indices(IMIN1,IMAX1,JMIN1,JMAX1,KMIN1,KMAX1,block_sizes[block1_index]) + get_starting_vertex(block1_index, block_sizes)    
+        face2 = get_face_vertex_indices(IMIN2,IMAX2,JMIN2,JMAX2,KMIN2,KMAX2,block_sizes[block2_index]) + get_starting_vertex(block2_index, block_sizes)
+        
+        if block1_index!= block2_index:
+            nodes_to_add = face1
+            nodes_to_replace = face2
+            for node_to_add,node_to_replace in zip(nodes_to_add,nodes_to_replace):
+                G.add_edges_from(
+                    it.product(
+                        G.neighbors(node_to_add),
+                        G.neighbors(node_to_replace)
+                        )
+                )
+                G.remove_node(node_to_replace)
+                
+        assert len(face1) == len(face2), f"Number of connections from {block1_index} I[{IMIN1},{IMAX1}], J[{JMIN1},{JMAX1}], K[{KMIN1},{KMAX1}] to {block2_index} I[{IMIN2},{IMAX2}], J[{JMIN2},{JMAX2}], K[{KMIN2},{KMAX2}] should match."
+        
+        for i in range(len(face1)):
+            G.add_edge(face1[i],face2[i])
+            
+    return G

{plot3d-1.6.1 → plot3d-1.6.3}/plot3d/periodicity.py

@@ -545,9 +545,18 @@ def translational_periodicity(blocks:List[Block], lower_connected_faces:List[Dic
             dx = xmax-xmin if not delta else delta
             [b.shift(sign*dx,translational_direction) for b in blocks_shifted]
         elif translational_direction.lower().strip() == "y":
-            ymin = min([b.Y.min() for b in blocks])
-            ymax = max([b.Y.max() for b in blocks])
-            dy = ymax-ymin if not delta else delta
+            ymin = np.array([(b.X.min(), b.Y.min(), b.Z.min()) for b in blocks]) # Look at the front face 
+            ymax = np.array([(b.X.min(), b.Y.max(), b.Z.min()) for b in blocks])
+            xmin = min([b.X.min() for b in blocks])
+            zmin = min([b.Z.min() for b in blocks])
+
+            ymin = ymin[ymin[:,0] == xmin,:]
+            ymax = ymax[ymax[:,0] == xmin,:]
+
+            ymin = ymin[ymin[:,2] == zmin,:]
+            ymax = ymax[ymax[:,2] == zmin,:]
+            
+            dy = ymax[:,1].max() - ymin[:,1].min() if not delta else delta
             [b.shift(sign*dy,translational_direction) for b in blocks_shifted]
         else: #  direction.lower().strip() == "z"
             zmin = min([b.Z.min() for b in blocks])
@@ -580,11 +589,14 @@ def translational_periodicity(blocks:List[Block], lower_connected_faces:List[Dic
             pbar.set_description(f"Checking connections block {face1.blockIndex} with {face2.blockIndex}")
             # Shift block 1 -> Check periodicity -> if not periodic -> shift Block 1 opposite direction -> Check periodicity
             #   Rotate Block 1
+            block1 = blocks[face1.blockIndex]
             block1_shifted = blocks_shifted[face1.blockIndex]
             block2 = blocks[face2.blockIndex]
+            block2_shifted = blocks_shifted[face2.blockIndex]
+
             #   Check periodicity
-            _, periodic_faces_temp, split_faces_temp = __periodicity_check__(face1,face2,block1_shifted, block2,periodicity_tol)
-            
+            _, periodic_faces_temp, split_faces_temp = __periodicity_check__(face1,face2,block1_shifted, block2,periodicity_tol)                           
+
             if len(periodic_faces_temp) > 0:
                 lower_connected_faces.pop(0)
                 upper_connected_faces.pop(indx)
@@ -597,6 +609,21 @@ def translational_periodicity(blocks:List[Block], lower_connected_faces:List[Dic
                 periodic_found = True
                 pbar.update(1)
                 break
+            else:
+                # Try the other way 
+                _, periodic_faces_temp, split_faces_temp = __periodicity_check__(face1,face2,block1,block2_shifted,periodicity_tol)
+                if len(periodic_faces_temp) > 0:
+                    lower_connected_faces.pop(0)
+                    upper_connected_faces.pop(indx)
+                    periodic_faces.append(periodic_faces_temp)
+                    periodic_faces_export.append(face_matches_to_dict(periodic_faces_temp[0],periodic_faces_temp[1],block1, block2_shifted))
+                    lower_split_faces = [s for s in split_faces_temp if s.BlockIndex in lower_blocks]
+                    upper_split_faces = [s for s in split_faces_temp if s.BlockIndex in upper_blocks]
+                    lower_connected_faces.extend(lower_split_faces)
+                    upper_connected_faces.extend(upper_split_faces)
+                    periodic_found = True
+                    pbar.update(1)
+                    break
     
         if periodic_found == False:
             # Lets switch the order 
@@ -609,8 +636,7 @@ def translational_periodicity(blocks:List[Block], lower_connected_faces:List[Dic
         print(f"\nNot periodic {translational_direction}")
     else:
         print(f"\nPeriodic {translational_direction}")
-
-                        
+        
     # remove any duplicate periodic face pairs 
     indx_to_remove = list()
     for i in range(len(periodic_faces)):

{plot3d-1.6.1 → plot3d-1.6.3}/plot3d/read.py

@@ -4,6 +4,7 @@ import struct
 from typing import List
 from .block import Block
 from scipy.io import FortranFile
+from tqdm import trange
 
 def __read_plot3D_chunk_binary(f,IMAX:int,JMAX:int,KMAX:int, big_endian:bool=False,read_double:bool=True):
     """Reads and formats a binary chunk of data into a plot3D block
@@ -28,29 +29,45 @@ def __read_plot3D_chunk_binary(f,IMAX:int,JMAX:int,KMAX:int, big_endian:bool=Fal
                     A[i,j,k] = struct.unpack(">f",f.read(4))[0] if big_endian else struct.unpack("<f",f.read(4))[0]
     return A
 
-def __read_plot3D_chunk_ASCII(tokenArray:List[str],offset:int,IMAX:int,JMAX:int,KMAX:int):
-    """Reads an ascii chunk of plot3D data into a block 
+def read_word(f):
+    """Continously read a word from an ascii file
 
     Args:
-        tokenArray (List[str]): this is a list of strings separated by a space, new line character removed ["12","22", ... etc]
-        offset (int): how many entries to skip in the array based on block size (IMAX*JMAX*KMAX) of the previous block
+        f (io): file handle
+
+    Yields:
+        float: value from ascii file
+    """
+    for line in f:
+        line = line.strip().replace('\n','').split(' ')
+        tokenArray = [float(entry) for entry in line if entry]
+        for token in tokenArray:
+            yield token
+
+def __read_plot3D_chunk_ASCII(f,IMAX:int,JMAX:int,KMAX:int):
+    """Reads and formats a binary chunk of data into a plot3D block
+
+    Args:
+        f (io): file handle
         IMAX (int): maximum I index
         JMAX (int): maximum J index
-        KMAX (int): maximum K index 
+        KMAX (int): maximum K index
+        big_endian (bool, Optional): Use big endian format for reading binary files. Defaults False.
 
     Returns:
-        numpy.ndarray: Plot3D variable either X,Y, or Z
+        numpy.ndarray: Plot3D variable either X,Y, or Z 
     """
-    '''Works for ASCII files 
-    '''
-    A = np.empty(shape=(IMAX, JMAX, KMAX))
-    for k in range(KMAX):
-        for j in range(JMAX):
-            for i in range(IMAX):
-                A[i,j,k] = tokenArray[offset]
-                offset+=1
-
-    return A, offset
+    tokenArray = np.zeros(shape=(IMAX*JMAX*KMAX))
+    i = 0
+    for w in read_word(f):
+        tokenArray[i] = w
+        i+=1
+        if i>len(tokenArray)-1:
+            break
+
+    A = np.reshape(tokenArray,newshape=(KMAX,JMAX,IMAX))
+    A = np.transpose(A,[2,1,0])    
+    return A
 
 def read_ap_nasa(filename:str):
     """Reads an AP NASA File and converts it to Block format which can be exported to a plot3d file
@@ -151,17 +168,12 @@ def read_plot3D(filename:str, binary:bool=True,big_endian:bool=False,read_double
                     tokens = [int(w) for w in IJK if w]
                     IMAX.append(tokens[0])
                     JMAX.append(tokens[1])
-                    KMAX.append(tokens[2])
-                
-                lines = [l.replace('\n','').split(' ') for l in f.readlines()] # Basically an array of strings representing numbers
-                lines = [item for sublist in lines for item in sublist]         # Flatten list of lists https://stackabuse.com/python-how-to-flatten-list-of-lists/
- 
-                tokenArray = [float(entry) for entry in lines if entry] # Convert everything to float 
-                offset = 0
-                for b in range(nblocks):
-                    X, offset = __read_plot3D_chunk_ASCII(tokenArray,offset,IMAX[b],JMAX[b],KMAX[b])
-                    Y, offset = __read_plot3D_chunk_ASCII(tokenArray,offset,IMAX[b],JMAX[b],KMAX[b])
-                    Z, offset = __read_plot3D_chunk_ASCII(tokenArray,offset,IMAX[b],JMAX[b],KMAX[b])
+                    KMAX.append(tokens[2])            
+
+                for b in trange(nblocks):
+                    X = __read_plot3D_chunk_ASCII(f,IMAX[b],JMAX[b],KMAX[b])
+                    Y = __read_plot3D_chunk_ASCII(f,IMAX[b],JMAX[b],KMAX[b])
+                    Z = __read_plot3D_chunk_ASCII(f,IMAX[b],JMAX[b],KMAX[b])
                     b_temp = Block(X,Y,Z)                    
                     blocks.append(b_temp)
     return blocks

{plot3d-1.6.1 → plot3d-1.6.3}/pyproject.toml

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

plot3d-1.6.1/setup.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['plot3d']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['numpy', 'pandas', 'scipy', 'tqdm']
-
-setup_kwargs = {
-    'name': 'plot3d',
-    'version': '1.6.1',
-    'description': 'Plot3D python utilities for reading and writing and also finding connectivity between blocks',
-    'long_description': 'None',
-    'author': 'Paht Juangphanich',
-    'author_email': 'paht.juangphanich@nasa.gov',
-    'maintainer': 'None',
-    'maintainer_email': 'None',
-    'url': 'None',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.7.1,<4.0.0',
-}
-
-
-setup(**setup_kwargs)