Changeset 6145


Ignore:
Timestamp:
Jan 13, 2009, 11:51:22 AM (10 years ago)
Author:
rwilson
Message:

Change Numeric imports to general form - ready to change to NumPy?.

Location:
anuga_core/source/anuga/abstract_2d_finite_volumes
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • anuga_core/source/anuga/abstract_2d_finite_volumes/domain.py

    r6129 r6145  
    88"""
    99
    10 from Numeric import allclose, argmax, zeros, Float
    1110from anuga.config import epsilon
    1211from anuga.config import beta_euler, beta_rk2
     
    3130from anuga.abstract_2d_finite_volumes.util import get_textual_float
    3231
    33 from Numeric import zeros, Float, Int, ones
    3432from quantity import Quantity
    3533
     
    3735from time import time as walltime
    3836
     37import Numeric as num
    3938
    4039
     
    156155        for key in self.full_send_dict:
    157156            buffer_shape = self.full_send_dict[key][0].shape[0]
    158             self.full_send_dict[key].append(zeros( (buffer_shape,self.nsys) ,Float))
    159 
     157            self.full_send_dict[key].append(num.zeros((buffer_shape, self.nsys), num.Float))
    160158
    161159        for key in self.ghost_recv_dict:
    162160            buffer_shape = self.ghost_recv_dict[key][0].shape[0]
    163             self.ghost_recv_dict[key].append(zeros( (buffer_shape,self.nsys) ,Float))
    164 
     161            self.ghost_recv_dict[key].append(num.zeros((buffer_shape, self.nsys), num.Float))
    165162
    166163        # Setup cell full flag
     
    169166        N = len(self) #number_of_elements
    170167        self.number_of_elements = N
    171         self.tri_full_flag = ones(N, Int)
     168        self.tri_full_flag = num.ones(N, num.Int)
    172169        for i in self.ghost_recv_dict.keys():
    173170            for id in self.ghost_recv_dict[i][0]:
     
    176173        # Test the assumption that all full triangles are store before
    177174        # the ghost triangles.
    178         if not allclose(self.tri_full_flag[:self.number_of_full_nodes],1):
     175        if not num.allclose(self.tri_full_flag[:self.number_of_full_nodes],1):
    179176            print 'WARNING:  Not all full triangles are store before ghost triangles'
    180177                       
     
    229226        # calculation
    230227        N = len(self) # Number_of_triangles
    231         self.already_computed_flux = zeros((N, 3), Int)
     228        self.already_computed_flux = num.zeros((N, 3), num.Int)
    232229
    233230        # Storage for maximal speeds computed for each triangle by
    234231        # compute_fluxes
    235232        # This is used for diagnostics only (reset at every yieldstep)
    236         self.max_speed = zeros(N, Float)
     233        self.max_speed = num.zeros(N, num.Float)
    237234
    238235        if mesh_filename is not None:
     
    265262        """
    266263
    267         from Numeric import zeros, Float
    268 
    269264        if not (vertex is None or edge is None):
    270265            msg = 'Values for both vertex and edge was specified.'
     
    272267            raise msg
    273268
    274         q = zeros( len(self.conserved_quantities), Float)
     269        q = num.zeros(len(self.conserved_quantities), num.Float)
    275270
    276271        for i, name in enumerate(self.conserved_quantities):
     
    791786            # Find index of largest computed flux speed
    792787            if triangle_id is None:
    793                 k = self.k = argmax(self.max_speed)
     788                k = self.k = num.argmax(self.max_speed)
    794789            else:
    795790                errmsg = 'Triangle_id %d does not exist in mesh: %s' %(triangle_id,
     
    12241219                self.number_of_steps = 0
    12251220                self.number_of_first_order_steps = 0
    1226                 self.max_speed = zeros(N, Float)
     1221                self.max_speed = num.zeros(N, num.Float)
    12271222
    12281223    def evolve_one_euler_step(self, yieldstep, finaltime):
     
    15881583        """
    15891584
    1590         from Numeric import ones, sum, equal, Float
    1591 
    15921585        N = len(self) # Number_of_triangles
    15931586        d = len(self.conserved_quantities)
  • anuga_core/source/anuga/abstract_2d_finite_volumes/ermapper_grids.py

    r5897 r6145  
    22
    33# from os import open, write, read
    4 import Numeric
    5 
    6 celltype_map = {'IEEE4ByteReal': Numeric.Float32, 'IEEE8ByteReal': Numeric.Float64}
     4import Numeric as num
     5
     6celltype_map = {'IEEE4ByteReal': num.Float32, 'IEEE8ByteReal': num.Float64}
    77
    88
     
    2222    ofile:      string - filename for output (note the output will consist of two files
    2323                ofile and ofile.ers.  Either of these can be entered into this function
    24     data:       Numeric.array - 2D array containing the data to be output to the grid
     24    data:       num.array - 2D array containing the data to be output to the grid
    2525    header:     dictionary - contains spatial information about the grid, in particular:
    2626                    header['datum'] datum for the data ('"GDA94"')
     
    5757
    5858    # Check that the data is a 2 dimensional array
    59     data_size = Numeric.shape(data)
     59    data_size = num.shape(data)
    6060    assert len(data_size) == 2
    6161   
     
    8383    nrofcellsperlines = int(header['nrofcellsperline'])
    8484    data = read_ermapper_data(data_file)
    85     data = Numeric.reshape(data,(nroflines,nrofcellsperlines))
     85    data = num.reshape(data,(nroflines,nrofcellsperlines))
    8686    return data
    8787   
     
    163163    return header                     
    164164
    165 def write_ermapper_data(grid, ofile, data_format = Numeric.Float32):
     165def write_ermapper_data(grid, ofile, data_format = num.Float32):
    166166
    167167
     
    193193
    194194
    195 def read_ermapper_data(ifile, data_format = Numeric.Float32):
     195def read_ermapper_data(ifile, data_format = num.Float32):
    196196    # open input file in a binary format and read the input string
    197197    fid = open(ifile,'rb')
     
    199199    fid.close()
    200200
    201     # convert input string to required format (Note default format is Numeric.Float32)
    202     grid_as_float = Numeric.fromstring(input_string,data_format)
     201    # convert input string to required format (Note default format is num.Float32)
     202    grid_as_float = num.fromstring(input_string,data_format)
    203203    return grid_as_float
    204204
  • anuga_core/source/anuga/abstract_2d_finite_volumes/general_mesh.py

    r5897 r6145  
    1 
    2 from Numeric import concatenate, reshape, take, allclose
    3 from Numeric import array, zeros, Int, Float, sqrt, sum, arange
     1import Numeric as num
    42
    53from anuga.coordinate_transforms.geo_reference import Geo_reference
     
    9088        if verbose: print 'General_mesh: Building basic mesh structure in ANUGA domain'
    9189
    92         self.triangles = array(triangles, Int)
    93         self.nodes = array(nodes, Float)
     90        self.triangles = num.array(triangles, num.Int)
     91        self.nodes = num.array(nodes, num.Float)
    9492
    9593
     
    146144                      max(self.nodes[:,0]), max(self.nodes[:,1]) ]
    147145
    148         self.xy_extent = array(xy_extent, Float)
     146        self.xy_extent = num.array(xy_extent, num.Float)
    149147
    150148
    151149        # Allocate space for geometric quantities
    152         self.normals = zeros((N, 6), Float)
    153         self.areas = zeros(N, Float)
    154         self.edgelengths = zeros((N, 3), Float)
     150        self.normals = num.zeros((N, 6), num.Float)
     151        self.areas = num.zeros(N, num.Float)
     152        self.edgelengths = num.zeros((N, 3), num.Float)
    155153
    156154        # Get x,y coordinates for all triangles and store
     
    187185            #   - Stored as six floats n0x,n0y,n1x,n1y,n2x,n2y per triangle
    188186
    189             n0 = array([x2 - x1, y2 - y1])
    190             l0 = sqrt(sum(n0**2))
    191 
    192             n1 = array([x0 - x2, y0 - y2])
    193             l1 = sqrt(sum(n1**2))
    194 
    195             n2 = array([x1 - x0, y1 - y0])
    196             l2 = sqrt(sum(n2**2))
     187            n0 = num.array([x2 - x1, y2 - y1])
     188            l0 = num.sqrt(num.sum(n0**2))
     189
     190            n1 = num.array([x0 - x2, y0 - y2])
     191            l1 = num.sqrt(num.sum(n1**2))
     192
     193            n2 = num.array([x1 - x0, y1 - y0])
     194            l2 = num.sqrt(num.sum(n2**2))
    197195
    198196            # Normalise
     
    274272        if absolute is True:
    275273            if not self.geo_reference.is_absolute():
    276                 return V + array([self.geo_reference.get_xllcorner(),
    277                                   self.geo_reference.get_yllcorner()])
     274                return V + num.array([self.geo_reference.get_xllcorner(),
     275                                      self.geo_reference.get_yllcorner()])
    278276            else:
    279277                return V
     
    316314            i3 = 3*i 
    317315            if absolute is True and not self.geo_reference.is_absolute():
    318                 offset=array([self.geo_reference.get_xllcorner(),
     316                offset=num.array([self.geo_reference.get_xllcorner(),
    319317                                  self.geo_reference.get_yllcorner()])
    320                 return array([V[i3,:]+offset,
    321                               V[i3+1,:]+offset,
    322                               V[i3+2,:]+offset])
     318                return num.array([V[i3,:]+offset,
     319                                  V[i3+1,:]+offset,
     320                                  V[i3+2,:]+offset])
    323321            else:
    324                 return array([V[i3,:], V[i3+1,:], V[i3+2,:]])
     322                return num.array([V[i3,:], V[i3+1,:], V[i3+2,:]])
    325323               
    326324
     
    349347
    350348        M = self.number_of_triangles
    351         vertex_coordinates = zeros((3*M, 2), Float)
     349        vertex_coordinates = num.zeros((3*M, 2), num.Float)
    352350
    353351        for i in range(M):
     
    376374            indices = range(M)
    377375
    378         return take(self.triangles, indices)
     376        return num.take(self.triangles, indices)
    379377   
    380378
     
    408406        K = 3*M       # Total number of unique vertices
    409407       
    410         #T = reshape(array(range(K)).astype(Int), (M,3))
    411         T = reshape(arange(K).astype(Int), (M,3))  # Faster
     408        T = num.reshape(num.arange(K).astype(num.Int), (M,3))
    412409       
    413410        return T     
     
    439436        if node is not None:
    440437            # Get index for this node
    441             first = sum(self.number_of_triangles_per_node[:node])
     438            first = num.sum(self.number_of_triangles_per_node[:node])
    442439           
    443440            # Get number of triangles for this node
     
    452449                triangle_list.append( (volume_id, vertex_id) )
    453450
    454             triangle_list = array(triangle_list)   
     451            triangle_list = num.array(triangle_list)   
    455452        else:
    456453            # Get info for all nodes recursively.
     
    529526
    530527        # Count number of triangles per node
    531         number_of_triangles_per_node = zeros(self.number_of_full_nodes)
     528        number_of_triangles_per_node = num.zeros(self.number_of_full_nodes)
    532529        for volume_id, triangle in enumerate(self.get_triangles()):
    533530            for vertex_id in triangle:
     
    535532
    536533        # Allocate space for inverted structure
    537         number_of_entries = sum(number_of_triangles_per_node)
    538         vertex_value_indices = zeros(number_of_entries)
     534        number_of_entries = num.sum(number_of_triangles_per_node)
     535        vertex_value_indices = num.zeros(number_of_entries)
    539536
    540537        # Register (triangle, vertex) indices for each node
     
    598595        """
    599596
    600         return sum(self.areas)
    601 
    602        
    603        
     597        return num.sum(self.areas)
     598
     599       
     600       
  • anuga_core/source/anuga/abstract_2d_finite_volumes/generic_boundary_conditions.py

    r6011 r6145  
    77from anuga.fit_interpolate.interpolate import Modeltime_too_late
    88from anuga.fit_interpolate.interpolate import Modeltime_too_early
     9
     10import Numeric as num
    911
    1012
     
    6769            raise Exception, msg
    6870
    69         from Numeric import array, Float
    70         self.conserved_quantities=array(conserved_quantities).astype(Float)
     71        self.conserved_quantities=num.array(conserved_quantities).astype(num.Float)
    7172
    7273    def __repr__(self):
     
    9798
    9899
    99         from Numeric import array, Float
    100100        try:
    101             q = array(q).astype(Float)
     101            q = num.array(q).astype(num.Float)
    102102        except:
    103103            msg = 'Return value from time boundary function could '
     
    164164
    165165        import time
    166         from Numeric import array, zeros, Float
    167166        from anuga.config import time_format
    168167        from anuga.abstract_2d_finite_volumes.util import file_function
     
    180179
    181180        if verbose: print 'Find midpoint coordinates of entire boundary'
    182         self.midpoint_coordinates = zeros( (len(domain.boundary), 2), Float)
     181        self.midpoint_coordinates = num.zeros((len(domain.boundary), 2), num.Float)
    183182        boundary_keys = domain.boundary.keys()
    184183
     
    200199           
    201200            # Compute midpoints
    202             if edge_id == 0: m = array([(x1 + x2)/2, (y1 + y2)/2])
    203             if edge_id == 1: m = array([(x0 + x2)/2, (y0 + y2)/2])
    204             if edge_id == 2: m = array([(x1 + x0)/2, (y1 + y0)/2])
     201            if edge_id == 0: m = num.array([(x1 + x2)/2, (y1 + y2)/2])
     202            if edge_id == 1: m = num.array([(x0 + x2)/2, (y0 + y2)/2])
     203            if edge_id == 2: m = num.array([(x1 + x0)/2, (y1 + y0)/2])
    205204
    206205            # Convert to absolute UTM coordinates
  • anuga_core/source/anuga/abstract_2d_finite_volumes/mesh_factory.py

    r5897 r6145  
    22mesh file formats
    33"""
     4
     5import Numeric as num
    46
    57
     
    7375
    7476    from anuga.config import epsilon
    75     from Numeric import zeros, Float, Int
    7677
    7778    delta1 = float(len1)/m
     
    9394    index = Index(n,m)
    9495
    95     points = zeros( (Np,2), Float)
     96    points = num.zeros((Np, 2), num.Float)
    9697
    9798    for i in range(m+1):
     
    105106
    106107
    107     elements = zeros( (Nt,3), Int)
     108    elements = num.zeros((Nt, 3), num.Int)
    108109    boundary = {}
    109110    nt = -1
     
    149150
    150151    from anuga.config import epsilon
    151     from Numeric import zeros, Float, Int
    152152
    153153    delta1 = float(len1)/m
     
    208208    """
    209209
    210     from Numeric import array
    211210    import math
    212211
     
    510509    """
    511510
    512     from Numeric import array
    513511    import math
    514512
     
    592590    """
    593591
    594     from Numeric import array
    595592    import math
    596593
     
    686683    """
    687684
    688     from Numeric import array
    689685    import math
    690686
  • anuga_core/source/anuga/abstract_2d_finite_volumes/neighbour_mesh.py

    r5897 r6145  
    1111from anuga.caching import cache
    1212from math import pi, sqrt
    13 from Numeric import array, allclose
     13
     14import Numeric as num
    1415       
    1516
     
    8182
    8283
    83         from Numeric import array, zeros, Int, Float, maximum, sqrt, sum
    8484
    8585        General_mesh.__init__(self, coordinates, triangles,
     
    9898
    9999        #Allocate space for geometric quantities
    100         self.centroid_coordinates = zeros((N, 2), Float)
    101 
    102         self.radii = zeros(N, Float)
    103 
    104         self.neighbours = zeros((N, 3), Int)
    105         self.neighbour_edges = zeros((N, 3), Int)
    106         self.number_of_boundaries = zeros(N, Int)
    107         self.surrogate_neighbours = zeros((N, 3), Int)
     100        self.centroid_coordinates = num.zeros((N, 2), num.Float)
     101
     102        self.radii = num.zeros(N, num.Float)
     103
     104        self.neighbours = num.zeros((N, 3), num.Int)
     105        self.neighbour_edges = num.zeros((N, 3), num.Int)
     106        self.number_of_boundaries = num.zeros(N, num.Int)
     107        self.surrogate_neighbours = num.zeros((N, 3), num.Int)
    108108
    109109        #Get x,y coordinates for all triangles and store
     
    124124
    125125            #Compute centroid
    126             centroid = array([(x0 + x1 + x2)/3, (y0 + y1 + y2)/3])
     126            centroid = num.array([(x0 + x1 + x2)/3, (y0 + y1 + y2)/3])
    127127            self.centroid_coordinates[i] = centroid
    128128
     
    133133
    134134                #Midpoints
    135                 m0 = array([(x1 + x2)/2, (y1 + y2)/2])
    136                 m1 = array([(x0 + x2)/2, (y0 + y2)/2])
    137                 m2 = array([(x1 + x0)/2, (y1 + y0)/2])
     135                m0 = num.array([(x1 + x2)/2, (y1 + y2)/2])
     136                m1 = num.array([(x0 + x2)/2, (y0 + y2)/2])
     137                m2 = num.array([(x1 + x0)/2, (y1 + y0)/2])
    138138
    139139                #The radius is the distance from the centroid of
    140140                #a triangle to the midpoint of the side of the triangle
    141141                #closest to the centroid
    142                 d0 = sqrt(sum( (centroid-m0)**2 ))
    143                 d1 = sqrt(sum( (centroid-m1)**2 ))
    144                 d2 = sqrt(sum( (centroid-m2)**2 ))
     142                d0 = num.sqrt(num.sum( (centroid-m0)**2 ))
     143                d1 = num.sqrt(num.sum( (centroid-m1)**2 ))
     144                d2 = num.sqrt(num.sum( (centroid-m2)**2 ))
    145145
    146146                self.radii[i] = min(d0, d1, d2)
     
    150150                #of inscribed circle is computed
    151151
    152                 a = sqrt((x0-x1)**2+(y0-y1)**2)
    153                 b = sqrt((x1-x2)**2+(y1-y2)**2)
    154                 c = sqrt((x2-x0)**2+(y2-y0)**2)
     152                a = num.sqrt((x0-x1)**2+(y0-y1)**2)
     153                b = num.sqrt((x1-x2)**2+(y1-y2)**2)
     154                c = num.sqrt((x2-x0)**2+(y2-y0)**2)
    155155
    156156                self.radii[i]=2.0*self.areas[i]/(a+b+c)
     
    212212        x1 = V[i, 2]; y1 = V[i, 3]
    213213        x2 = V[i, 4]; y2 = V[i, 5]
    214         a = sqrt((x0-x1)**2+(y0-y1)**2)
    215         b = sqrt((x1-x2)**2+(y1-y2)**2)
    216         c = sqrt((x2-x0)**2+(y2-y0)**2)
     214        a = num.sqrt((x0-x1)**2+(y0-y1)**2)
     215        b = num.sqrt((x1-x2)**2+(y1-y2)**2)
     216        c = num.sqrt((x2-x0)**2+(y2-y0)**2)
    217217        ratio = old_rad/self.radii[i]
    218218        max_ratio = ratio
     
    224224            x1 = V[i, 2]; y1 = V[i, 3]
    225225            x2 = V[i, 4]; y2 = V[i, 5]
    226             a = sqrt((x0-x1)**2+(y0-y1)**2)
    227             b = sqrt((x1-x2)**2+(y1-y2)**2)
    228             c = sqrt((x2-x0)**2+(y2-y0)**2)
     226            a = num.sqrt((x0-x1)**2+(y0-y1)**2)
     227            b = num.sqrt((x1-x2)**2+(y1-y2)**2)
     228            c = num.sqrt((x2-x0)**2+(y2-y0)**2)
    229229            self.radii[i]=self.areas[i]/(2*(a+b+c))*safety_factor
    230230            ratio = old_rad/self.radii[i]
     
    388388            self.element_tag is defined
    389389        """
    390         from Numeric import array, Int
    391390
    392391        if tagged_elements is None:
     
    395394            #Check that all keys in given boundary exist
    396395            for tag in tagged_elements.keys():
    397                 tagged_elements[tag] = array(tagged_elements[tag]).astype(Int)
     396                tagged_elements[tag] = num.array(tagged_elements[tag]).astype(num.Int)
    398397
    399398                msg = 'Not all elements exist. '
     
    463462        """
    464463       
    465         from Numeric import allclose, sqrt, array, minimum, maximum
    466464        from anuga.utilities.numerical_tools import angle, ensure_numeric     
    467465
     
    477475        inverse_segments = {}
    478476        p0 = None
    479         mindist = sqrt(sum((pmax-pmin)**2)) # Start value across entire mesh
     477        mindist = num.sqrt(num.sum((pmax-pmin)**2)) # Start value across entire mesh
    480478        for i, edge_id in self.boundary.keys():
    481479            # Find vertex ids for boundary segment
     
    491489            # Note: Could be arbitrary, but nice to have
    492490            # a unique way of selecting
    493             dist_A = sqrt(sum((A-pmin)**2))
    494             dist_B = sqrt(sum((B-pmin)**2))
     491            dist_A = num.sqrt(num.sum((A-pmin)**2))
     492            dist_B = num.sqrt(num.sum((B-pmin)**2))
    495493
    496494            # Find lower leftmost point
     
    593591                # We have reached a point already visited.
    594592               
    595                 if allclose(p1, polygon[0]):
     593                if num.allclose(p1, polygon[0]):
    596594                    # If it is the initial point, the polygon is complete.
    597595                   
     
    629627        from anuga.utilities.numerical_tools import anglediff
    630628
    631         from Numeric import sort, allclose
    632 
    633629        N = len(self)
    634630
     
    672668
    673669                # Normalise
    674                 l_u = sqrt(u[0]*u[0] + u[1]*u[1])
    675                 l_v = sqrt(v[0]*v[0] + v[1]*v[1])
     670                l_u = num.sqrt(u[0]*u[0] + u[1]*u[1])
     671                l_v = num.sqrt(v[0]*v[0] + v[1]*v[1])
    676672
    677673                msg = 'Normal vector in triangle %d does not have unit length' %i
    678                 assert allclose(l_v, 1), msg
     674                assert num.allclose(l_v, 1), msg
    679675
    680676                x = (u[0]*v[0] + u[1]*v[1])/l_u # Inner product
     
    730726
    731727        V = self.vertex_value_indices[:] #Take a copy
    732         V = sort(V)
    733         assert allclose(V, range(3*N))
    734 
    735         assert sum(self.number_of_triangles_per_node) ==\
    736                len(self.vertex_value_indices)
     728        V = num.sort(V)
     729        assert num.allclose(V, range(3*N))
     730
     731        assert num.sum(self.number_of_triangles_per_node) ==\
     732                       len(self.vertex_value_indices)
    737733
    738734        # Check number of triangles per node
     
    742738                count[i] += 1
    743739
    744         assert allclose(count, self.number_of_triangles_per_node)
     740        assert num.allclose(count, self.number_of_triangles_per_node)
    745741
    746742
     
    805801        """
    806802
    807         from Numeric import arange
    808803        from anuga.utilities.numerical_tools import histogram, create_bins
    809804
     
    11411136
    11421137            # Distances from line origin to the two intersections
    1143             z0 = array([x0 - xi0, y0 - eta0])
    1144             z1 = array([x1 - xi0, y1 - eta0])             
    1145             d0 = sqrt(sum(z0**2))
    1146             d1 = sqrt(sum(z1**2))
     1138            z0 = num.array([x0 - xi0, y0 - eta0])
     1139            z1 = num.array([x1 - xi0, y1 - eta0])             
     1140            d0 = num.sqrt(num.sum(z0**2))
     1141            d1 = num.sqrt(num.sum(z1**2))
    11471142               
    11481143            if d1 < d0:
     
    11571152            # Normal direction:
    11581153            # Right hand side relative to line direction
    1159             vector = array([x1 - x0, y1 - y0]) # Segment vector
    1160             length = sqrt(sum(vector**2))      # Segment length
    1161             normal = array([vector[1], -vector[0]])/length
     1154            vector = num.array([x1 - x0, y1 - y0]) # Segment vector
     1155            length = num.sqrt(num.sum(vector**2))      # Segment length
     1156            normal = num.array([vector[1], -vector[0]])/length
    11621157
    11631158
     
    12391234        assert isinstance(segment, Triangle_intersection), msg
    12401235       
    1241         midpoint = sum(array(segment.segment))/2
     1236        midpoint = num.sum(num.array(segment.segment))/2
    12421237        midpoints.append(midpoint)
    12431238
  • anuga_core/source/anuga/abstract_2d_finite_volumes/pmesh2domain.py

    r5897 r6145  
    99import sys
    1010
     11import Numeric as num
    1112
    1213
     
    161162    """
    162163
    163     from Numeric import transpose
    164164    from load_mesh.loadASCII import import_mesh_file
    165165
     
    172172    volumes = mesh_dict['triangles']
    173173    vertex_quantity_dict = {}
    174     point_atts = transpose(mesh_dict['vertex_attributes'])
     174    point_atts = num.transpose(mesh_dict['vertex_attributes'])
    175175    point_titles  = mesh_dict['vertex_attribute_titles']
    176176    geo_reference  = mesh_dict['geo_reference']
  • anuga_core/source/anuga/abstract_2d_finite_volumes/quantity.py

    r5990 r6145  
    1515"""
    1616
    17 from Numeric import array, zeros, Float, less, concatenate, NewAxis,\
    18      argmax, argmin, allclose, take, reshape, alltrue
    19 
    2017from anuga.utilities.numerical_tools import ensure_numeric, is_scalar
    2118from anuga.utilities.polygon import inside_polygon
     
    2623from anuga.config import epsilon
    2724
     25import Numeric as num
     26
     27
    2828class Quantity:
    2929
     
    3838        if vertex_values is None:
    3939            N = len(domain) # number_of_elements
    40             self.vertex_values = zeros((N, 3), Float)
     40            self.vertex_values = num.zeros((N, 3), num.Float)
    4141        else:
    42             self.vertex_values = array(vertex_values).astype(Float)
     42            self.vertex_values = num.array(vertex_values).astype(num.Float)
    4343
    4444            N, V = self.vertex_values.shape
     
    5757
    5858        # Allocate space for other quantities
    59         self.centroid_values = zeros(N, Float)
    60         self.edge_values = zeros((N, 3), Float)
     59        self.centroid_values = num.zeros(N, num.Float)
     60        self.edge_values = num.zeros((N, 3), num.Float)
    6161
    6262        # Allocate space for Gradient
    63         self.x_gradient = zeros(N, Float)
    64         self.y_gradient = zeros(N, Float)
     63        self.x_gradient = num.zeros(N, num.Float)
     64        self.y_gradient = num.zeros(N, num.Float)
    6565
    6666        # Allocate space for Limiter Phi
    67         self.phi = zeros(N, Float)       
     67        self.phi = num.zeros(N, num.Float)       
    6868
    6969        # Intialise centroid and edge_values
     
    7272        # Allocate space for boundary values
    7373        L = len(domain.boundary)
    74         self.boundary_values = zeros(L, Float)
     74        self.boundary_values = num.zeros(L, num.Float)
    7575
    7676        # Allocate space for updates of conserved quantities by
     
    7878
    7979        # Allocate space for update fields
    80         self.explicit_update = zeros(N, Float )
    81         self.semi_implicit_update = zeros(N, Float )
    82         self.centroid_backup_values = zeros(N, Float)
     80        self.explicit_update = num.zeros(N, num.Float )
     81        self.semi_implicit_update = num.zeros(N, num.Float )
     82        self.centroid_backup_values = num.zeros(N, num.Float)
    8383
    8484        self.set_beta(1.0)
     
    382382        from anuga.geospatial_data.geospatial_data import Geospatial_data
    383383        from types import FloatType, IntType, LongType, ListType, NoneType
    384         from Numeric import ArrayType
    385384
    386385        # Treat special case: Polygon situation
     
    450449
    451450        msg = 'Indices must be a list or None'
    452         assert type(indices) in [ListType, NoneType, ArrayType], msg
     451        assert type(indices) in [ListType, NoneType, num.ArrayType], msg
    453452
    454453
     
    460459                self.set_values_from_constant(numeric,
    461460                                              location, indices, verbose)
    462             elif type(numeric) in [ArrayType, ListType]:
     461            elif type(numeric) in [num.ArrayType, ListType]:
    463462                self.set_values_from_array(numeric,
    464463                                           location, indices, verbose)
     
    612611        """
    613612
    614         from Numeric import array, Float, Int, allclose
    615 
    616         values = array(values).astype(Float)
     613        values = num.array(values).astype(num.Float)
    617614
    618615        if indices is not None:
    619             indices = array(indices).astype(Int)
     616            indices = num.array(indices).astype(num.Int)
    620617            msg = 'Number of values must match number of indices:'
    621618            msg += ' You specified %d values and %d indices'\
     
    642639
    643640        elif location == 'unique vertices':
    644             assert len(values.shape) == 1 or allclose(values.shape[1:], 1),\
     641            assert len(values.shape) == 1 or num.allclose(values.shape[1:], 1),\
    645642                   'Values array must be 1d'
    646643
     
    678675        A = q.vertex_values
    679676
    680         from Numeric import allclose
    681677        msg = 'Quantities are defined on different meshes. '+\
    682678              'This might be a case for implementing interpolation '+\
    683679              'between different meshes.'
    684         assert allclose(A.shape, self.vertex_values.shape), msg
     680        assert num.allclose(A.shape, self.vertex_values.shape), msg
    685681
    686682        self.set_values(A, location='vertices',
     
    718714                indices = range(len(self))
    719715               
    720             V = take(self.domain.get_centroid_coordinates(), indices)
     716            V = num.take(self.domain.get_centroid_coordinates(), indices)
    721717            self.set_values(f(V[:,0], V[:,1]),
    722718                            location=location,
     
    738734            # more robust and simple.
    739735           
    740             #values = reshape(values, (M,3))
     736            #values = num.reshape(values, (M,3))
    741737            #self.set_values(values,
    742738            #                location='vertices',
     
    782778
    783779
    784         points = ensure_numeric(points, Float)
    785         values = ensure_numeric(values, Float)
     780        points = ensure_numeric(points, num.Float)
     781        values = ensure_numeric(values, num.Float)
    786782
    787783        if location != 'vertices':
     
    915911        # Always return absolute indices
    916912        if mode is None or mode == 'max':
    917             i = argmax(V)
     913            i = num.argmax(V)
    918914        elif mode == 'min':   
    919             i = argmin(V)
     915            i = num.argmin(V)
    920916
    921917           
     
    11201116        """
    11211117       
    1122         from Numeric import take
    11231118
    11241119        # FIXME (Ole): I reckon we should have the option of passing a
     
    11451140            raise msg
    11461141
    1147         import types, Numeric
     1142        import types
    11481143        assert type(indices) in [types.ListType, types.NoneType,
    1149                                  Numeric.ArrayType],\
     1144                                 num.ArrayType],\
    11501145                                 'Indices must be a list or None'
    11511146
     
    11531148            if (indices ==  None):
    11541149                indices = range(len(self))
    1155             return take(self.centroid_values,indices)
     1150            return num.take(self.centroid_values,indices)
    11561151        elif location == 'edges':
    11571152            if (indices ==  None):
    11581153                indices = range(len(self))
    1159             return take(self.edge_values,indices)
     1154            return num.take(self.edge_values,indices)
    11601155        elif location == 'unique vertices':
    11611156            if (indices ==  None):
     
    11801175                    sum += self.vertex_values[triangle_id, vertex_id]
    11811176                vert_values.append(sum/len(triangles))
    1182             return Numeric.array(vert_values)
     1177            return num.array(vert_values)
    11831178        else:
    11841179            if (indices is None):
    11851180                indices = range(len(self))
    1186             return take(self.vertex_values, indices)
     1181            return num.take(self.vertex_values, indices)
    11871182
    11881183
     
    11981193        """
    11991194
    1200         from Numeric import array, Float
    12011195
    12021196        # Assert that A can be converted to a Numeric array of appropriate dim
    1203         A = ensure_numeric(A, Float)
     1197        A = ensure_numeric(A, num.Float)
    12041198
    12051199        # print 'SHAPE A', A.shape
     
    12751269        """
    12761270
    1277         from Numeric import concatenate, zeros, Float, Int, array, reshape
    1278 
    12791271
    12801272        if smooth is None:
     
    12861278
    12871279        if precision is None:
    1288             precision = Float
     1280            precision = num.Float
    12891281           
    12901282
     
    12951287            V = self.domain.get_triangles()
    12961288            N = self.domain.number_of_full_nodes # Ignore ghost nodes if any
    1297             A = zeros(N, Float)
     1289            A = num.zeros(N, num.Float)
    12981290            points = self.domain.get_nodes()           
    12991291           
  • anuga_core/source/anuga/abstract_2d_finite_volumes/region.py

    r5897 r6145  
    88# FIXME (DSG-DSG) add better comments
    99
    10 from Numeric import average
     10import Numeric as num
     11
     12
    1113class Region:
    1214    """Base class for modifying quantities based on a region.
     
    101103                values = Q.get_values(indices=self.build_indices(elements, domain),
    102104                                      location=self.location)
    103                 av = average(values)
     105                av = num.average(values)
    104106                if self.location == "vertices":
    105                     av = average(av)
     107                    av = num.average(av)
    106108                new_values = av + self.X   
    107109            else:
  • anuga_core/source/anuga/abstract_2d_finite_volumes/show_balanced_limiters.py

    r5897 r6145  
    1818
    1919from mesh_factory import rectangular
    20 from Numeric import array
    21    
     20
    2221
    2322######################
     
    7877domain.set_quantity('stage', Z)
    7978
    80 from Numeric import allclose
    81 
    8279#Evolve
    8380for t in domain.evolve(yieldstep = 0.1, finaltime = 30):
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_domain.py

    r6129 r6145  
    66from domain import *
    77from anuga.config import epsilon
    8 from Numeric import allclose, array, ones, Float
     8
     9import Numeric as num
    910
    1011
     
    9596        #Centroids
    9697        q = domain.get_conserved_quantities(0)
    97         assert allclose(q, [2., 2., 0.])
     98        assert num.allclose(q, [2., 2., 0.])
    9899
    99100        q = domain.get_conserved_quantities(1)
    100         assert allclose(q, [5., 5., 0.])
     101        assert num.allclose(q, [5., 5., 0.])
    101102
    102103        q = domain.get_conserved_quantities(2)
    103         assert allclose(q, [3., 3., 0.])
     104        assert num.allclose(q, [3., 3., 0.])
    104105
    105106        q = domain.get_conserved_quantities(3)
    106         assert allclose(q, [0., 0., 0.])
     107        assert num.allclose(q, [0., 0., 0.])
    107108
    108109
    109110        #Edges
    110111        q = domain.get_conserved_quantities(0, edge=0)
    111         assert allclose(q, [2.5, 2.5, 0.])
     112        assert num.allclose(q, [2.5, 2.5, 0.])
    112113        q = domain.get_conserved_quantities(0, edge=1)
    113         assert allclose(q, [2., 2., 0.])
     114        assert num.allclose(q, [2., 2., 0.])
    114115        q = domain.get_conserved_quantities(0, edge=2)
    115         assert allclose(q, [1.5, 1.5, 0.])
     116        assert num.allclose(q, [1.5, 1.5, 0.])
    116117
    117118        for i in range(3):
    118119            q = domain.get_conserved_quantities(1, edge=i)
    119             assert allclose(q, [5, 5, 0.])
     120            assert num.allclose(q, [5, 5, 0.])
    120121
    121122
    122123        q = domain.get_conserved_quantities(2, edge=0)
    123         assert allclose(q, [4.5, 4.5, 0.])
     124        assert num.allclose(q, [4.5, 4.5, 0.])
    124125        q = domain.get_conserved_quantities(2, edge=1)
    125         assert allclose(q, [4.5, 4.5, 0.])
     126        assert num.allclose(q, [4.5, 4.5, 0.])
    126127        q = domain.get_conserved_quantities(2, edge=2)
    127         assert allclose(q, [0., 0., 0.])
     128        assert num.allclose(q, [0., 0., 0.])
    128129
    129130
    130131        q = domain.get_conserved_quantities(3, edge=0)
    131         assert allclose(q, [3., 3., 0.])
     132        assert num.allclose(q, [3., 3., 0.])
    132133        q = domain.get_conserved_quantities(3, edge=1)
    133         assert allclose(q, [-1.5, -1.5, 0.])
     134        assert num.allclose(q, [-1.5, -1.5, 0.])
    134135        q = domain.get_conserved_quantities(3, edge=2)
    135         assert allclose(q, [-1.5, -1.5, 0.])
     136        assert num.allclose(q, [-1.5, -1.5, 0.])
    136137
    137138
     
    179180        Q = domain.create_quantity_from_expression(expression)
    180181
    181         assert allclose(Q.vertex_values, [[2,3,4], [6,6,6],
    182                                       [1,1,10], [-5, 4, 4]])
     182        assert num.allclose(Q.vertex_values, [[2,3,4], [6,6,6],
     183                                              [1,1,10], [-5, 4, 4]])
    183184
    184185        expression = '(xmomentum*xmomentum + ymomentum*ymomentum)**0.5'
     
    188189        Y = domain.quantities['ymomentum'].vertex_values
    189190
    190         assert allclose(Q.vertex_values, (X**2 + Y**2)**0.5)
     191        assert num.allclose(Q.vertex_values, (X**2 + Y**2)**0.5)
    191192
    192193
     
    314315        Q = domain.quantities['depth']
    315316
    316         assert allclose(Q.vertex_values, [[2,3,4], [6,6,6],
    317                                       [1,1,10], [-5, 4, 4]])
     317        assert num.allclose(Q.vertex_values, [[2,3,4], [6,6,6],
     318                                              [1,1,10], [-5, 4, 4]])
    318319
    319320
     
    344345
    345346
    346         A = array([[1,2,3], [5,5,-5], [0,0,9], [-6,3,3]], 'f')
    347         B = array([[2,4,4], [3,2,1], [6,-3,4], [4,5,-1]], 'f')
     347        A = num.array([[1,2,3], [5,5,-5], [0,0,9], [-6,3,3]], 'f')
     348        B = num.array([[2,4,4], [3,2,1], [6,-3,4], [4,5,-1]], 'f')
    348349       
    349350        #print A
     
    359360        domain.set_quantity('elevation', A)
    360361        domain.add_quantity('elevation', B)
    361         assert allclose(elevation.vertex_values, A+B)
     362        assert num.allclose(elevation.vertex_values, A+B)
    362363       
    363364        domain.add_quantity('elevation', 4)
    364         assert allclose(elevation.vertex_values, A+B+4)       
     365        assert num.allclose(elevation.vertex_values, A+B+4)       
    365366       
    366367       
     
    370371        domain.set_quantity('depth', 1.0)                                     
    371372        domain.add_quantity('depth', expression = 'stage - elevation')       
    372         assert allclose(depth.vertex_values, stage.vertex_values-elevation.vertex_values+1)
     373        assert num.allclose(depth.vertex_values, stage.vertex_values-elevation.vertex_values+1)
    373374               
    374375       
     
    376377        reference = 2*stage.vertex_values - depth.vertex_values
    377378        domain.add_quantity('stage', expression = 'stage - depth')               
    378         assert allclose(stage.vertex_values, reference)       
     379        assert num.allclose(stage.vertex_values, reference)       
    379380                                     
    380381
     
    388389       
    389390        domain.add_quantity('depth', f)
    390         assert allclose(stage.vertex_values, depth.vertex_values)               
     391        assert num.allclose(stage.vertex_values, depth.vertex_values)               
    391392         
    392393           
     
    458459        domain.check_integrity()
    459460
    460         assert allclose(domain.neighbours, [[-1,-2,-3]])
     461        assert num.allclose(domain.neighbours, [[-1,-2,-3]])
    461462
    462463
     
    547548                                      [0,0,9], [-6, 3, 3]])
    548549
    549         assert allclose( domain.quantities['stage'].centroid_values,
    550                          [2,5,3,0] )
     550        assert num.allclose( domain.quantities['stage'].centroid_values,
     551                             [2,5,3,0] )
    551552
    552553        domain.set_quantity('xmomentum', [[1,1,1], [2,2,2],
     
    560561
    561562        #First order extrapolation
    562         assert allclose( domain.quantities['stage'].vertex_values,
    563                          [[ 2.,  2.,  2.],
    564                           [ 5.,  5.,  5.],
    565                           [ 3.,  3.,  3.],
    566                           [ 0.,  0.,  0.]])
     563        assert num.allclose( domain.quantities['stage'].vertex_values,
     564                             [[ 2.,  2.,  2.],
     565                              [ 5.,  5.,  5.],
     566                              [ 3.,  3.,  3.],
     567                              [ 0.,  0.,  0.]])
    567568
    568569
     
    603604
    604605        for name in domain.conserved_quantities:
    605             domain.quantities[name].explicit_update = array([4.,3.,2.,1.])
    606             domain.quantities[name].semi_implicit_update = array([1.,1.,1.,1.])
     606            domain.quantities[name].explicit_update = num.array([4.,3.,2.,1.])
     607            domain.quantities[name].semi_implicit_update = num.array([1.,1.,1.,1.])
    607608
    608609
     
    611612        domain.update_conserved_quantities()
    612613
    613         sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
    614         denom = ones(4, Float)-domain.timestep*sem
     614        sem = num.array([1.,1.,1.,1.])/num.array([1, 2, 3, 4])
     615        denom = num.ones(4, num.Float)-domain.timestep*sem
    615616
    616617#        x = array([1, 2, 3, 4]) + array( [.4,.3,.2,.1] )
    617618#        x /= denom
    618619
    619         x = array([1., 2., 3., 4.])
     620        x = num.array([1., 2., 3., 4.])
    620621        x /= denom
    621         x += domain.timestep*array( [4,3,2,1] )
     622        x += domain.timestep*num.array( [4,3,2,1] )
    622623
    623624        for name in domain.conserved_quantities:
    624             assert allclose(domain.quantities[name].centroid_values, x)
     625            assert num.allclose(domain.quantities[name].centroid_values, x)
    625626
    626627
     
    654655                                      [0,0,9], [-6, 3, 3]])
    655656
    656         assert allclose( domain.quantities['stage'].centroid_values,
    657                          [2,5,3,0] )
     657        assert num.allclose( domain.quantities['stage'].centroid_values,
     658                             [2,5,3,0] )
    658659
    659660        domain.set_quantity('xmomentum', [[1,1,1], [2,2,2],
     
    667668
    668669        #First order extrapolation
    669         assert allclose( domain.quantities['stage'].vertex_values,
    670                          [[ 2.,  2.,  2.],
    671                           [ 5.,  5.,  5.],
    672                           [ 3.,  3.,  3.],
    673                           [ 0.,  0.,  0.]])
     670        assert num.allclose( domain.quantities['stage'].vertex_values,
     671                             [[ 2.,  2.,  2.],
     672                              [ 5.,  5.,  5.],
     673                              [ 3.,  3.,  3.],
     674                              [ 0.,  0.,  0.]])
    674675
    675676        domain.build_tagged_elements_dictionary({'mound':[0,1]})
     
    686687        from mesh_factory import rectangular
    687688        from shallow_water import Domain
    688         from Numeric import zeros, Float
    689689
    690690        #Create basic mesh
     
    703703        from mesh_factory import rectangular
    704704        from shallow_water import Domain
    705         from Numeric import zeros, Float
    706705
    707706        #Create basic mesh
     
    721720        domain.set_region([set_bottom_friction, set_top_friction])
    722721        #print domain.quantities['friction'].get_values()
    723         assert allclose(domain.quantities['friction'].get_values(),\
    724                         [[ 0.09,  0.09,  0.09],
    725                          [ 0.09,  0.09,  0.09],
    726                          [ 0.07,  0.07,  0.07],
    727                          [ 0.07,  0.07,  0.07],
    728                          [ 1.0,  1.0,  1.0],
    729                          [ 1.0,  1.0,  1.0]])
     722        assert num.allclose(domain.quantities['friction'].get_values(),\
     723                            [[ 0.09,  0.09,  0.09],
     724                             [ 0.09,  0.09,  0.09],
     725                             [ 0.07,  0.07,  0.07],
     726                             [ 0.07,  0.07,  0.07],
     727                             [ 1.0,  1.0,  1.0],
     728                             [ 1.0,  1.0,  1.0]])
    730729
    731730        domain.set_region([set_all_friction])
    732731        #print domain.quantities['friction'].get_values()
    733         assert allclose(domain.quantities['friction'].get_values(),
    734                         [[ 10.09, 10.09, 10.09],
    735                          [ 10.09, 10.09, 10.09],
    736                          [ 10.07, 10.07, 10.07],
    737                          [ 10.07, 10.07, 10.07],
    738                          [ 11.0,  11.0,  11.0],
    739                          [ 11.0,  11.0,  11.0]])
     732        assert num.allclose(domain.quantities['friction'].get_values(),
     733                            [[ 10.09, 10.09, 10.09],
     734                             [ 10.09, 10.09, 10.09],
     735                             [ 10.07, 10.07, 10.07],
     736                             [ 10.07, 10.07, 10.07],
     737                             [ 11.0,  11.0,  11.0],
     738                             [ 11.0,  11.0,  11.0]])
    740739
    741740
     
    746745        from mesh_factory import rectangular
    747746        from shallow_water import Domain
    748         from Numeric import zeros, Float
    749747
    750748        #Create basic mesh
     
    766764       
    767765        #print domain.quantities['friction'].get_values()
    768         assert allclose(domain.quantities['friction'].get_values(),\
    769                         [[ 0.09,  0.09,  0.09],
    770                          [ 0.09,  0.09,  0.09],
    771                          [ 0.07,  0.07,  0.07],
    772                          [ 0.07,  0.07,  0.07],
    773                          [ 1.0,  1.0,  1.0],
    774                          [ 1.0,  1.0,  1.0]])
     766        assert num.allclose(domain.quantities['friction'].get_values(),
     767                            [[ 0.09,  0.09,  0.09],
     768                             [ 0.09,  0.09,  0.09],
     769                             [ 0.07,  0.07,  0.07],
     770                             [ 0.07,  0.07,  0.07],
     771                             [ 1.0,  1.0,  1.0],
     772                             [ 1.0,  1.0,  1.0]])
    775773       
    776774        domain.set_region([set_bottom_friction, set_top_friction])
    777775        #print domain.quantities['friction'].get_values()
    778         assert allclose(domain.quantities['friction'].get_values(),\
    779                         [[ 0.09,  0.09,  0.09],
    780                          [ 0.09,  0.09,  0.09],
    781                          [ 0.07,  0.07,  0.07],
    782                          [ 0.07,  0.07,  0.07],
    783                          [ 1.0,  1.0,  1.0],
    784                          [ 1.0,  1.0,  1.0]])
     776        assert num.allclose(domain.quantities['friction'].get_values(),
     777                            [[ 0.09,  0.09,  0.09],
     778                             [ 0.09,  0.09,  0.09],
     779                             [ 0.07,  0.07,  0.07],
     780                             [ 0.07,  0.07,  0.07],
     781                             [ 1.0,  1.0,  1.0],
     782                             [ 1.0,  1.0,  1.0]])
    785783
    786784        domain.set_region([set_all_friction])
    787785        #print domain.quantities['friction'].get_values()
    788         assert allclose(domain.quantities['friction'].get_values(),
    789                         [[ 10.09, 10.09, 10.09],
    790                          [ 10.09, 10.09, 10.09],
    791                          [ 10.07, 10.07, 10.07],
    792                          [ 10.07, 10.07, 10.07],
    793                          [ 11.0,  11.0,  11.0],
    794                          [ 11.0,  11.0,  11.0]])
     786        assert num.allclose(domain.quantities['friction'].get_values(),
     787                            [[ 10.09, 10.09, 10.09],
     788                             [ 10.09, 10.09, 10.09],
     789                             [ 10.07, 10.07, 10.07],
     790                             [ 10.07, 10.07, 10.07],
     791                             [ 11.0,  11.0,  11.0],
     792                             [ 11.0,  11.0,  11.0]])
    795793
    796794#-------------------------------------------------------------
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_ermapper.py

    r5897 r6145  
    55
    66import ermapper_grids
    7 import Numeric
    87from os import remove
     8
     9import Numeric as num
     10
    911
    1012class Test_ERMapper(unittest.TestCase):
     
    1921        data_filename = 'test_write_ermapper_grid'
    2022       
    21         original_grid = Numeric.array([[0.0, 0.1, 1.0], [2.0, 3.0, 4.0]])
     23        original_grid = num.array([[0.0, 0.1, 1.0], [2.0, 3.0, 4.0]])
    2224
    2325        # Check that the function works when passing the filename without
     
    2527        ermapper_grids.write_ermapper_grid(data_filename, original_grid)
    2628        new_grid = ermapper_grids.read_ermapper_grid(data_filename)
    27         assert Numeric.allclose(original_grid, new_grid)
     29        assert num.allclose(original_grid, new_grid)
    2830
    2931        # Check that the function works when passing the filename with
     
    3133        ermapper_grids.write_ermapper_grid(header_filename, original_grid)
    3234        new_grid = ermapper_grids.read_ermapper_grid(header_filename)
    33         assert Numeric.allclose(original_grid, new_grid)
     35        assert num.allclose(original_grid, new_grid)
    3436
    3537        # Clean up created files
     
    4042        # Setup test data
    4143        filename = 'test_write_ermapper_grid'
    42         original_grid = Numeric.array([0.0, 0.1, 1.0, 2.0, 3.0, 4.0])
     44        original_grid = num.array([0.0, 0.1, 1.0, 2.0, 3.0, 4.0])
    4345
    4446        # Write test data
    45         ermapper_grids.write_ermapper_data(original_grid, filename, Numeric.Float64)
     47        ermapper_grids.write_ermapper_data(original_grid, filename, num.Float64)
    4648
    4749        # Read in the test data
    48         new_grid = ermapper_grids.read_ermapper_data(filename, Numeric.Float64)
     50        new_grid = ermapper_grids.read_ermapper_data(filename, num.Float64)
    4951
    5052        # Check that the test data that has been read in matches the original data
    51         assert Numeric.allclose(original_grid, new_grid)
     53        assert num.allclose(original_grid, new_grid)
    5254
    5355        # Clean up created files
     
    5759        # Setup test data
    5860        filename = 'test_write_ermapper_grid'
    59         original_grid = Numeric.array([0.0, 0.1, 1.0, 2.0, 3.0, 4.0])
     61        original_grid = num.array([0.0, 0.1, 1.0, 2.0, 3.0, 4.0])
    6062
    6163        # Write test data
     
    6668
    6769        # Check that the test data that has been read in matches the original data
    68         assert Numeric.allclose(original_grid, new_grid)
     70        assert num.allclose(original_grid, new_grid)
    6971
    7072        # Clean up created files
     
    7577
    7678        # setup test data
    77         original_grid = Numeric.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
     79        original_grid = num.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
    7880        # Write test data
    7981        ermapper_grids.write_ermapper_data(original_grid, data_filename)
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_general_mesh.py

    r5897 r6145  
    77
    88from anuga.config import epsilon
    9 from Numeric import allclose, array, ones, Float
    109from general_mesh import General_mesh
    1110from anuga.coordinate_transforms.geo_reference import Geo_reference
    1211
     12import Numeric as num
    1313
    1414
     
    2323    def test_get_vertex_coordinates(self):
    2424        from mesh_factory import rectangular
    25         from Numeric import zeros, Float
    2625
    2726        #Create basic mesh
     
    3029
    3130
    32         assert allclose(domain.get_nodes(), nodes)
     31        assert num.allclose(domain.get_nodes(), nodes)
    3332
    3433
     
    4140            for j in range(3):
    4241                k = triangles[i,j]  #Index of vertex j in triangle i
    43                 assert allclose(V[3*i+j,:], nodes[k])
     42                assert num.allclose(V[3*i+j,:], nodes[k])
    4443
    4544    def test_get_vertex_coordinates_with_geo_ref(self):
     
    5554        f = [4.0, 0.0]
    5655
    57         nodes = array([a, b, c, d, e, f])
     56        nodes = num.array([a, b, c, d, e, f])
    5857
    5958        nodes_absolute = geo.get_absolute(nodes)
    6059       
    6160        #bac, bce, ecf, dbe, daf, dae
    62         triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     61        triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    6362
    6463        domain = General_mesh(nodes, triangles,
    6564                       geo_reference = geo)
    6665        verts = domain.get_vertex_coordinates(triangle_id=0)       
    67         self.assert_(allclose(array([b,a,c]), verts))
     66        self.assert_(num.allclose(num.array([b,a,c]), verts))
    6867        verts = domain.get_vertex_coordinates(triangle_id=0)       
    69         self.assert_(allclose(array([b,a,c]), verts))
     68        self.assert_(num.allclose(num.array([b,a,c]), verts))
    7069        verts = domain.get_vertex_coordinates(triangle_id=0,
    7170                                              absolute=True)       
    72         self.assert_(allclose(array([nodes_absolute[1],
     71        self.assert_(num.allclose(num.array([nodes_absolute[1],
    7372                                     nodes_absolute[0],
    7473                                     nodes_absolute[2]]), verts))
    7574        verts = domain.get_vertex_coordinates(triangle_id=0,
    7675                                              absolute=True)       
    77         self.assert_(allclose(array([nodes_absolute[1],
     76        self.assert_(num.allclose(num.array([nodes_absolute[1],
    7877                                     nodes_absolute[0],
    7978                                     nodes_absolute[2]]), verts))
     
    8685        """
    8786        from mesh_factory import rectangular
    88         from Numeric import zeros, Float
    8987
    9088        #Create basic mesh
     
    9391
    9492
    95         assert allclose(domain.get_nodes(), nodes)
     93        assert num.allclose(domain.get_nodes(), nodes)
    9694
    9795
     
    104102            for j in range(3):
    105103                k = triangles[i,j]  #Index of vertex j in triangle i
    106                 assert allclose(V[j,:], nodes[k])
     104                assert num.allclose(V[j,:], nodes[k])
    107105
    108106
     
    114112        """
    115113        from mesh_factory import rectangular
    116         from Numeric import zeros, Float
    117114
    118115        #Create basic mesh
     
    121118
    122119        value = [7]
    123         assert allclose(domain.get_triangles(), triangles)
    124         assert allclose(domain.get_triangles([0,4]),
     120        assert num.allclose(domain.get_triangles(), triangles)
     121        assert num.allclose(domain.get_triangles([0,4]),
    125122                        [triangles[0], triangles[4]])
    126123       
     
    130127        """
    131128        from mesh_factory import rectangular
    132         from Numeric import zeros, Float, array
    133 
    134         a = [0.0, 0.0]
    135         b = [0.0, 2.0]
    136         c = [2.0, 0.0]
    137         d = [0.0, 4.0]
    138         e = [2.0, 2.0]
    139         f = [4.0, 0.0]
    140 
    141         nodes = array([a, b, c, d, e, f])
     129
     130        a = [0.0, 0.0]
     131        b = [0.0, 2.0]
     132        c = [2.0, 0.0]
     133        d = [0.0, 4.0]
     134        e = [2.0, 2.0]
     135        f = [4.0, 0.0]
     136
     137        nodes = num.array([a, b, c, d, e, f])
    142138        #bac, bce, ecf, dbe, daf, dae
    143         triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     139        triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    144140
    145141        domain1 = General_mesh(nodes, triangles)
     
    162158            #print count
    163159            #
    164             assert allclose(count, domain.number_of_triangles_per_node)
     160            assert num.allclose(count, domain.number_of_triangles_per_node)
    165161           
    166162            # Check indices
     
    196192        f = [4.0, 0.0]
    197193
    198         nodes = array([a, b, c, d, e, f])
     194        nodes = num.array([a, b, c, d, e, f])
    199195        #bac, bce, ecf, dbe, daf, dae
    200         triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     196        triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    201197
    202198        domain = General_mesh(nodes, triangles)
     
    204200        # One node
    205201        L = domain.get_triangles_and_vertices_per_node(node=2)
    206         assert allclose(L[0], [0, 2])
    207         assert allclose(L[1], [1, 1])
    208         assert allclose(L[2], [2, 1])
     202        assert num.allclose(L[0], [0, 2])
     203        assert num.allclose(L[1], [1, 1])
     204        assert num.allclose(L[2], [2, 1])
    209205
    210206        # All nodes
     
    213209        for i, Lref in enumerate(ALL):
    214210            L = domain.get_triangles_and_vertices_per_node(node=i)
    215             assert allclose(L, Lref)
     211            assert num.allclose(L, Lref)
    216212           
    217213
     
    224220        from mesh_factory import rectangular
    225221        from shallow_water import Domain
    226         from Numeric import zeros, Float
    227222
    228223        #Create basic mesh
     
    239234        from mesh_factory import rectangular
    240235        from shallow_water import Domain
    241         from Numeric import zeros, Float
    242236
    243237        #Create basic mesh
     
    273267        f = [4.0, 0.0]
    274268
    275         nodes = array([a, b, c, d, e, f])
     269        nodes = num.array([a, b, c, d, e, f])
    276270
    277271        nodes_absolute = geo.get_absolute(nodes)
    278272       
    279273        #bac, bce, ecf, dbe, daf, dae
    280         triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     274        triangles = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    281275
    282276        domain = General_mesh(nodes, triangles,
     
    310304        f = [4.0, 0.0]
    311305
    312         nodes = array([a, b, c, d, e, f])
     306        nodes = num.array([a, b, c, d, e, f])
    313307
    314308        nodes_absolute = geo.get_absolute(nodes)
    315309       
    316310        # max index is 5, use 5, expect success
    317         triangles = array([[1,5,2], [1,2,4], [4,2,5], [3,1,4]])
     311        triangles = num.array([[1,5,2], [1,2,4], [4,2,5], [3,1,4]])
    318312        General_mesh(nodes, triangles, geo_reference=geo)
    319313       
    320314        # max index is 5, use 6, expect assert failure
    321         triangles = array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]])
     315        triangles = num.array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]])
    322316        self.failUnlessRaises(AssertionError, General_mesh,
    323317                              nodes, triangles, geo_reference=geo)
    324318       
    325319        # max index is 5, use 10, expect assert failure
    326         triangles = array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]])
     320        triangles = num.array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]])
    327321        self.failUnlessRaises(AssertionError, General_mesh,
    328322                              nodes, triangles, geo_reference=geo)
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_generic_boundary_conditions.py

    r5897 r6145  
    66from generic_boundary_conditions import *
    77from anuga.config import epsilon
    8 from Numeric import allclose, array
     8
     9import Numeric as num
    910
    1011
     
    4445
    4546        q = Bd.evaluate()
    46         assert allclose(q, x)
     47        assert num.allclose(q, x)
    4748
    4849
     
    9899        q = T.evaluate(0, 2)  #Vol=0, edge=2
    99100
    100         assert allclose(q, [1.5, 2.5])
     101        assert num.allclose(q, [1.5, 2.5])
    101102
    102103
     
    175176
    176177        #Check that midpoint coordinates at boundary are correctly computed
    177         assert allclose( F.midpoint_coordinates,
    178                          [[1.0, 0.0], [0.0, 1.0], [3.0, 0.0],
    179                           [3.0, 1.0], [1.0, 3.0], [0.0, 3.0]])
     178        assert num.allclose( F.midpoint_coordinates,
     179                             [[1.0, 0.0], [0.0, 1.0], [3.0, 0.0],
     180                              [3.0, 1.0], [1.0, 3.0], [0.0, 3.0]])
    180181
    181182        #assert allclose(F.midpoint_coordinates[(3,2)], [0.0, 3.0])
     
    193194        domain.time = 5*30/2  #A quarter way through first step
    194195        q = F.evaluate()
    195         assert allclose(q, [1.0/4, sin(2*pi/10)/4])
     196        assert num.allclose(q, [1.0/4, sin(2*pi/10)/4])
    196197
    197198
    198199        domain.time = 2.5*5*60  #Half way between steps 2 and 3
    199200        q = F.evaluate()
    200         assert allclose(q, [2.5, (sin(2*2*pi/10) + sin(3*2*pi/10))/2])
     201        assert num.allclose(q, [2.5, (sin(2*2*pi/10) + sin(3*2*pi/10))/2])
    201202
    202203
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_ghost.py

    r5897 r6145  
    66from domain import *
    77from anuga.config import epsilon
    8 from Numeric import allclose, array, ones, Float
    9 
    10 
    118
    129
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_neighbour_mesh.py

    r6003 r6145  
    1313from mesh_factory import rectangular
    1414from anuga.config import epsilon
    15 from Numeric import allclose, array, Int
    1615
    1716from anuga.coordinate_transforms.geo_reference import Geo_reference
     
    1918from anuga.utilities.numerical_tools import ensure_numeric
    2019
     20import Numeric as num
     21
     22
    2123def distance(x, y):
    22     return sqrt( sum( (array(x)-array(y))**2 ))
     24    return sqrt( sum( (num.array(x)-num.array(y))**2 ))
    2325
    2426class Test_Mesh(unittest.TestCase):
     
    6365        #Normals
    6466        normals = mesh.get_normals()
    65         assert allclose(normals[0, 0:2], [3.0/5, 4.0/5])
    66         assert allclose(normals[0, 2:4], [-1.0, 0.0])
    67         assert allclose(normals[0, 4:6], [0.0, -1.0])
    68 
    69         assert allclose(mesh.get_normal(0,0), [3.0/5, 4.0/5])
    70         assert allclose(mesh.get_normal(0,1), [-1.0, 0.0])
    71         assert allclose(mesh.get_normal(0,2), [0.0, -1.0])
     67        assert num.allclose(normals[0, 0:2], [3.0/5, 4.0/5])
     68        assert num.allclose(normals[0, 2:4], [-1.0, 0.0])
     69        assert num.allclose(normals[0, 4:6], [0.0, -1.0])
     70
     71        assert num.allclose(mesh.get_normal(0,0), [3.0/5, 4.0/5])
     72        assert num.allclose(mesh.get_normal(0,1), [-1.0, 0.0])
     73        assert num.allclose(mesh.get_normal(0,2), [0.0, -1.0])
    7274
    7375        #Edge lengths
    74         assert allclose(mesh.edgelengths[0], [5.0, 3.0, 4.0])
     76        assert num.allclose(mesh.edgelengths[0], [5.0, 3.0, 4.0])
    7577
    7678
     
    8183
    8284        V = mesh.get_vertex_coordinates()
    83         assert allclose(V, [ [0.0, 0.0],
     85        assert num.allclose(V, [ [0.0, 0.0],
    8486                             [4.0, 0.0],
    8587                             [0.0, 3.0] ])
    8688
    8789        V0 = mesh.get_vertex_coordinate(0, 0)
    88         assert allclose(V0, [0.0, 0.0])
     90        assert num.allclose(V0, [0.0, 0.0])
    8991
    9092        V1 = mesh.get_vertex_coordinate(0, 1)
    91         assert allclose(V1, [4.0, 0.0])
     93        assert num.allclose(V1, [4.0, 0.0])
    9294
    9395        V2 = mesh.get_vertex_coordinate(0, 2)
    94         assert allclose(V2, [0.0, 3.0])
     96        assert num.allclose(V2, [0.0, 3.0])
    9597
    9698
     
    237239
    238240        mesh = Mesh(points, vertices,use_inscribed_circle=False)
    239         assert allclose(mesh.radii[0],sqrt(3.0)/3),'Steve''s doesn''t work'
     241        assert num.allclose(mesh.radii[0],sqrt(3.0)/3),'Steve''s doesn''t work'
    240242
    241243        mesh = Mesh(points, vertices,use_inscribed_circle=True)
    242         assert allclose(mesh.radii[0],sqrt(3.0)/3),'inscribed circle doesn''t work'
     244        assert num.allclose(mesh.radii[0],sqrt(3.0)/3),'inscribed circle doesn''t work'
    243245
    244246    def test_inscribed_circle_rightangle_triangle(self):
     
    252254
    253255        mesh = Mesh(points, vertices,use_inscribed_circle=False)
    254         assert allclose(mesh.radii[0],5.0/6),'Steve''s doesn''t work'
     256        assert num.allclose(mesh.radii[0],5.0/6),'Steve''s doesn''t work'
    255257
    256258        mesh = Mesh(points, vertices,use_inscribed_circle=True)
    257         assert allclose(mesh.radii[0],1.0),'inscribed circle doesn''t work'
     259        assert num.allclose(mesh.radii[0],1.0),'inscribed circle doesn''t work'
    258260
    259261
     
    269271        assert mesh.areas[0] == 2.0
    270272
    271         assert allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
     273        assert num.allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
    272274
    273275
     
    303305        assert mesh.edgelengths[1,2] == sqrt(8.0)
    304306
    305         assert allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
    306         assert allclose(mesh.centroid_coordinates[1], [4.0/3, 4.0/3])
    307         assert allclose(mesh.centroid_coordinates[2], [8.0/3, 2.0/3])
    308         assert allclose(mesh.centroid_coordinates[3], [2.0/3, 8.0/3])
     307        assert num.allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
     308        assert num.allclose(mesh.centroid_coordinates[1], [4.0/3, 4.0/3])
     309        assert num.allclose(mesh.centroid_coordinates[2], [8.0/3, 2.0/3])
     310        assert num.allclose(mesh.centroid_coordinates[3], [2.0/3, 8.0/3])
    309311
    310312    def test_mesh_and_neighbours(self):
     
    698700        """
    699701        from mesh_factory import rectangular
    700         from Numeric import zeros, Float
    701702
    702703        #Create basic mesh
     
    717718        from mesh_factory import rectangular
    718719        #from mesh import Mesh
    719         from Numeric import zeros, Float
    720720
    721721        #Create basic mesh
     
    727727
    728728        assert len(P) == 8
    729         assert allclose(P, [[0.0, 0.0], [0.5, 0.0], [1.0, 0.0],
    730                             [1.0, 0.5], [1.0, 1.0], [0.5, 1.0],
    731                             [0.0, 1.0], [0.0, 0.5]])
     729        assert num.allclose(P, [[0.0, 0.0], [0.5, 0.0], [1.0, 0.0],
     730                                [1.0, 0.5], [1.0, 1.0], [0.5, 1.0],
     731                                [0.0, 1.0], [0.0, 0.5]])
    732732        for p in points:
    733733            #print p, P
     
    736736
    737737    def test_boundary_polygon_II(self):
    738         from Numeric import zeros, Float
    739        
    740738
    741739        #Points
     
    764762
    765763        assert len(P) == 8
    766         assert allclose(P, [a, d, f, i, h, e, c, b])
     764        assert num.allclose(P, [a, d, f, i, h, e, c, b])
    767765
    768766        for p in points:
     
    774772        """Same as II but vertices ordered differently
    775773        """
    776 
    777         from Numeric import zeros, Float
    778774
    779775
     
    804800
    805801        assert len(P) == 8
    806         assert allclose(P, [a, d, f, i, h, e, c, b])
     802        assert num.allclose(P, [a, d, f, i, h, e, c, b])
    807803
    808804        for p in points:
     
    815811        is partitioned using pymetis.
    816812        """
    817 
    818         from Numeric import zeros, Float
    819813
    820814
     
    847841       
    848842        # Note that point e appears twice!
    849         assert allclose(P, [a, d, f, e, g, h, e, c, b])
     843        assert num.allclose(P, [a, d, f, e, g, h, e, c, b])
    850844
    851845        for p in points:
     
    864858        """
    865859
    866         from Numeric import zeros, Float
    867860        from mesh_factory import rectangular       
    868861
     
    907900       
    908901        """
    909         from Numeric import zeros, Float
    910        
    911902
    912903        #Points
     
    955946       
    956947        assert len(P) == 8
    957         assert allclose(P, [a, d, f, i, h, e, c, b])
    958         assert allclose(P, [(0.0, 0.0), (0.5, 0.0), (1.0, 0.0), (1.5, 0.5), (1.0, 1.0), (0.5, 0.5), (0.0, 1.0), (0.0, 0.5)])
     948        assert num.allclose(P, [a, d, f, i, h, e, c, b])
     949        assert num.allclose(P, [(0.0, 0.0), (0.5, 0.0), (1.0, 0.0), (1.5, 0.5), (1.0, 1.0), (0.5, 0.5), (0.0, 1.0), (0.0, 0.5)])
    959950       
    960951
     
    11011092                  [  35406.3359375 ,  79332.9140625 ]]
    11021093
    1103         scaled_points = ensure_numeric(points, Int)/1000  # Simplify for ease of interpretation
     1094        scaled_points = ensure_numeric(points, num.Int)/1000  # Simplify for ease of interpretation
    11041095
    11051096        triangles = [[ 0, 1, 2],
     
    11421133            assert is_inside_polygon(p, P)           
    11431134
    1144         assert allclose(P, Pref)   
     1135        assert num.allclose(P, Pref)   
    11451136
    11461137    def test_lone_vertices(self):
     
    11991190        boundary_polygon = mesh.get_boundary_polygon()
    12001191
    1201         assert allclose(absolute_points, boundary_polygon)
     1192        assert num.allclose(absolute_points, boundary_polygon)
    12021193
    12031194    def test_get_triangle_containing_point(self):
     
    12461237
    12471238        neighbours = mesh.get_triangle_neighbours(0)
    1248         assert allclose(neighbours, [-1,1,-1])
     1239        assert num.allclose(neighbours, [-1,1,-1])
    12491240        neighbours = mesh.get_triangle_neighbours(-10)
    12501241        assert neighbours == []
     
    12951286            for x in L:
    12961287                if x.triangle_id % 2 == 0:
    1297                     assert allclose(x.length, ceiling-y_line)
     1288                    assert num.allclose(x.length, ceiling-y_line)
    12981289                else:
    1299                     assert allclose(x.length, y_line-floor)               
     1290                    assert num.allclose(x.length, y_line-floor)               
    13001291
    13011292               
    1302                 assert allclose(x.normal, [0,-1])
    1303 
    1304                 assert allclose(x.segment[1][0], x.segment[0][0] + x.length)
    1305                 assert allclose(x.segment[0][1], y_line)
    1306                 assert allclose(x.segment[1][1], y_line)               
     1293                assert num.allclose(x.normal, [0,-1])
     1294
     1295                assert num.allclose(x.segment[1][0], x.segment[0][0] + x.length)
     1296                assert num.allclose(x.segment[0][1], y_line)
     1297                assert num.allclose(x.segment[1][1], y_line)               
    13071298
    13081299                assert x.triangle_id in intersected_triangles
     
    13111302
    13121303            msg = 'Segments do not add up'
    1313             assert allclose(total_length, 2), msg
     1304            assert num.allclose(total_length, 2), msg
    13141305           
    13151306
     
    13461337        total_length = 0
    13471338        for x in L:
    1348             assert allclose(x.length, 1.0)
    1349             assert allclose(x.normal, [0,-1])
    1350 
    1351             assert allclose(x.segment[1][0], x.segment[0][0] + x.length)
    1352             assert allclose(x.segment[0][1], y_line)
    1353             assert allclose(x.segment[1][1], y_line)                           
     1339            assert num.allclose(x.length, 1.0)
     1340            assert num.allclose(x.normal, [0,-1])
     1341
     1342            assert num.allclose(x.segment[1][0], x.segment[0][0] + x.length)
     1343            assert num.allclose(x.segment[0][1], y_line)
     1344            assert num.allclose(x.segment[1][1], y_line)                           
    13541345
    13551346
     
    13601351
    13611352        msg = 'Segments do not add up'
    1362         assert allclose(total_length, 2), msg
     1353        assert num.allclose(total_length, 2), msg
    13631354       
    13641355
     
    14001391        for x in L:
    14011392            if x.triangle_id == 1:
    1402                 assert allclose(x.length, 1)       
    1403                 assert allclose(x.normal, [0, -1])
     1393                assert num.allclose(x.length, 1)       
     1394                assert num.allclose(x.normal, [0, -1])
    14041395               
    14051396            if x.triangle_id == 5:
    1406                 assert allclose(x.length, 0.5)
    1407                 assert allclose(x.normal, [0, -1])
     1397                assert num.allclose(x.length, 0.5)
     1398                assert num.allclose(x.normal, [0, -1])
    14081399
    14091400
     
    14131404
    14141405        msg = 'Segments do not add up'
    1415         assert allclose(total_length, 1.5), msg           
     1406        assert num.allclose(total_length, 1.5), msg           
    14161407
    14171408
     
    14471438        total_length = 0
    14481439        for i, x in enumerate(L):
    1449             assert allclose(x.length, s2)
    1450             assert allclose(x.normal, [-s2, -s2])
    1451             assert allclose(sum(x.normal**2), 1)
     1440            assert num.allclose(x.length, s2)
     1441            assert num.allclose(x.normal, [-s2, -s2])
     1442            assert num.allclose(sum(x.normal**2), 1)
    14521443           
    14531444            assert x.triangle_id in intersected_triangles
     
    14561447
    14571448        msg = 'Segments do not add up'
    1458         assert allclose(total_length, 4*s2), msg
     1449        assert num.allclose(total_length, 4*s2), msg
    14591450
    14601451
     
    14711462        total_length = 0
    14721463        for i, x in enumerate(L):
    1473             assert allclose(x.length, s2)
    1474             assert allclose(x.normal, [s2, s2])
    1475             assert allclose(sum(x.normal**2), 1)
     1464            assert num.allclose(x.length, s2)
     1465            assert num.allclose(x.normal, [s2, s2])
     1466            assert num.allclose(sum(x.normal**2), 1)
    14761467           
    14771468            assert x.triangle_id in intersected_triangles
     
    14801471
    14811472        msg = 'Segments do not add up'
    1482         assert allclose(total_length, 4*s2), msg                   
     1473        assert num.allclose(total_length, 4*s2), msg                   
    14831474
    14841475
     
    14961487        total_length = 0
    14971488        for i, x in enumerate(L):
    1498             assert allclose(x.length, 2*s2)
    1499             assert allclose(x.normal, [-s2, s2])
    1500             assert allclose(sum(x.normal**2), 1)
     1489            assert num.allclose(x.length, 2*s2)
     1490            assert num.allclose(x.normal, [-s2, s2])
     1491            assert num.allclose(sum(x.normal**2), 1)
    15011492           
    15021493            assert x.triangle_id in intersected_triangles
     
    15051496
    15061497        msg = 'Segments do not add up'
    1507         assert allclose(total_length, 4*s2), msg                       
     1498        assert num.allclose(total_length, 4*s2), msg                       
    15081499
    15091500
     
    15201511        total_length = 0
    15211512        for i, x in enumerate(L):
    1522             assert allclose(x.length, 2*s2)
    1523             assert allclose(x.normal, [s2, -s2])
    1524             assert allclose(sum(x.normal**2), 1)
     1513            assert num.allclose(x.length, 2*s2)
     1514            assert num.allclose(x.normal, [s2, -s2])
     1515            assert num.allclose(sum(x.normal**2), 1)
    15251516           
    15261517            assert x.triangle_id in intersected_triangles
     
    15291520
    15301521        msg = 'Segments do not add up'
    1531         assert allclose(total_length, 4*s2), msg                       
     1522        assert num.allclose(total_length, 4*s2), msg                       
    15321523
    15331524
     
    15451536        total_length = 0
    15461537        for i, x in enumerate(L):
    1547             assert allclose(x.length, s2)
    1548             assert allclose(x.normal, [-s2, -s2])
    1549             assert allclose(sum(x.normal**2), 1)
     1538            assert num.allclose(x.length, s2)
     1539            assert num.allclose(x.normal, [-s2, -s2])
     1540            assert num.allclose(sum(x.normal**2), 1)
    15501541           
    15511542            assert x.triangle_id in intersected_triangles
     
    15541545
    15551546        msg = 'Segments do not add up'
    1556         assert allclose(total_length, 2*s2), msg
     1547        assert num.allclose(total_length, 2*s2), msg
    15571548
    15581549
     
    15671558        total_length = 0
    15681559        for i, x in enumerate(L):
    1569             assert allclose(x.normal, [-s2, -s2])
    1570             assert allclose(sum(x.normal**2), 1)
     1560            assert num.allclose(x.normal, [-s2, -s2])
     1561            assert num.allclose(sum(x.normal**2), 1)
    15711562
    15721563            msg = 'Triangle %d' %x.triangle_id + ' is not in %s' %(intersected_triangles)
     
    16031594        assert len(L) == 1
    16041595        assert L[0].triangle_id == 3
    1605         assert allclose(L[0].length, 0.5)       
    1606         assert allclose(L[0].normal, [-1,0])               
     1596        assert num.allclose(L[0].length, 0.5)       
     1597        assert num.allclose(L[0].normal, [-1,0])               
    16071598
    16081599
     
    16151606        assert len(L) == 1
    16161607        assert L[0].triangle_id == 3
    1617         assert allclose(L[0].length, 0.4)
    1618         assert allclose(L[0].normal, [-1,0])
     1608        assert num.allclose(L[0].length, 0.4)
     1609        assert num.allclose(L[0].normal, [-1,0])
    16191610
    16201611        intersected_triangles = [3]
     
    16281619        assert len(L) == 1
    16291620        assert L[0].triangle_id == 3
    1630         assert allclose(L[0].length, 0.4)
    1631         assert allclose(L[0].normal, [1,0])               
     1621        assert num.allclose(L[0].length, 0.4)
     1622        assert num.allclose(L[0].normal, [1,0])               
    16321623       
    16331624
     
    16631654        for x in L:
    16641655            if x.triangle_id == 3:
    1665                 assert allclose(x.length, 0.5)       
    1666                 assert allclose(x.normal, [-1,0])
     1656                assert num.allclose(x.length, 0.5)       
     1657                assert num.allclose(x.normal, [-1,0])
    16671658               
    16681659            if x.triangle_id == 2:
    1669                 assert allclose(x.length, s2)
    1670                 assert allclose(x.normal, [-s2,-s2])
     1660                assert num.allclose(x.length, s2)
     1661                assert num.allclose(x.normal, [-s2,-s2])
    16711662
    16721663
     
    17011692        for x in L:
    17021693            if x.triangle_id == 3:
    1703                 assert allclose(x.length, 0.5)       
    1704                 assert allclose(x.normal, [-1,0])
     1694                assert num.allclose(x.length, 0.5)       
     1695                assert num.allclose(x.normal, [-1,0])
    17051696               
    17061697            if x.triangle_id == 2:
    17071698                msg = str(x.length)
    1708                 assert allclose(x.length, s2), msg
    1709                 assert allclose(x.normal, [-s2,-s2])
     1699                assert num.allclose(x.length, s2), msg
     1700                assert num.allclose(x.normal, [-s2,-s2])
    17101701
    17111702            if x.triangle_id == 5:
    1712                 segvec = array([line[2][0]-1,
    1713                                 line[2][1]-1])
     1703                segvec = num.array([line[2][0]-1,
     1704                                    line[2][1]-1])
    17141705                msg = str(x.length)
    1715                 assert allclose(x.length, sqrt(sum(segvec**2))), msg
    1716                 assert allclose(x.normal, [-s2,-s2])                                               
     1706                assert num.allclose(x.length, sqrt(sum(segvec**2))), msg
     1707                assert num.allclose(x.normal, [-s2,-s2])                                               
    17171708
    17181709
     
    17521743        for x in L:
    17531744            if x.triangle_id == 3:
    1754                 assert allclose(x.length, 0.5)       
    1755                 assert allclose(x.normal, [-1,0])
     1745                assert num.allclose(x.length, 0.5)       
     1746                assert num.allclose(x.normal, [-1,0])
    17561747               
    17571748            if x.triangle_id == 2:
    17581749                msg = str(x.length)
    1759                 assert allclose(x.length, s2), msg
    1760                 assert allclose(x.normal, [-s2,-s2])
     1750                assert num.allclose(x.length, s2), msg
     1751                assert num.allclose(x.normal, [-s2,-s2])
    17611752
    17621753            if x.triangle_id == 5:
    17631754                if x.segment == ((1.0, 1.0), (1.25, 0.75)):                   
    1764                     segvec = array([line[2][0]-1,
    1765                                     line[2][1]-1])
     1755                    segvec = num.array([line[2][0]-1,
     1756                                        line[2][1]-1])
    17661757                    msg = str(x.length)
    1767                     assert allclose(x.length, sqrt(sum(segvec**2))), msg
    1768                     assert allclose(x.normal, [-s2,-s2])
     1758                    assert num.allclose(x.length, sqrt(sum(segvec**2))), msg
     1759                    assert num.allclose(x.normal, [-s2,-s2])
    17691760                elif x.segment == ((1.25, 0.75), (1.5, 1.0)):
    1770                     segvec = array([1.5-line[2][0],
    1771                                     1.0-line[2][1]])
     1761                    segvec = num.array([1.5-line[2][0],
     1762                                        1.0-line[2][1]])
    17721763                   
    1773                     assert allclose(x.length, sqrt(sum(segvec**2))), msg
    1774                     assert allclose(x.normal, [s2,-s2])
     1764                    assert num.allclose(x.length, sqrt(sum(segvec**2))), msg
     1765                    assert num.allclose(x.normal, [s2,-s2])
    17751766                else:
    17761767                    msg = 'Unknow segment: %s' %x.segment
     
    17801771                   
    17811772            if x.triangle_id == 6:
    1782                 assert allclose(x.normal, [s2,-s2])
    1783                 assert allclose(x.segment, ((1.5, 1.0), (2, 1.5)))
     1773                assert num.allclose(x.normal, [s2,-s2])
     1774                assert num.allclose(x.segment, ((1.5, 1.0), (2, 1.5)))
    17841775
    17851776
     
    17911782      #xi1 = line[1][0]
    17921783      #eta1 = line[1][1]
    1793       #linevector = array([xi1-xi0, eta1-eta0])
     1784      #linevector = num.array([xi1-xi0, eta1-eta0])
    17941785      #linelength = sqrt(sum(linevector**2))
    17951786      #
     
    18471838            ref_length = line[1][1] - line[0][1]
    18481839            #print ref_length, total_length
    1849             assert allclose(total_length, ref_length)
     1840            assert num.allclose(total_length, ref_length)
    18501841
    18511842
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_pmesh2domain.py

    r5897 r6145  
    33
    44import unittest
    5 
    6 from Numeric import allclose, array
    7 
    85
    96#from anuga.pyvolution.pmesh2domain import *
     
    1613from anuga.coordinate_transforms.geo_reference import Geo_reference
    1714from anuga.pmesh.mesh import importMeshFromFile
     15
     16import Numeric as num
     17
    1818
    1919class Test_pmesh2domain(unittest.TestCase):
     
    6666
    6767         tags = {}
    68          b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
    69          b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
    70          b3 =  Dirichlet_boundary(conserved_quantities = array([2.0]))
     68         b1 =  Dirichlet_boundary(conserved_quantities = num.array([0.0]))
     69         b2 =  Dirichlet_boundary(conserved_quantities = num.array([1.0]))
     70         b3 =  Dirichlet_boundary(conserved_quantities = num.array([2.0]))
    7171         tags["1"] = b1
    7272         tags["2"] = b2
     
    8080         answer = [[0., 8., 0.],
    8181                   [0., 10., 8.]]
    82          assert allclose(domain.quantities['elevation'].vertex_values,
    83                         answer)
     82         assert num.allclose(domain.quantities['elevation'].vertex_values,
     83                             answer)
    8484
    8585         #print domain.quantities['stage'].vertex_values
    8686         answer = [[0., 12., 10.],
    8787                   [0., 10., 12.]]
    88          assert allclose(domain.quantities['stage'].vertex_values,
    89                         answer)
     88         assert num.allclose(domain.quantities['stage'].vertex_values,
     89                             answer)
    9090
    9191         #print domain.quantities['friction'].vertex_values
    9292         answer = [[0.01, 0.04, 0.03],
    9393                   [0.01, 0.02, 0.04]]
    94          assert allclose(domain.quantities['friction'].vertex_values,
    95                         answer)
    96 
    97          #print domain.quantities['friction'].vertex_values
    98          assert allclose(domain.tagged_elements['dsg'][0],0)
    99          assert allclose(domain.tagged_elements['ole nielsen'][0],1)
     94         assert num.allclose(domain.quantities['friction'].vertex_values,
     95                             answer)
     96
     97         #print domain.quantities['friction'].vertex_values
     98         assert num.allclose(domain.tagged_elements['dsg'][0],0)
     99         assert num.allclose(domain.tagged_elements['ole nielsen'][0],1)
    100100
    101101         self.failUnless( domain.boundary[(1, 0)]  == '1',
     
    159159       
    160160         tags = {}
    161          b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
    162          b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
    163          b3 =  Dirichlet_boundary(conserved_quantities = array([2.0]))
     161         b1 =  Dirichlet_boundary(conserved_quantities = num.array([0.0]))
     162         b2 =  Dirichlet_boundary(conserved_quantities = num.array([1.0]))
     163         b3 =  Dirichlet_boundary(conserved_quantities = num.array([2.0]))
    164164         tags["1"] = b1
    165165         tags["2"] = b2
     
    174174         answer = [[0., 8., 0.],
    175175                   [0., 10., 8.]]
    176          assert allclose(domain.quantities['elevation'].vertex_values,
    177                         answer)
     176         assert num.allclose(domain.quantities['elevation'].vertex_values,
     177                             answer)
    178178
    179179         #print domain.quantities['stage'].vertex_values
    180180         answer = [[0., 12., 10.],
    181181                   [0., 10., 12.]]
    182          assert allclose(domain.quantities['stage'].vertex_values,
    183                         answer)
     182         assert num.allclose(domain.quantities['stage'].vertex_values,
     183                             answer)
    184184
    185185         #print domain.quantities['friction'].vertex_values
    186186         answer = [[0.01, 0.04, 0.03],
    187187                   [0.01, 0.02, 0.04]]
    188          assert allclose(domain.quantities['friction'].vertex_values,
    189                         answer)
    190 
    191          #print domain.quantities['friction'].vertex_values
    192          assert allclose(domain.tagged_elements['dsg'][0],0)
    193          assert allclose(domain.tagged_elements['ole nielsen'][0],1)
     188         assert num.allclose(domain.quantities['friction'].vertex_values,
     189                             answer)
     190
     191         #print domain.quantities['friction'].vertex_values
     192         assert num.allclose(domain.tagged_elements['dsg'][0],0)
     193         assert num.allclose(domain.tagged_elements['ole nielsen'][0],1)
    194194
    195195         self.failUnless( domain.boundary[(1, 0)]  == '1',
     
    228228         #domain.set_tag_dict(tag_dict)
    229229         #Boundary tests
    230          b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
    231          b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
    232          b3 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
     230         b1 =  Dirichlet_boundary(conserved_quantities = num.array([0.0]))
     231         b2 =  Dirichlet_boundary(conserved_quantities = num.array([1.0]))
     232         b3 =  Dirichlet_boundary(conserved_quantities = num.array([1.0]))
    233233         #test adding a boundary
    234234         tags = {}
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_quantity.py

    r6131 r6145  
    77from quantity import *
    88from anuga.config import epsilon
    9 from Numeric import allclose, array, ones, Float
    109
    1110from anuga.fit_interpolate.fit import fit_to_mesh
     
    1615from anuga.utilities.polygon import *
    1716
     17import Numeric as num
     18
     19
    1820#Aux for fit_interpolate.fit example
    1921def linear_function(point):
    20     point = array(point)
     22    point = num.array(point)
    2123    return point[:,0]+point[:,1]
    2224
     
    6365
    6466        quantity = Quantity(self.mesh1, [[1,2,3]])
    65         assert allclose(quantity.vertex_values, [[1.,2.,3.]])
     67        assert num.allclose(quantity.vertex_values, [[1.,2.,3.]])
    6668
    6769        try:
     
    8486
    8587        quantity = Quantity(self.mesh1)
    86         assert allclose(quantity.vertex_values, [[0.,0.,0.]])
    87 
    88 
    89         quantity = Quantity(self.mesh4)
    90         assert allclose(quantity.vertex_values, [[0.,0.,0.], [0.,0.,0.],
    91                                                  [0.,0.,0.], [0.,0.,0.]])
     88        assert num.allclose(quantity.vertex_values, [[0.,0.,0.]])
     89
     90
     91        quantity = Quantity(self.mesh4)
     92        assert num.allclose(quantity.vertex_values, [[0.,0.,0.], [0.,0.,0.],
     93                                                     [0.,0.,0.], [0.,0.,0.]])
    9294
    9395
    9496    def test_interpolation(self):
    9597        quantity = Quantity(self.mesh1, [[1,2,3]])
    96         assert allclose(quantity.centroid_values, [2.0]) #Centroid
    97 
    98         assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5]])
     98        assert num.allclose(quantity.centroid_values, [2.0]) #Centroid
     99
     100        assert num.allclose(quantity.edge_values, [[2.5, 2.0, 1.5]])
    99101
    100102
     
    102104        quantity = Quantity(self.mesh4,
    103105                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
    104         assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
     106        assert num.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
    105107
    106108
     
    108110
    109111        #print quantity.vertex_values
    110         assert allclose(quantity.vertex_values, [[3.5, -1.0, 3.5],
    111                                                  [3.+2./3, 6.+2./3, 4.+2./3],
     112        assert num.allclose(quantity.vertex_values, [[3.5, -1.0, 3.5],
     113                                                     [3.+2./3, 6.+2./3, 4.+2./3],
    112114                                                 [4.6, 3.4, 1.],
    113115                                                 [-5.0, 1.0, 4.0]])
    114116
    115117        #print quantity.edge_values
    116         assert allclose(quantity.edge_values, [[1.25, 3.5, 1.25],
    117                                                [5. + 2/3.0, 4.0 + 1.0/6, 5.0 + 1.0/6],
    118                                                [2.2, 2.8, 4.0],
    119                                                [2.5, -0.5, -2.0]])
     118        assert num.allclose(quantity.edge_values, [[1.25, 3.5, 1.25],
     119                                                   [5. + 2/3.0, 4.0 + 1.0/6, 5.0 + 1.0/6],
     120                                                   [2.2, 2.8, 4.0],
     121                                                   [2.5, -0.5, -2.0]])
    120122
    121123
     
    128130        quantity = Quantity(self.mesh4,
    129131                                      [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
    130         assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroids
     132        assert num.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroids
    131133
    132134        v = quantity.get_maximum_value()
     
    148150
    149151        v = quantity.get_values(interpolation_points = [[x,y]])
    150         assert allclose(v, 5)
     152        assert num.allclose(v, 5)
    151153
    152154
    153155        x,y = quantity.get_minimum_location()
    154156        v = quantity.get_values(interpolation_points = [[x,y]])
    155         assert allclose(v, 0)
     157        assert num.allclose(v, 0)
    156158
    157159
     
    192194
    193195        v = quantity.get_values(interpolation_points = [[x,y]])
    194         assert allclose(v, 6)
     196        assert num.allclose(v, 6)
    195197
    196198        x,y = quantity.get_minimum_location()       
    197199        v = quantity.get_values(interpolation_points = [[x,y]])
    198         assert allclose(v, 2)
     200        assert num.allclose(v, 2)
    199201
    200202        #Multiple locations for maximum -
    201203        #Test that the algorithm picks the first occurrence       
    202204        v = quantity.get_maximum_value(indices=[0,1,2])
    203         assert allclose(v, 4)
     205        assert num.allclose(v, 4)
    204206
    205207        i = quantity.get_maximum_index(indices=[0,1,2])
     
    212214
    213215        v = quantity.get_values(interpolation_points = [[x,y]])
    214         assert allclose(v, 4)       
     216        assert num.allclose(v, 4)       
    215217
    216218        # More test of indices......
    217219        v = quantity.get_maximum_value(indices=[2,3])
    218         assert allclose(v, 6)
     220        assert num.allclose(v, 6)
    219221
    220222        i = quantity.get_maximum_index(indices=[2,3])
     
    227229
    228230        v = quantity.get_values(interpolation_points = [[x,y]])
    229         assert allclose(v, 6)       
     231        assert num.allclose(v, 6)       
    230232
    231233       
     
    244246        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
    245247                            location = 'vertices')
    246         assert allclose(quantity.vertex_values,
    247                         [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
    248         assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
    249         assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
    250                                                [5., 5., 5.],
    251                                                [4.5, 4.5, 0.],
    252                                                [3.0, -1.5, -1.5]])
     248        assert num.allclose(quantity.vertex_values,
     249                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
     250        assert num.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
     251        assert num.allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
     252                                                   [5., 5., 5.],
     253                                                   [4.5, 4.5, 0.],
     254                                                   [3.0, -1.5, -1.5]])
    253255
    254256
    255257        # Test default
    256258        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
    257         assert allclose(quantity.vertex_values,
    258                         [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
    259         assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
    260         assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
    261                                                [5., 5., 5.],
    262                                                [4.5, 4.5, 0.],
    263                                                [3.0, -1.5, -1.5]])
     259        assert num.allclose(quantity.vertex_values,
     260                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
     261        assert num.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
     262        assert num.allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
     263                                                   [5., 5., 5.],
     264                                                   [4.5, 4.5, 0.],
     265                                                   [3.0, -1.5, -1.5]])
    264266
    265267        # Test centroids
    266268        quantity.set_values([1,2,3,4], location = 'centroids')
    267         assert allclose(quantity.centroid_values, [1., 2., 3., 4.]) #Centroid
     269        assert num.allclose(quantity.centroid_values, [1., 2., 3., 4.]) #Centroid
    268270
    269271        # Test exceptions
     
    288290
    289291        quantity.set_values(1.0, location = 'vertices')
    290         assert allclose(quantity.vertex_values,
    291                         [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
    292 
    293         assert allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
    294         assert allclose(quantity.edge_values, [[1, 1, 1],
    295                                                [1, 1, 1],
    296                                                [1, 1, 1],
    297                                                [1, 1, 1]])
     292        assert num.allclose(quantity.vertex_values,
     293                            [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
     294
     295        assert num.allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
     296        assert num.allclose(quantity.edge_values, [[1, 1, 1],
     297                                                   [1, 1, 1],
     298                                                   [1, 1, 1],
     299                                                   [1, 1, 1]])
    298300
    299301
    300302        quantity.set_values(2.0, location = 'centroids')
    301         assert allclose(quantity.centroid_values, [2, 2, 2, 2])
     303        assert num.allclose(quantity.centroid_values, [2, 2, 2, 2])
    302304
    303305
     
    310312        quantity.set_values(f, location = 'vertices')
    311313        #print "quantity.vertex_values",quantity.vertex_values
    312         assert allclose(quantity.vertex_values,
    313                         [[2,0,2], [2,2,4], [4,2,4], [4,2,4]])
    314         assert allclose(quantity.centroid_values,
    315                         [4.0/3, 8.0/3, 10.0/3, 10.0/3])
    316         assert allclose(quantity.edge_values,
    317                         [[1,2,1], [3,3,2], [3,4,3], [3,4,3]])
     314        assert num.allclose(quantity.vertex_values,
     315                            [[2,0,2], [2,2,4], [4,2,4], [4,2,4]])
     316        assert num.allclose(quantity.centroid_values,
     317                            [4.0/3, 8.0/3, 10.0/3, 10.0/3])
     318        assert num.allclose(quantity.edge_values,
     319                            [[1,2,1], [3,3,2], [3,4,3], [3,4,3]])
    318320
    319321
    320322        quantity.set_values(f, location = 'centroids')
    321         assert allclose(quantity.centroid_values,
    322                         [4.0/3, 8.0/3, 10.0/3, 10.0/3])
     323        assert num.allclose(quantity.centroid_values,
     324                            [4.0/3, 8.0/3, 10.0/3, 10.0/3])
    323325
    324326
     
    331333        #print 'Q', quantity.get_integral()
    332334
    333         assert allclose(quantity.get_integral(), self.mesh4.get_area() * const)
     335        assert num.allclose(quantity.get_integral(), self.mesh4.get_area() * const)
    334336
    335337        # Try with a linear function
     
    342344        ref_integral = (4.0/3 + 8.0/3 + 10.0/3 + 10.0/3) * 2
    343345
    344         assert allclose (quantity.get_integral(), ref_integral)
     346        assert num.allclose (quantity.get_integral(), ref_integral)
    345347
    346348
     
    350352        quantity.set_vertex_values([0,1,2,3,4,5])
    351353
    352         assert allclose(quantity.vertex_values,
    353                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    354         assert allclose(quantity.centroid_values,
    355                         [1., 7./3, 11./3, 8./3]) #Centroid
    356         assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
    357                                                [3., 2.5, 1.5],
    358                                                [3.5, 4.5, 3.],
    359                                                [2.5, 3.5, 2]])
     354        assert num.allclose(quantity.vertex_values,
     355                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     356        assert num.allclose(quantity.centroid_values,
     357                            [1., 7./3, 11./3, 8./3]) #Centroid
     358        assert num.allclose(quantity.edge_values, [[1., 1.5, 0.5],
     359                                                   [3., 2.5, 1.5],
     360                                                   [3.5, 4.5, 3.],
     361                                                   [2.5, 3.5, 2]])
    360362
    361363
     
    365367        quantity.set_vertex_values([0,20,30,50], indices = [0,2,3,5])
    366368
    367         assert allclose(quantity.vertex_values,
    368                         [[1,0,20], [1,20,4], [4,20,50], [30,1,4]])
     369        assert num.allclose(quantity.vertex_values,
     370                            [[1,0,20], [1,20,4], [4,20,50], [30,1,4]])
    369371
    370372
     
    376378
    377379
    378         assert allclose(quantity.vertex_values,
    379                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     380        assert num.allclose(quantity.vertex_values,
     381                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    380382
    381383        #Centroid
    382         assert allclose(quantity.centroid_values, [1., 7./3, 11./3, 8./3])
    383 
    384         assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
    385                                                [3., 2.5, 1.5],
    386                                                [3.5, 4.5, 3.],
    387                                                [2.5, 3.5, 2]])
     384        assert num.allclose(quantity.centroid_values, [1., 7./3, 11./3, 8./3])
     385
     386        assert num.allclose(quantity.edge_values, [[1., 1.5, 0.5],
     387                                                   [3., 2.5, 1.5],
     388                                                   [3.5, 4.5, 3.],
     389                                                   [2.5, 3.5, 2]])
    388390
    389391
     
    399401
    400402        quantity.set_values([0,2,3,5], indices=[0,2,3,5])
    401         assert allclose(quantity.vertex_values,
    402                         [[0,0,2], [0,2,0], [0,2,5], [3,0,0]])
     403        assert num.allclose(quantity.vertex_values,
     404                            [[0,0,2], [0,2,0], [0,2,5], [3,0,0]])
    403405
    404406
     
    408410
    409411        # Indices refer to triangle numbers
    410         assert allclose(quantity.vertex_values,
    411                         [[3.14,3.14,3.14], [0,0,0],
    412                          [3.14,3.14,3.14], [0,0,0]])       
     412        assert num.allclose(quantity.vertex_values,
     413                            [[3.14,3.14,3.14], [0,0,0],
     414                             [3.14,3.14,3.14], [0,0,0]])       
    413415       
    414416
     
    419421        quantity.set_values(3.14, polygon=polygon)
    420422       
    421         assert allclose(quantity.vertex_values,
    422                         [[0,0,0], [0,0,0], [0,0,0],
    423                          [3.14,3.14,3.14]])               
     423        assert num.allclose(quantity.vertex_values,
     424                            [[0,0,0], [0,0,0], [0,0,0],
     425                             [3.14,3.14,3.14]])               
    424426
    425427
     
    429431        quantity.set_values(0.0)
    430432        quantity.set_values(3.14, location='centroids', polygon=polygon)
    431         assert allclose(quantity.vertex_values,
    432                         [[0,0,0],
    433                          [3.14,3.14,3.14],
    434                          [3.14,3.14,3.14],                         
    435                          [0,0,0]])               
     433        assert num.allclose(quantity.vertex_values,
     434                            [[0,0,0],
     435                             [3.14,3.14,3.14],
     436                             [3.14,3.14,3.14],                         
     437                             [0,0,0]])               
    436438
    437439
     
    441443        #print 'Here 2'
    442444        quantity.set_values(3.14, polygon=polygon)
    443         assert allclose(quantity.vertex_values,
    444                         [[0,0,0],
    445                          [3.14,3.14,3.14],
    446                          [3.14,3.14,3.14],                         
    447                          [0,0,0]])               
     445        assert num.allclose(quantity.vertex_values,
     446                            [[0,0,0],
     447                             [3.14,3.14,3.14],
     448                             [3.14,3.14,3.14],                         
     449                             [0,0,0]])               
    448450       
    449451
     
    478480
    479481        # Indices refer to triangle numbers here - not vertices (why?)
    480         assert allclose(quantity.vertex_values,
    481                         [[3.14,3.14,3.14], [0,0,0],
    482                          [3.14,3.14,3.14], [0,0,0]])       
     482        assert num.allclose(quantity.vertex_values,
     483                            [[3.14,3.14,3.14], [0,0,0],
     484                             [3.14,3.14,3.14], [0,0,0]])       
    483485       
    484486
    485487
    486488        # Now try with polygon (pick points where y>2)
    487         polygon = array([[0,2.1], [4,2.1], [4,7], [0,7]])
     489        polygon = num.array([[0,2.1], [4,2.1], [4,7], [0,7]])
    488490        polygon += [G.xllcorner, G.yllcorner]
    489491       
     
    491493        quantity.set_values(3.14, polygon=polygon, location='centroids')
    492494       
    493         assert allclose(quantity.vertex_values,
    494                         [[0,0,0], [0,0,0], [0,0,0],
    495                          [3.14,3.14,3.14]])               
     495        assert num.allclose(quantity.vertex_values,
     496                            [[0,0,0], [0,0,0], [0,0,0],
     497                             [3.14,3.14,3.14]])               
    496498
    497499
    498500        # Another polygon (pick triangle 1 and 2 (rightmost triangles)
    499         polygon = array([[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]])
     501        polygon = num.array([[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]])
    500502        polygon += [G.xllcorner, G.yllcorner]
    501503       
     
    503505        quantity.set_values(3.14, polygon=polygon)
    504506
    505         assert allclose(quantity.vertex_values,
    506                         [[0,0,0],
    507                          [3.14,3.14,3.14],
    508                          [3.14,3.14,3.14],                         
    509                          [0,0,0]])               
     507        assert num.allclose(quantity.vertex_values,
     508                            [[0,0,0],
     509                             [3.14,3.14,3.14],
     510                             [3.14,3.14,3.14],                         
     511                             [0,0,0]])               
    510512
    511513
     
    540542        answer = linear_function(quantity.domain.get_vertex_coordinates())
    541543        #print quantity.vertex_values, answer
    542         assert allclose(quantity.vertex_values.flat, answer)
     544        assert num.allclose(quantity.vertex_values.flat, answer)
    543545
    544546
     
    553555        #print vertex_attributes
    554556        quantity.set_values(vertex_attributes)
    555         assert allclose(quantity.vertex_values.flat, answer)
     557        assert num.allclose(quantity.vertex_values.flat, answer)
    556558
    557559
     
    593595                          alpha = 0)
    594596
    595         assert allclose( ref, [0,5,5] )
     597        assert num.allclose( ref, [0,5,5] )
    596598
    597599
     
    610612        #                    data_georef = data_georef,
    611613        #                    alpha = 0)
    612         assert allclose(quantity.vertex_values.flat, ref)
     614        assert num.allclose(quantity.vertex_values.flat, ref)
    613615
    614616
     
    621623
    622624        quantity.set_values(geospatial_data = geo, alpha = 0)
    623         assert allclose(quantity.vertex_values.flat, ref)
     625        assert num.allclose(quantity.vertex_values.flat, ref)
    624626
    625627
     
    670672
    671673
    672         assert allclose(quantity.vertex_values.flat, answer)
     674        assert num.allclose(quantity.vertex_values.flat, answer)
    673675
    674676
    675677        #Check that values can be set from file using default attribute
    676678        quantity.set_values(filename = ptsfile, alpha = 0)
    677         assert allclose(quantity.vertex_values.flat, answer)
     679        assert num.allclose(quantity.vertex_values.flat, answer)
    678680
    679681        #Cleanup
     
    730732        #print self.mesh4.nodes
    731733        #print inside_polygon(self.mesh4.nodes, polygon)
    732         assert allclose(inside_polygon(self.mesh4.nodes, polygon), 4)
     734        assert num.allclose(inside_polygon(self.mesh4.nodes, polygon), 4)
    733735
    734736        #print quantity.domain.get_vertex_coordinates()
     
    752754
    753755        # Check vertices in polygon have been set
    754         assert allclose(take(quantity.vertex_values.flat, indices),
    755                              answer)
     756        assert num.allclose(take(quantity.vertex_values.flat, indices),
     757                            answer)
    756758
    757759        # Check vertices outside polygon are zero
    758760        indices = outside_polygon(quantity.domain.get_vertex_coordinates(),
    759761                                  polygon)       
    760         assert allclose(take(quantity.vertex_values.flat, indices),
    761                              0.0)       
     762        assert num.allclose(take(quantity.vertex_values.flat, indices),
     763                            0.0)       
    762764
    763765        #Cleanup
     
    815817                            verbose=False)
    816818        answer = linear_function(quantity.domain.get_vertex_coordinates())
    817         assert allclose(quantity.vertex_values.flat, answer)
     819        assert num.allclose(quantity.vertex_values.flat, answer)
    818820
    819821
     
    821823        quantity.set_values(filename=ptsfile,
    822824                            alpha=0)
    823         assert allclose(quantity.vertex_values.flat, answer)
     825        assert num.allclose(quantity.vertex_values.flat, answer)
    824826
    825827        # Check cache
     
    869871        #print "answer",answer
    870872
    871         assert allclose(quantity.vertex_values.flat, answer)
     873        assert num.allclose(quantity.vertex_values.flat, answer)
    872874
    873875
    874876        #Check that values can be set from file using default attribute
    875877        quantity.set_values(filename=txt_file, alpha=0)
    876         assert allclose(quantity.vertex_values.flat, answer)
     878        assert num.allclose(quantity.vertex_values.flat, answer)
    877879
    878880        #Cleanup
     
    913915        #print "answer",answer
    914916
    915         assert allclose(quantity.vertex_values.flat, answer)
     917        assert num.allclose(quantity.vertex_values.flat, answer)
    916918
    917919
    918920        #Check that values can be set from file using default attribute
    919921        quantity.set_values(filename=txt_file, alpha=0)
    920         assert allclose(quantity.vertex_values.flat, answer)
     922        assert num.allclose(quantity.vertex_values.flat, answer)
    921923
    922924        #Cleanup
     
    959961        #print "quantity.vertex_values.flat", quantity.vertex_values.flat
    960962        #print "answer",answer
    961         assert allclose(quantity.vertex_values.flat, answer)
     963        assert num.allclose(quantity.vertex_values.flat, answer)
    962964
    963965        #Check that values can be set from file
     
    967969        #print "quantity.vertex_values.flat", quantity.vertex_values.flat
    968970        #print "answer",answer
    969         assert allclose(quantity.vertex_values.flat, answer)
     971        assert num.allclose(quantity.vertex_values.flat, answer)
    970972
    971973
    972974        #Check that values can be set from file using default attribute
    973975        quantity.set_values(filename=txt_file, alpha=0)
    974         assert allclose(quantity.vertex_values.flat, answer)
     976        assert num.allclose(quantity.vertex_values.flat, answer)
    975977
    976978        #Cleanup
     
    10411043        #print "quantity.vertex_values.flat", quantity.vertex_values.flat
    10421044        #print "answer",answer
    1043         assert allclose(quantity.vertex_values.flat, answer)
     1045        assert num.allclose(quantity.vertex_values.flat, answer)
    10441046
    10451047        #Check that values can be set from file
     
    10491051        #print "quantity.vertex_values.flat", quantity.vertex_values.flat
    10501052        #print "answer",answer
    1051         assert allclose(quantity.vertex_values.flat, answer)
     1053        assert num.allclose(quantity.vertex_values.flat, answer)
    10521054
    10531055
    10541056        #Check that values can be set from file using default attribute
    10551057        quantity.set_values(filename=txt_file, alpha=0)
    1056         assert allclose(quantity.vertex_values.flat, answer)
     1058        assert num.allclose(quantity.vertex_values.flat, answer)
    10571059
    10581060        #Cleanup
     
    11281130        answer = linear_function(quantity.domain.get_vertex_coordinates())
    11291131
    1130         assert allclose(quantity.vertex_values.flat, answer)
     1132        assert num.allclose(quantity.vertex_values.flat, answer)
    11311133
    11321134
    11331135        #Check that values can be set from file using default attribute
    11341136        quantity.set_values(filename=ptsfile, alpha=0)
    1135         assert allclose(quantity.vertex_values.flat, answer)
     1137        assert num.allclose(quantity.vertex_values.flat, answer)
    11361138
    11371139        #Cleanup
     
    12071209
    12081210
    1209         assert allclose(quantity.vertex_values.flat, answer)
     1211        assert num.allclose(quantity.vertex_values.flat, answer)
    12101212
    12111213
    12121214        #Check that values can be set from file using default attribute
    12131215        quantity.set_values(filename=ptsfile, alpha=0)
    1214         assert allclose(quantity.vertex_values.flat, answer)
     1216        assert num.allclose(quantity.vertex_values.flat, answer)
    12151217
    12161218        #Cleanup
     
    12261228        quantity1.set_vertex_values([0,1,2,3,4,5])
    12271229
    1228         assert allclose(quantity1.vertex_values,
    1229                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     1230        assert num.allclose(quantity1.vertex_values,
     1231                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    12301232
    12311233
    12321234        quantity2 = Quantity(self.mesh4)
    12331235        quantity2.set_values(quantity=quantity1)
    1234         assert allclose(quantity2.vertex_values,
    1235                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     1236        assert num.allclose(quantity2.vertex_values,
     1237                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    12361238
    12371239        quantity2.set_values(quantity = 2*quantity1)
    1238         assert allclose(quantity2.vertex_values,
    1239                         [[2,0,4], [2,4,8], [8,4,10], [6,2,8]])
     1240        assert num.allclose(quantity2.vertex_values,
     1241                            [[2,0,4], [2,4,8], [8,4,10], [6,2,8]])
    12401242
    12411243        quantity2.set_values(quantity = 2*quantity1 + 3)
    1242         assert allclose(quantity2.vertex_values,
    1243                         [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
     1244        assert num.allclose(quantity2.vertex_values,
     1245                            [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
    12441246
    12451247
    12461248        #Check detection of quantity as first orgument
    12471249        quantity2.set_values(2*quantity1 + 3)
    1248         assert allclose(quantity2.vertex_values,
    1249                         [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
     1250        assert num.allclose(quantity2.vertex_values,
     1251                            [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
    12501252
    12511253
     
    12621264        polygon = [[1.0, 1.0], [4.0, 1.0],
    12631265                   [4.0, 4.0], [1.0, 4.0]]
    1264         assert allclose(inside_polygon(self.mesh4.nodes, polygon), 4)                   
     1266        assert num.allclose(inside_polygon(self.mesh4.nodes, polygon), 4)                   
    12651267       
    12661268        quantity1 = Quantity(self.mesh4)
    12671269        quantity1.set_vertex_values([0,1,2,3,4,5])
    12681270
    1269         assert allclose(quantity1.vertex_values,
    1270                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     1271        assert num.allclose(quantity1.vertex_values,
     1272                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    12711273
    12721274
     
    12761278                             
    12771279        msg = 'Only node #4(e) at (2,2) should have values applied '
    1278         assert allclose(quantity2.vertex_values,
    1279                         [[0,0,0], [0,0,4], [4,0,0], [0,0,4]]), msg       
    1280                         #bac,     bce,     ecf,     dbe
     1280        assert num.allclose(quantity2.vertex_values,
     1281                            [[0,0,0], [0,0,4], [4,0,0], [0,0,4]]), msg       
     1282                            #bac,     bce,     ecf,     dbe
    12811283                       
    12821284
     
    12871289        quantity1.set_vertex_values([0,1,2,3,4,5])
    12881290
    1289         assert allclose(quantity1.vertex_values,
    1290                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     1291        assert num.allclose(quantity1.vertex_values,
     1292                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    12911293
    12921294
     
    13041306        # Negation
    13051307        Q = -quantity1
    1306         assert allclose(Q.vertex_values, -quantity1.vertex_values)
    1307         assert allclose(Q.centroid_values, -quantity1.centroid_values)
    1308         assert allclose(Q.edge_values, -quantity1.edge_values)
     1308        assert num.allclose(Q.vertex_values, -quantity1.vertex_values)
     1309        assert num.allclose(Q.centroid_values, -quantity1.centroid_values)
     1310        assert num.allclose(Q.edge_values, -quantity1.edge_values)
    13091311
    13101312        # Addition
    13111313        Q = quantity1 + 7
    1312         assert allclose(Q.vertex_values, quantity1.vertex_values + 7)
    1313         assert allclose(Q.centroid_values, quantity1.centroid_values + 7)
    1314         assert allclose(Q.edge_values, quantity1.edge_values + 7)
     1314        assert num.allclose(Q.vertex_values, quantity1.vertex_values + 7)
     1315        assert num.allclose(Q.centroid_values, quantity1.centroid_values + 7)
     1316        assert num.allclose(Q.edge_values, quantity1.edge_values + 7)
    13151317
    13161318        Q = 7 + quantity1
    1317         assert allclose(Q.vertex_values, quantity1.vertex_values + 7)
    1318         assert allclose(Q.centroid_values, quantity1.centroid_values + 7)
    1319         assert allclose(Q.edge_values, quantity1.edge_values + 7)
     1319        assert num.allclose(Q.vertex_values, quantity1.vertex_values + 7)
     1320        assert num.allclose(Q.centroid_values, quantity1.centroid_values + 7)
     1321        assert num.allclose(Q.edge_values, quantity1.edge_values + 7)
    13201322
    13211323        Q = quantity1 + quantity2
    1322         assert allclose(Q.vertex_values,
    1323                         quantity1.vertex_values + quantity2.vertex_values)
    1324         assert allclose(Q.centroid_values,
    1325                         quantity1.centroid_values + quantity2.centroid_values)
    1326         assert allclose(Q.edge_values,
    1327                         quantity1.edge_values + quantity2.edge_values)
     1324        assert num.allclose(Q.vertex_values,
     1325                            quantity1.vertex_values + quantity2.vertex_values)
     1326        assert num.allclose(Q.centroid_values,
     1327                            quantity1.centroid_values + quantity2.centroid_values)
     1328        assert num.allclose(Q.edge_values,
     1329                            quantity1.edge_values + quantity2.edge_values)
    13281330
    13291331
    13301332        Q = quantity1 + quantity2 - 3
    1331         assert allclose(Q.vertex_values,
    1332                         quantity1.vertex_values + quantity2.vertex_values - 3)
     1333        assert num.allclose(Q.vertex_values,
     1334                            quantity1.vertex_values + quantity2.vertex_values - 3)
    13331335
    13341336        Q = quantity1 - quantity2
    1335         assert allclose(Q.vertex_values,
    1336                         quantity1.vertex_values - quantity2.vertex_values)
     1337        assert num.allclose(Q.vertex_values,
     1338                            quantity1.vertex_values - quantity2.vertex_values)
    13371339
    13381340        #Scaling
    13391341        Q = quantity1*3
    1340         assert allclose(Q.vertex_values, quantity1.vertex_values*3)
    1341         assert allclose(Q.centroid_values, quantity1.centroid_values*3)
    1342         assert allclose(Q.edge_values, quantity1.edge_values*3)
     1342        assert num.allclose(Q.vertex_values, quantity1.vertex_values*3)
     1343        assert num.allclose(Q.centroid_values, quantity1.centroid_values*3)
     1344        assert num.allclose(Q.edge_values, quantity1.edge_values*3)
    13431345        Q = 3*quantity1
    1344         assert allclose(Q.vertex_values, quantity1.vertex_values*3)
     1346        assert num.allclose(Q.vertex_values, quantity1.vertex_values*3)
    13451347
    13461348        #Multiplication
     
    13511353        #print quantity2.centroid_values
    13521354
    1353         assert allclose(Q.vertex_values,
    1354                         quantity1.vertex_values * quantity2.vertex_values)
     1355        assert num.allclose(Q.vertex_values,
     1356                            quantity1.vertex_values * quantity2.vertex_values)
    13551357
    13561358        #Linear combinations
    13571359        Q = 4*quantity1 + 2
    1358         assert allclose(Q.vertex_values,
    1359                         4*quantity1.vertex_values + 2)
     1360        assert num.allclose(Q.vertex_values,
     1361                            4*quantity1.vertex_values + 2)
    13601362
    13611363        Q = quantity1*quantity2 + 2
    1362         assert allclose(Q.vertex_values,
    1363                         quantity1.vertex_values * quantity2.vertex_values + 2)
     1364        assert num.allclose(Q.vertex_values,
     1365                            quantity1.vertex_values * quantity2.vertex_values + 2)
    13641366
    13651367        Q = quantity1*quantity2 + quantity3
    1366         assert allclose(Q.vertex_values,
    1367                         quantity1.vertex_values * quantity2.vertex_values +
     1368        assert num.allclose(Q.vertex_values,
     1369                            quantity1.vertex_values * quantity2.vertex_values +
    13681370                        quantity3.vertex_values)
    13691371        Q = quantity1*quantity2 + 3*quantity3
    1370         assert allclose(Q.vertex_values,
    1371                         quantity1.vertex_values * quantity2.vertex_values +
    1372                         3*quantity3.vertex_values)
     1372        assert num.allclose(Q.vertex_values,
     1373                            quantity1.vertex_values * quantity2.vertex_values +
     1374                            3*quantity3.vertex_values)
    13731375        Q = quantity1*quantity2 + 3*quantity3 + 5.0
    1374         assert allclose(Q.vertex_values,
    1375                         quantity1.vertex_values * quantity2.vertex_values +
    1376                         3*quantity3.vertex_values + 5)
     1376        assert num.allclose(Q.vertex_values,
     1377                            quantity1.vertex_values * quantity2.vertex_values +
     1378                            3*quantity3.vertex_values + 5)
    13771379
    13781380        Q = quantity1*quantity2 - quantity3
    1379         assert allclose(Q.vertex_values,
    1380                         quantity1.vertex_values * quantity2.vertex_values -
    1381                         quantity3.vertex_values)
     1381        assert num.allclose(Q.vertex_values,
     1382                            quantity1.vertex_values * quantity2.vertex_values -
     1383                            quantity3.vertex_values)
    13821384        Q = 1.5*quantity1*quantity2 - 3*quantity3 + 5.0
    1383         assert allclose(Q.vertex_values,
    1384                         1.5*quantity1.vertex_values * quantity2.vertex_values -
    1385                         3*quantity3.vertex_values + 5)
     1385        assert num.allclose(Q.vertex_values,
     1386                            1.5*quantity1.vertex_values * quantity2.vertex_values -
     1387                            3*quantity3.vertex_values + 5)
    13861388
    13871389        #Try combining quantities and arrays and scalars
    13881390        Q = 1.5*quantity1*quantity2.vertex_values -\
    13891391            3*quantity3.vertex_values + 5.0
    1390         assert allclose(Q.vertex_values,
    1391                         1.5*quantity1.vertex_values * quantity2.vertex_values -
    1392                         3*quantity3.vertex_values + 5)
     1392        assert num.allclose(Q.vertex_values,
     1393                            1.5*quantity1.vertex_values * quantity2.vertex_values -
     1394                            3*quantity3.vertex_values + 5)
    13931395
    13941396
    13951397        #Powers
    13961398        Q = quantity1**2
    1397         assert allclose(Q.vertex_values, quantity1.vertex_values**2)
     1399        assert num.allclose(Q.vertex_values, quantity1.vertex_values**2)
    13981400
    13991401        Q = quantity1**2 +quantity2**2
    1400         assert allclose(Q.vertex_values,
    1401                         quantity1.vertex_values**2 + \
    1402                         quantity2.vertex_values**2)
     1402        assert num.allclose(Q.vertex_values,
     1403                            quantity1.vertex_values**2 + \
     1404                            quantity2.vertex_values**2)
    14031405
    14041406        Q = (quantity1**2 +quantity2**2)**0.5
    1405         assert allclose(Q.vertex_values,
    1406                         (quantity1.vertex_values**2 + \
    1407                         quantity2.vertex_values**2)**0.5)
     1407        assert num.allclose(Q.vertex_values,
     1408                            (quantity1.vertex_values**2 + \
     1409                            quantity2.vertex_values**2)**0.5)
    14081410
    14091411
     
    14311433        #The central triangle (1)
    14321434        #(using standard gradient based on neigbours controid values)
    1433         assert allclose(a[1], 2.0)
    1434         assert allclose(b[1], 0.0)
     1435        assert num.allclose(a[1], 2.0)
     1436        assert num.allclose(b[1], 0.0)
    14351437
    14361438
     
    14381440        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
    14391441        #2  = 4  + a*(-2/3)  + b*(-2/3)
    1440         assert allclose(a[0] + b[0], 3)
     1442        assert num.allclose(a[0] + b[0], 3)
    14411443        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
    1442         assert allclose(a[0] - b[0], 0)
     1444        assert num.allclose(a[0] - b[0], 0)
    14431445
    14441446
     
    14461448        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
    14471449        #6  = 4  + a*(4/3)  + b*(-2/3)
    1448         assert allclose(2*a[2] - b[2], 3)
     1450        assert num.allclose(2*a[2] - b[2], 3)
    14491451        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
    1450         assert allclose(a[2] + 2*b[2], 0)
     1452        assert num.allclose(a[2] + 2*b[2], 0)
    14511453
    14521454
     
    14541456        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
    14551457        #2  = 4  + a*(-2/3)  + b*(4/3)
    1456         assert allclose(a[3] - 2*b[3], 3)
     1458        assert num.allclose(a[3] - 2*b[3], 3)
    14571459        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
    1458         assert allclose(2*a[3] + b[3], 0)
     1460        assert num.allclose(2*a[3] + b[3], 0)
    14591461
    14601462
     
    14641466
    14651467        #Apply q(x,y) = qc + a*(x-xc) + b*(y-yc)
    1466         assert allclose(quantity.vertex_values[0,:], [3., 0.,  3.])
    1467         assert allclose(quantity.vertex_values[1,:], [4./3, 16./3,  16./3])
     1468        assert num.allclose(quantity.vertex_values[0,:], [3., 0.,  3.])
     1469        assert num.allclose(quantity.vertex_values[1,:], [4./3, 16./3,  16./3])
    14681470
    14691471
    14701472        #a = 1.2, b=-0.6
    14711473        #q(4,0) = 6 + a*(4 - 8/3) + b*(-2/3)
    1472         assert allclose(quantity.vertex_values[2,2], 8)
     1474        assert num.allclose(quantity.vertex_values[2,2], 8)
    14731475
    14741476    def test_get_gradients(self):
     
    14891491        #The central triangle (1)
    14901492        #(using standard gradient based on neigbours controid values)
    1491         assert allclose(a[1], 2.0)
    1492         assert allclose(b[1], 0.0)
     1493        assert num.allclose(a[1], 2.0)
     1494        assert num.allclose(b[1], 0.0)
    14931495
    14941496
     
    14961498        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
    14971499        #2  = 4  + a*(-2/3)  + b*(-2/3)
    1498         assert allclose(a[0] + b[0], 3)
     1500        assert num.allclose(a[0] + b[0], 3)
    14991501        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
    1500         assert allclose(a[0] - b[0], 0)
     1502        assert num.allclose(a[0] - b[0], 0)
    15011503
    15021504
     
    15041506        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
    15051507        #6  = 4  + a*(4/3)  + b*(-2/3)
    1506         assert allclose(2*a[2] - b[2], 3)
     1508        assert num.allclose(2*a[2] - b[2], 3)
    15071509        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
    1508         assert allclose(a[2] + 2*b[2], 0)
     1510        assert num.allclose(a[2] + 2*b[2], 0)
    15091511
    15101512
     
    15121514        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
    15131515        #2  = 4  + a*(-2/3)  + b*(4/3)
    1514         assert allclose(a[3] - 2*b[3], 3)
     1516        assert num.allclose(a[3] - 2*b[3], 3)
    15151517        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
    1516         assert allclose(2*a[3] + b[3], 0)
     1518        assert num.allclose(2*a[3] + b[3], 0)
    15171519
    15181520
     
    15321534        #print a, b
    15331535
    1534         assert allclose(a[1], 3.0)
    1535         assert allclose(b[1], 1.0)
     1536        assert num.allclose(a[1], 3.0)
     1537        assert num.allclose(b[1], 1.0)
    15361538
    15371539        #Work out the others
     
    15401542
    15411543        #print quantity.vertex_values
    1542         assert allclose(quantity.vertex_values[1,0], 2.0)
    1543         assert allclose(quantity.vertex_values[1,1], 6.0)
    1544         assert allclose(quantity.vertex_values[1,2], 8.0)
     1544        assert num.allclose(quantity.vertex_values[1,0], 2.0)
     1545        assert num.allclose(quantity.vertex_values[1,1], 6.0)
     1546        assert num.allclose(quantity.vertex_values[1,2], 8.0)
    15451547
    15461548
     
    15501552
    15511553        #Set up for a gradient of (3,1), f(x) = 3x+y
    1552         c_values = array([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3])
    1553         d_values = array([1.0, 2.0, 3.0, 4.0])
     1554        c_values = num.array([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3])
     1555        d_values = num.array([1.0, 2.0, 3.0, 4.0])
    15541556        quantity.set_values(c_values, location = 'centroids')
    15551557
     
    15581560
    15591561        #print quantity.vertex_values
    1560         assert allclose(quantity.centroid_values, quantity.centroid_backup_values)
     1562        assert num.allclose(quantity.centroid_values, quantity.centroid_backup_values)
    15611563
    15621564
     
    15741576        #Test centroids
    15751577        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
    1576         assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
     1578        assert num.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
    15771579
    15781580        #Extrapolate
     
    15811583        #Check that gradient is zero
    15821584        a,b = quantity.get_gradients()
    1583         assert allclose(a, [0,0,0,0])
    1584         assert allclose(b, [0,0,0,0])
     1585        assert num.allclose(a, [0,0,0,0])
     1586        assert num.allclose(b, [0,0,0,0])
    15851587
    15861588        #Check vertices but not edge values
    1587         assert allclose(quantity.vertex_values,
    1588                         [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
     1589        assert num.allclose(quantity.vertex_values,
     1590                            [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
    15891591
    15901592
     
    16141616
    16151617        #Assert that quantities are conserved
    1616         from Numeric import sum
    16171618        for k in range(quantity.centroid_values.shape[0]):
    1618             assert allclose (quantity.centroid_values[k],
    1619                              sum(quantity.vertex_values[k,:])/3)
     1619            assert num.allclose (quantity.centroid_values[k],
     1620                             num.sum(quantity.vertex_values[k,:])/3)
    16201621
    16211622
     
    16461647
    16471648        #Assert that quantities are conserved
    1648         from Numeric import sum
    16491649        for k in range(quantity.centroid_values.shape[0]):
    1650             assert allclose (quantity.centroid_values[k],
    1651                              sum(quantity.vertex_values[k,:])/3)
     1650            assert num.allclose (quantity.centroid_values[k],
     1651                                 num.sum(quantity.vertex_values[k,:])/3)
    16521652
    16531653
     
    16761676
    16771677        #Assert that quantities are conserved
    1678         from Numeric import sum
    16791678        for k in range(quantity.centroid_values.shape[0]):
    1680             assert allclose (quantity.centroid_values[k],
    1681                              sum(quantity.vertex_values[k,:])/3)
     1679            assert num.allclose (quantity.centroid_values[k],
     1680                                 num.sum(quantity.vertex_values[k,:])/3)
    16821681
    16831682
     
    17051704
    17061705        #Assert that quantities are conserved
    1707         from Numeric import sum
    17081706        for k in range(quantity.centroid_values.shape[0]):
    1709             assert allclose (quantity.centroid_values[k],
    1710                              sum(quantity.vertex_values[k,:])/3)
     1707            assert num.allclose (quantity.centroid_values[k],
     1708                                 num.sum(quantity.vertex_values[k,:])/3)
    17111709
    17121710    def test_limiter2(self):
     
    17181716        #Test centroids
    17191717        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
    1720         assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
     1718        assert num.allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
    17211719
    17221720
     
    17241722        quantity.extrapolate_second_order()
    17251723
    1726         assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
     1724        assert num.allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
    17271725
    17281726        #Limit
     
    17311729        # limited value for beta_w = 0.9
    17321730       
    1733         assert allclose(quantity.vertex_values[1,:], [2.2, 4.9, 4.9])
     1731        assert num.allclose(quantity.vertex_values[1,:], [2.2, 4.9, 4.9])
    17341732        # limited values for beta_w = 0.5
    17351733        #assert allclose(quantity.vertex_values[1,:], [3.0, 4.5, 4.5])
     
    17371735
    17381736        #Assert that quantities are conserved
    1739         from Numeric import sum
    17401737        for k in range(quantity.centroid_values.shape[0]):
    1741             assert allclose (quantity.centroid_values[k],
    1742                              sum(quantity.vertex_values[k,:])/3)
     1738            assert num.allclose (quantity.centroid_values[k],
     1739                                 num.sum(quantity.vertex_values[k,:])/3)
    17431740
    17441741
     
    17511748        #Test centroids
    17521749        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
    1753         assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
     1750        assert num.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
    17541751
    17551752
     
    17601757        #quantity.interpolate_from_vertices_to_edges()
    17611758
    1762         assert allclose(quantity.vertex_values,
    1763                         [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
    1764         assert allclose(quantity.edge_values, [[1,1,1], [2,2,2],
    1765                                                [3,3,3], [4, 4, 4]])
     1759        assert num.allclose(quantity.vertex_values,
     1760                            [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
     1761        assert num.allclose(quantity.edge_values, [[1,1,1], [2,2,2],
     1762                                                   [3,3,3], [4, 4, 4]])
    17661763
    17671764
     
    17691766        quantity = Quantity(self.mesh4)
    17701767
    1771         quantity.vertex_values = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]],Float)
     1768        quantity.vertex_values = num.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]],num.Float)
    17721769
    17731770        quantity.interpolate_from_vertices_to_edges()
    17741771
    1775         assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
    1776                                                [3., 2.5, 1.5],
    1777                                                [3.5, 4.5, 3.],
    1778                                                [2.5, 3.5, 2]])
     1772        assert num.allclose(quantity.edge_values, [[1., 1.5, 0.5],
     1773                                                   [3., 2.5, 1.5],
     1774                                                   [3.5, 4.5, 3.],
     1775                                                   [2.5, 3.5, 2]])
    17791776
    17801777
     
    17821779        quantity = Quantity(self.mesh4)
    17831780
    1784         quantity.edge_values = array([[1., 1.5, 0.5],
    1785                                 [3., 2.5, 1.5],
    1786                                 [3.5, 4.5, 3.],
    1787                                 [2.5, 3.5, 2]],Float)
     1781        quantity.edge_values = num.array([[1., 1.5, 0.5],
     1782                                          [3., 2.5, 1.5],
     1783                                          [3.5, 4.5, 3.],
     1784                                          [2.5, 3.5, 2]],num.Float)
    17881785
    17891786        quantity.interpolate_from_edges_to_vertices()
    17901787
    1791         assert allclose(quantity.vertex_values,
    1792                         [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
     1788        assert num.allclose(quantity.vertex_values,
     1789                            [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
    17931790
    17941791
     
    17991796        #Test centroids
    18001797        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
    1801         assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
     1798        assert num.allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
    18021799
    18031800
     
    18051802        quantity.extrapolate_second_order()
    18061803
    1807         assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
     1804        assert num.allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
    18081805
    18091806
     
    18131810        #Test centroids
    18141811        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
    1815         assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
     1812        assert num.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
    18161813
    18171814        #Set explicit_update
    1818         quantity.explicit_update = array( [1.,1.,1.,1.] )
     1815        quantity.explicit_update = num.array( [1.,1.,1.,1.] )
    18191816
    18201817        #Update with given timestep
    18211818        quantity.update(0.1)
    18221819
    1823         x = array([1, 2, 3, 4]) + array( [.1,.1,.1,.1] )
    1824         assert allclose( quantity.centroid_values, x)
     1820        x = num.array([1, 2, 3, 4]) + num.array( [.1,.1,.1,.1] )
     1821        assert num.allclose( quantity.centroid_values, x)
    18251822
    18261823    def test_update_semi_implicit(self):
     
    18291826        #Test centroids
    18301827        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
    1831         assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
     1828        assert num.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
    18321829
    18331830        #Set semi implicit update
    1834         quantity.semi_implicit_update = array([1.,1.,1.,1.])
     1831        quantity.semi_implicit_update = num.array([1.,1.,1.,1.])
    18351832
    18361833        #Update with given timestep
     
    18381835        quantity.update(timestep)
    18391836
    1840         sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
    1841         denom = ones(4, Float)-timestep*sem
    1842 
    1843         x = array([1, 2, 3, 4])/denom
    1844         assert allclose( quantity.centroid_values, x)
     1837        sem = num.array([1.,1.,1.,1.])/num.array([1, 2, 3, 4])
     1838        denom = num.ones(4, num.Float)-timestep*sem
     1839
     1840        x = num.array([1, 2, 3, 4])/denom
     1841        assert num.allclose( quantity.centroid_values, x)
    18451842
    18461843
     
    18501847        #Test centroids
    18511848        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
    1852         assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
     1849        assert num.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
    18531850
    18541851        #Set explicit_update
    1855         quantity.explicit_update = array( [4.,3.,2.,1.] )
     1852        quantity.explicit_update = num.array( [4.,3.,2.,1.] )
    18561853
    18571854        #Set semi implicit update
    1858         quantity.semi_implicit_update = array( [1.,1.,1.,1.] )
     1855        quantity.semi_implicit_update = num.array( [1.,1.,1.,1.] )
    18591856
    18601857        #Update with given timestep
     
    18621859        quantity.update(0.1)
    18631860
    1864         sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
    1865         denom = ones(4, Float)-timestep*sem
    1866 
    1867         x = array([1., 2., 3., 4.])
     1861        sem = num.array([1.,1.,1.,1.])/num.array([1, 2, 3, 4])
     1862        denom = num.ones(4, num.Float)-timestep*sem
     1863
     1864        x = num.array([1., 2., 3., 4.])
    18681865        x /= denom
    1869         x += timestep*array( [4.0, 3.0, 2.0, 1.0] )
    1870 
    1871         assert allclose( quantity.centroid_values, x)
     1866        x += timestep*num.array( [4.0, 3.0, 2.0, 1.0] )
     1867
     1868        assert num.allclose( quantity.centroid_values, x)
    18721869
    18731870
     
    18791876        from mesh_factory import rectangular
    18801877        from shallow_water import Domain, Transmissive_boundary
    1881         from Numeric import zeros, Float
    18821878        from anuga.utilities.numerical_tools import mean
    18831879
     
    19061902
    19071903        bed = domain.quantities['elevation'].vertex_values
    1908         stage = zeros(bed.shape, Float)
     1904        stage = num.zeros(bed.shape, num.Float)
    19091905
    19101906        h = 0.03
     
    19291925
    19301926        #First four points
    1931         assert allclose(A[0], (Q[0,2] + Q[1,1])/2)
    1932         assert allclose(A[1], (Q[1,0] + Q[3,1] + Q[2,2])/3)
    1933         assert allclose(A[2], Q[3,0])
    1934         assert allclose(A[3], (Q[0,0] + Q[5,1] + Q[4,2])/3)
     1927        assert num.allclose(A[0], (Q[0,2] + Q[1,1])/2)
     1928        assert num.allclose(A[1], (Q[1,0] + Q[3,1] + Q[2,2])/3)
     1929        assert num.allclose(A[2], Q[3,0])
     1930        assert num.allclose(A[3], (Q[0,0] + Q[5,1] + Q[4,2])/3)
    19351931
    19361932        #Center point
    1937         assert allclose(A[4], (Q[0,1] + Q[1,2] + Q[2,0] +\
    1938                                Q[5,0] + Q[6,2] + Q[7,1])/6)
     1933        assert num.allclose(A[4], (Q[0,1] + Q[1,2] + Q[2,0] +\
     1934                                   Q[5,0] + Q[6,2] + Q[7,1])/6)
    19391935
    19401936
    19411937        #Check V
    1942         assert allclose(V[0,:], [3,4,0])
    1943         assert allclose(V[1,:], [1,0,4])
    1944         assert allclose(V[2,:], [4,5,1])
    1945         assert allclose(V[3,:], [2,1,5])
    1946         assert allclose(V[4,:], [6,7,3])
    1947         assert allclose(V[5,:], [4,3,7])
    1948         assert allclose(V[6,:], [7,8,4])
    1949         assert allclose(V[7,:], [5,4,8])
     1938        assert num.allclose(V[0,:], [3,4,0])
     1939        assert num.allclose(V[1,:], [1,0,4])
     1940        assert num.allclose(V[2,:], [4,5,1])
     1941        assert num.allclose(V[3,:], [2,1,5])
     1942        assert num.allclose(V[4,:], [6,7,3])
     1943        assert num.allclose(V[5,:], [4,3,7])
     1944        assert num.allclose(V[6,:], [7,8,4])
     1945        assert num.allclose(V[7,:], [5,4,8])
    19501946
    19511947        #Get smoothed stage with XY
    19521948        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=True)
    19531949
    1954         assert allclose(A, A1)
    1955         assert allclose(V, V1)
     1950        assert num.allclose(A, A1)
     1951        assert num.allclose(V, V1)
    19561952
    19571953        #Check XY
    1958         assert allclose(X[4], 0.5)
    1959         assert allclose(Y[4], 0.5)
    1960 
    1961         assert allclose(X[7], 1.0)
    1962         assert allclose(Y[7], 0.5)
     1954        assert num.allclose(X[4], 0.5)
     1955        assert num.allclose(Y[4], 0.5)
     1956
     1957        assert num.allclose(X[7], 1.0)
     1958        assert num.allclose(Y[7], 0.5)
    19631959
    19641960
     
    19691965        from mesh_factory import rectangular
    19701966        from shallow_water import Domain, Transmissive_boundary
    1971         from Numeric import zeros, Float
    19721967        from anuga.utilities.numerical_tools import mean
    19731968
     
    19911986
    19921987        bed = domain.quantities['elevation'].vertex_values
    1993         stage = zeros(bed.shape, Float)
     1988        stage = num.zeros(bed.shape, num.Float)
    19941989
    19951990        h = 0.03
     
    20082003
    20092004        for k in range(8):
    2010             assert allclose(A[k], Q[k])
     2005            assert num.allclose(A[k], Q[k])
    20112006
    20122007
     
    20212016
    20222017
    2023         assert allclose(A, A1)
    2024         assert allclose(V, V1)
     2018        assert num.allclose(A, A1)
     2019        assert num.allclose(V, V1)
    20252020
    20262021        #Check XY
    2027         assert allclose(X[1], 0.5)
    2028         assert allclose(Y[1], 0.5)
    2029         assert allclose(X[4], 0.0)
    2030         assert allclose(Y[4], 0.0)
    2031         assert allclose(X[12], 1.0)
    2032         assert allclose(Y[12], 0.0)
     2022        assert num.allclose(X[1], 0.5)
     2023        assert num.allclose(Y[1], 0.5)
     2024        assert num.allclose(X[4], 0.0)
     2025        assert num.allclose(Y[4], 0.0)
     2026        assert num.allclose(X[12], 1.0)
     2027        assert num.allclose(Y[12], 0.0)
    20332028
    20342029
     
    20382033        from mesh_factory import rectangular
    20392034        from shallow_water import Domain
    2040         from Numeric import zeros, Float
    20412035
    20422036        #Create basic mesh
     
    20542048        #print "quantity.centroid_values",quantity.centroid_values
    20552049
    2056         assert allclose(quantity.centroid_values, [1,7])
     2050        assert num.allclose(quantity.centroid_values, [1,7])
    20572051
    20582052        quantity.set_array_values([15,20,25], indices = indices)
    2059         assert allclose(quantity.centroid_values, [1,20])
     2053        assert num.allclose(quantity.centroid_values, [1,20])
    20602054
    20612055        quantity.set_array_values([15,20,25], indices = indices)
    2062         assert allclose(quantity.centroid_values, [1,20])
     2056        assert num.allclose(quantity.centroid_values, [1,20])
    20632057
    20642058    def test_setting_some_vertex_values(self):
     
    20682062        from mesh_factory import rectangular
    20692063        from shallow_water import Domain
    2070         from Numeric import zeros, Float
    20712064
    20722065        #Create basic mesh
     
    20872080                            indices = indices)
    20882081        #print "quantity.centroid_values",quantity.centroid_values
    2089         assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
     2082        assert num.allclose(quantity.centroid_values, [1,7,3,4,5,6])
    20902083       
    20912084        value = [7]
     
    20952088                            indices = indices)
    20962089        #print "quantity.centroid_values",quantity.centroid_values
    2097         assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
     2090        assert num.allclose(quantity.centroid_values, [1,7,3,4,5,6])
    20982091
    20992092        value = [[15,20,25]]
    21002093        quantity.set_values(value, indices = indices)
    21012094        #print "1 quantity.vertex_values",quantity.vertex_values
    2102         assert allclose(quantity.vertex_values[1], value[0])
     2095        assert num.allclose(quantity.vertex_values[1], value[0])
    21032096
    21042097
     
    21072100        quantity.set_values(values, indices = [0,1,5], location = 'centroids')
    21082101        #print "2 quantity.vertex_values",quantity.vertex_values
    2109         assert allclose(quantity.vertex_values[0], [10,10,10])
    2110         assert allclose(quantity.vertex_values[5], [50,50,50])
     2102        assert num.allclose(quantity.vertex_values[0], [10,10,10])
     2103        assert num.allclose(quantity.vertex_values[5], [50,50,50])
    21112104        #quantity.interpolate()
    21122105        #print "quantity.centroid_values",quantity.centroid_values
    2113         assert allclose(quantity.centroid_values, [10,100,3,4,5,50])
     2106        assert num.allclose(quantity.centroid_values, [10,100,3,4,5,50])
    21142107
    21152108
     
    21212114        quantity.set_values(values, indices = [0,1,5])
    21222115        #print "quantity.vertex_values",quantity.vertex_values
    2123         assert allclose(quantity.vertex_values[0], [1,50,10])
    2124         assert allclose(quantity.vertex_values[5], [6,6,6])
    2125         assert allclose(quantity.vertex_values[1], [100,10,50])
     2116        assert num.allclose(quantity.vertex_values[0], [1,50,10])
     2117        assert num.allclose(quantity.vertex_values[5], [6,6,6])
     2118        assert num.allclose(quantity.vertex_values[1], [100,10,50])
    21262119
    21272120        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
     
    21302123        quantity.set_values(values, indices = [3,3,5])
    21312124        quantity.interpolate()
    2132         assert allclose(quantity.centroid_values, [1,2,3,400,5,999])
     2125        assert num.allclose(quantity.centroid_values, [1,2,3,400,5,999])
    21332126
    21342127        values = [[1,1,1],[2,2,2],[3,3,3],
     
    21422135        quantity.set_values(values)
    21432136        #print "1 quantity.vertex_values",quantity.vertex_values
    2144         assert allclose(quantity.vertex_values,[[ 4.,  5.,  0.],
    2145                                                 [ 1.,  0.,  5.],
    2146                                                 [ 5.,  6.,  1.],
    2147                                                 [ 2.,  1.,  6.],
    2148                                                 [ 6.,  7.,  2.],
    2149                                                 [ 3.,  2.,  7.]])
     2137        assert num.allclose(quantity.vertex_values,[[ 4.,  5.,  0.],
     2138                                                    [ 1.,  0.,  5.],
     2139                                                    [ 5.,  6.,  1.],
     2140                                                    [ 2.,  1.,  6.],
     2141                                                    [ 6.,  7.,  2.],
     2142                                                    [ 3.,  2.,  7.]])
    21502143
    21512144    def test_setting_unique_vertex_values(self):
     
    21552148        from mesh_factory import rectangular
    21562149        from shallow_water import Domain
    2157         from Numeric import zeros, Float
    21582150
    21592151        #Create basic mesh
     
    21712163                            indices = indices)
    21722164        #print "quantity.centroid_values",quantity.centroid_values
    2173         assert allclose(quantity.vertex_values[0], [0,7,0])
    2174         assert allclose(quantity.vertex_values[1], [7,1,7])
    2175         assert allclose(quantity.vertex_values[2], [7,2,7])
     2165        assert num.allclose(quantity.vertex_values[0], [0,7,0])
     2166        assert num.allclose(quantity.vertex_values[1], [7,1,7])
     2167        assert num.allclose(quantity.vertex_values[2], [7,2,7])
    21762168
    21772169
     
    21822174        from mesh_factory import rectangular
    21832175        from shallow_water import Domain
    2184         from Numeric import zeros, Float
    21852176
    21862177        #Create basic mesh
     
    22052196
    22062197        answer = [0.5,2,4,5,0,1,3,4.5]
    2207         assert allclose(answer,
    2208                         quantity.get_values(location = 'unique vertices'))
     2198        assert num.allclose(answer,
     2199                            quantity.get_values(location = 'unique vertices'))
    22092200
    22102201        indices = [0,5,3]
    22112202        answer = [0.5,1,5]
    2212         assert allclose(answer,
    2213                         quantity.get_values(indices=indices, \
    2214                                             location = 'unique vertices'))
     2203        assert num.allclose(answer,
     2204                            quantity.get_values(indices=indices,
     2205                                                location = 'unique vertices'))
    22152206        #print "quantity.centroid_values",quantity.centroid_values
    22162207        #print "quantity.get_values(location = 'centroids') ",\
     
    22412232        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
    22422233       
    2243         assert allclose(quantity.get_values(location='centroids'), [2,4,4,6])
    2244         assert allclose(quantity.get_values(location='centroids', indices=[1,3]), [4,6])
    2245 
    2246 
    2247         assert allclose(quantity.get_values(location='vertices'), [[4,0,2],
    2248                                                                    [4,2,6],
    2249                                                                    [6,2,4],
    2250                                                                    [8,4,6]])
    2251        
    2252         assert allclose(quantity.get_values(location='vertices', indices=[1,3]), [[4,2,6],
    2253                                                                                   [8,4,6]])
    2254 
    2255 
    2256         assert allclose(quantity.get_values(location='edges'), [[1,3,2],
    2257                                                                 [4,5,3],
    2258                                                                 [3,5,4],
    2259                                                                 [5,7,6]])
    2260         assert allclose(quantity.get_values(location='edges', indices=[1,3]),
    2261                         [[4,5,3],
    2262                          [5,7,6]])       
     2234        assert num.allclose(quantity.get_values(location='centroids'), [2,4,4,6])
     2235        assert num.allclose(quantity.get_values(location='centroids', indices=[1,3]), [4,6])
     2236
     2237
     2238        assert num.allclose(quantity.get_values(location='vertices'), [[4,0,2],
     2239                                                                       [4,2,6],
     2240                                                                       [6,2,4],
     2241                                                                       [8,4,6]])
     2242       
     2243        assert num.allclose(quantity.get_values(location='vertices', indices=[1,3]), [[4,2,6],
     2244                                                                                      [8,4,6]])
     2245
     2246
     2247        assert num.allclose(quantity.get_values(location='edges'), [[1,3,2],
     2248                                                                    [4,5,3],
     2249                                                                    [3,5,4],
     2250                                                                    [5,7,6]])
     2251        assert num.allclose(quantity.get_values(location='edges', indices=[1,3]),
     2252                            [[4,5,3],
     2253                             [5,7,6]])       
    22632254
    22642255        # Check averaging over vertices
     
    22802271        from mesh_factory import rectangular
    22812272        from shallow_water import Domain
    2282         from Numeric import zeros, Float
    22832273
    22842274        #Create basic mesh
     
    22982288       
    22992289        #print quantity.get_values(points=interpolation_points)
    2300         assert allclose(answer, quantity.get_values(interpolation_points=interpolation_points))
     2290        assert num.allclose(answer, quantity.get_values(interpolation_points=interpolation_points))
    23012291
    23022292
     
    23112301        #print answer
    23122302        #print quantity.get_values(interpolation_points=interpolation_points)
    2313         assert allclose(answer, quantity.get_values(interpolation_points=interpolation_points,
    2314                                                     verbose=False))       
     2303        assert num.allclose(answer, quantity.get_values(interpolation_points=interpolation_points,
     2304                                                        verbose=False))       
    23152305                       
    23162306
     
    23452335        x, y = 2.0/3, 8.0/3
    23462336        v = quantity.get_values(interpolation_points = [[x,y]])
    2347         assert allclose(v, 6)       
     2337        assert num.allclose(v, 6)       
    23482338
    23492339        # Then another to test that algorithm won't blindly
     
    23512341        x, y = 4.0/3, 4.0/3
    23522342        v = quantity.get_values(interpolation_points = [[x,y]])
    2353         assert allclose(v, 4)       
     2343        assert num.allclose(v, 4)       
    23542344
    23552345
     
    23802370        x, y = 2.0/3, 8.0/3
    23812371        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
    2382         assert allclose(v, 6)
     2372        assert num.allclose(v, 6)
    23832373       
    23842374
     
    23872377        x, y = 4.0/3, 4.0/3
    23882378        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
    2389         assert allclose(v, 4)       
     2379        assert num.allclose(v, 4)       
    23902380       
    23912381        # Try two points
     
    23932383               [4.0/3 + xllcorner, 4.0/3 + yllcorner]]         
    23942384        v = quantity.get_values(interpolation_points=pts)
    2395         assert allclose(v, [6, 4])               
     2385        assert num.allclose(v, [6, 4])               
    23962386       
    23972387        # Test it using the geospatial data format with absolute input points and default georef
    23982388        pts = Geospatial_data(data_points=pts)
    23992389        v = quantity.get_values(interpolation_points=pts)
    2400         assert allclose(v, [6, 4])                               
     2390        assert num.allclose(v, [6, 4])                               
    24012391       
    24022392       
     
    24052395                              geo_reference=Geo_reference(zone,xllcorner,yllcorner))
    24062396        v = quantity.get_values(interpolation_points=pts)
    2407         assert allclose(v, [6, 4])                       
     2397        assert num.allclose(v, [6, 4])                       
    24082398       
    24092399       
     
    24162406        from mesh_factory import rectangular
    24172407        from shallow_water import Domain
    2418         from Numeric import zeros, Float
    24192408
    24202409        #Create basic mesh
     
    24382427        #print "quantity.get_values(location = 'centroids') ",\
    24392428        #      quantity.get_values(location = 'centroids')
    2440         assert allclose(quantity.centroid_values,
    2441                         quantity.get_values(location = 'centroids'))
     2429        assert num.allclose(quantity.centroid_values,
     2430                            quantity.get_values(location = 'centroids'))
    24422431
    24432432
     
    24452434        quantity.set_values(value, indices = indices)
    24462435        #print "1 quantity.vertex_values",quantity.vertex_values
    2447         assert allclose(quantity.vertex_values, quantity.get_values())
    2448 
    2449         assert allclose(quantity.edge_values,
    2450                         quantity.get_values(location = 'edges'))
     2436        assert num.allclose(quantity.vertex_values, quantity.get_values())
     2437
     2438        assert num.allclose(quantity.edge_values,
     2439                            quantity.get_values(location = 'edges'))
    24512440
    24522441        # get a subset of elements
    24532442        subset = quantity.get_values(location='centroids', indices=[0,5])
    24542443        answer = [quantity.centroid_values[0],quantity.centroid_values[5]]
    2455         assert allclose(subset, answer)
     2444        assert num.allclose(subset, answer)
    24562445
    24572446
     
    24602449        #print "subset",subset
    24612450        #print "answer",answer
    2462         assert allclose(subset, answer)
     2451        assert num.allclose(subset, answer)
    24632452
    24642453        subset = quantity.get_values( indices=[1,5])
     
    24662455        #print "subset",subset
    24672456        #print "answer",answer
    2468         assert allclose(subset, answer)
     2457        assert num.allclose(subset, answer)
    24692458
    24702459    def test_smooth_vertex_values(self):
     
    24742463        from mesh_factory import rectangular
    24752464        from shallow_water import Domain
    2476         from Numeric import zeros, Float
    24772465
    24782466        #Create basic mesh
     
    25122500                                [4,5,3],[3.5,3,5],[5,6.5,3.5],[4,3.5,6.5]]
    25132501       
    2514         assert allclose(answer_vertex_values,
    2515                         quantity.vertex_values)
     2502        assert num.allclose(answer_vertex_values,
     2503                            quantity.vertex_values)
    25162504        #print "quantity.centroid_values",quantity.centroid_values
    25172505        #print "quantity.get_values(location = 'centroids') ",\
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_region.py

    r5897 r6145  
    77from region import *
    88#from anuga.config import epsilon
    9 from Numeric import allclose, average #, array, ones, Float
     9
     10import Numeric as num
     11
     12
    1013"""
    1114This is what the mesh in these tests look like;
     
    4447        from mesh_factory import rectangular
    4548        from shallow_water import Domain
    46         from Numeric import zeros, Float
    4749
    4850        #Create basic mesh
     
    6466        domain.set_region([a, b])
    6567        #print domain.quantities['friction'].get_values()
    66         assert allclose(domain.quantities['friction'].get_values(),\
    67                         [[ 0.09,  0.09,  0.09],
    68                          [ 0.09,  0.09,  0.09],
    69                          [ 0.07,  0.07,  0.07],
    70                          [ 0.07,  0.07,  0.07],
    71                          [ 1.0,  1.0,  1.0],
    72                          [ 1.0,  1.0,  1.0]])
     68        assert num.allclose(domain.quantities['friction'].get_values(),\
     69                            [[ 0.09,  0.09,  0.09],
     70                             [ 0.09,  0.09,  0.09],
     71                             [ 0.07,  0.07,  0.07],
     72                             [ 0.07,  0.07,  0.07],
     73                             [ 1.0,  1.0,  1.0],
     74                             [ 1.0,  1.0,  1.0]])
    7375
    7476        #c = Add_Value_To_region('all', 'friction', 10.0)
    7577        domain.set_region(Add_value_to_region('all', 'friction', 10.0))
    7678        #print domain.quantities['friction'].get_values()
    77         assert allclose(domain.quantities['friction'].get_values(),
    78                         [[ 10.09, 10.09, 10.09],
    79                          [ 10.09, 10.09, 10.09],
    80                          [ 10.07, 10.07, 10.07],
    81                          [ 10.07, 10.07, 10.07],
    82                          [ 11.0,  11.0,  11.0],
    83                          [ 11.0,  11.0,  11.0]])
     79        assert num.allclose(domain.quantities['friction'].get_values(),
     80                            [[ 10.09, 10.09, 10.09],
     81                             [ 10.09, 10.09, 10.09],
     82                             [ 10.07, 10.07, 10.07],
     83                             [ 10.07, 10.07, 10.07],
     84                             [ 11.0,  11.0,  11.0],
     85                             [ 11.0,  11.0,  11.0]])
    8486
    8587        # trying a function
    8688        domain.set_region(Set_region('top', 'friction', add_x_y))
    8789        #print domain.quantities['friction'].get_values()
    88         assert allclose(domain.quantities['friction'].get_values(),
    89                         [[ 10.09, 10.09, 10.09],
    90                          [ 10.09, 10.09, 10.09],
    91                          [ 10.07, 10.07, 10.07],
    92                          [ 10.07, 10.07, 10.07],
    93                          [ 5./3,  2.0,  2./3],
    94                          [ 1.0,  2./3,  2.0]])
     90        assert num.allclose(domain.quantities['friction'].get_values(),
     91                            [[ 10.09, 10.09, 10.09],
     92                             [ 10.09, 10.09, 10.09],
     93                             [ 10.07, 10.07, 10.07],
     94                             [ 10.07, 10.07, 10.07],
     95                             [ 5./3,  2.0,  2./3],
     96                             [ 1.0,  2./3,  2.0]])
    9597
    9698        domain.set_quantity('elevation', 10.0)
     
    98100        domain.set_region(Add_value_to_region('top', 'stage', 1.0,initial_quantity='elevation'))
    99101        #print domain.quantities['stage'].get_values()
    100         assert allclose(domain.quantities['stage'].get_values(),
    101                         [[ 10., 10., 10.],
    102                          [ 10., 10., 10.],
    103                          [ 10., 10., 10.],
    104                          [ 10., 10., 10.],
    105                          [ 11.0,  11.0,  11.0],
    106                          [ 11.0,  11.0,  11.0]])
     102        assert num.allclose(domain.quantities['stage'].get_values(),
     103                            [[ 10., 10., 10.],
     104                             [ 10., 10., 10.],
     105                             [ 10., 10., 10.],
     106                             [ 10., 10., 10.],
     107                             [ 11.0,  11.0,  11.0],
     108                             [ 11.0,  11.0,  11.0]])
    107109
    108110       
     
    115117        domain.set_region(Add_quantities('top', 'elevation','stage'))
    116118        #print domain.quantities['stage'].get_values()
    117         assert allclose(domain.quantities['elevation'].get_values(),
    118                         [[ 10., 10., 10.],
    119                          [ 10., 10., 10.],
    120                          [ 10., 10., 10.],
    121                          [ 10., 10., 10.],
    122                          [ 33.,  33.0,  33.],
    123                          [ 33.0,  33.,  33.]])
     119        assert num.allclose(domain.quantities['elevation'].get_values(),
     120                            [[ 10., 10., 10.],
     121                             [ 10., 10., 10.],
     122                             [ 10., 10., 10.],
     123                             [ 10., 10., 10.],
     124                             [ 33.,  33.0,  33.],
     125                             [ 33.0,  33.,  33.]])
    124126       
    125127    def test_unique_vertices(self):
     
    129131        from mesh_factory import rectangular
    130132        from shallow_water import Domain
    131         from Numeric import zeros, Float
    132133
    133134        #Create basic mesh
     
    147148        domain.set_region(a)
    148149        #print domain.quantities['friction'].get_values()
    149         assert allclose(domain.quantities['friction'].get_values(),\
    150                         [[ 0.09,  0.09,  0.09],
    151                          [ 0.09,  0.09,  0.09],
    152                          [ 0.09,  0.07,  0.09],
    153                          [ 0.07,  0.09,  0.07],
    154                          [ 0.07,  0.07,  0.07],
    155                          [ 0.07,  0.07,  0.07]])
     150        assert num.allclose(domain.quantities['friction'].get_values(),\
     151                            [[ 0.09,  0.09,  0.09],
     152                             [ 0.09,  0.09,  0.09],
     153                             [ 0.09,  0.07,  0.09],
     154                             [ 0.07,  0.09,  0.07],
     155                             [ 0.07,  0.07,  0.07],
     156                             [ 0.07,  0.07,  0.07]])
    156157
    157158
     
    162163        from mesh_factory import rectangular
    163164        from shallow_water import Domain
    164         from Numeric import zeros, Float
    165165
    166166        #Create basic mesh
     
    180180
    181181        #print domain.quantities['friction'].get_values()
    182         assert allclose(domain.quantities['friction'].get_values(),\
    183                         [[ 1.07,  1.07,  1.07],
    184                          [ 1.07,  1.07,  1.07],
    185                          [ 1.07,  0.07,  1.07],
    186                          [ 0.07,  1.07,  0.07],
    187                          [ 0.07,  0.07,  0.07],
    188                          [ 0.07,  0.07,  0.07]])
     182        assert num.allclose(domain.quantities['friction'].get_values(),\
     183                            [[ 1.07,  1.07,  1.07],
     184                             [ 1.07,  1.07,  1.07],
     185                             [ 1.07,  0.07,  1.07],
     186                             [ 0.07,  1.07,  0.07],
     187                             [ 0.07,  0.07,  0.07],
     188                             [ 0.07,  0.07,  0.07]])
    189189                         
    190190    def test_unique_vertices_average_loc_vert(self):
     
    194194        from mesh_factory import rectangular
    195195        from shallow_water import Domain
    196         from Numeric import zeros, Float
    197196
    198197        #Create basic mesh
     
    218217        #print domain.quantities['friction'].get_values()
    219218        frict_points = domain.quantities['friction'].get_values()
    220         assert allclose(frict_points[0],\
    221                         [ calc_frict, calc_frict, calc_frict])
    222         assert allclose(frict_points[1],\
    223                         [ calc_frict, calc_frict, calc_frict])
     219        assert num.allclose(frict_points[0],\
     220                            [ calc_frict, calc_frict, calc_frict])
     221        assert num.allclose(frict_points[1],\
     222                            [ calc_frict, calc_frict, calc_frict])
    224223 
    225224    def test_unique_vertices_average_loc_unique_vert(self):
     
    229228        from mesh_factory import rectangular
    230229        from shallow_water import Domain
    231         from Numeric import zeros, Float
    232230
    233231        #Create basic mesh
     
    252250        #print domain.quantities['friction'].get_values()
    253251        frict_points = domain.quantities['friction'].get_values()
    254         assert allclose(frict_points[0],\
    255                         [ calc_frict, calc_frict, calc_frict])
    256         assert allclose(frict_points[1],\
    257                         [ calc_frict, calc_frict, calc_frict])
    258         assert allclose(frict_points[2],\
    259                         [ calc_frict, 1.0 + 2.0/3.0, calc_frict])
    260         assert allclose(frict_points[3],\
    261                         [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
     252        assert num.allclose(frict_points[0],\
     253                            [ calc_frict, calc_frict, calc_frict])
     254        assert num.allclose(frict_points[1],\
     255                            [ calc_frict, calc_frict, calc_frict])
     256        assert num.allclose(frict_points[2],\
     257                            [ calc_frict, 1.0 + 2.0/3.0, calc_frict])
     258        assert num.allclose(frict_points[3],\
     259                            [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
    262260                                               
    263261                         
  • anuga_core/source/anuga/abstract_2d_finite_volumes/test_util.py

    r6086 r6145  
    33
    44import unittest
    5 from Numeric import zeros, array, allclose, Float
    65from math import sqrt, pi
    76import tempfile, os
     
    2221import time
    2322import string
     23
     24import Numeric as num
     25
    2426
    2527def test_function(x, y):
     
    9193
    9294            #Exact linear intpolation
    93             assert allclose(q[0], 2*t)
     95            assert num.allclose(q[0], 2*t)
    9496            if i%6 == 0:
    95                 assert allclose(q[1], t**2)
    96                 assert allclose(q[2], sin(t*pi/600))
     97                assert num.allclose(q[1], t**2)
     98                assert num.allclose(q[2], sin(t*pi/600))
    9799
    98100        #Check non-exact
     
    100102        t = 90 #Halfway between 60 and 120
    101103        q = F(t)
    102         assert allclose( (120**2 + 60**2)/2, q[1] )
    103         assert allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
     104        assert num.allclose( (120**2 + 60**2)/2, q[1] )
     105        assert num.allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
    104106
    105107
    106108        t = 100 #Two thirds of the way between between 60 and 120
    107109        q = F(t)
    108         assert allclose( 2*120**2/3 + 60**2/3, q[1] )
    109         assert allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
     110        assert num.allclose( 2*120**2/3 + 60**2/3, q[1] )
     111        assert num.allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
    110112
    111113        os.remove(filename + '.txt')
     
    125127        from shallow_water import Domain, Dirichlet_boundary
    126128        from mesh_factory import rectangular
    127         from Numeric import take, concatenate, reshape
    128129
    129130        #Create basic mesh and shallow water domain
     
    182183
    183184        last_time_index = len(time)-1 #Last last_time_index
    184         d_stage = reshape(take(stage[last_time_index, :], [0,5,10,15]), (4,1))
    185         d_uh = reshape(take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
    186         d_vh = reshape(take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
    187         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     185        d_stage = num.reshape(num.take(stage[last_time_index, :], [0,5,10,15]), (4,1))
     186        d_uh = num.reshape(num.take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
     187        d_vh = num.reshape(num.take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
     188        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    188189
    189190        #Reference interpolated values at midpoints on diagonal at
     
    194195
    195196        #And the midpoints are found now
    196         Dx = take(reshape(x, (16,1)), [0,5,10,15])
    197         Dy = take(reshape(y, (16,1)), [0,5,10,15])
    198 
    199         diag = concatenate( (Dx, Dy), axis=1)
     197        Dx = num.take(num.reshape(x, (16,1)), [0,5,10,15])
     198        Dy = num.take(num.reshape(y, (16,1)), [0,5,10,15])
     199
     200        diag = num.concatenate( (Dx, Dy), axis=1)
    200201        d_midpoints = (diag[1:] + diag[:-1])/2
    201202
     
    209210        assert not T[-1] == T[-2], msg
    210211        t = time[last_time_index]
    211         q = f(t, point_id=0); assert allclose(r0, q)
    212         q = f(t, point_id=1); assert allclose(r1, q)
    213         q = f(t, point_id=2); assert allclose(r2, q)
     212        q = f(t, point_id=0); assert num.allclose(r0, q)
     213        q = f(t, point_id=1); assert num.allclose(r1, q)
     214        q = f(t, point_id=2); assert num.allclose(r2, q)
    214215
    215216
     
    218219
    219220        timestep = 0 #First timestep
    220         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    221         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    222         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    223         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     221        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     222        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     223        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     224        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    224225
    225226        #Reference interpolated values at midpoints on diagonal at
     
    231232        #Let us see if the file function can find the correct
    232233        #values
    233         q = f(0, point_id=0); assert allclose(r0, q)
    234         q = f(0, point_id=1); assert allclose(r1, q)
    235         q = f(0, point_id=2); assert allclose(r2, q)
     234        q = f(0, point_id=0); assert num.allclose(r0, q)
     235        q = f(0, point_id=1); assert num.allclose(r1, q)
     236        q = f(0, point_id=2); assert num.allclose(r2, q)
    236237
    237238
     
    240241
    241242        timestep = 33
    242         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    243         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    244         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    245         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     243        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     244        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     245        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     246        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    246247
    247248        #Reference interpolated values at midpoints on diagonal at
     
    251252        r2 = (D[2] + D[3])/2
    252253
    253         q = f(timestep/10., point_id=0); assert allclose(r0, q)
    254         q = f(timestep/10., point_id=1); assert allclose(r1, q)
    255         q = f(timestep/10., point_id=2); assert allclose(r2, q)
     254        q = f(timestep/10., point_id=0); assert num.allclose(r0, q)
     255        q = f(timestep/10., point_id=1); assert num.allclose(r1, q)
     256        q = f(timestep/10., point_id=2); assert num.allclose(r2, q)
    256257
    257258
     
    261262
    262263        timestep = 15
    263         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    264         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    265         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    266         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     264        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     265        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     266        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     267        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    267268
    268269        #Reference interpolated values at midpoints on diagonal at
     
    274275        #
    275276        timestep = 16
    276         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    277         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    278         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    279         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     277        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     278        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     279        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     280        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    280281
    281282        #Reference interpolated values at midpoints on diagonal at
     
    290291        r2 = (r2_0 + r2_1)/2
    291292
    292         q = f((timestep - 0.5)/10., point_id=0); assert allclose(r0, q)
    293         q = f((timestep - 0.5)/10., point_id=1); assert allclose(r1, q)
    294         q = f((timestep - 0.5)/10., point_id=2); assert allclose(r2, q)
     293        q = f((timestep - 0.5)/10., point_id=0); assert num.allclose(r0, q)
     294        q = f((timestep - 0.5)/10., point_id=1); assert num.allclose(r1, q)
     295        q = f((timestep - 0.5)/10., point_id=2); assert num.allclose(r2, q)
    295296
    296297        ##################
     
    304305
    305306        #And the file function gives
    306         q = f((timestep - 1.0/3)/10., point_id=0); assert allclose(r0, q)
    307         q = f((timestep - 1.0/3)/10., point_id=1); assert allclose(r1, q)
    308         q = f((timestep - 1.0/3)/10., point_id=2); assert allclose(r2, q)
     307        q = f((timestep - 1.0/3)/10., point_id=0); assert num.allclose(r0, q)
     308        q = f((timestep - 1.0/3)/10., point_id=1); assert num.allclose(r1, q)
     309        q = f((timestep - 1.0/3)/10., point_id=2); assert num.allclose(r2, q)
    309310
    310311        fid.close()
     
    326327        from shallow_water import Domain, Dirichlet_boundary
    327328        from mesh_factory import rectangular
    328         from Numeric import take, concatenate, reshape
    329329
    330330
     
    386386
    387387        last_time_index = len(time)-1 #Last last_time_index     
    388         d_stage = reshape(take(stage[last_time_index, :], [0,5,10,15]), (4,1))
    389         d_uh = reshape(take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
    390         d_vh = reshape(take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
    391         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     388        d_stage = num.reshape(num.take(stage[last_time_index, :], [0,5,10,15]), (4,1))
     389        d_uh = num.reshape(num.take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
     390        d_vh = num.reshape(num.take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
     391        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    392392
    393393        #Reference interpolated values at midpoints on diagonal at
     
    398398
    399399        #And the midpoints are found now
    400         Dx = take(reshape(x, (16,1)), [0,5,10,15])
    401         Dy = take(reshape(y, (16,1)), [0,5,10,15])
    402 
    403         diag = concatenate( (Dx, Dy), axis=1)
     400        Dx = num.take(num.reshape(x, (16,1)), [0,5,10,15])
     401        Dy = num.take(num.reshape(y, (16,1)), [0,5,10,15])
     402
     403        diag = num.concatenate( (Dx, Dy), axis=1)
    404404        d_midpoints = (diag[1:] + diag[:-1])/2
    405405
     
    415415
    416416        t = time[last_time_index]                         
    417         q = f(t, point_id=0); assert allclose(r0, q)
    418         q = f(t, point_id=1); assert allclose(r1, q)
    419         q = f(t, point_id=2); assert allclose(r2, q)
     417        q = f(t, point_id=0); assert num.allclose(r0, q)
     418        q = f(t, point_id=1); assert num.allclose(r1, q)
     419        q = f(t, point_id=2); assert num.allclose(r2, q)
    420420
    421421
     
    424424
    425425        timestep = 0 #First timestep
    426         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    427         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    428         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    429         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     426        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     427        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     428        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     429        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    430430
    431431        #Reference interpolated values at midpoints on diagonal at
     
    437437        #Let us see if the file function can find the correct
    438438        #values
    439         q = f(0, point_id=0); assert allclose(r0, q)
    440         q = f(0, point_id=1); assert allclose(r1, q)
    441         q = f(0, point_id=2); assert allclose(r2, q)
     439        q = f(0, point_id=0); assert num.allclose(r0, q)
     440        q = f(0, point_id=1); assert num.allclose(r1, q)
     441        q = f(0, point_id=2); assert num.allclose(r2, q)
    442442
    443443
     
    446446
    447447        timestep = 33
    448         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    449         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    450         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    451         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     448        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     449        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     450        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     451        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    452452
    453453        #Reference interpolated values at midpoints on diagonal at
     
    457457        r2 = (D[2] + D[3])/2
    458458
    459         q = f(timestep/10., point_id=0); assert allclose(r0, q)
    460         q = f(timestep/10., point_id=1); assert allclose(r1, q)
    461         q = f(timestep/10., point_id=2); assert allclose(r2, q)
     459        q = f(timestep/10., point_id=0); assert num.allclose(r0, q)
     460        q = f(timestep/10., point_id=1); assert num.allclose(r1, q)
     461        q = f(timestep/10., point_id=2); assert num.allclose(r2, q)
    462462
    463463
     
    467467
    468468        timestep = 15
    469         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    470         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    471         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    472         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     469        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     470        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     471        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     472        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    473473
    474474        #Reference interpolated values at midpoints on diagonal at
     
    480480        #
    481481        timestep = 16
    482         d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
    483         d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
    484         d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
    485         D = concatenate( (d_stage, d_uh, d_vh), axis=1)
     482        d_stage = num.reshape(num.take(stage[timestep, :], [0,5,10,15]), (4,1))
     483        d_uh = num.reshape(num.take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
     484        d_vh = num.reshape(num.take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
     485        D = num.concatenate( (d_stage, d_uh, d_vh), axis=1)
    486486
    487487        #Reference interpolated values at midpoints on diagonal at
     
    496496        r2 = (r2_0 + r2_1)/2
    497497
    498         q = f((timestep - 0.5)/10., point_id=0); assert allclose(r0, q)
    499         q = f((timestep - 0.5)/10., point_id=1); assert allclose(r1, q)
    500         q = f((timestep - 0.5)/10., point_id=2); assert allclose(r2, q)
     498        q = f((timestep - 0.5)/10., point_id=0); assert num.allclose(r0, q)
     499        q = f((timestep - 0.5)/10., point_id=1); assert num.allclose(r1, q)
     500        q = f((timestep - 0.5)/10., point_id=2); assert num.allclose(r2, q)
    501501
    502502        ##################
     
    510510
    511511        #And the file function gives
    512         q = f((timestep - 1.0/3)/10., point_id=0); assert allclose(r0, q)
    513         q = f((timestep - 1.0/3)/10., point_id=1); assert allclose(r1, q)
    514         q = f((timestep - 1.0/3)/10., point_id=2); assert allclose(r2, q)
     512        q = f((timestep - 1.0/3)/10., point_id=0); assert num.allclose(r0, q)
     513        q = f((timestep - 1.0/3)/10., point_id=1); assert num.allclose(r1, q)
     514        q = f((timestep - 1.0/3)/10., point_id=2); assert num.allclose(r2, q)
    515515
    516516        fid.close()
     
    542542        import os, time
    543543        from anuga.config import time_format
    544         from Numeric import sin, pi, exp
    545544        from mesh_factory import rectangular
    546545        from shallow_water import Domain
     
    584583            domain.set_quantity('xmomentum', f2)
    585584
    586             f3 = lambda x,y: x**2 + y**2 * sin(t*pi/600)
     585            f3 = lambda x,y: x**2 + y**2 * num.sin(t*num.pi/600)
    587586            domain.set_quantity('ymomentum', f3)
    588587
     
    604603
    605604        #Check that FF updates fixes domain starttime
    606         assert allclose(domain.starttime, start)
     605        assert num.allclose(domain.starttime, start)
    607606
    608607        #Check that domain.starttime isn't updated if later
     
    611610                          quantities = domain.conserved_quantities,
    612611                          interpolation_points = interpolation_points)
    613         assert allclose(domain.starttime, start+1)
     612        assert num.allclose(domain.starttime, start+1)
    614613        domain.starttime = start
    615614
     
    645644                     self.failUnless( q == actual, 'Fail!')
    646645                else:
    647                     assert allclose(q, actual)
     646                    assert num.allclose(q, actual)
    648647
    649648
     
    655654            t = 90 #Halfway between 60 and 120
    656655            q = F(t, point_id=id)
    657             assert allclose( (q120+q60)/2, q )
     656            assert num.allclose( (q120+q60)/2, q )
    658657
    659658            t = 100 #Two thirds of the way between between 60 and 120
    660659            q = F(t, point_id=id)
    661             assert allclose(q60/3 + 2*q120/3, q)
     660            assert num.allclose(q60/3 + 2*q120/3, q)
    662661
    663662
     
    670669                          quantities = domain.conserved_quantities,
    671670                          interpolation_points = interpolation_points)
    672         assert allclose(domain.starttime, start+delta)
     671        assert num.allclose(domain.starttime, start+delta)
    673672
    674673
     
    689688
    690689                q = F(t-delta, point_id=id)
    691                 assert allclose(q, (k*q1 + (6-k)*q0)/6)
     690                assert num.allclose(q, (k*q1 + (6-k)*q0)/6)
    692691
    693692
     
    703702        import os, time
    704703        from anuga.config import time_format
    705         from Numeric import sin, pi, exp
    706704        from mesh_factory import rectangular
    707705        from shallow_water import Domain
     
    751749            domain.set_quantity('xmomentum', f2)
    752750
    753             f3 = lambda x,y: x**2 + y**2 * sin(t*pi/600)
     751            f3 = lambda x,y: x**2 + y**2 * num.sin(t*num.pi/600)
    754752            domain.set_quantity('ymomentum', f3)
    755753
     
    774772
    775773        #Check that FF updates fixes domain starttime
    776         assert allclose(domain.starttime, start)
     774        assert num.allclose(domain.starttime, start)
    777775
    778776        #Check that domain.starttime isn't updated if later
     
    781779                          quantities = domain.conserved_quantities,
    782780                          interpolation_points = interpolation_points)
    783         assert allclose(domain.starttime, start+1)
     781        assert num.allclose(domain.starttime, start+1)
    784782        domain.starttime = start
    785783
     
    817815                     self.failUnless( q == actual, 'Fail!')
    818816                else:
    819                     assert allclose(q, actual)
     817                    assert num.allclose(q, actual)
    820818
    821819        # now lets check points inside the mesh
     
    863861                     self.failUnless( q == actual, 'Fail!')
    864862                else:
    865                     assert allclose(q, actual)
     863                    assert num.allclose(q, actual)
    866864
    867865
     
    873871            t = 90 #Halfway between 60 and 120
    874872            q = F(t, point_id=id)
    875             assert allclose( (q120+q60)/2, q )
     873            assert num.allclose( (q120+q60)/2, q )
    876874
    877875            t = 100 #Two thirds of the way between between 60 and 120
    878876            q = F(t, point_id=id)
    879             assert allclose(q60/3 + 2*q120/3, q)
     877            assert num.allclose(q60/3 + 2*q120/3, q)