def test_no_flow_receivers(): """Test that correct error is raised when no flow recievers are on the grid.""" # instantiate a model grid, do not run flow accumulation on it mg = RasterModelGrid((30, 70)) # test that the flow distance utility will fail because of a ValueError with pytest.raises(FieldError): calculate_flow__distance(mg)
def test_no_flow_recievers(): """Test that correct error is raised when no flow recievers are on the grid.""" # instantiate a model grid, do not run flow accumulation on it mg = RasterModelGrid((30, 70)) # test that the flow distance utility will fail because of a ValueError with pytest.raises(FieldError): calculate_flow__distance(mg)
def test_flow__distance_regular_grid_d8(): """Test to demonstrate that flow__distance utility works as expected with regular grids""" # instantiate a model grid mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) # instantiate an elevation array z = np.array( [[0, 0, 0, 0], [0, 21, 10, 0], [0, 31, 20, 0], [0, 32, 30, 0], [0, 0, 0, 0]], dtype="float64", ) # add the elevation field to the grid mg.add_field("topographic__elevation", z, at="node") # instantiate the expected flow__distance array # considering flow directions calculated with D8 algorithm flow__distance_expected = np.array( [ [0, 0, 0, 0], [0, 1, 0, 0], [0, math.sqrt(2), 1, 0], [0, 1 + math.sqrt(2), 2, 0], [0, 0, 0, 0], ], dtype="float64", ) flow__distance_expected = np.reshape( flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns ) # setting boundary conditions mg.set_closed_boundaries_at_grid_edges( bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True, ) # calculating flow directions with FlowAccumulator component fr = FlowAccumulator(mg, flow_director="D8") fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, clobber=True) flow__distance = np.reshape( flow__distance, mg.number_of_node_rows * mg.number_of_node_columns ) # test that the flow distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_regular_grid_d8(): """Test to demonstrate that flow__distance utility works as expected with regular grids""" # instantiate a model grid mg = RasterModelGrid((5, 4), spacing=(1, 1)) # instantiate an elevation array z = np.array([[0, 0, 0, 0], [0, 21, 10, 0], [0, 31, 20, 0], [0, 32, 30, 0], [0, 0, 0, 0]], dtype='float64') # add the elevation field to the grid mg.add_field('node', 'topographic__elevation', z) # instantiate the expected flow__distance array # considering flow directions calculated with D8 algorithm flow__distance_expected = np.array( [[0, 0, 0, 0], [0, 1, 0, 0], [0, math.sqrt(2), 1, 0], [0, 1 + math.sqrt(2), 2, 0], [0, 0, 0, 0]], dtype='float64') flow__distance_expected = np.reshape( flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns) #setting boundary conditions mg.set_closed_boundaries_at_grid_edges(bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True) # calculating flow directions with FlowAccumulator component fr = FlowAccumulator(mg, flow_director='D8') fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) flow__distance = np.reshape( flow__distance, mg.number_of_node_rows * mg.number_of_node_columns) # modifying the flow distance map because boundary and outlet nodes should # not have flow__distance value different from 0 flow__distance[mg.boundary_nodes] = 0 outlet_id = 6 flow__distance[outlet_id] = 0 # test that the flow distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_raster_MFD_diagonals_true(): """Test of flow__distance utility with a raster grid and MFD.""" # instantiate a model grid mg = RasterModelGrid((5, 4), spacing=(1, 1)) # instantiate an elevation array z = np.array( [[0, 0, 0, 0], [0, 21, 10, 0], [0, 31, 20, 0], [0, 32, 30, 0], [0, 0, 0, 0]], dtype="float64", ) # add the elevation field to the grid mg.add_field("node", "topographic__elevation", z) # instantiate the expected flow__distance array # considering flow directions calculated with MFD algorithm flow__distance_expected = np.array( [ [0, 0, 0, 0], [0, 1, 0, 0], [0, math.sqrt(2), 1, 0], [0, 1 + math.sqrt(2), 2, 0], [0, 0, 0, 0], ], dtype="float64", ) flow__distance_expected = np.reshape( flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns ) # setting boundary conditions mg.set_closed_boundaries_at_grid_edges( bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True, ) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator( mg, "topographic__elevation", flow_director="MFD", diagonals=True ) fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_regular_grid_d8(): """Test to demonstrate that flow__distance utility works as expected with regular grids""" # instantiate a model grid mg = RasterModelGrid((5, 4), spacing=(1, 1)) # instantiate an elevation array z = np.array([[0, 0, 0, 0], [0, 21, 10, 0], [0, 31, 20, 0], [0, 32, 30, 0], [0, 0, 0, 0]], dtype='float64') # add the elevation field to the grid mg.add_field('node', 'topographic__elevation', z) # instantiate the expected flow__distance array # considering flow directions calculated with D8 algorithm flow__distance_expected = np.array([[0, 0, 0, 0], [0, 1, 0, 0], [0, math.sqrt(2), 1, 0], [0, 1+math.sqrt(2), 2, 0], [0, 0, 0, 0]], dtype='float64') flow__distance_expected = np.reshape(flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns) #setting boundary conditions mg.set_closed_boundaries_at_grid_edges(bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True) # calculating flow directions with FlowAccumulator component fr = FlowAccumulator(mg, flow_director='D8') fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) flow__distance = np.reshape(flow__distance, mg.number_of_node_rows * mg.number_of_node_columns) # modifying the flow distance map because boundary and outlet nodes should # not have flow__distance value different from 0 flow__distance[mg.boundary_nodes] = 0 outlet_id = 6 flow__distance[outlet_id] = 0 # test that the flow distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_raster_MFD_diagonals_true(): """Test of flow__distance utility with a raster grid and MFD.""" # instantiate a model grid mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) # instantiate an elevation array z = np.array( [[0, 0, 0, 0], [0, 21, 10, 0], [0, 31, 20, 0], [0, 32, 30, 0], [0, 0, 0, 0]], dtype="float64", ) # add the elevation field to the grid mg.add_field("node", "topographic__elevation", z) # instantiate the expected flow__distance array # considering flow directions calculated with MFD algorithm flow__distance_expected = np.array( [ [0, 0, 0, 0], [0, 1, 0, 0], [0, math.sqrt(2), 1, 0], [0, 1 + math.sqrt(2), 2, 0], [0, 0, 0, 0], ], dtype="float64", ) flow__distance_expected = np.reshape( flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns ) # setting boundary conditions mg.set_closed_boundaries_at_grid_edges( bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True, ) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator( mg, "topographic__elevation", flow_director="MFD", diagonals=True ) fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def _calculate_distances(self): """Get distances along the network data structure.""" distance_upstream = calculate_flow__distance(self._grid) for outlet_id in self._data_struct: for segment_tuple in self._data_struct[outlet_id]: ids = self._data_struct[outlet_id][segment_tuple]["ids"] d = distance_upstream[ids] self._data_struct[outlet_id][segment_tuple]["distances"] = d
def test_flow__distance_irregular_grid_d4(): """Test to demonstrate that flow__distance utility works as expected with irregular grids""" # instantiate a model grid dx = 1.0 hmg = HexModelGrid(5, 3, dx) # instantiate and add the elevation field hmg.add_field( "topographic__elevation", hmg.node_x + np.round(hmg.node_y), at="node" ) # instantiate the expected flow__distance array flow__distance_expected = np.array( [ 0.0, 0.0, 0.0, 0.0, 0.0, dx, 0.0, 0.0, dx, dx, 2.0 * dx, 0.0, 0.0, 2.0 * dx, 2.0 * dx, 0.0, 0.0, 0.0, 0.0, ] ) # setting boundary conditions hmg.set_closed_nodes(hmg.boundary_nodes) # calculating flow directions with FlowAccumulator component: D4 algorithm fr = FlowAccumulator(hmg, flow_director="D4") fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(hmg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_almost_equal(flow__distance_expected, flow__distance, decimal=10)
def test_flow__distance_irregular_grid_d4(): """Test to demonstrate that flow__distance utility works as expected with irregular grids""" # instantiate a model grid dx = 1.0 hmg = HexModelGrid((5, 3), spacing=dx) # instantiate and add the elevation field hmg.add_field( "topographic__elevation", hmg.node_x + np.round(hmg.node_y), at="node" ) # instantiate the expected flow__distance array flow__distance_expected = np.array( [ 0.0, 0.0, 0.0, 0.0, 0.0, dx, 0.0, 0.0, dx, dx, 2.0 * dx, 0.0, 0.0, 2.0 * dx, 2.0 * dx, 0.0, 0.0, 0.0, 0.0, ] ) # setting boundary conditions hmg.status_at_node[hmg.boundary_nodes] = hmg.BC_NODE_IS_CLOSED # calculating flow directions with FlowAccumulator component: D4 algorithm fr = FlowAccumulator(hmg, flow_director="D4") fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(hmg, add_to_grid=True, clobber=True) # test that the flow__distance utility works as expected assert_almost_equal(flow__distance_expected, flow__distance, decimal=10)
def test_no_upstream_array(): """Test that correct error is raised when no flow__upstream_node_order.""" # instantiate a model grid, do not run flow accumulation on it mg = RasterModelGrid((30, 70)) # Add a field called topographic__elevation to mg mg.add_ones("topographic__elevation", at="node") # Run the FlowDirectorSteepest component fd = FlowDirectorSteepest(mg) fd.run_one_step() # test that the flow distance utility will fail because of a ValueError with pytest.raises(FieldError): calculate_flow__distance(mg)
def test_no_upstream_array(): """Test that correct error is raised when no flow__upstream_node_order.""" # instantiate a model grid, do not run flow accumulation on it mg = RasterModelGrid(30, 70) #Add a field called topographic__elevation to mg z = mg.add_ones('node','topographic__elevation') #Run the FlowDirectorSteepest component fd = FlowDirectorSteepest(mg) fd.run_one_step() # test that the flow distance utility will fail because of a ValueError with pytest.raises(FieldError): calculate_flow__distance(mg)
def test_flow__distance_raster_D_infinity(): """Test of flow__distance utility with a raster grid and D infinity.""" mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) # instantiate an elevation array z = mg.x_of_node + 3.0 * mg.y_of_node # add the elevation field to the grid mg.add_field("node", "topographic__elevation", z) # instantiate the expected flow_length array flow__distance_expected = np.array( [ [0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0 + math.sqrt(2.0), 0], [0, 2, 1 + math.sqrt(2.0), 0], [0, 0, 0, 0], ], dtype="float64", ) # setting boundary conditions mg.set_closed_boundaries_at_grid_edges( bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True, ) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator(mg, "topographic__elevation", flow_director="DINF") fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False).reshape( mg.shape) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_raster_D_infinity(): """Test of flow__distance utility with a raster grid and D infinity.""" mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) # instantiate an elevation array z = mg.x_of_node + 3.0 * mg.y_of_node # add the elevation field to the grid mg.add_field("node", "topographic__elevation", z) # instantiate the expected flow_length array flow__distance_expected = np.array( [ [0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0 + math.sqrt(2.0), 0], [0, 2, 1 + math.sqrt(2.0), 0], [0, 0, 0, 0], ], dtype="float64", ) # setting boundary conditions mg.set_closed_boundaries_at_grid_edges( bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True, ) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator(mg, "topographic__elevation", flow_director="DINF") fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance( mg, add_to_grid=True, noclobber=False ).reshape(mg.shape) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_raster_D_infinity(): """Test of flow__distance utility with a raster grid and D infinity.""" # instantiate a model grid mg = RasterModelGrid((5, 4), spacing=(1, 1)) # instantiate an elevation array z = mg.x_of_node + 2.0 * mg.y_of_node # add the elevation field to the grid mg.add_field('node', 'topographic__elevation', z) # instantiate the expected flow_length array flow__distance_expected = np.array( [[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, math.sqrt(2)], [0, 2, 2, 1 + math.sqrt(2)], [0, 3, 3, 2 + math.sqrt(2)]], dtype='float64') flow__distance_expected = np.reshape( flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns) #setting boundary conditions mg.set_closed_boundaries_at_grid_edges(bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator(mg, 'topographic__elevation', flow_director='DINF') fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_raster_D_infinity(): """Test of flow__distance utility with a raster grid and D infinity.""" # instantiate a model grid mg = RasterModelGrid((5, 4), spacing=(1, 1)) # instantiate an elevation array z = mg.x_of_node + 2.0 * mg.y_of_node # add the elevation field to the grid mg.add_field('node', 'topographic__elevation', z) # instantiate the expected flow_length array flow__distance_expected = np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, math.sqrt(2)], [0, 2, 2, 1+math.sqrt(2)], [0, 3, 3, 2+math.sqrt(2)]], dtype='float64') flow__distance_expected = np.reshape(flow__distance_expected, mg.number_of_node_rows * mg.number_of_node_columns) #setting boundary conditions mg.set_closed_boundaries_at_grid_edges(bottom_is_closed=True, left_is_closed=True, right_is_closed=True, top_is_closed=True) # calculating flow directions with FlowAccumulator component fa = FlowAccumulator(mg, 'topographic__elevation', flow_director='DINF') fa.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(mg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_array_equal(flow__distance_expected, flow__distance)
def test_flow__distance_irregular_grid_d4(): """Test to demonstrate that flow__distance utility works as expected with irregular grids""" # instantiate a model grid dx = 1.0 hmg = HexModelGrid(5, 3, dx) # instantiate and add the elevation field hmg.add_field('topographic__elevation', hmg.node_x + np.round(hmg.node_y), at='node') # instantiate the expected flow__distance array flow__distance_expected = np.array([ 0., 0., 0., 0., 0., dx, 0., 0., dx, dx, 2. * dx, 0., 0., 2. * dx, 2. * dx, 0., 0., 0., 0. ]) #setting boundary conditions hmg.set_closed_nodes(hmg.boundary_nodes) # calculating flow directions with FlowAccumulator component: D4 algorithm fr = FlowAccumulator(hmg, flow_director='D4') fr.run_one_step() # calculating flow distance map flow__distance = calculate_flow__distance(hmg, add_to_grid=True, noclobber=False) # test that the flow__distance utility works as expected assert_almost_equal(flow__distance_expected, flow__distance, decimal=10)