def test_split_even_tiles():
   """
   @summary: This test checks that a surface can be split into even tiles
   """
   # Write input file - 10 degree by 10 degree
   tf = NamedTemporaryFile(delete=False)
   tfn = tf.name
   tf.write('ncols   {0}\n'.format(str(len(TEST_SURFACE[0]))))
   tf.write('nrows   {0}\n'.format(str(len(TEST_SURFACE))))
   tf.write("xllcorner   0\n")
   tf.write("yllcorner   0\n")
   tf.write("cellsize   0.5\n")
   tf.write("NODATA_value   -999\n")
   for line in TEST_SURFACE:
      tf.write("{0}\n".format(' '.join([str(i) for i in line])))
   tf.close()

   # Create directory
   outDir = _getTemporaryDirectory(randint(0, 1000))
   
   # Run tile splitter
   splitTile(tfn, 5.0, outDir)
   
   # Look at results
   # Should have (0,0,5,5),(5,0,10,5),(0,5,5,10),(5,5,10,10)
   t1Fn = os.path.join(outDir, "grid0.0-0.0-5.0-5.0.asc")
   t2Fn = os.path.join(outDir, "grid5.0-0.0-10.0-5.0.asc")
   t3Fn = os.path.join(outDir, "grid0.0-5.0-5.0-10.0.asc")
   t4Fn = os.path.join(outDir, "grid5.0-5.0-10.0-10.0.asc")
   
   assert os.path.exists(t1Fn)
   assert os.path.exists(t2Fn)
   assert os.path.exists(t3Fn)
   assert os.path.exists(t4Fn)
   
   # Check headers of each
   # Check content of each
   
   # Check (0,0,5,5)
   #  -- Check headers
   ncols, nrows, xll, yll, cs, nd = _readHeaders(t1Fn)
   assert ncols == 10
   assert nrows == 10
   assert xll == 0.0
   assert yll == 0.0
   assert cs == 0.5
   assert nd == -999
   
   # -- Check content
   mtx1 = np.loadtxt(t1Fn, dtype=int, comments='', skiprows=6)
   cmp1 = np.array([line[:10] for line in TEST_SURFACE[10:]], dtype=int)
   assert np.array_equal(mtx1, cmp1)
   
   # Check (5,0,10,5)
   #  -- Check headers
   ncols, nrows, xll, yll, cs, nd = _readHeaders(t2Fn)
   assert ncols == 10
   assert nrows == 10
   assert xll == 5.0
   assert yll == 0.0
   assert cs == 0.5
   assert nd == -999
   
   # -- Check content
   mtx2 = np.loadtxt(t2Fn, dtype=int, comments='', skiprows=6)
   cmp2 = np.array([line[10:] for line in TEST_SURFACE[10:]], dtype=int)
   assert np.array_equal(mtx2, cmp2)
   
   # Check (0,5,5,10)
   #  -- Check headers
   ncols, nrows, xll, yll, cs, nd = _readHeaders(t3Fn)
   assert ncols == 10
   assert nrows == 10
   assert xll == 0.0
   assert yll == 5.0
   assert cs == 0.5
   assert nd == -999
   
   # -- Check content
   mtx3 = np.loadtxt(t3Fn, dtype=int, comments='', skiprows=6)
   cmp3 = np.array([line[:10] for line in TEST_SURFACE[:10]], dtype=int)
   assert np.array_equal(mtx3, cmp3)
   
   # Check (5,5,10,10)
   #  -- Check headers
   ncols, nrows, xll, yll, cs, nd = _readHeaders(t4Fn)
   assert ncols == 10
   assert nrows == 10
   assert xll == 5.0
   assert yll == 5.0
   assert cs == 0.5
   assert nd == -999
   
   # -- Check content
   mtx4 = np.loadtxt(t4Fn, dtype=int, comments='', skiprows=6)
   cmp4 = np.array([line[10:] for line in TEST_SURFACE[:10]], dtype=int)
   assert np.array_equal(mtx4, cmp4)
Esempio n. 2
0
 def test_all_even(self):
    """
    @summary: This test creates a surface and runs each implementation of the
                 algorithm and checks that the results are the same
    """
    SURFACE_WIDTH = 1000
    SURFACE_HEIGHT = 1000
    STEP_SIZE = .2
    CELL_SIZE = .005
    TILE_SIZE = 1.0
    NUM_CONES = 100
    NUM_ELLIPSOIDS = 100
    MAX_HEIGHT = 50
    MAX_RADIUS = 200
    NUM_WORKERS = 1
    
    # Generate surface
    sg = SurfaceGenerator(SURFACE_HEIGHT, SURFACE_WIDTH, 0.0, 0.0, CELL_SIZE, 
                          defVal=0)
    sg.addRandom(numCones=NUM_CONES, numEllipsoids=NUM_ELLIPSOIDS, 
                 maxHeight=MAX_HEIGHT, maxRad=MAX_RADIUS)
    
    # Make sure that we have at least one source cell
    if np.min(sg.grid) > 0:
       sg.grid[0,0] = 0
    
    # Write out grid
    sg.writeGrid(self.surfaceFn)
    
    inputGrid = np.loadtxt(self.surfaceFn, dtype=int, comments='', skiprows=6)
    
    # Run Dijkstra
    serialInstance = SingleTileSerialDijkstraLCP(self.surfaceFn, 
                                                 self.serialCostFn, 
                                                 seaLevelRiseCostFn)
    serialInstance.findSourceCells()
    serialInstance.calculate()
 
    # Verify grid
    serialAry = np.loadtxt(self.serialCostFn, dtype=int, comments='', skiprows=6)
    self._verifyGrid(serialAry, inputGrid)
 
    # Run parallel Dijkstra
    parInstance = SingleTileParallelDijkstraLCP(self.surfaceFn,
                                                self.parCostFn,
                                                seaLevelRiseCostFn)
    parInstance.setMaxWorkers(16)
    parInstance.setStepSize(.20)
    parInstance.findSourceCells()
    parInstance.calculate()
    
    # Compare serial and parallel single tile
    parAry = np.loadtxt(self.parCostFn, dtype=int, comments='', skiprows=6)
    
    # Verify parallel run
    self._verifyGrid(parAry, inputGrid)
    
    #print len(np.where(serialAry != parAry))
    assert np.array_equal(serialAry, parAry)
    
    # Split surface
    splitTile(self.surfaceFn, TILE_SIZE, self.mtSurfaceDir)
    
    # Split cost surface
    splitTile(self.parCostFn, TILE_SIZE, self.mtCmpDir)
    
    # Run multi-tile
    mtInstance = MultiTileWqParallelDijkstraLCP(self.mtSurfaceDir,
                                                self.mtCostDir,
                                                self.mtOutDir,
                                                TILE_SIZE,
                                                STEP_SIZE,
                                                summaryFn=self.mtSummaryFn)
 
    # Run
    print "Starting workers"
    mtInstance.startWorkers(NUM_WORKERS)
    mtInstance.calculate()
    
    # Only on success
    print "Stopping workers"
    mtInstance.stopWorkers()
    
    # Compare output directories
    assert self._checkOutputs(self.mtCostDir, self.mtCmpDir)