Changeset 5947


Ignore:
Timestamp:
Nov 12, 2008, 12:09:05 PM (16 years ago)
Author:
rwilson
Message:

More NumPy? changes.

Location:
anuga_core/source_numpy_conversion/anuga/shallow_water
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • anuga_core/source_numpy_conversion/anuga/shallow_water/data_manager.py

    r5901 r5947  
    7979from os import getcwd
    8080
    81 
     81from anuga.config import Int, Float, Float32
    8282from anuga.coordinate_transforms.redfearn import redfearn, \
    8383     convert_from_latlon_to_utm
    … …  
    314314        from Scientific.IO.NetCDF import NetCDFFile
    315315
    316         self.precision = numpy.float32 #Use single precision for quantities
     316        self.precision = Float32 #Use single precision for quantities
    317317        if hasattr(domain, 'max_size'):
    318318            self.max_size = domain.max_size #file size max is 2Gig
    … …  
    407407        z = fid.variables['elevation']
    408408
    409         volumes = fid.variables['volumes']
     409        volumes = numpy.array(fid.variables['volumes'])
    410410
    411411        # Get X, Y and bed elevation Z
    … …  
    632632
    633633
    634             fid.createVariable('volumes', numpy.int, ('number_of_volumes',
     634            fid.createVariable('volumes', Int, ('number_of_volumes',
    635635                                                'number_of_vertices'))
    636636
    … …  
    14181418
    14191419    # Variable definitions
    1420     outfile.createVariable('points', numpy.float, ('number_of_points',
     1420    outfile.createVariable('points', Float, ('number_of_points',
    14211421                                             'number_of_dimensions'))
    1422     outfile.createVariable('elevation', numpy.float, ('number_of_points',))
     1422    outfile.createVariable('elevation', Float, ('number_of_points',))
    14231423
    14241424    # Get handles to the variables
    … …  
    26002600
    26012601    # variable definitions
    2602     fid.createVariable('elevation', numpy.float, ('number_of_rows',
     2602    fid.createVariable('elevation', Float, ('number_of_rows',
    26032603                                            'number_of_columns'))
    26042604
    … …  
    31633163    fid.createDimension('number_of_timesteps', len(T))
    31643164
    3165     fid.createVariable('time', numpy.float, ('number_of_timesteps',))
     3165    fid.createVariable('time', Float, ('number_of_timesteps',))
    31663166
    31673167    fid.variables['time'][:] = T
    … …  
    31733173            name = 'Attribute%d'%i
    31743174
    3175         fid.createVariable(name, numpy.float, ('number_of_timesteps',))
     3175        fid.createVariable(name, Float, ('number_of_timesteps',))
    31763176        fid.variables[name][:] = Q[:,i]
    31773177
    … …  
    35583558
    35593559    # variable definition
    3560     outfile.createVariable('elevation', numpy.float, ('number_of_points',))
     3560    outfile.createVariable('elevation', Float, ('number_of_points',))
    35613561
    35623562    # Get handle to the variable
    … …  
    37753775    #################################
    37763776
    3777     outfile.createVariable('volumes', numpy.int, ('number_of_volumes',
     3777    outfile.createVariable('volumes', Int, ('number_of_volumes',
    37783778                                            'number_of_vertices'))
    37793779
    … …  
    53215321                     smoothing=True,
    53225322                     order=1,
    5323                      sww_precision=numpy.float32,
     5323                     sww_precision=None,
    53245324                     verbose=False):
    53255325        """
    … …  
    53325332        outfile.institution = 'Geoscience Australia'
    53335333        outfile.description = description
     5334
     5335        # ensure sww_precision is a character data type
     5336        if sww_precision is None:
     5337            sww_precision = Float32
     5338        elif isinstance(sww_precision, type):
     5339            sww_precision = numpy.dtype(sww_precision).char
    53345340
    53355341        # For sww compatibility
    … …  
    54065412        #################################
    54075413
    5408         outfile.createVariable('volumes', numpy.int, ('number_of_volumes',
     5414        outfile.createVariable('volumes', Int, ('number_of_volumes',
    54095415                                                'number_of_vertices'))
    54105416        # Doing sww_precision instead of Float gives cast errors.
    5411         outfile.createVariable('time', numpy.float,
     5417        outfile.createVariable('time', Float,
    54125418                               ('number_of_timesteps',))
    54135419       
    … …  
    57445750
    57455751        # Variable definitions
    5746         outfile.createVariable('permutation', numpy.int, ('number_of_points',)) 
     5752        outfile.createVariable('permutation', Int, ('number_of_points',))
    57475753        outfile.createVariable('x', sts_precision, ('number_of_points',))
    57485754        outfile.createVariable('y', sts_precision, ('number_of_points',))
    … …  
    57595765
    57605766        # Doing sts_precision instead of Float gives cast errors.
    5761         outfile.createVariable('time', numpy.float, ('number_of_timesteps',))
     5767        outfile.createVariable('time', Floatr, ('number_of_timesteps',))
    57625768
    57635769        for q in Write_sts.sts_quantities:

  • anuga_core/source_numpy_conversion/anuga/shallow_water/shallow_water_domain.py

    r5901 r5947  
    14571457            # FIXME: Reconsider this semantics
    14581458            raise msg
    1459 
    14601459        try:
    14611460            q = numpy.array(q).astype(numpy.float)
    … …  
    14671466
    14681467        # Is this really what we want?
    1469         msg = 'Return vector from function %s ' %f
     1468        msg = 'Return vector from function %s ' % f
    14701469        msg += 'must have same lenght as input vectors'
    1471         assert len(q) == N, msg
     1470        try:
     1471            assert len(q) == N, msg
     1472        except:
     1473            raise AssertionError, msg
    14721474
    14731475    else:

  • anuga_core/source_numpy_conversion/anuga/shallow_water/test_data_manager.py

    r5901 r5947  
    1515from sets import ImmutableSet
    1616
     17from anuga.config import Float, Int
    1718from anuga.shallow_water import *
    1819from anuga.shallow_water.data_manager import *
    … …  
    6667        #Initial condition - with jumps
    6768        bed = domain.quantities['elevation'].vertex_values
    68         stage = numpy.zeros(bed.shape, numpy.float)
     69        stage = numpy.zeros(bed.shape, Float)
    6970
    7071        h = 0.3
    … …  
    446447
    447448        import time, os
    448 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    449449        from Scientific.IO.NetCDF import NetCDFFile
    450450
    … …  
    504504       
    505505        import time, os
    506 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    507506        from Scientific.IO.NetCDF import NetCDFFile
    508507
    … …  
    559558
    560559        import time, os, config
    561 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    562560        from Scientific.IO.NetCDF import NetCDFFile
    563561
    … …  
    607605
    608606        import time, os
    609 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    610607        from Scientific.IO.NetCDF import NetCDFFile
    611608
    … …  
    663660
    664661        import time, os
    665 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    666662        from Scientific.IO.NetCDF import NetCDFFile
    667663
    … …  
    724720
    725721        import time, os
    726 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate, ones
    727722        from Scientific.IO.NetCDF import NetCDFFile
    728723
    … …  
    838833
    839834        import time, os
    840 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate, ones
    841835        from Scientific.IO.NetCDF import NetCDFFile
    842836
    … …  
    861855        xvec = range(10)
    862856        #z = range(100)
    863         z = numpy.zeros(100)
     857        z = numpy.zeros(100, Float)
    864858        NODATA_value = -9999
    865859        count = -1
    … …  
    920914
    921915        #create new reference points
    922         newz = numpy.zeros(19)
     916        newz = numpy.zeros(19, Float)
    923917        newz[0:2] = ref_elevation[32:34]
    924918        newz[2:5] = ref_elevation[35:38]
    … …  
    969963
    970964        import time, os
    971 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate, ones
    972965        from Scientific.IO.NetCDF import NetCDFFile
    973966
    … …  
    992985        xvec = range(10)
    993986        #z = range(100)
    994         z = numpy.zeros(100)
     987        z = numpy.zeros(100, Float)
    995988        NODATA_value = -9999
    996989        count = -1
    … …  
    10511044
    10521045        #create new reference points
    1053         newz = numpy.zeros(14)
     1046        newz = numpy.zeros(14, Float)
    10541047        newz[0:2] = ref_elevation[32:34]
    10551048        newz[2:5] = ref_elevation[35:38]
    … …  
    11031096
    11041097        import time, os
    1105 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    11061098        from Scientific.IO.NetCDF import NetCDFFile
    11071099
    … …  
    12351227
    12361228        import time, os
    1237 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    12381229        from Scientific.IO.NetCDF import NetCDFFile
    12391230
    … …  
    14271418
    14281419        import time, os
    1429 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    14301420        from Scientific.IO.NetCDF import NetCDFFile
    14311421
    … …  
    15111501
    15121502        import time, os
    1513 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    15141503        from Scientific.IO.NetCDF import NetCDFFile
    15151504
    … …  
    16491638
    16501639        import time, os
    1651 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    16521640        from Scientific.IO.NetCDF import NetCDFFile
    16531641
    … …  
    17951783
    17961784        import time, os
    1797 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    17981785        from Scientific.IO.NetCDF import NetCDFFile
    17991786
    … …  
    19431930
    19441931        import time, os
    1945 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    19461932        from Scientific.IO.NetCDF import NetCDFFile
    19471933
    … …  
    21302116
    21312117        import time, os
    2132 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    21332118        from Scientific.IO.NetCDF import NetCDFFile
    21342119
    … …  
    22962281
    22972282        import time, os
    2298 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    22992283        from Scientific.IO.NetCDF import NetCDFFile
    23002284
    … …  
    24082392
    24092393        import time, os
    2410 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    24112394        from Scientific.IO.NetCDF import NetCDFFile
    24122395
    … …  
    25242507
    25252508        import time, os
    2526 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    25272509        from Scientific.IO.NetCDF import NetCDFFile
    25282510
    … …  
    25572539
    25582540        bed = domain.quantities['elevation'].vertex_values
    2559         stage = numpy.zeros(bed.shape, numpy.float)
     2541        stage = numpy.zeros(bed.shape, Float)
    25602542
    25612543        h = 0.3
    … …  
    26692651
    26702652        import time, os
    2671 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    26722653        from Scientific.IO.NetCDF import NetCDFFile
    26732654
    … …  
    27692750
    27702751        import time, os
    2771 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate, NewAxis
    27722752        from Scientific.IO.NetCDF import NetCDFFile
    27732753        # Used for points that lie outside mesh
    … …  
    35353515
    35363516        import time, os
    3537 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    35383517        from Scientific.IO.NetCDF import NetCDFFile
    35393518
    … …  
    35823561        ################################################
    35833562        from mesh_factory import rectangular
    3584 ##        from numpy.oldnumeric import array
    35853563
    35863564        #Create basic mesh
    … …  
    36273605        ##########################################
    36283606        from data_manager import sww2domain
    3629 ##        from numpy.oldnumeric import allclose
    36303607        import os
    36313608
    … …  
    37193696
    37203697        from mesh_factory import rectangular
    3721 ##        from numpy.oldnumeric import array
    37223698
    37233699        #Create basic mesh
    … …  
    37613737        ##################################
    37623738        from data_manager import sww2domain
    3763 ##        from numpy.oldnumeric import allclose
    37643739        import os
    37653740
    … …  
    38283803        ################################################
    38293804        from mesh_factory import rectangular
    3830 ##        from numpy.oldnumeric import array
    38313805        #Create basic mesh
    38323806
    … …  
    38723846        ##########################################
    38733847        from data_manager import sww2domain
    3874 ##        from numpy.oldnumeric import allclose
    38753848        import os
    38763849
    … …  
    39593932
    39603933        import os
    3961 ##        from numpy.oldnumeric import ones, allclose, Float, arange
    39623934        from Scientific.IO.NetCDF import NetCDFFile
    39633935
    … …  
    39913963        fid.createDimension('number_of_points', nrows*ncols)
    39923964
    3993         fid.createVariable('elevation', numpy.float, ('number_of_points',))
     3965        fid.createVariable('elevation', Float, ('number_of_points',))
    39943966
    39953967        elevation = fid.variables['elevation']
    … …  
    40183990
    40193991        #generate a stencil for computing the decimated values
    4020         stencil = numpy.ones((3,3), numpy.float) / 9.0
     3992        stencil = numpy.ones((3,3), Float) / 9.0
    40213993
    40223994        decimate_dem(root, stencil=stencil, cellsize_new=100)
    … …  
    40424014
    40434015        import os
    4044 ##        from numpy.oldnumeric import ones, allclose, Float, arange, reshape
    40454016        from Scientific.IO.NetCDF import NetCDFFile
    40464017
    … …  
    40754046        fid.createDimension('number_of_points', nrows*ncols)
    40764047
    4077         fid.createVariable('elevation', numpy.float, ('number_of_points',))
     4048        fid.createVariable('elevation', Float, ('number_of_points',))
    40784049
    40794050        elevation = fid.variables['elevation']
    … …  
    41134084
    41144085        #generate a stencil for computing the decimated values
    4115         stencil = numpy.ones((3,3), numpy.float) / 9.0
     4086        stencil = numpy.ones((3,3), Float) / 9.0
    41164087
    41174088        decimate_dem(root, stencil=stencil, cellsize_new=100)
    … …  
    41384109
    41394110        import time, os
    4140 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    41414111        from Scientific.IO.NetCDF import NetCDFFile
    41424112
    … …  
    41644134
    41654135        import time, os
    4166 ##        from numpy.oldnumeric import array, zeros, allclose, Float, concatenate
    41674136        from Scientific.IO.NetCDF import NetCDFFile
    41684137
    … …  
    55055474            quantities_init[i] = ensure_numeric(quantities_init[i])
    55065475            #print "HA_init", HA_init
    5507             q_time = numpy.zeros((time_step_count, points_num), numpy.float)
     5476            q_time = numpy.zeros((time_step_count, points_num), Float)
    55085477            for time in range(time_step_count):
    55095478                q_time[time,:] = quantities_init[i] #* time * 4
    … …  
    55885557            quantities_init[i] = ensure_numeric(quantities_init[i])
    55895558            #print "HA_init", HA_init
    5590             q_time = numpy.zeros((time_step_count, points_num), numpy.float)
     5559            q_time = numpy.zeros((time_step_count, points_num), Float)
    55915560            for time in range(time_step_count):
    55925561                q_time[time,:] = quantities_init[i] #* time * 4
    … …  
    60446013            if ha is None:
    60456014                this_ha = e
    6046                 quantities_init[0].append(numpy.ones(time_step_count,numpy.float)*this_ha) # HA
     6015                quantities_init[0].append(numpy.ones(time_step_count,Float)*this_ha) # HA
    60476016            else:
    60486017                quantities_init[0].append(ha[i])
    60496018            if ua is None:
    60506019                this_ua = n
    6051                 quantities_init[1].append(numpy.ones(time_step_count,numpy.float)*this_ua) # UA
     6020                quantities_init[1].append(numpy.ones(time_step_count,Float)*this_ua) # UA
    60526021            else:
    60536022                quantities_init[1].append(ua[i])
    60546023            if va is None:
    60556024                this_va = e
    6056                 quantities_init[2].append(numpy.ones(time_step_count,numpy.float)*this_va) #
     6025                quantities_init[2].append(numpy.ones(time_step_count,Float)*this_va) #
    60576026            else:
    60586027                quantities_init[2].append(va[i])           
    … …  
    60646033        files = []       
    60656034        for i,q in enumerate(quantities):
    6066             q_time = numpy.zeros((time_step_count, points_num), numpy.float)
     6035            q_time = numpy.zeros((time_step_count, points_num), Float)
    60676036            quantities_init[i] = ensure_numeric(quantities_init[i])
    60686037            for time in range(time_step_count):
    … …  
    61296098        first_tstep=numpy.ones(n,numpy.int)
    61306099        last_tstep=time_step_count*numpy.ones(n,numpy.int)
    6131         depth=20*numpy.ones(n,numpy.float)
    6132         ha=2*numpy.ones((n,time_step_count),numpy.float)
    6133         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6134         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6100        depth=20*numpy.ones(n,Float)
     6101        ha=2*numpy.ones((n,time_step_count),Float)
     6102        ua=5*numpy.ones((n,time_step_count),Float)
     6103        va=-10*numpy.ones((n,time_step_count),Float)
    61356104        #-ve added to take into account mux file format where south is positive.
    61366105        base_name, files = self.write_mux2(lat_long_points,
    … …  
    61426111                                      va=va)
    61436112
    6144         weights=numpy.ones(1, numpy.float)
     6113        weights=numpy.ones(1, Float)
    61456114        #ensure that files are indeed mux2 files
    61466115        times, latitudes, longitudes, elevation, stage, starttime =read_mux2_py([files[0]],weights)
    … …  
    61846153        first_tstep=numpy.ones(n,numpy.int)
    61856154        last_tstep=(time_step_count)*numpy.ones(n,numpy.int)
    6186         depth=20*numpy.ones(n,numpy.float)
    6187         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6155        depth=20*numpy.ones(n,Float)
     6156        ha=2*numpy.ones((n,time_step_count),Float)
    61886157        ha[0]=numpy.arange(0,time_step_count)+1
    61896158        ha[1]=time_step_count-numpy.arange(1,time_step_count+1)
    … …  
    61916160        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    61926161        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6193         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6194         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6162        ua=5*numpy.ones((n,time_step_count),Float)
     6163        va=-10*numpy.ones((n,time_step_count),Float)
    61956164        #-ve added to take into account mux file format where south is positive.
    61966165        base_name, files = self.write_mux2(lat_long_points,
    … …  
    62026171                                      va=va)
    62036172
    6204         weights=numpy.ones(1, numpy.float)
     6173        weights=numpy.ones(1, Float)
    62056174        #ensure that files are indeed mux2 files
    62066175        times, latitudes, longitudes, elevation, stage,starttime=read_mux2_py([files[0]],weights)
    … …  
    62466215        last_tstep[0]-=1
    62476216
    6248         depth=20*numpy.ones(n,numpy.float)
    6249         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6217        depth=20*numpy.ones(n,Float)
     6218        ha=2*numpy.ones((n,time_step_count),Float)
    62506219        ha[0]=numpy.arange(0,time_step_count)
    62516220        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    62526221        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    62536222        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6254         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6255         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6223        ua=5*numpy.ones((n,time_step_count),Float)
     6224        va=-10*numpy.ones((n,time_step_count),Float)
    62566225        #-ve added to take into account mux file format where south is positive.
    62576226        base_name, files = self.write_mux2(lat_long_points,
    … …  
    62636232                                      va=va)
    62646233
    6265         weights=numpy.ones(1, numpy.float)
     6234        weights=numpy.ones(1, Float)
    62666235        #ensure that files are indeed mux2 files
    62676236        times, latitudes, longitudes, elevation, stage,starttime=read_mux2_py([files[0]],weights)
    … …  
    63196288        last_tstep[0]-=1
    63206289
    6321         gauge_depth=20*numpy.ones(n,numpy.float)
    6322         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6290        gauge_depth=20*numpy.ones(n,Float)
     6291        ha=2*numpy.ones((n,time_step_count),Float)
    63236292        ha[0]=numpy.arange(0,time_step_count)
    63246293        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    63256294        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    63266295        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6327         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6328         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6296        ua=5*numpy.ones((n,time_step_count),Float)
     6297        va=-10*numpy.ones((n,time_step_count),Float)
    63296298
    63306299        base_name, files = self.write_mux2(lat_long_points,
    … …  
    63996368        #momentum = velocity_ua *(stage+depth)
    64006369
    6401         depth=numpy.zeros((len(lat_long_points),time_step_count),numpy.float)
     6370        depth=numpy.zeros((len(lat_long_points),time_step_count),Float)
    64026371        for i in range(len(lat_long_points)):
    64036372            depth[i]=gauge_depth[i]+tide+ha[i]
    … …  
    64346403        last_tstep[0]-=1
    64356404
    6436         gauge_depth=20*numpy.ones(n,numpy.float)
    6437         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6405        gauge_depth=20*numpy.ones(n,Float)
     6406        ha=2*numpy.ones((n,time_step_count),Float)
    64386407        ha[0]=numpy.arange(0,time_step_count)
    64396408        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    64406409        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    64416410        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6442         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6443         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6411        ua=5*numpy.ones((n,time_step_count),Float)
     6412        va=-10*numpy.ones((n,time_step_count),Float)
    64446413
    64456414        base_name, files = self.write_mux2(lat_long_points,
    … …  
    64966465        last_tstep[0]-=1
    64976466
    6498         gauge_depth=20*numpy.ones(n,numpy.float)
    6499         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6467        gauge_depth=20*numpy.ones(n,Float)
     6468        ha=2*numpy.ones((n,time_step_count),Float)
    65006469        ha[0]=numpy.arange(0,time_step_count)
    65016470        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    65026471        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    65036472        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6504         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6505         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6473        ua=5*numpy.ones((n,time_step_count),Float)
     6474        va=-10*numpy.ones((n,time_step_count),Float)
    65066475
    65076476        base_name, files = self.write_mux2(lat_long_points,
    … …  
    65576526        last_tstep[0]-=1
    65586527
    6559         gauge_depth=20*numpy.ones(n,numpy.float)
    6560         ha=2*numpy.ones((n,time_step_count),numpy.float)
     6528        gauge_depth=20*numpy.ones(n,Float)
     6529        ha=2*numpy.ones((n,time_step_count),Float)
    65616530        ha[0]=numpy.arange(0,time_step_count)
    65626531        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    65636532        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    65646533        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    6565         ua=5*numpy.ones((n,time_step_count),numpy.float)
    6566         va=-10*numpy.ones((n,time_step_count),numpy.float)
     6534        ua=5*numpy.ones((n,time_step_count),Float)
     6535        va=-10*numpy.ones((n,time_step_count),Float)
    65676536
    65686537        # Create two identical mux files to be combined by urs2sts
    … …  
    66536622        #momentum = velocity_ua *(stage+depth)
    66546623
    6655         depth=numpy.zeros((len(lat_long_points),time_step_count),numpy.float)
     6624        depth=numpy.zeros((len(lat_long_points),time_step_count),Float)
    66566625        for i in range(len(lat_long_points)):
    66576626            depth[i]=gauge_depth[i]+tide+2.0*ha[i]
    … …  
    66856654           over waveheight, easting and northing velocity
    66866655        """
    6687 ##        from numpy.oldnumeric import asarray,numpy.transpose,sqrt,argmax,argmin,arange,numpy.float,\
    6688 ##            compress,zeros,fabs,take,size
    66896656       
    66906657        # Get path where this test is run
    … …  
    68506817           over waveheight, easting and northing velocity
    68516818        """
    6852 ##        from numpy.oldnumeric import asarray,numpy.transpose,sqrt,argmax,argmin,arange,numpy.float,\
    6853 ##            compress,zeros,fabs,take,size
    68546819
    68556820        # combined
    … …  
    70336998        last_tstep[0]-=1
    70346999
    7035         gauge_depth=20*numpy.ones(n,numpy.float)
    7036         ha=2*numpy.ones((n,time_step_count),numpy.float)
     7000        gauge_depth=20*numpy.ones(n,Float)
     7001        ha=2*numpy.ones((n,time_step_count),Float)
    70377002        ha[0]=numpy.arange(0,time_step_count)
    70387003        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    70397004        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    70407005        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    7041         ua=5*numpy.ones((n,time_step_count),numpy.float)
    7042         va=-10*numpy.ones((n,time_step_count),numpy.float)
     7006        ua=5*numpy.ones((n,time_step_count),Float)
     7007        va=-10*numpy.ones((n,time_step_count),Float)
    70437008
    70447009        # Create two identical mux files to be combined by urs2sts
    … …  
    71717136        #momentum = velocity_ua *(stage+depth)
    71727137
    7173         depth=numpy.zeros((len(lat_long_points),time_step_count),numpy.float)
     7138        depth=numpy.zeros((len(lat_long_points),time_step_count),Float)
    71747139        for i in range(len(lat_long_points)):
    71757140            depth[i]=gauge_depth[i]+tide+2.0*ha[i]
    … …  
    72207185        last_tstep[0]-=1
    72217186
    7222         gauge_depth=20*numpy.ones(n,numpy.float)
    7223         ha=2*numpy.ones((n,time_step_count),numpy.float)
     7187        gauge_depth=20*numpy.ones(n,Float)
     7188        ha=2*numpy.ones((n,time_step_count),Float)
    72247189        ha[0]=numpy.arange(0,time_step_count)
    72257190        ha[1]=numpy.arange(time_step_count,2*time_step_count)
    72267191        ha[2]=numpy.arange(2*time_step_count,3*time_step_count)
    72277192        ha[3]=numpy.arange(3*time_step_count,4*time_step_count)
    7228         ua=5*numpy.ones((n,time_step_count),numpy.float)
    7229         va=-10*numpy.ones((n,time_step_count),numpy.float)
     7193        ua=5*numpy.ones((n,time_step_count),Float)
     7194        va=-10*numpy.ones((n,time_step_count),Float)
    72307195
    72317196        # Create two identical mux files to be combined by urs2sts
    … …  
    72837248        """
    72847249       
    7285 ##        from numpy.oldnumeric import sin, cos
    7286                
    72877250        tide = 1.5
    72887251        time_step_count = 10
    … …  
    73307293       
    73317294        # Create varying elevation data (positive values for seafloor)
    7332         gauge_depth=20*numpy.ones(n,numpy.float)
     7295        gauge_depth=20*numpy.ones(n,Float)
    73337296        for i in range(n):
    73347297            gauge_depth[i] += i**2
    … …  
    73377300       
    73387301        # Create data to be written to first mux file       
    7339         ha0=2*numpy.ones((n,time_step_count),numpy.float)
     7302        ha0=2*numpy.ones((n,time_step_count),Float)
    73407303        ha0[0]=numpy.arange(0,time_step_count)
    73417304        ha0[1]=numpy.arange(time_step_count,2*time_step_count)
    73427305        ha0[2]=numpy.arange(2*time_step_count,3*time_step_count)
    73437306        ha0[3]=numpy.arange(3*time_step_count,4*time_step_count)
    7344         ua0=5*numpy.ones((n,time_step_count),numpy.float)
    7345         va0=-10*numpy.ones((n,time_step_count),numpy.float)
     7307        ua0=5*numpy.ones((n,time_step_count),Float)
     7308        va0=-10*numpy.ones((n,time_step_count),Float)
    73467309
    73477310        # Ensure data used to write mux file to be zero when gauges are
    … …  
    73747337                                             
    73757338        # Create data to be written to second mux file       
    7376         ha1=numpy.ones((n,time_step_count),numpy.float)
     7339        ha1=numpy.ones((n,time_step_count),Float)
    73777340        ha1[0]=numpy.sin(times_ref)
    73787341        ha1[1]=2*numpy.sin(times_ref - 3)
    … …  
    73817344        ha1[4]=numpy.sin(2*times_ref-0.7)
    73827345               
    7383         ua1=numpy.zeros((n,time_step_count),numpy.float)
     7346        ua1=numpy.zeros((n,time_step_count),Float)
    73847347        ua1[0]=3*numpy.cos(times_ref)       
    73857348        ua1[1]=2*numpy.sin(times_ref-0.7)   
    … …  
    73877350        ua1[4]=2*numpy.ones(time_step_count)
    73887351       
    7389         va1=numpy.zeros((n,time_step_count),numpy.float)
     7352        va1=numpy.zeros((n,time_step_count),Float)
    73907353        va1[0]=2*numpy.cos(times_ref-0.87)       
    73917354        va1[1]=3*numpy.ones(time_step_count)
    … …  
    75197482        #momentum = velocity_ua *(stage+depth)
    75207483
    7521         depth_ref = numpy.zeros((len(permutation), time_step_count), numpy.float)
     7484        depth_ref = numpy.zeros((len(permutation), time_step_count), Float)
    75227485        for i in range(len(permutation)):
    75237486            depth_ref[i]=gauge_depth_ref[i]+tide+ha_ref[i]
    … …  
    76317594        #momentum = velocity_ua *(stage+depth)
    76327595
    7633         depth_ref = numpy.zeros((len(permutation), time_step_count), numpy.float)
     7596        depth_ref = numpy.zeros((len(permutation), time_step_count), Float)
    76347597        for i in range(len(permutation)):
    76357598            depth_ref[i]=gauge_depth_ref[i]+tide+ha_ref[i]
    … …  
    77377700        #momentum = velocity_ua *(stage+depth)
    77387701
    7739         depth_ref = numpy.zeros((len(permutation), time_step_count), numpy.float)
     7702        depth_ref = numpy.zeros((len(permutation), time_step_count), Float)
    77407703        for i in range(len(permutation)):
    77417704            depth_ref[i]=gauge_depth_ref[i]+tide+ha_ref[i]
    … …  
    78197782        u = 10
    78207783        v = -10
    7821         gauge_depth=h*numpy.ones(n,numpy.float)
    7822         ha=w*numpy.ones((n,time_step_count),numpy.float)
    7823         ua=u*numpy.ones((n,time_step_count),numpy.float)
    7824         va=v*numpy.ones((n,time_step_count),numpy.float)
     7784        gauge_depth=h*numpy.ones(n,Float)
     7785        ha=w*numpy.ones((n,time_step_count),Float)
     7786        ua=u*numpy.ones((n,time_step_count),Float)
     7787        va=v*numpy.ones((n,time_step_count),Float)
    78257788        base_name, files = self.write_mux2(lat_long_points,
    78267789                                           time_step_count, time_step,
    … …  
    78757838        finaltime=time_step*(time_step_count-1)
    78767839        yieldstep=time_step
    7877         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     7840        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    78787841
    78797842        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    79077870
    79087871        domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
    7909         temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     7872        temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    79107873
    79117874        for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
    … …  
    79697932        u = 10
    79707933        v = -10
    7971         gauge_depth=h*numpy.ones(n,numpy.float)
    7972         ha=w*numpy.ones((n,time_step_count),numpy.float)
    7973         ua=u*numpy.ones((n,time_step_count),numpy.float)
    7974         va=v*numpy.ones((n,time_step_count),numpy.float)
     7934        gauge_depth=h*numpy.ones(n,Float)
     7935        ha=w*numpy.ones((n,time_step_count),Float)
     7936        ua=u*numpy.ones((n,time_step_count),Float)
     7937        va=v*numpy.ones((n,time_step_count),Float)
    79757938        base_name, files = self.write_mux2(lat_long_points,
    79767939                                           time_step_count, time_step,
    … …  
    80347997        finaltime = data_finaltime + 10 # Let model time exceed available data
    80357998        yieldstep = time_step
    8036         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1, numpy.float)
     7999        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1, Float)
    80378000
    80388001        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    80668029
    80678030        domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
    8068         temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8031        temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    80698032
    80708033        for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
    … …  
    81278090        u = 10
    81288091        v = -10
    8129         gauge_depth=h*numpy.ones(n,numpy.float)
    8130         ha=w*numpy.ones((n,time_step_count),numpy.float)
    8131         ua=u*numpy.ones((n,time_step_count),numpy.float)
    8132         va=v*numpy.ones((n,time_step_count),numpy.float)
     8092        gauge_depth=h*numpy.ones(n,Float)
     8093        ha=w*numpy.ones((n,time_step_count),Float)
     8094        ua=u*numpy.ones((n,time_step_count),Float)
     8095        va=v*numpy.ones((n,time_step_count),Float)
    81338096        base_name, files = self.write_mux2(lat_long_points,
    81348097                                           time_step_count, time_step,
    … …  
    81958158        finaltime = data_finaltime + 10 # Let model time exceed available data
    81968159        yieldstep = time_step
    8197         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1, numpy.float)
     8160        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1, Float)
    81988161
    81998162        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    82418204        first_tstep=numpy.ones(n,numpy.int)
    82428205        last_tstep=(time_step_count)*numpy.ones(n,numpy.int)
    8243         gauge_depth=20*numpy.ones(n,numpy.float)
    8244         ha=2*numpy.ones((n,time_step_count),numpy.float)
    8245         ua=10*numpy.ones((n,time_step_count),numpy.float)
    8246         va=-10*numpy.ones((n,time_step_count),numpy.float)
     8206        gauge_depth=20*numpy.ones(n,Float)
     8207        ha=2*numpy.ones((n,time_step_count),Float)
     8208        ua=10*numpy.ones((n,time_step_count),Float)
     8209        va=-10*numpy.ones((n,time_step_count),Float)
    82478210        base_name, files = self.write_mux2(lat_long_points,
    82488211                                           time_step_count,
    … …  
    82868249        finaltime=time_step*(time_step_count-1)
    82878250        yieldstep=time_step
    8288         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8251        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    82898252       
    82908253        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    82988261        Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
    82998262        domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
    8300         temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8263        temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    83018264
    83028265        for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
    … …  
    83478310        first_tstep=numpy.ones(n,numpy.int)
    83488311        last_tstep=(time_step_count)*numpy.ones(n,numpy.int)
    8349         gauge_depth=20*numpy.ones(n,numpy.float)
    8350         ha=2*numpy.ones((n,time_step_count),numpy.float)
    8351         ua=10*numpy.ones((n,time_step_count),numpy.float)
    8352         va=-10*numpy.ones((n,time_step_count),numpy.float)
     8312        gauge_depth=20*numpy.ones(n,Float)
     8313        ha=2*numpy.ones((n,time_step_count),Float)
     8314        ua=10*numpy.ones((n,time_step_count),Float)
     8315        va=-10*numpy.ones((n,time_step_count),Float)
    83538316        base_name, files = self.write_mux2(lat_long_points,
    83548317                                           time_step_count,
    … …  
    84368399        finaltime=time_step*(time_step_count-1)
    84378400        yieldstep=time_step
    8438         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8401        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    84398402   
    84408403        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    84498412        Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
    84508413        domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
    8451         temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8414        temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    84528415       
    84538416        for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
    … …  
    85148477        last_tstep=(time_step_count)*numpy.ones(n,numpy.int)
    85158478       
    8516         gauge_depth=20*numpy.ones(n,numpy.float)
     8479        gauge_depth=20*numpy.ones(n,Float)
    85178480        ha1[1]=2*sin(times_ref - 3)
    8518         ua=0.0*numpy.ones((n,time_step_count),numpy.float)
    8519         va=0.0*numpy.ones((n,time_step_count),numpy.float)
     8481        ua=0.0*numpy.ones((n,time_step_count),Float)
     8482        va=0.0*numpy.ones((n,time_step_count),Float)
    85208483       
    85218484       
    … …  
    86308593        finaltime=time_step*(time_step_count-1)
    86318594        yieldstep=time_step
    8632         temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8595        temp_fbound=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    86338596   
    86348597        for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
    … …  
    86468609        domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
    86478610       
    8648         temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,numpy.float)
     8611        temp_drchlt=numpy.zeros(int(finaltime/yieldstep)+1,Float)
    86498612       
    86508613        for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,finaltime=finaltime,
    … …  
    100149977
    100159978        import time, os
    10016 ##        from numpy.oldnumeric import array, zeros, allclose, numpy.float, concatenate
    100179979        from Scientific.IO.NetCDF import NetCDFFile
    100189980
    … …  
    1014810110       
    1014910111        import time, os
    10150 ##        from numpy.oldnumeric import array, zeros, allclose, numpy.float, concatenate
    1015110112        from Scientific.IO.NetCDF import NetCDFFile
    1015210113
    … …  
    1023610197
    1023710198        import time, os
    10238 ##        from numpy.oldnumeric import array, zeros, allclose, numpy.float, concatenate
    1023910199        from Scientific.IO.NetCDF import NetCDFFile
    1024010200
    … …  
    1036310323
    1036410324        import time, os
    10365 ##        from numpy.oldnumeric import array, zeros, allclose, numpy.float, concatenate
    1036610325        from Scientific.IO.NetCDF import NetCDFFile
    1036710326
    … …  
    1046610425
    1046710426        import time, os
    10468 ##        from numpy.oldnumeric import array, zeros, allclose, numpy.float, concatenate
    1046910427        from Scientific.IO.NetCDF import NetCDFFile
    1047010428

  • anuga_core/source_numpy_conversion/anuga/shallow_water/test_shallow_water_domain.py

    r5901 r5947  
    433433
    434434
    435         assert domain.get_conserved_quantities(0, edge=1) == 0.
     435        assert numpy.alltrue(domain.get_conserved_quantities(0, edge=1) == 0.)
    436436
    437437
    … …  
    60806080    suite = unittest.makeSuite(Test_Shallow_Water,'test')
    60816081
    6082     #suite = unittest.makeSuite(Test_Shallow_Water,'test_get_energy_through_cross_section_with_g')   
     6082##    suite = unittest.makeSuite(Test_Shallow_Water,'test_wind_stress_error_condition')   
    60836083    #suite = unittest.makeSuite(Test_Shallow_Water,'test_fitting_using_shallow_water_domain')   
    60846084    #suite = unittest.makeSuite(Test_Shallow_Water,'test_tight_slope_limiters')
Note: See TracChangeset for help on using the changeset viewer.