Changeset 1500

Timestamp:

Jun 6, 2005, 9:39:01 AM (19 years ago)

Author:

linda

Message:

 

Location:

inundation/ga/storm_surge/parallel

Files:

• build_commun.py (added)
• build_local.py (added)
• build_submesh.py (added)
• demo.py (modified) (1 diff)
• linda_dummy.py (modified) (2 diffs)
• mg2ga.py (modified) (1 diff)
• parallel_advection.py (modified) (5 diffs)
• run_parallel_mesh.py (added)
• test_3l_1c.out (added)
• test_3l_2c.out (modified) (2 diffs)
• test_4l_2c.out (added)
• test_4l_3c.out (added)
• test_4l_4c.out (added)
• test_5l_4c.out (added)

inundation/ga/storm_surge/parallel/demo.py

@@ -20 +20 @@
 #   mpirun -np 4 demo.py
 
-
 import pypar    # The Python-MPI interface 
-
 numproc = pypar.size()
 myid =    pypar.rank()

inundation/ga/storm_surge/parallel/linda_dummy.py

@@ +1 @@
+#mpirun -np 4 /usr/bin/python linda_dummy.py
+
+
 import sys
 from os import sep
 sys.path.append('..'+sep+'pyvolution')
 from mg2ga import *
+from build_submesh import *
+from build_local import *
+import pypar
+
 # open file
-f=open('test_3l_2cc.out', 'r')
+f=open('test_3l_1c.out', 'r')
 print f
 # read in nodes and triangles
-[nodes, triangles, triangles_per_proc] = mg2ga(f)
+[nodes, triangles, boundary, triangles_per_proc] = mg2ga(f)
 f.close
 # find whole mesh on host
 mesh = Mesh(nodes, triangles)
+
+submesh_struc = submesh_full(nodes, triangles, boundary, triangles_per_proc)
+submesh_struc2 = submesh_ghost(submesh_struc, mesh, triangles_per_proc)
+
+# this will eventually be done on the processors
+submesh_cell = {}
+lower_t = 0
+for p in range(len(triangles_per_proc)):
+    submesh_cell["full_nodes"] = [];
+    for n in submesh_struc2["full_nodes"][p]:
+        submesh_cell["full_nodes"].append(n)
+    submesh_cell["ghost_nodes"] = []
+    for n in submesh_struc2["ghost_nodes"][p]:
+        submesh_cell["ghost_nodes"].append(n)
+    submesh_cell["full_triangles"] = []
+    for t in submesh_struc2["full_triangles"][p]:
+        submesh_cell["full_triangles"].append(t)
+    submesh_cell["ghost_triangles"] = []
+    for t in submesh_struc2["ghost_triangles"][p]:
+        submesh_cell["ghost_triangles"].append(t)
+    submesh_cell["full_commun"] = submesh_struc2["full_commun"][p]
+    submesh_cell["ghost_commun"] = submesh_struc2["ghost_commun"][p]
+    submesh_cell["full_boundary"] = submesh_struc2["full_boundary"][p]
+    upper_t = lower_t + triangles_per_proc[p]
+    [GAnodes, GAtriangle, boundary, ghost_rec, full_send] = build_local_mesh(submesh_cell, lower_t, upper_t, len(triangles_per_proc))
+    lower_t = upper_t
+
+            
 # find sub domains (i.e. full triangles)
 submesh = []
-tlower = 0
-nproc = len(triangles_per_proc)
-nnodes = len(nodes)
-# loop over processors
-for p in range(nproc):
-    # find triangles on processor p
-    tupper = triangles_per_proc[p]+tlower
-    subtriangles = triangles[tlower:tupper]
-    # find nodes in processor p
-    nodemap = map(lambda n: 0, nodes)
-    for t in subtriangles:
-        nodemap[t[0]]=1
-        nodemap[t[1]]=1
-        nodemap[t[2]]=1
-    subnodes = []  
-    for i in range(nnodes):
-        if nodemap[i] == 1:
-            subnodes.append([i,nodes[i][0],nodes[i][1]])
-    # renumber nodes (have to change to store local/global map)
-    [GAnodes, GAtriangles] = restructure(subnodes, subtriangles)
-    # build GA data structure (maybe not needed, maybe can just remember
-    # GAnodes, GAtriangles and build mesh on processors)
-    submesh.append(Mesh(GAnodes, GAtriangles))
-    tlower = tupper
+for p in range(len(triangles_per_proc)):
+    print p
+    nodes = submesh_struc["full_nodes"][p]
+    triangles = submesh_struc["full_triangles"][p]
+    edges = []
+    [GAnodes, GAtriangles, GAedges] = restructure(nodes, triangles, edges)
+    submesh.append(Mesh(GAnodes,GAtriangles))
+
 # check results
 #write a data file for use by scilab script
@@ -59 +78 @@
             string='Error: Triangle '+repr(t)+' on processor '+repr(p)+' is oriented clockwise or degenerate'
             print(string)
-fp.close()
+fp.close
 #END160505 VISUALISE MESH IN SCILAB
 mesh

inundation/ga/storm_surge/parallel/mg2ga.py

@@ +1 @@
+#########################################################
+#   
+#  
+#  Read in a data file stored in the mg_cell data format.
+#
+#  mg_cell is a code written by Linda Stals for parallel
+# mulitgrid solver based on adaptive finite elements. The
+# reason this code is used is because it gives a grid
+# partition.
+#
+#  This is only intended as a temporary file, once an
+# automatic grid partitioner has been incorporated this
+# file will become redundant.
+#
+#  Authors: Linda Stals and Matthew Hardy, June 2005
+#
+#
+#########################################################
+
 from string import atoi
-
 from string import atof
-
 from string import split
 
 
-
-
-
-from general_mesh import General_mesh as Mesh
-
-from Numeric import shape
-
-
-
-##################################################################################
-
-#  Read in a data file stored in the mg_cell data format                 
-
-##################################################################################
-
-
-
-
-
+#########################################################
+#  Read in a mg_cell file. It is assumed that the file
+# has a very specific format. An example file is given in
+# test_3l_2c.out.
+#
+#  *) The mg_cell data-structure is a node-based
+# data-structure, consequently the same triangle will
+# appear three times (mg_cell outputs all of the triangles
+# connected to a given node).
+#
+#  *) The node labels are given in terms of the global ID,
+# which may be thought of as a string (e.g. 12_2), this
+# needs to be converted into an integer format for the GA
+# data structure.
+#
+#  *) It is necessary to specify the boundary conditions,
+# which has been done in mg_cel by outputing the edges
+# with a tag. If the tag is negative the edge is an
+# interior edge, if the tag is positive it is a boundary
+# edge. Different boundary conditions will be given
+# different tags.
+#
+# -------------------------------------------------------
+#
+#  *) The information returned by this routine is the
+# nodes, triangles, boundary edges and the number of
+# triangles to be assigned to each processor. All of the
+# node labels are still stored by the global ID.
+#
+#########################################################
 def readmg(f):
 
-
-
     # read the nuber of processors
 
-
-
     f.readline()
-
     no_proc = atoi(f.readline().split()[0])
 
-    print no_proc
-
-   
-
+    # skip over additional information not needed
+    
     for i in range(5):
-
         f.readline();
 
-
-
     # nodes list
 
-
-
     nodes = []
 
-
+    # boundary edge list
+
+    edges = []
 
     # 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 = [] 
-
     triangles_per_proc = []
 
-
-
     # loop over the processors
 
-
-
     for q in range(no_proc):
-
-
-
-        print q
-
-    
-
+    
         # read the nodes
 
-
-
         no_nodes = atoi(f.readline().split()[1])
-
-        print no_nodes
-
         nodes_per_proc.append(no_nodes)
-
-        f.readline()
-
-
+        f.readline()
 
         for i in range(no_nodes):
-
             line = f.readline().split()
-
             line[1:3] = map(atof, line[1:3])
-
             nodes.append(line[0:3])
 
-
-
+        # read the edges
+        
+        f.readline()
+        no_edges = atoi(f.readline().split()[1])
+        f.readline()
+
+        for i in range(no_edges):
+            line = f.readline().split()
+            if (atoi(line[2]) >= 0):
+                edges.append(line)
+        
         # read the triangles
 
-
-
-        f.readline()
-
+        f.readline(), f.readline(), f.readline()
         no_triangles = atoi(f.readline().split()[1])
-
-        print no_triangles
-
-        f.readline()
-
-
-
-        
-
+        f.readline()
+
+        # remove any triangles that have been repeated
+        
         for i in range(no_triangles):
-
             line = f.readline().split()
-
-#            triangles.append(line)
-
-
-
-            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
-
+            line.sort()
+            if (len(triangles)==0):
                 triangles.append(line)
-
                 continue
-
-            
-
-            for t in range(len(triangles)): #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
-
+            
+            for t in range(len(triangles)):
+                if (triangles[t]==line): 
                     break
-
-            if (triangles[t]!=line): #need to add line to list
-
+            if (triangles[t]!=line): 
                triangles.append(line)
 
-               
-
+        # keep a record of how many triangles belong to each processor
+        
         no_triangles=len(triangles)-sum(triangles_per_proc)
-
         triangles_per_proc.append(no_triangles)
 
-
-
-
-
         # skip extra space
-
-    
-
-        f.readline()
-
-        f.readline()
-
-        f.readline()
-
-        a = f.readline()
-
-        print a
-
-
-
-    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):
-
+    
+        f.readline()
+        f.readline()
+        f.readline()
+        f.readline()
+
+    # return the nodes, triangles, boundary edges and the number of triangles
+    # to be assigned to each processor
+    
+    return nodes, triangles, edges, triangles_per_proc
+
+
+#########################################################
+# Convert the format of the data to that used by
+# pyvolution
+#
+#
+# *) Change the nodes global ID's to an integer value,
+#starting from 0.
+#
+# *) The triangles and boundary edges must also be
+# updated accordingly.
+#
+# -------------------------------------------------------
+#
+# *) The nodes, triangles and boundary edges defined by
+# the new numbering scheme are returned
+#
+#########################################################
+
+def restructure(nodes, triangles, edges):
     Nnodes =len(nodes)
-
     Ntriangles = len(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
 
-
-
-
-
-        
-
+    GAedges = {}
+    for e in edges:
+        GAedges[index[e[0]]]=[]
+    for e in edges:
+        GAedges[index[e[0]]].append([index[e[1]],e[2]])
+    
     #Now loop over the triangles, changing the node ids and orientation. 
-
     for t in range(Ntriangles):
-
         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
 
-
-
-            
-
+            
     del(index) #delete the dictionary
 
-
-
-    return GAnodes, triangles
-
-
-
-
-
-#Now renumber the nodes as 0,1,2,... and make the corresponding changes to the triangle definitions,
-
-#changing the orientation if necessary.
-
-
-
+    return GAnodes, triangles, GAedges
+
+
+#########################################################
+#
+# Reorientate the triangles
+#
+#
+# *) The ordering of the nodes in the triangles may need
+# be changed to ensure the correct orientation.
+#
+# -------------------------------------------------------
+#
+# *) The modified list of triangles is returned
+#
+#########################################################
 def reorient(nodes, triangles):
-
-    
-
-
+    
 
     Nnodes =len(nodes)
-
     Ntriangles = len(triangles)
-
-    
-
+    
     #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=triangles[t][i] #use the dictionary to get the new node id
-
             x.append(nodes[n][0])
-
             y.append(nodes[n][1])
-
         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)
-
-    
-
+    
     return triangles
 
 
+#########################################################
+#
+# Put the boundary edge information into a form compatible
+# with the GA datastructure
+#
+# *) The GA datastructure assumes that the boundary edge
+# information is stored in a dictionary. The dictionary
+# key is a list [ti, ei], where ti is the triangle number
+# and ei (0 <= ei < 2) is the edge number for the triangle
+# ti. The value assigned to the given key is the boundary
+# tag.
+#
+# -------------------------------------------------------
+#
+# *) The boundary edge information is returned.
+#########################################################
+def mesh_boundary(triangles, edges):
+
+    # intialise the boundary dictionary
+    
+    boundary = {}
+
+    # loop over all of the triangles
+    
+    for i in range(len(triangles)):
+
+        # given a particular triangle
+        
+        t = triangles[i]
+
+        # is the first vertex a boundary node?
+        
+        if (edges.has_key(t[0])):
+
+            # check to see if the triangles has a boundary
+            # edge 
+            
+            for b in edges[t[0]]:
+                if (b[0] == t[1]):
+                   boundary[i, 2] = b[1]
+                elif (b[0] == t[2]):
+                    boundary[i, 1] = b[1]
+
+        # is the second vertex a boundary node?
+        
+        if (edges.has_key(t[1])):
+
+            # check to see if the triangles has a boundary
+            # edge
+            
+            for b in edges[t[1]]:
+                if (b[0] == t[0]):
+                   boundary[i, 2] = b[1]
+                elif (b[0] == t[2]):
+                    boundary[i, 0] = b[1]
+
+        # is the third vertex a boundary node?
+        
+        if (edges.has_key(t[2])):
+
+            # check to see if the triangles has a boundary
+            # edge
+            
+            for b in edges[t[2]]:
+                if (b[0] == t[0]):
+                   boundary[i, 1] = b[1]
+                elif (b[0] == t[1]):
+                    boundary[i, 0] = b[1]
+
+    # return the boundary information
+    
+    return boundary
+
+
+#########################################################
+#
+# Read the nodes, triangles and boundary information from
+# given file
+#
+# *) The information in the file is stored using the
+# mg_cell format.
+#
+# *) See the documentation of the previous functions.
+#
+# -------------------------------------------------------
+#
+# *The information returned by this routine includes the
+# nodes, triangles, boundary edges and the number of
+# triangles to be assigned to each processor.
+#
+#########################################################
 
 def mg2ga(f):
 
-
-
-    [nodes, triangles, triangles_per_proc] = readmg(f)
-
-    [nodes, triangles] = restructure(nodes, triangles)
-
+    # read in the information from the file
+    
+    [nodes, triangles, edges, triangles_per_proc] = readmg(f)
+
+    # change the node numbering scheme to be compatible
+    # with the GA datastructure
+    
+    [nodes, triangles, edges] = restructure(nodes, triangles, edges)
+
+    # makesure the triangles are orientated in the correct
+    # way
     triangles = reorient(nodes, triangles)
 
-
-
-    return nodes, triangles, triangles_per_proc
-
+    # collect the boundary edge information
+    
+    boundary = mesh_boundary(triangles, edges)
+
+    # return the information
+    
+    return nodes, triangles, boundary, triangles_per_proc

inundation/ga/storm_surge/parallel/parallel_advection.py

@@ -61 +61 @@
         # Calculate local timestep
         Advection_Domain.update_timestep(self, yieldstep, finaltime)
-
+        
         import time
         t0 = time.time()
@@ -72 +72 @@
         gtimestep = zeros( 1, Float) # Buffer for results
 
+        
+        #LINDA
         pypar.raw_reduce(ltimestep, gtimestep, pypar.MIN, 0)
         pypar.broadcast(gtimestep,0)
@@ -79 +81 @@
 
         self.communication_reduce_time += time.time()-t0
-
 
     def update_ghosts(self):
@@ -98 +99 @@
         import time
         t0 = time.time()
-
-
+    
         stage_cv = self.quantities['stage'].centroid_values
-
+        
         # update of non-local ghost cells
         for iproc in range(self.numproc):
-
             if iproc == self.processor:
                 #Send data from iproc processor to other processors
                 for send_proc in self.full_send_dict:
                     if send_proc != iproc:
+                        # LINDA:
+                        # now store full as local id, global_id, value
+
                         Idf  = self.full_send_dict[send_proc][0]
-                        Xout = self.full_send_dict[send_proc][1]
+                        Xout = self.full_send_dict[send_proc][2]
+                        #Xout = self.full_send_dict[send_proc][1]
                         N = len(Xout)
 
-                        """
-                        ==============================
+#                        for i in range(N):
+#                            Xout[i] = stage_cv[Idf[i]]
+                        
+#                        pypar.send(Xout,send_proc)
+
+#                        return
+
+#                        """
+#                        ==============================
                         # Original python Code
                         for i in range(N):
                             Xout[i] = stage_cv[Idf[i]]
-                        ==============================
-                        """
-
-                        code1 = """
-                        for (int i=0; i<N ; i++){
-                            Xout(i) = stage_cv(Idf(i));
-                        }
-                        """
-                        weave.inline(code1, ['stage_cv','Idf','Xout','N'],
-                                     type_converters = converters.blitz, compiler='gcc');
+#                        ==============================
+#                        """
+
+                        #LINDA:
+                        #could not get the code below to work, kept on complaining about error: no match for call to `(py::list) (int&)'
+
+#                        code1 = """
+#                        for (int i=0; i<N ; i++){
+#                            Xout(i) = stage_cv(Idf(i));
+#                        }
+#                        """
+#                        weave.inline(code1, ['stage_cv','Idf','Xout','N'],
+#                                     type_converters = converters.blitz, compiler='gcc');
 
                         pypar.send(Xout,send_proc)
+
 
             else:
                 #Receive data from the iproc processor
                 if  self.ghost_recv_dict.has_key(iproc):
+                    
+                    # LINDA:
+                    # now store ghost as local id, global id, value            
                     Idg = self.ghost_recv_dict[iproc][0]
-                    X   = self.ghost_recv_dict[iproc][1]
+                    X = self.ghost_recv_dict[iproc][2]
+                    #X   = self.ghost_recv_dict[iproc][1]
 
                     X = pypar.receive(iproc,X)
                     N = len(X)
 
-                    """
-                    ===========================
+                    #LINDA: had problems getting C code to work
+                    
+#                    """
+#                    ===========================
                     # Origin Python Code
                     for i in range(N):
                         stage_cv[Idg[i]] = X[i]
-                    ===========================
-                    """
-
-                    code2 = """
-                    for (int i=0; i<N; i++){
-                        stage_cv(Idg(i)) = X(i);
-                    }
-                    """
-                    weave.inline(code2, ['stage_cv','Idg','X','N'],
-                                 type_converters = converters.blitz, compiler='gcc');
-
+#                    ===========================
+#                    """
+
+#                    code2 = """
+#                    for (int i=0; i<N; i++){
+#                        stage_cv(Idg(i)) = X(i);
+#                    }
+#                    """
+#                    weave.inline(code2, ['stage_cv','Idg','X','N'],
+#                                 type_converters = converters.blitz, compiler='gcc');
+                    
         #local update of ghost cells
         iproc = self.processor
         if self.full_send_dict.has_key(iproc):
+
+            # LINDA:
+            # now store full as local id, global id, value
             Idf  = self.full_send_dict[iproc][0]
-            #print Idf
-            Idg  = self.ghost_recv_dict[iproc][0]
+            
+            # LINDA:
+            # now store ghost as local id, global id, value
+            Idg = self.ghost_recv_dict[iproc][0]
+            
             N = len(Idg)
-            #print Idg
 
             """
@@ -181 +206 @@
             weave.inline(code3, ['stage_cv','Idg','Idf','N'],
                                  type_converters = converters.blitz, compiler='gcc');
-
 
         self.communication_time += time.time()-t0

inundation/ga/storm_surge/parallel/test_3l_2c.out

@@ -46 +46 @@
 34_2 1.0000000000 0.7500000000 0.0000000000 0.0000000000 0.0000000000
 76_3 0.7500000000 0.8750000000 0.0132446401 0.0004640172 0.0000000000
+
+0 292
+
+14_2 37_3 -1
+14_2 38_3 37
+14_2 27_3 -1
+87_3 11_0 37
+87_3 43_2 37
+87_3 77_3 -1
+67_3 33_2 -1
+67_3 34_2 -1
+67_3 77_3 -1
+67_3 57_3 -1
+23_3 11_2 -1
+23_3 12_2 -1
+23_3 33_3 -1
+78_3 11_0 37
+78_3 34_2 37
+78_3 77_3 -1
+32_3 11_2 -1
+32_3 21_2 -1
+32_3 33_3 -1
+12_2 33_3 -1
+12_2 35_3 -1
+12_2 34_3 -1
+12_2 23_3 -1
+12_2 25_3 -1
+65_3 33_2 -1
+65_3 32_2 -1
+65_3 55_3 -1
+65_3 75_3 -1
+21_2 33_3 -1
+21_2 53_3 -1
+21_2 51_3 -1
+21_2 43_3 -1
+21_2 41_3 -1
+21_2 32_3 -1
+21_2 52_3 -1
+30_2 71_3 -1
+30_2 51_3 -1
+30_2 70_3 37
+30_2 50_3 37
+30_2 61_3 -1
+72_3 31_2 -1
+72_3 41_2 -1
+72_3 71_3 -1
+72_3 73_3 -1
+56_3 33_2 -1
+56_3 23_2 -1
+56_3 55_3 -1
+56_3 57_3 -1
+45_3 11_1 -1
+45_3 23_2 -1
+45_3 55_3 -1
+45_3 35_3 -1
+41_2 71_3 -1
+41_2 73_3 -1
+41_2 81_3 37
+41_2 83_3 37
+41_2 72_3 -1
+77_3 11_0 -1
+77_3 33_2 -1
+77_3 43_2 -1
+77_3 34_2 -1
+77_3 87_3 -1
+77_3 78_3 -1
+77_3 76_3 -1
+77_3 67_3 -1
+70_3 10_0 37
+70_3 30_2 37
+70_3 71_3 -1
+11_0 77_3 -1
+11_0 87_3 37
+11_0 78_3 37
+81_3 10_0 37
+81_3 41_2 37
+81_3 71_3 -1
+63_3 31_2 -1
+63_3 32_2 -1
+63_3 53_3 -1
+63_3 73_3 -1
+32_2 55_3 -1
+32_2 53_3 -1
+32_2 75_3 -1
+32_2 73_3 -1
+32_2 54_3 -1
+32_2 74_3 -1
+32_2 65_3 -1
+32_2 63_3 -1
+71_3 10_0 -1
+71_3 31_2 -1
+71_3 30_2 -1
+71_3 41_2 -1
+71_3 70_3 -1
+71_3 81_3 -1
+71_3 61_3 -1
+71_3 72_3 -1
+23_2 55_3 -1
+23_2 35_3 -1
+23_2 57_3 -1
+23_2 37_3 -1
+23_2 45_3 -1
+23_2 47_3 -1
+23_2 56_3 -1
+23_2 36_3 -1
+10_0 71_3 -1
+10_0 70_3 37
+10_0 81_3 37
+61_3 31_2 -1
+61_3 30_2 -1
+61_3 71_3 -1
+61_3 51_3 -1
+55_3 11_1 -1
+55_3 33_2 -1
+55_3 32_2 -1
+55_3 23_2 -1
+55_3 54_3 -1
+55_3 45_3 -1
+55_3 65_3 -1
+55_3 56_3 -1
+54_3 11_1 -1
+54_3 32_2 -1
+54_3 55_3 -1
+54_3 53_3 -1
+11_1 33_3 -1
+11_1 55_3 -1
+11_1 35_3 -1
+11_1 53_3 -1
+11_1 34_3 -1
+11_1 43_3 -1
+11_1 54_3 -1
+11_1 45_3 -1
+34_3 11_1 -1
+34_3 12_2 -1
+34_3 33_3 -1
+34_3 35_3 -1
+53_3 11_1 -1
+53_3 31_2 -1
+53_3 21_2 -1
+53_3 32_2 -1
+53_3 43_3 -1
+53_3 54_3 -1
+53_3 52_3 -1
+53_3 63_3 -1
+27_3 13_2 -1
+27_3 14_2 -1
+27_3 37_3 -1
+85_3 21_1 37
+85_3 43_2 37
+85_3 75_3 -1
+43_3 11_1 -1
+43_3 21_2 -1
+43_3 33_3 -1
+43_3 53_3 -1
+21_1 75_3 -1
+21_1 73_3 -1
+21_1 85_3 37
+21_1 83_3 37
+21_1 74_3 -1
+25_3 13_2 -1
+25_3 12_2 -1
+25_3 35_3 -1
+83_3 21_1 37
+83_3 41_2 37
+83_3 73_3 -1
+36_3 13_2 -1
+36_3 23_2 -1
+36_3 35_3 -1
+36_3 37_3 -1
+12_1 57_3 -1
+12_1 37_3 -1
+12_1 58_3 37
+12_1 38_3 37
+12_1 47_3 -1
+74_3 21_1 -1
+74_3 32_2 -1
+74_3 75_3 -1
+74_3 73_3 -1
+33_3 11_1 -1
+33_3 11_2 -1
+33_3 12_2 -1
+33_3 21_2 -1
+33_3 34_3 -1
+33_3 43_3 -1
+33_3 23_3 -1
+33_3 32_3 -1
+58_3 12_1 37
+58_3 34_2 37
+58_3 57_3 -1
+10_1 51_3 -1
+10_1 50_3 37
+10_1 41_3 -1
+33_2 77_3 -1
+33_2 55_3 -1
+33_2 75_3 -1
+33_2 57_3 -1
+33_2 76_3 -1
+33_2 67_3 -1
+33_2 65_3 -1
+33_2 56_3 -1
+52_3 31_2 -1
+52_3 21_2 -1
+52_3 53_3 -1
+52_3 51_3 -1
+75_3 21_1 -1
+75_3 33_2 -1
+75_3 43_2 -1
+75_3 32_2 -1
+75_3 85_3 -1
+75_3 74_3 -1
+75_3 76_3 -1
+75_3 65_3 -1
+35_3 11_1 -1
+35_3 13_2 -1
+35_3 12_2 -1
+35_3 23_2 -1
+35_3 34_3 -1
+35_3 45_3 -1
+35_3 25_3 -1
+35_3 36_3 -1
+47_3 12_1 -1
+47_3 23_2 -1
+47_3 57_3 -1
+47_3 37_3 -1
+50_3 10_1 37
+50_3 30_2 37
+50_3 51_3 -1
+73_3 21_1 -1
+73_3 31_2 -1
+73_3 41_2 -1
+73_3 32_2 -1
+73_3 83_3 -1
+73_3 74_3 -1
+73_3 72_3 -1
+73_3 63_3 -1
+11_2 33_3 -1
+11_2 23_3 -1
+11_2 32_3 -1
+31_2 71_3 -1
+31_2 53_3 -1
+31_2 51_3 -1
+31_2 73_3 -1
+31_2 61_3 -1
+31_2 72_3 -1
+31_2 52_3 -1
+31_2 63_3 -1
+41_3 10_1 -1
+41_3 21_2 -1
+41_3 51_3 -1
+57_3 12_1 -1
+57_3 33_2 -1
+57_3 34_2 -1
+57_3 23_2 -1
+57_3 58_3 -1
+57_3 47_3 -1
+57_3 67_3 -1
+57_3 56_3 -1
+13_2 35_3 -1
+13_2 37_3 -1
+13_2 27_3 -1
+13_2 25_3 -1
+13_2 36_3 -1
+43_2 77_3 -1
+43_2 75_3 -1
+43_2 87_3 37
+43_2 85_3 37
+43_2 76_3 -1
+51_3 10_1 -1
+51_3 31_2 -1
+51_3 30_2 -1
+51_3 21_2 -1
+51_3 50_3 -1
+51_3 41_3 -1
+51_3 61_3 -1
+51_3 52_3 -1
+34_2 77_3 -1
+34_2 57_3 -1
+34_2 78_3 37
+34_2 58_3 37
+34_2 67_3 -1
+38_3 12_1 37
+38_3 14_2 37
+38_3 37_3 -1
+76_3 33_2 -1
+76_3 43_2 -1
+76_3 77_3 -1
+76_3 75_3 -1
+37_3 12_1 -1
+37_3 13_2 -1
+37_3 14_2 -1
+37_3 23_2 -1
+37_3 38_3 -1
+37_3 47_3 -1
+37_3 27_3 -1
+37_3 36_3 -1
+
+
 
 0 182
@@ -280 +577 @@
 35_3 0.6250000000 0.3750000000 0.0428550839 0.0003864360 0.0000000000
 10_2 0.0000000000 0.2500000000 0.0000000000 0.0000000000 0.0000000000
+
+1 254
+
+52_3 21_2 -1
+52_3 31_2 -1
+52_3 51_3 -1
+52_3 53_3 -1
+37_3 13_2 -1
+37_3 12_1 -1
+37_3 14_2 -1
+37_3 23_2 -1
+37_3 27_3 -1
+37_3 36_3 -1
+37_3 38_3 -1
+37_3 47_3 -1
+3_2 17_3 -1
+3_2 15_3 -1
+3_2 7_3 37
+3_2 5_3 37
+3_2 16_3 -1
+14_2 17_3 -1
+14_2 37_3 -1
+14_2 18_3 37
+14_2 27_3 -1
+14_2 38_3 37
+12_2 13_3 -1
+12_2 15_3 -1
+12_2 33_3 -1
+12_2 35_3 -1
+12_2 14_3 -1
+12_2 23_3 -1
+12_2 25_3 -1
+12_2 34_3 -1
+1_3 0_0 37
+1_3 1_2 37
+1_3 11_3 -1
+32_3 11_2 -1
+32_3 21_2 -1
+32_3 31_3 -1
+32_3 33_3 -1
+21_2 31_3 -1
+21_2 51_3 -1
+21_2 33_3 -1
+21_2 53_3 -1
+21_2 41_3 -1
+21_2 32_3 -1
+21_2 43_3 -1
+21_2 52_3 -1
+11_3 0_0 -1
+11_3 11_2 -1
+11_3 1_2 -1
+11_3 10_2 -1
+11_3 1_3 -1
+11_3 10_3 -1
+11_3 12_3 -1
+11_3 21_3 -1
+10_3 0_0 37
+10_3 10_2 37
+10_3 11_3 -1
+0_0 11_3 -1
+0_0 1_3 37
+0_0 10_3 37
+7_3 1_0 37
+7_3 3_2 37
+7_3 17_3 -1
+16_3 13_2 -1
+16_3 3_2 -1
+16_3 17_3 -1
+16_3 15_3 -1
+18_3 1_0 37
+18_3 14_2 37
+18_3 17_3 -1
+17_3 1_0 -1
+17_3 13_2 -1
+17_3 3_2 -1
+17_3 14_2 -1
+17_3 7_3 -1
+17_3 18_3 -1
+17_3 16_3 -1
+17_3 27_3 -1
+3_3 1_1 37
+3_3 1_2 37
+3_3 13_3 -1
+1_0 17_3 -1
+1_0 7_3 37
+1_0 18_3 37
+5_3 1_1 37
+5_3 3_2 37
+5_3 15_3 -1
+27_3 13_2 -1
+27_3 14_2 -1
+27_3 17_3 -1
+27_3 37_3 -1
+14_3 1_1 -1
+14_3 12_2 -1
+14_3 13_3 -1
+14_3 15_3 -1
+13_3 1_1 -1
+13_3 11_2 -1
+13_3 1_2 -1
+13_3 12_2 -1
+13_3 3_3 -1
+13_3 14_3 -1
+13_3 12_3 -1
+13_3 23_3 -1
+30_3 10_1 37
+30_3 10_2 37
+30_3 31_3 -1
+1_1 13_3 -1
+1_1 15_3 -1
+1_1 3_3 37
+1_1 5_3 37
+1_1 14_3 -1
+50_3 10_1 37
+50_3 30_2 37
+50_3 51_3 -1
+25_3 13_2 -1
+25_3 12_2 -1
+25_3 15_3 -1
+25_3 35_3 -1
+41_3 10_1 -1
+41_3 21_2 -1
+41_3 31_3 -1
+41_3 51_3 -1
+15_3 1_1 -1
+15_3 13_2 -1
+15_3 3_2 -1
+15_3 12_2 -1
+15_3 5_3 -1
+15_3 14_3 -1
+15_3 16_3 -1
+15_3 25_3 -1
+12_3 11_2 -1
+12_3 1_2 -1
+12_3 11_3 -1
+12_3 13_3 -1
+10_1 31_3 -1
+10_1 51_3 -1
+10_1 30_3 37
+10_1 50_3 37
+10_1 41_3 -1
+21_3 11_2 -1
+21_3 10_2 -1
+21_3 11_3 -1
+21_3 31_3 -1
+36_3 13_2 -1
+36_3 23_2 -1
+36_3 35_3 -1
+36_3 37_3 -1
+23_3 11_2 -1
+23_3 12_2 -1
+23_3 13_3 -1
+23_3 33_3 -1
+31_3 10_1 -1
+31_3 11_2 -1
+31_3 10_2 -1
+31_3 21_2 -1
+31_3 30_3 -1
+31_3 41_3 -1
+31_3 21_3 -1
+31_3 32_3 -1
+61_3 31_2 -1
+61_3 30_2 -1
+61_3 51_3 -1
+11_2 11_3 -1
+11_2 13_3 -1
+11_2 31_3 -1
+11_2 33_3 -1
+11_2 12_3 -1
+11_2 21_3 -1
+11_2 23_3 -1
+11_2 32_3 -1
+11_1 33_3 -1
+11_1 35_3 -1
+11_1 53_3 -1
+11_1 34_3 -1
+11_1 43_3 -1
+11_1 45_3 -1
+38_3 14_2 37
+38_3 12_1 37
+38_3 37_3 -1
+12_1 37_3 -1
+12_1 38_3 37
+12_1 47_3 -1
+51_3 10_1 -1
+51_3 31_2 -1
+51_3 30_2 -1
+51_3 21_2 -1
+51_3 50_3 -1
+51_3 41_3 -1
+51_3 52_3 -1
+51_3 61_3 -1
+31_2 51_3 -1
+31_2 53_3 -1
+31_2 52_3 -1
+31_2 61_3 -1
+13_2 17_3 -1
+13_2 15_3 -1
+13_2 35_3 -1
+13_2 37_3 -1
+13_2 16_3 -1
+13_2 27_3 -1
+13_2 25_3 -1
+13_2 36_3 -1
+30_2 51_3 -1
+30_2 50_3 37
+30_2 61_3 -1
+34_3 12_2 -1
+34_3 11_1 -1
+34_3 33_3 -1
+34_3 35_3 -1
+23_2 35_3 -1
+23_2 37_3 -1
+23_2 36_3 -1
+23_2 45_3 -1
+23_2 47_3 -1
+33_3 11_2 -1
+33_3 11_1 -1
+33_3 12_2 -1
+33_3 21_2 -1
+33_3 23_3 -1
+33_3 32_3 -1
+33_3 34_3 -1
+33_3 43_3 -1
+45_3 11_1 -1
+45_3 23_2 -1
+45_3 35_3 -1
+1_2 11_3 -1
+1_2 13_3 -1
+1_2 1_3 37
+1_2 3_3 37
+1_2 12_3 -1
+53_3 11_1 -1
+53_3 31_2 -1
+53_3 21_2 -1
+53_3 43_3 -1
+53_3 52_3 -1
+43_3 21_2 -1
+43_3 11_1 -1
+43_3 33_3 -1
+43_3 53_3 -1
+47_3 12_1 -1
+47_3 23_2 -1
+47_3 37_3 -1
+35_3 13_2 -1
+35_3 11_1 -1
+35_3 12_2 -1
+35_3 23_2 -1
+35_3 25_3 -1
+35_3 36_3 -1
+35_3 34_3 -1
+35_3 45_3 -1
+10_2 11_3 -1
+10_2 31_3 -1
+10_2 10_3 37
+10_2 30_3 37
+10_2 21_3 -1
+
+
 
 1 202