Index: /inundation/ga/storm_surge/parallel/advection.py
===================================================================
--- /inundation/ga/storm_surge/parallel/advection.py	(revision 1509)
+++ /inundation/ga/storm_surge/parallel/advection.py	(revision 1510)
@@ -23,4 +23,15 @@
 Geoscience Australia, 2004
 """
+
+
+import logging, logging.config
+logger = logging.getLogger('advection')
+logger.setLevel(logging.WARNING)
+
+try:
+    logging.config.fileConfig('log.ini')
+except:
+    pass
+
 
 from realtime_visualisation_new import Visualiser
@@ -52,8 +63,8 @@
         self.smooth = True
 
-    def initialise_visualiser(self,scale_z=1.0):
+    def initialise_visualiser(self,scale_z=1.0,rect=None):
         #Realtime visualisation
         if self.visualiser is None:
-            self.visualiser = Visualiser(self,scale_z)
+            self.visualiser = Visualiser(self,scale_z,rect)
         self.visualise = True
 
@@ -297,4 +308,5 @@
         """
 
+        logger.debug('Trying to weave compute_fluxes')
         weave.inline(code, ['stage_edge','stage_bdry','stage_update',
                              'neighbours','neighbour_edges','normals',
Index: /inundation/ga/storm_surge/parallel/build_local.py
===================================================================
--- /inundation/ga/storm_surge/parallel/build_local.py	(revision 1509)
+++ /inundation/ga/storm_surge/parallel/build_local.py	(revision 1510)
@@ -1,8 +1,8 @@
 #########################################################
-#   
+#
 #  Given the subdivision of the grid assigned to the
 # current processor convert it into a form that is
-# appropriate for the GA datastructure. 
-#  
+# appropriate for the GA datastructure.
+#
 #  The main function of these modules is to change the
 # node numbering. The GA datastructure assumes they
@@ -38,8 +38,8 @@
 
 def build_local_GA(nodes, triangles):
-    
+
     Nnodes =len(nodes)
     Ntriangles = len(triangles)
-    
+
     index={} #a dictionary mapping existing node ids to the new ids 0,1,2,...
 
@@ -51,6 +51,6 @@
         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. 
+
+    #Now loop over the triangles, changing the node ids and orientation.
     for t in range(Ntriangles):
         for i in range(3):
@@ -59,5 +59,5 @@
 
     del (index)
-    
+
     return GAnodes, triangles
 
@@ -92,5 +92,5 @@
 
     # initialise
-    
+
     full_send = {}
     ghost_recv = {}
@@ -98,5 +98,5 @@
     # build the ghost_recv dictionary (sort the
     # information by the global numbering)
-    
+
     ghostc.sort(sort_tup)
     for c in ghostc:
@@ -113,5 +113,5 @@
     # (this version allows the information to be stored
     # by the global numbering)
-    
+
     tmp_send = {}
     for global_id in fullc:
@@ -124,5 +124,5 @@
     # extract the full send information and put it in the form
     # required for the full_send dictionary
-    
+
     for neigh in tmp_send:
         neigh_commun = tmp_send[neigh]
@@ -137,4 +137,17 @@
             full_send[neigh][2].append(0.0)
 
+
+    # parallel advection expects numeric arrays
+    for key in full_send:
+        full_send[key][0] = array(full_send[key][0],Int)
+        full_send[key][1] = array(full_send[key][1],Int)
+        full_send[key][2] = array(full_send[key][2],Float)
+
+    for key in ghost_recv:
+        ghost_recv[key][0] = array(ghost_recv[key][0],Int)
+        ghost_recv[key][1] = array(ghost_recv[key][1],Int)
+        ghost_recv[key][2] = array(ghost_recv[key][2],Float)
+
+
     return ghost_recv, full_send
 
@@ -147,5 +160,5 @@
 # *) Change the nodes global ID's to an integer value,
 # starting from 0. The node numbering in the triangles
-# must also be updated to take this into accound. 
+# must also be updated to take this into accound.
 #
 # *) The triangle number will also change, which affects
@@ -163,10 +176,10 @@
 
     # combine the full nodes and ghost nodes
-    
+
     nodes = submesh["full_nodes"]
     nodes.extend(submesh["ghost_nodes"])
 
     # combine the full triangles and ghost triangles
-    
+
     triangles = submesh["full_triangles"]
     triangles.extend(map(lambda t: t[1], submesh["ghost_triangles"]))
@@ -174,5 +187,5 @@
     # renumber the boundary edges to correspond to the new
     # triangle numbering
-    
+
     GAboundary = {}
     for b in submesh["full_boundary"]:
@@ -180,6 +193,6 @@
 
     # make note of the new triangle numbers, including the ghost
-    # triangles 
-    
+    # triangles
+
     index = {}
     for i in range(lower_t, upper_t):
@@ -190,10 +203,10 @@
     # change the node numbering (and update the numbering in the
     # triangles)
-    
+
     [GAnodes, GAtriangles] = build_local_GA(nodes, triangles)
 
     # change the communication pattern into a form needed by
     # the parallel_advection.py file
-    
+
     gcommun = submesh["ghost_commun"]
     fcommun = submesh["full_commun"]
@@ -201,6 +214,6 @@
 
     # clean up before exiting
-    
+
     del(index)
-    
+
     return GAnodes, GAtriangles, GAboundary, ghost_rec, full_send
Index: /inundation/ga/storm_surge/parallel/parallel_advection.py
===================================================================
--- /inundation/ga/storm_surge/parallel/parallel_advection.py	(revision 1509)
+++ /inundation/ga/storm_surge/parallel/parallel_advection.py	(revision 1510)
@@ -14,4 +14,13 @@
 """
 
+import logging, logging.config
+logger = logging.getLogger('parallel')
+logger.setLevel(logging.WARNING)
+
+try:
+    logging.config.fileConfig('log.ini')
+except:
+    pass
+
 from advection import *
 Advection_Domain = Domain
@@ -41,5 +50,13 @@
 
         self.full_send_dict  = full_send_dict
+#        for key in self.full_send_dict:
+#            self.full_send_dict[key][0] = array(self.full_send_dict[key][0],Int)
+#            self.full_send_dict[key][2] = array(self.full_send_dict[key][2],Float)
+
+
         self.ghost_recv_dict = ghost_recv_dict
+#        for key in self.ghost_recv_dict:
+#            self.ghost_recv_dict[key][0] = array(self.ghost_recv_dict[key][0],Int)
+#            self.ghost_recv_dict[key][2] = array(self.ghost_recv_dict[key][2],Float)
 
         self.communication_time = 0.0
@@ -61,5 +78,5 @@
         # Calculate local timestep
         Advection_Domain.update_timestep(self, yieldstep, finaltime)
-        
+
         import time
         t0 = time.time()
@@ -72,5 +89,5 @@
         gtimestep = zeros( 1, Float) # Buffer for results
 
-        
+
         #LINDA
         pypar.raw_reduce(ltimestep, gtimestep, pypar.MIN, 0)
@@ -99,7 +116,7 @@
         import time
         t0 = time.time()
-    
+
         stage_cv = self.quantities['stage'].centroid_values
-        
+
         # update of non-local ghost cells
         for iproc in range(self.numproc):
@@ -113,32 +130,25 @@
                         Idf  = self.full_send_dict[send_proc][0]
                         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]]
-#                        ==============================
-#                        """
+                        #==============================
+
 
                         #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');
+                        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)
@@ -148,10 +158,9 @@
                 #Receive data from the iproc processor
                 if  self.ghost_recv_dict.has_key(iproc):
-                    
+
                     # LINDA:
-                    # now store ghost as local id, global id, value            
+                    # now store ghost as local id, global id, value
                     Idg = self.ghost_recv_dict[iproc][0]
                     X = self.ghost_recv_dict[iproc][2]
-                    #X   = self.ghost_recv_dict[iproc][1]
 
                     X = pypar.receive(iproc,X)
@@ -159,21 +168,21 @@
 
                     #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);
-#                    }
-#                    """
+                    #===========================
+
+
+                    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
@@ -183,12 +192,12 @@
             # now store full as local id, global id, value
             Idf  = self.full_send_dict[iproc][0]
-            
+
             # LINDA:
             # now store ghost as local id, global id, value
             Idg = self.ghost_recv_dict[iproc][0]
-            
+
             N = len(Idg)
 
-            """
+
             #======================================
             # Original python loop
@@ -197,5 +206,5 @@
                 stage_cv[Idg[i]] = stage_cv[Idf[i]]
             #======================================
-            """
+
 
             code3 = """
@@ -204,6 +213,6 @@
             }
             """
-            weave.inline(code3, ['stage_cv','Idg','Idf','N'],
-                                 type_converters = converters.blitz, compiler='gcc');
+            #weave.inline(code3, ['stage_cv','Idg','Idf','N'],
+            #                     type_converters = converters.blitz, compiler='gcc');
 
         self.communication_time += time.time()-t0
@@ -346,369 +355,2 @@
 
 
-def parallel_rectangular(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):
-
-
-    """Setup a rectangular grid of triangles
-    with m+1 by n+1 grid points
-    and side lengths len1, len2. If side lengths are omitted
-    the mesh defaults to the unit square, divided between all the
-    processors
-
-    len1: x direction (left to right)
-    len2: y direction (bottom to top)
-    """
-
-    from config import epsilon
-    from Numeric import zeros, Float, Int
-
-    processor = pypar.rank()
-    numproc   = pypar.size()
-
-
-
-    delta1 = float(len1)/m
-    delta2 = float(len2)/n
-
-    #Calculate number of points
-    Np = (m+1)*(n+1)
-
-    class VIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return j+i*(self.n+1)
-
-    class EIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return 2*(j+i*self.n)
-
-
-    I = VIndex(n,m)
-    E = EIndex(n,m)
-
-    points = zeros( (Np,2), Float)
-
-    for i in range(m+1):
-        for j in range(n+1):
-
-            points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]
-
-    #Construct 2 triangles per rectangular element and assign tags to boundary
-    #Calculate number of triangles
-    Nt = 2*m*n
-
-
-    elements = zeros( (Nt,3), Int)
-    boundary = {}
-    Idgl = []
-    Xgl  = []
-    Idfl = []
-    Xfl  = []
-    Idgr = []
-    Xgr  = []
-    Idfr = []
-    Xfr  = []
-
-    full_send_dict = {}
-    ghost_recv_dict = {}
-    nt = -1
-    for i in range(m):
-        for j in range(n):
-
-            i1 = I(i,j+1)
-            i2 = I(i,j)
-            i3 = I(i+1,j+1)
-            i4 = I(i+1,j)
-
-            #Lower Element
-            nt = E(i,j)
-            if i == m-1:
-                #print 'nt =',nt
-                Idgr.append(nt)
-                Idfr.append(E(1,j))
-            if i == 0:
-                Idgl.append(nt)
-                Idfl.append(E(m-2,j))
-
-            if i == m-1:
-                boundary[nt, 2] = 'right'
-            if j == 0:
-                boundary[nt, 1] = 'bottom'
-            elements[nt,:] = [i4,i3,i2]
-
-            #Upper Element
-            nt = E(i,j)+1
-            if i == m-1:
-                Idgr.append(nt)
-                Idfr.append(E(1,j)+1)
-            if i == 0:
-                Idgl.append(nt)
-                Idfl.append(E(m-2,j)+1)
-
-            if i == 0:
-                boundary[nt, 2] = 'left'
-            if j == n-1:
-                boundary[nt, 1] = 'top'
-            elements[nt,:] = [i1,i2,i3]
-
-    Idfl = array(Idfl,Int)
-    Idgl = array(Idgl,Int)
-    Xfl  = zeros(Idfl.shape,Float)
-    Xgl  = zeros(Idgl.shape,Float)
-
-    Idfr = array(Idfr,Int)
-    Idgr = array(Idgr,Int)
-    Xfr  = zeros(Idfr.shape,Float)
-    Xgr  = zeros(Idgr.shape,Float)
-
-    #print Idf
-    #print Idg
-    full_send_dict[(processor-1)%numproc]  = [Idfl, Xfl]
-    ghost_recv_dict[(processor-1)%numproc] = [Idgl, Xgl]
-    full_send_dict[(processor+1)%numproc]  = [Idfr, Xfr]
-    ghost_recv_dict[(processor+1)%numproc] = [Idgr, Xgr]
-
-    return  points, elements, boundary, full_send_dict, ghost_recv_dict
-
-
-
-def rectangular_periodic(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):
-
-
-    """Setup a rectangular grid of triangles
-    with m+1 by n+1 grid points
-    and side lengths len1, len2. If side lengths are omitted
-    the mesh defaults to the unit square.
-
-    len1: x direction (left to right)
-    len2: y direction (bottom to top)
-
-    Return to lists: points and elements suitable for creating a Mesh or
-    FVMesh object, e.g. Mesh(points, elements)
-    """
-
-    from config import epsilon
-    from Numeric import zeros, Float, Int
-
-    delta1 = float(len1)/m
-    delta2 = float(len2)/n
-
-    #Calculate number of points
-    Np = (m+1)*(n+1)
-
-    class VIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return j+i*(self.n+1)
-
-    class EIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return 2*(j+i*self.n)
-
-
-    I = VIndex(n,m)
-    E = EIndex(n,m)
-
-    points = zeros( (Np,2), Float)
-
-    for i in range(m+1):
-        for j in range(n+1):
-
-            points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]
-
-    #Construct 2 triangles per rectangular element and assign tags to boundary
-    #Calculate number of triangles
-    Nt = 2*m*n
-
-
-    elements = zeros( (Nt,3), Int)
-    boundary = {}
-    ghosts = {}
-    nt = -1
-    for i in range(m):
-        for j in range(n):
-
-            i1 = I(i,j+1)
-            i2 = I(i,j)
-            i3 = I(i+1,j+1)
-            i4 = I(i+1,j)
-
-            #Lower Element
-            nt = E(i,j)
-            if i == m-1:
-                ghosts[nt] = E(1,j)
-            if i == 0:
-                ghosts[nt] = E(m-2,j)
-
-            if j == n-1:
-                ghosts[nt] = E(i,1)
-
-            if j == 0:
-                ghosts[nt] = E(i,n-2)
-
-            if i == m-1:
-                boundary[nt, 2] = 'right'
-            if j == 0:
-                boundary[nt, 1] = 'bottom'
-            elements[nt,:] = [i4,i3,i2]
-
-            #Upper Element
-            nt = E(i,j)+1
-            if i == m-1:
-                ghosts[nt] = E(1,j)+1
-            if i == 0:
-                ghosts[nt] = E(m-2,j)+1
-
-            if j == n-1:
-                ghosts[nt] = E(i,1)+1
-
-            if j == 0:
-                ghosts[nt] = E(i,n-2)+1
-
-            if i == 0:
-                boundary[nt, 2] = 'left'
-            if j == n-1:
-                boundary[nt, 1] = 'top'
-            elements[nt,:] = [i1,i2,i3]
-
-    #bottom left
-    nt = E(0,0)
-    nf = E(m-2,n-2)
-    ghosts[nt]   = nf
-    ghosts[nt+1] = nf+1
-
-    #bottom right
-    nt = E(m-1,0)
-    nf = E(1,n-2)
-    ghosts[nt]   = nf
-    ghosts[nt+1] = nf+1
-
-    #top left
-    nt = E(0,n-1)
-    nf = E(m-2,1)
-    ghosts[nt]   = nf
-    ghosts[nt+1] = nf+1
-
-    #top right
-    nt = E(m-1,n-1)
-    nf = E(1,1)
-    ghosts[nt]   = nf
-    ghosts[nt+1] = nf+1
-
-    return points, elements, boundary, ghosts
-
-def rectangular_periodic_lr(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):
-
-
-    """Setup a rectangular grid of triangles
-    with m+1 by n+1 grid points
-    and side lengths len1, len2. If side lengths are omitted
-    the mesh defaults to the unit square.
-
-    len1: x direction (left to right)
-    len2: y direction (bottom to top)
-
-    Return to lists: points and elements suitable for creating a Mesh or
-    Domain object, e.g. Mesh(points, elements)
-    """
-
-    from config import epsilon
-    from Numeric import zeros, Float, Int
-
-    delta1 = float(len1)/m
-    delta2 = float(len2)/n
-
-    #Calculate number of points
-    Np = (m+1)*(n+1)
-
-    class VIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return j+i*(self.n+1)
-
-    class EIndex:
-
-        def __init__(self, n,m):
-            self.n = n
-            self.m = m
-
-        def __call__(self, i,j):
-            return 2*(j+i*self.n)
-
-
-    I = VIndex(n,m)
-    E = EIndex(n,m)
-
-    points = zeros( (Np,2), Float)
-
-    for i in range(m+1):
-        for j in range(n+1):
-
-            points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]
-
-    #Construct 2 triangles per rectangular element and assign tags to boundary
-    #Calculate number of triangles
-    Nt = 2*m*n
-
-
-    elements = zeros( (Nt,3), Int)
-    boundary = {}
-    ghosts = {}
-    nt = -1
-    for i in range(m):
-        for j in range(n):
-
-            i1 = I(i,j+1)
-            i2 = I(i,j)
-            i3 = I(i+1,j+1)
-            i4 = I(i+1,j)
-
-            #Lower Element
-            nt = E(i,j)
-            if i == m-1:
-                ghosts[nt] = E(1,j)
-            if i == 0:
-                ghosts[nt] = E(m-2,j)
-
-            if i == m-1:
-                boundary[nt, 2] = 'right'
-            if j == 0:
-                boundary[nt, 1] = 'bottom'
-            elements[nt,:] = [i4,i3,i2]
-
-            #Upper Element
-            nt = E(i,j)+1
-            if i == m-1:
-                ghosts[nt] = E(1,j)+1
-            if i == 0:
-                ghosts[nt] = E(m-2,j)+1
-
-            if i == 0:
-                boundary[nt, 2] = 'left'
-            if j == n-1:
-                boundary[nt, 1] = 'top'
-            elements[nt,:] = [i1,i2,i3]
-
-
-    return points, elements, boundary, ghosts
Index: /inundation/ga/storm_surge/parallel/parallel_meshes.py
===================================================================
--- /inundation/ga/storm_surge/parallel/parallel_meshes.py	(revision 1509)
+++ /inundation/ga/storm_surge/parallel/parallel_meshes.py	(revision 1510)
@@ -174,8 +174,8 @@
         Xgr  = zeros(Idgr.shape,Float)
 
-        full_send_dict[(processor-1)%numproc]  = [Idfl, Xfl]
-        ghost_recv_dict[(processor-1)%numproc] = [Idgl, Xgl]
-        full_send_dict[(processor+1)%numproc]  = [Idfr, Xfr]
-        ghost_recv_dict[(processor+1)%numproc] = [Idgr, Xgr]
+        full_send_dict[(processor-1)%numproc]  = [Idfl, Idfl, Xfl]
+        ghost_recv_dict[(processor-1)%numproc] = [Idgl, Idgl, Xgl]
+        full_send_dict[(processor+1)%numproc]  = [Idfr, Idfr, Xfr]
+        ghost_recv_dict[(processor+1)%numproc] = [Idgr, Idgr, Xgr]
 
     return  points, elements, boundary, full_send_dict, ghost_recv_dict
Index: /inundation/ga/storm_surge/parallel/run_parallel_mesh.py
===================================================================
--- /inundation/ga/storm_surge/parallel/run_parallel_mesh.py	(revision 1509)
+++ /inundation/ga/storm_surge/parallel/run_parallel_mesh.py	(revision 1510)
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 #########################################################
-#   
+#
 #  Main file for parallel mesh testing.
 #
@@ -12,5 +12,5 @@
 # required to build the grid, i.e. a higher number
 # corresponds to a finer grid. The term infront of the c
-# corresponds to the number of processors. 
+# corresponds to the number of processors.
 #
 # *) The (new) files that have been added to manage the
@@ -44,5 +44,5 @@
 #
 #
-# 
+#
 #########################################################
 
@@ -99,14 +99,14 @@
 
     # read in the test files
-    
-    f=open('test_5l_4c.out', 'r')
+
+    f=open('test_3l_1c.out', 'r')
     [nodes, triangles, boundary, triangles_per_proc] = mg2ga(f)
 
     # subdivide the mesh
-    
+
     submesh = build_submesh(nodes, triangles, boundary, triangles_per_proc)
 
     # send the mesh partition to the appropriate processor
-    
+
     for p in range(numprocs):
       send_submesh(submesh, triangles_per_proc, tagmap, p)
@@ -125,7 +125,8 @@
 # start the initialisation routines
 
+#rect = [ 0.0, 0.0, 1.0, 1.0]
 domain.initialise_visualiser()
-#domain.visualise=False
- 
+#domain.visualise=True
+
 #Boundaries
 
@@ -155,7 +156,11 @@
     import time
     t0 = time.time()
+
+
 for t in domain.evolve(yieldstep = 0.1, finaltime = 2.0):
     if myid == 0:
-      domain.write_time()
+        domain.write_time()
+
+
 if myid == 0:
     print 'That took %.2f seconds' %(time.time()-t0)
@@ -163,5 +168,5 @@
     print 'Reduction Communication time %.2f seconds'%domain.communication_reduce_time
 
-  
+
 print "`````````````````````````````"
 pypar.finalize()
Index: /inundation/ga/storm_surge/pyvolution/netherlands.py
===================================================================
--- /inundation/ga/storm_surge/pyvolution/netherlands.py	(revision 1509)
+++ /inundation/ga/storm_surge/pyvolution/netherlands.py	(revision 1510)
@@ -117,9 +117,10 @@
     domain.filename, _ = os.path.splitext(base)
 else:
-    domain.visualise = True
+    domain.initialise_visualiser(rect=[0.0,0.0,2.0,2.0])
     domain.visualise_color_stage = False
     domain.visualise_timer = True
     domain.checkpoint = False
     domain.store = False
+
 
 
Index: /inundation/ga/storm_surge/pyvolution/realtime_visualisation_new.py
===================================================================
--- /inundation/ga/storm_surge/pyvolution/realtime_visualisation_new.py	(revision 1509)
+++ /inundation/ga/storm_surge/pyvolution/realtime_visualisation_new.py	(revision 1510)
@@ -9,5 +9,5 @@
 class Visualiser:
 
-    def __init__(self,domain,scale_z=1.0):
+    def __init__(self,domain,scale_z=1.0,rect=None):
         """Create visualisation of domain
         """
@@ -29,11 +29,21 @@
         #print self.z_models
 
-        self.max_x = max(max(self.vertices[:,0]),max(self.vertices[:,2]),max(self.vertices[:,4]))
-        self.min_x = min(min(self.vertices[:,0]),min(self.vertices[:,2]),min(self.vertices[:,4]))
-        self.max_y = max(max(self.vertices[:,1]),max(self.vertices[:,3]),max(self.vertices[:,5]))
-        self.min_y = min(min(self.vertices[:,1]),min(self.vertices[:,3]),min(self.vertices[:,5]))
-        self.range_x = self.max_x - self.min_x
-        self.range_y = self.max_y - self.min_y
-        self.range_xy = max(self.range_x, self.range_y)
+        if rect is None:
+            self.max_x = max(max(self.vertices[:,0]),max(self.vertices[:,2]),max(self.vertices[:,4]))
+            self.min_x = min(min(self.vertices[:,0]),min(self.vertices[:,2]),min(self.vertices[:,4]))
+            self.max_y = max(max(self.vertices[:,1]),max(self.vertices[:,3]),max(self.vertices[:,5]))
+            self.min_y = min(min(self.vertices[:,1]),min(self.vertices[:,3]),min(self.vertices[:,5]))
+            self.range_x = self.max_x - self.min_x
+            self.range_y = self.max_y - self.min_y
+            self.range_xy = max(self.range_x, self.range_y)
+        else:
+            self.max_x = rect[2]
+            self.min_x = rect[0]
+            self.max_y = rect[3]
+            self.min_y = rect[1]
+            self.range_x = self.max_x - self.min_x
+            self.range_y = self.max_y - self.min_y
+            self.range_xy = max(self.range_x, self.range_y)
+
 
 #        print 'min_x=',self.min_x
@@ -211,4 +221,5 @@
 
 
+
     def update_arrays_color(self,quantity,qcolor,scale_z):
 
@@ -305,4 +316,5 @@
 
     code1 = """
+
         double s = 1.0;
 
Index: /inundation/ga/storm_surge/pyvolution/shallow_water.py
===================================================================
--- /inundation/ga/storm_surge/pyvolution/shallow_water.py	(revision 1509)
+++ /inundation/ga/storm_surge/pyvolution/shallow_water.py	(revision 1510)
@@ -108,9 +108,9 @@
         #self.eta = self.quantities['friction']
 
-    def initialise_visualiser(self,scale_z=1.0):
+    def initialise_visualiser(self,scale_z=1.0,rect=None):
         #Realtime visualisation
         if self.visualiser is None:
-            from realtime_visualisation_new import Visualiser            
-            self.visualiser = Visualiser(self,scale_z)
+            from realtime_visualisation_new import Visualiser
+            self.visualiser = Visualiser(self,scale_z,rect)
         self.visualise = True
 
@@ -204,5 +204,5 @@
         if self.visualise is True and self.time == 0.0:
             import realtime_visualisation_new as visualise
-            #import realtime_visualisation as visualise            
+            #import realtime_visualisation as visualise
             visualise.create_surface(self)
 
Index: /inundation/ga/storm_surge/zeus/parallel.zpi
===================================================================
--- /inundation/ga/storm_surge/zeus/parallel.zpi	(revision 1509)
+++ /inundation/ga/storm_surge/zeus/parallel.zpi	(revision 1510)
@@ -74,4 +74,7 @@
     <ReleaseProjectReload>Off</ReleaseProjectReload>
     <file>..\parallel\advection.py</file>
+    <file>..\parallel\build_commun.py</file>
+    <file>..\parallel\build_local.py</file>
+    <file>..\parallel\build_submesh.py</file>
     <file>..\parallel\linda_dummy.py</file>
     <file>..\parallel\mg2ga.py</file>
@@ -80,4 +83,5 @@
     <file>..\parallel\run_advection.py</file>
     <file>..\parallel\run_parallel_advection.py</file>
+    <file>..\parallel\run_parallel_mesh.py</file>
     <file>..\parallel\test_advection.py</file>
     <folder name="Header Files" />
