Index: uga_work/development/flow_1d/generic_1d/limit_util.py
===================================================================
--- /anuga_work/development/flow_1d/generic_1d/limit_util.py	(revision 7834)
+++ 	(revision )
@@ -1,175 +1,0 @@
-"""
-This module contains various auxiliary function used by pyvolution.
-"""
-
-
-import numpy
-
-def mean(x):
-    return numpy.sum(x)/len(x)
-
-
-def gradient(x0, x1, q0, q1):
-
-    if q1-q0 != 0:
-        a = (q1-q0)/(x1-x0)
-    else:
-        a = 0
-        
-    return a
-
-def  minmod(beta_p,beta_m):
-    if (abs(beta_p) < abs(beta_m)) & (beta_p*beta_m > 0.0):
-        phi = beta_p
-    elif (abs(beta_m) < abs(beta_p)) & (beta_p*beta_m > 0.0):
-        phi = beta_m
-    else:
-        phi = 0.0
-    return phi
-
-def  minmod_kurganov(a,b,c):
-    from numpy import sign
-    if sign(a)==sign(b)==sign(c):
-        return sign(a)*min(abs(a),abs(b),abs(c))
-    else:
-        return 0.0
-
-def  maxmod(a,b):
-    if (abs(a) > abs(b)) & (a*b > 0.0):
-        phi = a
-    elif (abs(b) > abs(a)) & (a*b > 0.0):
-        phi = b
-    else:
-        phi = 0.0
-    return phi
-
-def vanleer(a,b):
-    if abs(a)+abs(b) > 1e-12:
-        return (a*abs(b)+abs(a)*b)/(abs(a)+abs(b))
-    else:
-        return 0.0
-
-def vanalbada(a,b):
-    if a*a+b*b > 1e-12:
-        return (a*a*b+a*b*b)/(a*a+b*b)
-    else:
-        return 0.0
-
-def calculate_wetted_area(x1,x2,z1,z2,w1,w2):
-    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w1-z1)*(x-x1)
-        L = x-x1
-    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w2-z2)*(x2-x)
-        L = x2-x
-    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w2-z2)*(x2-x)
-        L = x2-x
-    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w1-z1)*(x-x1)
-        L = x-x1
-    elif (w1 <= z1) & (w2 <= z2):
-        A = 0.0
-    elif (w1 == z1) & (w2 > z2) & (z2 < z1):
-        A = 0.5*(x2-x1)*(w2-z2)
-    elif (w2 == z2) & (w1 > z1) & (z1 < z2):
-        A = 0.5*(x2-x1)*(w1-z1)
-    return A
-
-
-def calculate_new_wet_area(x1,x2,z1,z2,A):
-    from numpy import sqrt
-    min_centroid_height = 1.0e-3
-    # Assumes reconstructed stage flat in a wetted cell
-    M = (z2-z1)/(x2-x1)
-    L = (x2-x1)
-    min_area = min_centroid_height*L
-    max_area = 0.5*(x2-x1)*abs(z2-z1)
-    if A < max_area:
-        if (z1 < z2):
-            x = sqrt(2*A/M)+x1
-            wet_len = x-x1
-            wc = z1 + sqrt(M*2*A)
-        elif (z2 < z1):
-            x = -sqrt(-2*A/M)+x2
-            wet_len = x2-x 
-            wc = z2+sqrt(-M*2*A)
-        else:
-            wc = A/L+0.5*(z1+z2)
-            wet_len = x2-x1
-    else:
-        wc = 0.5*(z1+z2)+A/L
-        wet_len = x2-x1
-            
-    return wc,wet_len
-
-def calculate_new_wet_area_analytic(x1,x2,z1,z2,A,t):
-    min_centroid_height = 1.0e-3
-    # Assumes reconstructed stage flat in a wetted cell
-    M = (z2-z1)/(x2-x1)
-    L = (x2-x1)
-    min_area = min_centroid_height*L
-    max_area = 0.5*(x2-x1)*abs(z2-z1)
-    w1,uh1 = analytic_cannal(x1,t)
-    w2,uh2 = analytic_cannal(x2,t)
-    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
-        print "test1"
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x-x1
-    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
-        print "test2"
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x2-x
-    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
-        print "test3"
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x2-x
-    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
-        print "test4"
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x-x1
-    elif (w1 >= z1) & (w2 >= z2):
-        print "test5"
-        wet_len = x2-x1 
-    else: #(w1 <= z1) & (w2 <= z2)
-        print "test5"
-        if (w1 > z1) | (w2 > z2):
-            print "ERROR"
-        wet_len = x2-x1        
-    return w1,w2,wet_len,uh1,uh2
-
-def analytic_cannal(C,t):
-
-    import math
-    #N = len(C)
-    #u = zeros(N,numpy.float)    ## water velocity
-    #h = zeros(N,numpy.float)    ## water depth
-    x = C
-    g = 9.81
-
-
-    ## Define Basin Bathymetry
-    #z_b = zeros(N,numpy.float) ## elevation of basin
-    #z = zeros(N,numpy.float)   ## elevation of water surface
-    z_infty = 10.0       ## max equilibrium water depth at lowest point.
-    L_x = 2500.0         ## width of channel
-
-    A0 = 0.5*L_x                  ## determines amplitudes of oscillations
-    omega = math.sqrt(2*g*z_infty)/L_x ## angular frequency of osccilation
-
-    x1 = A0*cos(omega*t)-L_x # left shoreline
-    x2 = A0*cos(omega*t)+L_x # right shoreline
-    if (x >=x1) & (x <= x2):
-        z_b = z_infty*(x**2/L_x**2) ## or A0*cos(omega*t)\pmL_x
-        u = -A0*omega*sin(omega*t)
-        z = z_infty+2*A0*z_infty/L_x*cos(omega*t)*(x/L_x-0.5*A0/(L_x)*cos(omega*t))
-    else:
-       z_b = z_infty*(x**2/L_x**2)
-       u=0.0
-       z = z_b
-    h = z-z_b
-    return z,u*h
Index: /anuga_work/development/flow_1d/generic_1d/util.py
===================================================================
--- /anuga_work/development/flow_1d/generic_1d/util.py	(revision 7835)
+++ /anuga_work/development/flow_1d/generic_1d/util.py	(revision 7835)
@@ -0,0 +1,57 @@
+"""
+This module contains various auxiliary function used by pyvolution.
+"""
+
+
+import numpy
+
+def mean(x):
+    return numpy.sum(x)/len(x)
+
+
+def gradient(x0, x1, q0, q1):
+
+    if q1-q0 != 0:
+        a = (q1-q0)/(x1-x0)
+    else:
+        a = 0
+        
+    return a
+
+def  minmod(beta_p,beta_m):
+    if (abs(beta_p) < abs(beta_m)) & (beta_p*beta_m > 0.0):
+        phi = beta_p
+    elif (abs(beta_m) < abs(beta_p)) & (beta_p*beta_m > 0.0):
+        phi = beta_m
+    else:
+        phi = 0.0
+    return phi
+
+def  minmod_kurganov(a,b,c):
+    from numpy import sign
+    if sign(a)==sign(b)==sign(c):
+        return sign(a)*min(abs(a),abs(b),abs(c))
+    else:
+        return 0.0
+
+def  maxmod(a,b):
+    if (abs(a) > abs(b)) & (a*b > 0.0):
+        phi = a
+    elif (abs(b) > abs(a)) & (a*b > 0.0):
+        phi = b
+    else:
+        phi = 0.0
+    return phi
+
+def vanleer(a,b):
+    if abs(a)+abs(b) > 1e-12:
+        return (a*abs(b)+abs(a)*b)/(abs(a)+abs(b))
+    else:
+        return 0.0
+
+def vanalbada(a,b):
+    if a*a+b*b > 1e-12:
+        return (a*a*b+a*b*b)/(a*a+b*b)
+    else:
+        return 0.0
+
Index: /anuga_work/development/flow_1d/sww_flow/wet_dry.py
===================================================================
--- /anuga_work/development/flow_1d/sww_flow/wet_dry.py	(revision 7835)
+++ /anuga_work/development/flow_1d/sww_flow/wet_dry.py	(revision 7835)
@@ -0,0 +1,126 @@
+"""
+This module contains various auxiliary function used
+to ascertain wet dry areas.
+"""
+
+
+import numpy
+
+def calculate_wetted_area(x1,x2,z1,z2,w1,w2):
+    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
+        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
+        A = 0.5*(w1-z1)*(x-x1)
+        L = x-x1
+    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
+        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
+        A = 0.5*(w2-z2)*(x2-x)
+        L = x2-x
+    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
+        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
+        A = 0.5*(w2-z2)*(x2-x)
+        L = x2-x
+    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
+        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
+        A = 0.5*(w1-z1)*(x-x1)
+        L = x-x1
+    elif (w1 <= z1) & (w2 <= z2):
+        A = 0.0
+    elif (w1 == z1) & (w2 > z2) & (z2 < z1):
+        A = 0.5*(x2-x1)*(w2-z2)
+    elif (w2 == z2) & (w1 > z1) & (z1 < z2):
+        A = 0.5*(x2-x1)*(w1-z1)
+    return A
+
+
+def calculate_new_wet_area(x1,x2,z1,z2,A):
+    from numpy import sqrt
+    min_centroid_height = 1.0e-3
+    # Assumes reconstructed stage flat in a wetted cell
+    M = (z2-z1)/(x2-x1)
+    L = (x2-x1)
+    min_area = min_centroid_height*L
+    max_area = 0.5*(x2-x1)*abs(z2-z1)
+    if A < max_area:
+        if (z1 < z2):
+            x = sqrt(2*A/M)+x1
+            wet_len = x-x1
+            wc = z1 + sqrt(M*2*A)
+        elif (z2 < z1):
+            x = -sqrt(-2*A/M)+x2
+            wet_len = x2-x 
+            wc = z2+sqrt(-M*2*A)
+        else:
+            wc = A/L+0.5*(z1+z2)
+            wet_len = x2-x1
+    else:
+        wc = 0.5*(z1+z2)+A/L
+        wet_len = x2-x1
+            
+    return wc,wet_len
+
+def calculate_new_wet_area_analytic(x1,x2,z1,z2,A,t):
+    min_centroid_height = 1.0e-3
+    # Assumes reconstructed stage flat in a wetted cell
+    M = (z2-z1)/(x2-x1)
+    L = (x2-x1)
+    min_area = min_centroid_height*L
+    max_area = 0.5*(x2-x1)*abs(z2-z1)
+    w1,uh1 = analytic_cannal(x1,t)
+    w2,uh2 = analytic_cannal(x2,t)
+    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
+        print "test1"
+        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
+        wet_len = x-x1
+    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
+        print "test2"
+        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
+        wet_len = x2-x
+    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
+        print "test3"
+        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
+        wet_len = x2-x
+    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
+        print "test4"
+        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
+        wet_len = x-x1
+    elif (w1 >= z1) & (w2 >= z2):
+        print "test5"
+        wet_len = x2-x1 
+    else: #(w1 <= z1) & (w2 <= z2)
+        print "test5"
+        if (w1 > z1) | (w2 > z2):
+            print "ERROR"
+        wet_len = x2-x1        
+    return w1,w2,wet_len,uh1,uh2
+
+def analytic_cannal(C,t):
+
+    import math
+    #N = len(C)
+    #u = zeros(N,numpy.float)    ## water velocity
+    #h = zeros(N,numpy.float)    ## water depth
+    x = C
+    g = 9.81
+
+
+    ## Define Basin Bathymetry
+    #z_b = zeros(N,numpy.float) ## elevation of basin
+    #z = zeros(N,numpy.float)   ## elevation of water surface
+    z_infty = 10.0       ## max equilibrium water depth at lowest point.
+    L_x = 2500.0         ## width of channel
+
+    A0 = 0.5*L_x                  ## determines amplitudes of oscillations
+    omega = math.sqrt(2*g*z_infty)/L_x ## angular frequency of osccilation
+
+    x1 = A0*cos(omega*t)-L_x # left shoreline
+    x2 = A0*cos(omega*t)+L_x # right shoreline
+    if (x >=x1) & (x <= x2):
+        z_b = z_infty*(x**2/L_x**2) ## or A0*cos(omega*t)\pmL_x
+        u = -A0*omega*sin(omega*t)
+        z = z_infty+2*A0*z_infty/L_x*cos(omega*t)*(x/L_x-0.5*A0/(L_x)*cos(omega*t))
+    else:
+       z_b = z_infty*(x**2/L_x**2)
+       u=0.0
+       z = z_b
+    h = z-z_b
+    return z,u*h
Index: uga_work/development/flow_1d/utilities/util.py
===================================================================
--- /anuga_work/development/flow_1d/utilities/util.py	(revision 7834)
+++ 	(revision )
@@ -1,175 +1,0 @@
-"""
-This module contains various auxiliary function used by pyvolution.
-"""
-
-
-import numpy
-
-def mean(x):
-    return numpy.sum(x)/len(x)
-
-
-def gradient(x0, x1, q0, q1):
-
-    if q1-q0 != 0:
-        a = (q1-q0)/(x1-x0)
-    else:
-        a = 0
-        
-    return a
-
-def  minmod(beta_p,beta_m):
-    if (abs(beta_p) < abs(beta_m)) & (beta_p*beta_m > 0.0):
-        phi = beta_p
-    elif (abs(beta_m) < abs(beta_p)) & (beta_p*beta_m > 0.0):
-        phi = beta_m
-    else:
-        phi = 0.0
-    return phi
-
-def  minmod_kurganov(a,b,c):
-    from numpy import sign
-    if sign(a)==sign(b)==sign(c):
-        return sign(a)*min(abs(a),abs(b),abs(c))
-    else:
-        return 0.0
-
-def  maxmod(a,b):
-    if (abs(a) > abs(b)) & (a*b > 0.0):
-        phi = a
-    elif (abs(b) > abs(a)) & (a*b > 0.0):
-        phi = b
-    else:
-        phi = 0.0
-    return phi
-
-def vanleer(a,b):
-    if abs(a)+abs(b) > 1e-12:
-        return (a*abs(b)+abs(a)*b)/(abs(a)+abs(b))
-    else:
-        return 0.0
-
-def vanalbada(a,b):
-    if a*a+b*b > 1e-12:
-        return (a*a*b+a*b*b)/(a*a+b*b)
-    else:
-        return 0.0
-
-def calculate_wetted_area(x1,x2,z1,z2,w1,w2):
-    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w1-z1)*(x-x1)
-        L = x-x1
-    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w2-z2)*(x2-x)
-        L = x2-x
-    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w2-z2)*(x2-x)
-        L = x2-x
-    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        A = 0.5*(w1-z1)*(x-x1)
-        L = x-x1
-    elif (w1 <= z1) & (w2 <= z2):
-        A = 0.0
-    elif (w1 == z1) & (w2 > z2) & (z2 < z1):
-        A = 0.5*(x2-x1)*(w2-z2)
-    elif (w2 == z2) & (w1 > z1) & (z1 < z2):
-        A = 0.5*(x2-x1)*(w1-z1)
-    return A
-
-
-def calculate_new_wet_area(x1,x2,z1,z2,A):
-    from numpy import sqrt
-    min_centroid_height = 1.0e-3
-    # Assumes reconstructed stage flat in a wetted cell
-    M = (z2-z1)/(x2-x1)
-    L = (x2-x1)
-    min_area = min_centroid_height*L
-    max_area = 0.5*(x2-x1)*abs(z2-z1)
-    if A < max_area:
-        if (z1 < z2):
-            x = sqrt(2*A/M)+x1
-            wet_len = x-x1
-            wc = z1 + sqrt(M*2*A)
-        elif (z2 < z1):
-            x = -sqrt(-2*A/M)+x2
-            wet_len = x2-x 
-            wc = z2+sqrt(-M*2*A)
-        else:
-            wc = A/L+0.5*(z1+z2)
-            wet_len = x2-x1
-    else:
-        wc = 0.5*(z1+z2)+A/L
-        wet_len = x2-x1
-            
-    return wc,wet_len
-
-def calculate_new_wet_area_analytic(x1,x2,z1,z2,A,t):
-    min_centroid_height = 1.0e-3
-    # Assumes reconstructed stage flat in a wetted cell
-    M = (z2-z1)/(x2-x1)
-    L = (x2-x1)
-    min_area = min_centroid_height*L
-    max_area = 0.5*(x2-x1)*abs(z2-z1)
-    w1,uh1 = analytic_cannal(x1,t)
-    w2,uh2 = analytic_cannal(x2,t)
-    if (w1 > z1) & (w2 < z2) & (z1 <= z2):
-        print "test1"
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x-x1
-    elif (w1 < z1) & (w2 > z2) & (z1 < z2):
-        print "test2"
-        x = ((w2-z1)*(x2-x1)+x1*(z2-z1)-x2*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x2-x
-    elif (w1 < z1) & (w2 > z2) & (z1 >= z2):
-        print "test3"
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x2-x
-    elif (w1 > z1) & (w2 < z2) & (z1 > z2):
-        print "test4"
-        x = ((w1-z2)*(x2-x1)+x2*(z2-z1)-x1*(w2-w1))/(z2-z1+w1-w2)
-        wet_len = x-x1
-    elif (w1 >= z1) & (w2 >= z2):
-        print "test5"
-        wet_len = x2-x1 
-    else: #(w1 <= z1) & (w2 <= z2)
-        print "test5"
-        if (w1 > z1) | (w2 > z2):
-            print "ERROR"
-        wet_len = x2-x1        
-    return w1,w2,wet_len,uh1,uh2
-
-def analytic_cannal(C,t):
-
-    import math
-    #N = len(C)
-    #u = zeros(N,numpy.float)    ## water velocity
-    #h = zeros(N,numpy.float)    ## water depth
-    x = C
-    g = 9.81
-
-
-    ## Define Basin Bathymetry
-    #z_b = zeros(N,numpy.float) ## elevation of basin
-    #z = zeros(N,numpy.float)   ## elevation of water surface
-    z_infty = 10.0       ## max equilibrium water depth at lowest point.
-    L_x = 2500.0         ## width of channel
-
-    A0 = 0.5*L_x                  ## determines amplitudes of oscillations
-    omega = math.sqrt(2*g*z_infty)/L_x ## angular frequency of osccilation
-
-    x1 = A0*cos(omega*t)-L_x # left shoreline
-    x2 = A0*cos(omega*t)+L_x # right shoreline
-    if (x >=x1) & (x <= x2):
-        z_b = z_infty*(x**2/L_x**2) ## or A0*cos(omega*t)\pmL_x
-        u = -A0*omega*sin(omega*t)
-        z = z_infty+2*A0*z_infty/L_x*cos(omega*t)*(x/L_x-0.5*A0/(L_x)*cos(omega*t))
-    else:
-       z_b = z_infty*(x**2/L_x**2)
-       u=0.0
-       z = z_b
-    h = z-z_b
-    return z,u*h
