source: inundation/ga/storm_surge/parallel/mg2ga.py @ 1452

from string import atoi
from string import atof
import os
from mesh import Mesh
from Numeric import shape
##################################################################################
#                   TO BE REPLACED BY SPLIT
##################################################################################
def str2array(str,conv):
    l = len(str)
    a = 0
    b = 0
    data = []
    while str[a] == ' ':
        a = a+1
    while str[a] != '\n':
        b = a+1
        while str[b] != ' ' and str[b] != '\n':
           b = b+1
        data.append(conv(str[a:b]))
        a = b
    return data
##################################################################################
#  Read in a data file stored in the mg_cell data format                 
##################################################################################
def readmg(f):
    # read the number of processors
    f.readline()
    no_proc = str2array(f.readline(), atoi)[0]
    for i in range(5):
        f.readline();
    # nodes list
    nodes = []
    # triangle list
    triangles = []
    # know first nodes_per_proc[0] belong to cell 0, next
    # nodes_per_proc[1] belong to cell 1 etc.
    #nodes_per_proc = [] This is worked out later
    triangles_per_proc = [] #each triangle belongs to a unique processor
    # loop over the processors
    for q in range(no_proc):
        print q
        # read the nodes
        no_nodes = str2array(f.readline(), atoi)[1]
        #nodes_per_proc.append(no_nodes)
        f.readline()
        for i in range(no_nodes):
            line = str2array(f.readline(), atof)
            line[0] = int(line[0])
            nodes.append(line[0:3])
        # skip over the ghost nodes
        f.readline()
        no_ghost_nodes = str2array(f.readline(), atoi)[1]
        f.readline()
        for i in range(no_ghost_nodes):
            f.readline()
        # skip over the edges
        f.readline()
        f.readline()
        f.readline()
        no_edges = str2array(f.readline(), atoi)[1]
        f.readline()
        for i in range(no_edges):
            f.readline()
        # read the triangles
        f.readline()
        f.readline()
        f.readline()
        #STARTMH160505
        no_triangles = str2array(f.readline(), atoi)[1] #number of triangles listed in mg output file
        #triangles_per_proc.append(no_triangles)
        f.readline()
        for i in range(no_triangles): #loop over all triangles in input file, checking for duplication
            line = str2array(f.readline(), atoi)
            line.sort() #for easy comparison with triangles listed so far
            if (i==0):#always list the first triangle. This ensures that loop over t below is never empty
                triangles.append(line)
                continue
            for t in range(shape(triangles)[0]): #for all the (non-duplicated) triangles we've seen so far
                if (triangles[t]==line): #check to see if any of them match the triangle just read
                    break
            if (triangles[t]!=line): #need to add line to list
               triangles.append(line)
        no_triangles=shape(triangles)[0]-sum(triangles_per_proc)
        triangles_per_proc.append(no_triangles)
        #ENDMH160505
        # skip extra space
        f.readline()
        f.readline()
        f.readline()
        f.readline()
    return nodes, triangles, triangles_per_proc
##################################################################################
# Convert the format of the data to that used by pyvolution
##################################################################################
#Now renumber the nodes as 0,1,2,... and make the corresponding changes to the triangle definitions,
#changing the orientation if necessary.
def restructure(nodes, triangles):
    Nnodes=shape(nodes)[0] #the number of nodes (or vertices)
    Ntriangles=shape(triangles)[0] #the number of triangles
    index={} #a dictionary mapping existing node ids to the new ids 0,1,2,...
    GAnodes = []
    for node_idnew in range(Nnodes): #move through the list of nodes, renumbering to 0,1,2, ...
        index[nodes[node_idnew][0]]=node_idnew #make the dictionary entry, for later use by triangles
        GAnodes.append(nodes[node_idnew][1:3])
#        nodes[node_idnew][0]=node_idnew #renumber the node
    #Now loop over the triangles, changing the node ids and orientation. 
    for t in range(Ntriangles):
        x=[] #x-coordinates of the three nodes (vertices)
        y=[] #y-coordinates of the three nodes (vertices)
        for i in range(3):
            n=index[triangles[t][i]] #use the dictionary to get the new node id
            triangles[t][i]=n #relabel the node
            x.append(nodes[n][1])
            y.append(nodes[n][2])
        if ((x[1]-x[0])*(y[2]-y[0])-(x[2]-x[0])*(y[1]-y[0])<0): #need to change the orientation
            triangles[t][2]=triangles[t][0]#swap the 0th and 2nd nodes
            triangles[t][0]=n
    del(x)
    del(y)            
    del(index) #delete the dictionary
    return GAnodes, triangles
def mg2ga(f):
    [nodes, triangles, triangles_per_proc] = readmg(f)
    [nodes, triangles] = restructure(nodes, triangles)
    return nodes, triangles, triangles_per_proc