def test_error_for_to_many_with_depression(): """Check that an error is thrown when to_many methods started DF.""" mg0 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg0.add_field( "topographic__elevation", mg0.node_x ** 2 + mg0.node_y ** 2, at="node" ) mg1 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg1.add_field( "topographic__elevation", mg1.node_x ** 2 + mg1.node_y ** 2, at="node" ) with pytest.raises(NotImplementedError): LossyFlowAccumulator( mg0, flow_director="MFD", depression_finder="DepressionFinderAndRouter" ) with pytest.raises(NotImplementedError): LossyFlowAccumulator( mg0, flow_director="DINF", depression_finder="DepressionFinderAndRouter" ) fa0 = LossyFlowAccumulator(mg0, flow_director="MFD") fa0.run_one_step() with pytest.raises(NotImplementedError): DepressionFinderAndRouter(mg0) fa1 = LossyFlowAccumulator(mg1, flow_director="DINF") fa1.run_one_step() with pytest.raises(NotImplementedError): DepressionFinderAndRouter(mg1)
def test_run_with_2_fn_args(): mg = RasterModelGrid((3, 5), xy_spacing=(2, 1)) mg.set_closed_boundaries_at_grid_edges(True, True, False, True) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") def mylossfunction(qw, nodeID): return 0.5 * qw fa = LossyFlowAccumulator( mg, "topographic__elevation", flow_director=FlowDirectorSteepest, routing="D4", loss_function=mylossfunction, ) fa.run_one_step() assert np.allclose( mg.at_node["drainage_area"].reshape(mg.shape), np.array([[0., 0., 0., 0., 0.], [6., 6., 4., 2., 0.], [0., 0., 0., 0., 0.]]), ) assert np.allclose( mg.at_node["surface_water__discharge"].reshape(mg.shape), np.array( [ [0.00, 0.00, 0.00, 0.00, 0.00], [1.75, 3.50, 3.00, 2.00, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00], ] ), )
def test_accumulated_area_closes(fd): """Check that accumulated area is area of core nodes.""" mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fa = LossyFlowAccumulator(mg) fa.run_one_step() drainage_area = mg.at_node["drainage_area"] drained_area = np.sum(drainage_area[mg.boundary_nodes]) core_area = np.sum(mg.cell_area_at_node[mg.core_nodes]) assert drained_area == core_area
def test_specifying_routing_method_wrong(): """Test specifying incorrect method for routing compatability with DepressionFinderAndRouter.""" mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") with pytest.raises(ValueError): LossyFlowAccumulator( mg, flow_director="D4", depression_finder="DepressionFinderAndRouter" ) df = DepressionFinderAndRouter(mg) with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director="D4", depression_finder=df)
def test_accumulated_area_closes(): """Check that accumulated area is area of core nodes.""" fds = ["Steepest", "D8", "MFD", "DINF"] for fd in fds: mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fa = LossyFlowAccumulator(mg) fa.run_one_step() drainage_area = mg.at_node["drainage_area"] drained_area = np.sum(drainage_area[mg.boundary_nodes]) core_area = np.sum(mg.cell_area_at_node[mg.core_nodes]) assert drained_area == core_area
def test_depression_finder_bad_uninstantiated_component(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director="D8", depression_finder=LinearDiffuser)
def test_instantiated_depression_finder_with_kwargs(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") df = DepressionFinderAndRouter(mg) with pytest.raises(ValueError): LossyFlowAccumulator( mg, flow_director="D8", depression_finder=df, routing="eggs" )
def test_passing_a_bad_component(): """Check that a random component can't be a director.""" from landlab.components import ChiFinder mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") mg.set_closed_boundaries_at_grid_edges(True, True, True, False) with pytest.raises(ValueError): LossyFlowAccumulator(mg, "topographic__elevation", flow_director=ChiFinder)
def test_fields(): """Check to make sure the right fields have been created. Check that the sizes are also correct. """ mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fa = LossyFlowAccumulator(mg) fa.run_one_step() assert sorted(list(mg.at_node.keys())) == [ "drainage_area", "flow__data_structure_delta", "flow__link_to_receiver_node", "flow__receiver_node", "flow__sink_flag", "flow__upstream_node_order", "surface_water__discharge", "surface_water__discharge_loss", "topographic__elevation", "topographic__steepest_slope", "water__unit_flux_in", ] assert sorted(list(mg.at_grid.keys())) == ["flow__data_structure_D"] mg2 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg2.add_field("topographic__elevation", mg2.node_x + mg2.node_y, at="node") fa2 = LossyFlowAccumulator(mg2, flow_director="MFD") fa2.run_one_step() assert sorted(list(mg2.at_node.keys())) == [ "drainage_area", "flow__data_structure_delta", "flow__link_to_receiver_node", "flow__receiver_node", "flow__receiver_proportions", "flow__sink_flag", "flow__upstream_node_order", "surface_water__discharge", "surface_water__discharge_loss", "topographic__elevation", "topographic__steepest_slope", "water__unit_flux_in", ] assert sorted(list(mg2.at_grid.keys())) == ["flow__data_structure_D"]
def test_loss_func_arguments(): """Check the loss_function only has one argument.""" mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x**2 + mg.node_y**2, at="node") def funcgood(x): return 0.0 def funcgood2(x, y): return 0.0 def funcgood3(x, y, z): return 0.0 def funcgood4(x, y, z, grid): return 0.0 def funcbad(x, y, z, grid, K): return 0.0 def funcbad2(x): return "booooooo" def funcbad3(x, y): return np.array([0.0]) def funcbad4(x, y, z): return (0, 1) LossyFlowAccumulator(mg, loss_function=funcgood) # no problem LossyFlowAccumulator(mg, loss_function=funcgood2) # no problem LossyFlowAccumulator(mg, loss_function=funcgood3) # no problem LossyFlowAccumulator(mg, loss_function=funcgood4) # no problem with pytest.raises(ValueError): LossyFlowAccumulator(mg, loss_function=funcbad) with pytest.raises(TypeError): LossyFlowAccumulator(mg, loss_function=funcbad2) with pytest.raises(TypeError): LossyFlowAccumulator(mg, loss_function=funcbad3) with pytest.raises(TypeError): LossyFlowAccumulator(mg, loss_function=funcbad4)
def test_check_fields(): """Check to make sure the right fields have been created.""" mg = RasterModelGrid((10, 10), xy_spacing=(1, 1)) z = mg.add_field( "topographic__elevation", mg.node_x ** 2 + mg.node_y ** 2, at="node" ) LossyFlowAccumulator(mg) assert_array_equal(z, mg.at_node["topographic__elevation"]) assert_array_equal(np.zeros(100), mg.at_node["drainage_area"]) assert_array_equal(np.ones(100), mg.at_node["water__unit_flux_in"]) assert_array_equal(np.zeros(100), mg.at_node["surface_water__discharge_loss"]) LossyFlowAccumulator(mg, runoff_rate=2.) assert_array_equal(np.full(100, 2.), mg.at_node["water__unit_flux_in"]) # quick test that the component binds correctly to an existing field: L = mg.at_node["surface_water__discharge_loss"] fa = LossyFlowAccumulator(mg) fa.run_one_step() # this line is padding to make flake8 happy L[0] = 1. assert mg.at_node["surface_water__discharge_loss"] is L
def test_field_name_array_float_case6(): """Topography as array, runoff rate as array""" mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) topographic__elevation = np.array( [ 0., 0., 0., 0., 0., 21., 10., 0., 0., 31., 20., 0., 0., 32., 30., 0., 0., 0., 0., 0., ] ) runoff_rate = [ 1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4., 5., 5., 5., 5., ] mg.add_field("node", "topographic__elevation", topographic__elevation) mg.set_closed_boundaries_at_grid_edges(True, True, True, False) fa = LossyFlowAccumulator(mg, topographic__elevation, runoff_rate=runoff_rate) fa.run_one_step() reciever = np.array( [0, 1, 2, 3, 4, 1, 2, 7, 8, 10, 6, 11, 12, 14, 10, 15, 16, 17, 18, 19] ) da = np.array( [0., 1., 5., 0., 0., 1., 5., 0., 0., 1., 4., 0., 0., 1., 2., 0., 0., 0., 0., 0.] ) q = np.array( [ 0., 2., 16., 0., # KRB double checked these numbers by hand 5/15/18 - OK 0., 2., 16., 0., 0., 3., 14., 0., 0., 4., 8., 0., 0., 0., 0., 0., ] ) assert_array_equal(mg.at_node["flow__receiver_node"], reciever) assert_array_equal(mg.at_node["drainage_area"], da) assert_array_equal(mg.at_node["surface_water__discharge"], q)
def test_flow_accumulator_properties(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fa = LossyFlowAccumulator(mg) fa.run_one_step() node_drainage_area = np.array( [ 0., 3., 3., 3., 0., 0., 3., 3., 3., 0., 0., 2., 2., 2., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., ] ) node_order_upstream = np.array( [ 0, 1, 6, 11, 16, 2, 7, 12, 17, 3, 8, 13, 18, 4, 5, 9, 10, 14, 15, 19, 20, 21, 22, 23, 24, ] ) assert_array_equal(fa.node_order_upstream, node_order_upstream) assert_array_equal(fa.node_water_discharge, node_drainage_area) assert_array_equal(fa.node_drainage_area, node_drainage_area)
def test_bad_director_name(): mg = RasterModelGrid((5, 5), spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director="spam")
def test_field_name_array_float_case4(): """Topography as array, runoff rate as float""" mg = RasterModelGrid((5, 4), xy_spacing=(1, 1)) topographic__elevation = np.array( [ 0., 0., 0., 0., 0., 21., 10., 0., 0., 31., 20., 0., 0., 32., 30., 0., 0., 0., 0., 0., ] ) mg.add_field("node", "topographic__elevation", topographic__elevation) mg.set_closed_boundaries_at_grid_edges(True, True, True, False) fa = LossyFlowAccumulator(mg, topographic__elevation, runoff_rate=10.) assert_array_equal( mg.at_node["water__unit_flux_in"], 10. * np.ones(mg.size("node")) ) fa.run_one_step() reciever = np.array( [0, 1, 2, 3, 4, 1, 2, 7, 8, 10, 6, 11, 12, 14, 10, 15, 16, 17, 18, 19] ) da = np.array( [0., 1., 5., 0., 0., 1., 5., 0., 0., 1., 4., 0., 0., 1., 2., 0., 0., 0., 0., 0.] ) q = np.array( [ 0., 10., 50., 0., 0., 10., 50., 0., 0., 10., 40., 0., 0., 10., 20., 0., 0., 0., 0., 0., ] ) assert_array_equal(mg.at_node["flow__receiver_node"], reciever) assert_array_equal(mg.at_node["drainage_area"], da) assert_array_equal(mg.at_node["surface_water__discharge"], q)
def test_instantiated_director_with_kwargs(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fd = FlowDirectorSteepest(mg) with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director=fd, partition_method="eggs")
def test_water_discharge_in_supplied(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") mg.add_field("water__discharge_in", mg.node_x + mg.node_y, at="node") with pytest.deprecated_call(): LossyFlowAccumulator(mg)
def test_depression_finder_as_bad_string(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director="D8", depression_finder="spam")
def test_depression_finder_as_instance(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") df = DepressionFinderAndRouter(mg) LossyFlowAccumulator(mg, flow_director="D8", depression_finder=df)
def test_depression_finder_bad_instance(): mg = RasterModelGrid((5, 5), xy_spacing=(1, 1)) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") ld = LinearDiffuser(mg, linear_diffusivity=1.) with pytest.raises(ValueError): LossyFlowAccumulator(mg, flow_director="D8", depression_finder=ld)
def test_director_adding_methods_are_equivalent_MFD(): """Check that different methods to specifying the director are the same.""" mg0 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg0.add_field( "topographic__elevation", mg0.node_x ** 2 + mg0.node_y ** 2, at="node" ) fa0 = LossyFlowAccumulator(mg0, flow_director="MFD") fa0.run_one_step() mg1 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg1.add_field( "topographic__elevation", mg1.node_x ** 2 + mg1.node_y ** 2, at="node" ) fa1 = LossyFlowAccumulator(mg1, flow_director="FlowDirectorMFD") fa1.run_one_step() mg2 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg2.add_field( "topographic__elevation", mg2.node_x ** 2 + mg2.node_y ** 2, at="node" ) fa2 = LossyFlowAccumulator(mg2, flow_director=FlowDirectorMFD) fa2.run_one_step() mg3 = RasterModelGrid((10, 10), xy_spacing=(1, 1)) mg3.add_field( "topographic__elevation", mg3.node_x ** 2 + mg3.node_y ** 2, at="node" ) fd = FlowDirectorMFD(mg3) fa3 = LossyFlowAccumulator(mg3, flow_director=fd) fa3.run_one_step() for key in mg0.at_node.keys(): assert_array_equal(mg0.at_node[key], mg1.at_node[key]) assert_array_equal(mg1.at_node[key], mg2.at_node[key]) assert_array_equal(mg2.at_node[key], mg3.at_node[key])
def test_hex_mfd(): mg = HexModelGrid(5, 3) mg.add_field("topographic__elevation", mg.node_x + mg.node_y, at="node") fa = LossyFlowAccumulator(mg, flow_director="MFD") fa.run_one_step()