def accumulate_flow(self, update_flow_director=True): """ Function to make FlowAccumulator calculate drainage area and discharge. Running run_one_step() results in the following to occur: 1. Flow directions are updated (unless update_flow_director is set as False). 2. Intermediate steps that analyse the drainage network topology and create datastructures for efficient drainage area and discharge calculations. 3. Calculation of drainage area and discharge. 4. Depression finding and mapping, which updates drainage area and discharge. """ # step 1. Find flow directions by specified method if update_flow_director == True: self.flow_director.run_one_step() # further steps vary depending on how many recievers are present # one set of steps is for route to one (D8, Steepest/D4) if self.flow_director.to_n_receivers == 'one': # step 3. Run depression finder if passed # Depression finder reaccumulates flow at the end of its routine. if self.depression_finder_provided is not None: self.depression_finder.map_depressions() a = self._grid['node']['drainage_area'] q = self._grid['node']['surface_water__discharge'] else: # step 2. Get r r = self._grid['node']['flow__receiver_node'] # step 2. Stack, D, delta construction nd = flow_accum_bw._make_number_of_donors_array(r) delta = flow_accum_bw._make_delta_array(nd) D = flow_accum_bw._make_array_of_donors(r, delta) s = flow_accum_bw.make_ordered_node_array(r) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid['node']['flow__data_structure_delta'][:] = delta[1:] self._grid['link']['flow__data_structure_D'][:len(D)] = D self._grid['node']['flow__upstream_node_order'][:] = s # step 4. Accumulate (to one or to N depending on direction method. ) a, q = flow_accum_bw.find_drainage_area_and_discharge(s, r, self.node_cell_area, self._grid.at_node['water__unit_flux_in']) self._grid['node']['drainage_area'][:] = a self._grid['node']['surface_water__discharge'][:] = q else: # step 2. Get r and p r = self._grid['node']['flow__receiver_nodes'] p = self._grid['node']['flow__receiver_proportions'] # step 2. Stack, D, delta construction nd = flow_accum_to_n._make_number_of_donors_array_to_n(r, p) delta = flow_accum_to_n._make_delta_array_to_n(nd) D = flow_accum_to_n._make_array_of_donors_to_n(r, p, delta) s = flow_accum_to_n.make_ordered_node_array_to_n(r, p) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid['node']['flow__data_structure_delta'][:] = delta[1:] if self._is_raster: tempD = BAD_INDEX_VALUE * np.ones((self._grid.number_of_links*2)) tempD[:len(D)] = D self._grid['link']['flow__data_structure_D'][:] = tempD.reshape((self._grid.number_of_links, 2)) else: self._grid['link']['flow__data_structure_D'][:len(D)] = D self._grid['node']['flow__upstream_node_order'][:] = s # step 3. Run depression finder if passed # at present this must go at the end. # step 4. Accumulate (to one or to N depending on direction method. ) a, q = flow_accum_to_n.find_drainage_area_and_discharge_to_n(s, r, p, self.node_cell_area, self._grid.at_node['water__unit_flux_in']) # store drainage area and discharge. self._grid['node']['drainage_area'][:] = a self._grid['node']['surface_water__discharge'][:] = q # at the moment, this is where the depression finder needs to live. if self.depression_finder_provided is not None: self.depression_finder.map_depressions() return (a, q)
def accumulate_flow(self, update_flow_director=True): """ Function to make FlowAccumulator calculate drainage area and discharge. Running run_one_step() results in the following to occur: 1. Flow directions are updated (unless update_flow_director is set as False). 2. Intermediate steps that analyse the drainage network topology and create datastructures for efficient drainage area and discharge calculations. 3. Calculation of drainage area and discharge. 4. Depression finding and mapping, which updates drainage area and discharge. """ # set a couple of aliases a = self._grid["node"]["drainage_area"] q = self._grid["node"]["surface_water__discharge"] # step 1. Find flow directions by specified method if update_flow_director: self.flow_director.run_one_step() # further steps vary depending on how many recievers are present # one set of steps is for route to one (D8, Steepest/D4) # step 2. Get r r = self._grid["node"]["flow__receiver_node"] if self.flow_director.to_n_receivers == "one": # step 2b. Run depression finder if passed # Depression finder reaccumulates flow at the end of its routine. # At the moment, no depression finders work with to-many, so it # lives here if self.depression_finder_provided is not None: self.depression_finder.map_depressions() # step 3. Stack, D, delta construction nd = flow_accum_bw._make_number_of_donors_array(r) delta = flow_accum_bw._make_delta_array(nd) D = flow_accum_bw._make_array_of_donors(r, delta) s = flow_accum_bw.make_ordered_node_array(r) # put these in grid so that depression finder can use it. # store the generated data in the grid self._grid["node"]["flow__data_structure_delta"][:] = delta[1:] self._grid["link"]["flow__data_structure_D"][:len(D)] = D self._grid["node"]["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_one(s, r) else: # Get p p = self._grid["node"]["flow__receiver_proportions"] # step 3. Stack, D, delta construction nd = flow_accum_to_n._make_number_of_donors_array_to_n(r, p) delta = flow_accum_to_n._make_delta_array_to_n(nd) D = flow_accum_to_n._make_array_of_donors_to_n(r, p, delta) s = flow_accum_to_n.make_ordered_node_array_to_n(r, p) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid["node"]["flow__data_structure_delta"][:] = delta[1:] if self._is_raster: tempD = BAD_INDEX_VALUE * np.ones( (self._grid.number_of_links * 2)) tempD[:len(D)] = D self._grid["link"][ "flow__data_structure_D"][:] = tempD.reshape( (self._grid.number_of_links, 2)) else: self._grid["link"]["flow__data_structure_D"][:len(D)] = D self._grid["node"]["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_n(s, r, p) return (a, q)
def accumulate_flow(self, update_flow_director=True): """ Function to make FlowAccumulator calculate drainage area and discharge. Running run_one_step() results in the following to occur: 1. Flow directions are updated (unless update_flow_director is set as False). 2. Intermediate steps that analyse the drainage network topology and create datastructures for efficient drainage area and discharge calculations. 3. Calculation of drainage area and discharge. 4. Depression finding and mapping, which updates drainage area and discharge. """ # step 1. Find flow directions by specified method if update_flow_director == True: self.flow_director.run_one_step() # further steps vary depending on how many recievers are present # one set of steps is for route to one (D8, Steepest/D4) if self.flow_director.to_n_receivers == 'one': # step 2. Get r r = self._grid['node']['flow__receiver_node'] # step 2. Stack, D, delta construction nd = flow_accum_bw._make_number_of_donors_array(r) delta = flow_accum_bw._make_delta_array(nd) D = flow_accum_bw._make_array_of_donors(r, delta) s = flow_accum_bw.make_ordered_node_array(r) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid['node']['flow__data_structure_delta'][:] = delta[1:] self._grid['link']['flow__data_structure_D'][:len(D)] = D self._grid['node']['flow__upstream_node_order'][:] = s # step 3. Run depression finder if passed # at present this must go at the end. # step 4. Accumulate (to one or to N depending on direction method. ) a, q = flow_accum_bw.find_drainage_area_and_discharge( s, r, self.node_cell_area, self._grid.at_node['water__unit_flux_in']) else: # step 2. Get r and p r = self._grid['node']['flow__receiver_nodes'] p = self._grid['node']['flow__receiver_proportions'] # step 2. Stack, D, delta construction nd = flow_accum_to_n._make_number_of_donors_array_to_n(r, p) delta = flow_accum_to_n._make_delta_array_to_n(nd) D = flow_accum_to_n._make_array_of_donors_to_n(r, p, delta) s = flow_accum_to_n.make_ordered_node_array_to_n(r, p) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid['node']['flow__data_structure_delta'][:] = delta[1:] if self._is_raster: tempD = BAD_INDEX_VALUE * np.ones( (self._grid.number_of_links * 2)) tempD[:len(D)] = D self._grid['link'][ 'flow__data_structure_D'][:] = tempD.reshape( (self._grid.number_of_links, 2)) else: self._grid['link']['flow__data_structure_D'][:len(D)] = D self._grid['node']['flow__upstream_node_order'][:] = s # step 3. Run depression finder if passed # at present this must go at the end. # step 4. Accumulate (to one or to N depending on direction method. ) a, q = flow_accum_to_n.find_drainage_area_and_discharge_to_n( s, r, p, self.node_cell_area, self._grid.at_node['water__unit_flux_in']) # store drainage area and discharge. self._grid['node']['drainage_area'][:] = a self._grid['node']['surface_water__discharge'][:] = q # at the moment, this is where the depression finder needs to live. if self.depression_finder_provided is not None: self.depression_finder.map_depressions() return (a, q)
def accumulate_flow(self, update_flow_director=True): """Function to make FlowAccumulator calculate drainage area and discharge. Running run_one_step() results in the following to occur: 1. Flow directions are updated (unless update_flow_director is set as False). 2. Intermediate steps that analyse the drainage network topology and create datastructures for efficient drainage area and discharge calculations. 3. Calculation of drainage area and discharge. 4. Depression finding and mapping, which updates drainage area and discharge. """ # set a couple of aliases a = self._grid["node"]["drainage_area"] q = self._grid["node"]["surface_water__discharge"] # step 1. Find flow directions by specified method if update_flow_director: self.flow_director.run_one_step() # further steps vary depending on how many recievers are present # one set of steps is for route to one (D8, Steepest/D4) # step 2. Get r r = as_id_array(self._grid["node"]["flow__receiver_node"]) if self.flow_director.to_n_receivers == "one": # step 2b. Run depression finder if passed # Depression finder reaccumulates flow at the end of its routine. # At the moment, no depression finders work with to-many, so it # lives here if self.depression_finder_provided is not None: self.depression_finder.map_depressions() # if FlowDirectorSteepest is used, update the link directions if self.flow_director._name == "FlowDirectorSteepest": self.flow_director._determine_link_directions() # step 3. Stack, D, delta construction nd = as_id_array(flow_accum_bw._make_number_of_donors_array(r)) delta = as_id_array(flow_accum_bw._make_delta_array(nd)) D = as_id_array(flow_accum_bw._make_array_of_donors(r, delta)) s = as_id_array(flow_accum_bw.make_ordered_node_array(r)) # put these in grid so that depression finder can use it. # store the generated data in the grid self._grid["node"]["flow__data_structure_delta"][:] = delta[1:] self._grid["grid"]["flow__data_structure_D"] = np.array([D], dtype=object) self._grid["node"]["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_one(s, r) else: # Get p p = self._grid["node"]["flow__receiver_proportions"] # step 3. Stack, D, delta construction nd = as_id_array(flow_accum_to_n._make_number_of_donors_array_to_n(r, p)) delta = as_id_array(flow_accum_to_n._make_delta_array_to_n(nd)) D = as_id_array(flow_accum_to_n._make_array_of_donors_to_n(r, p, delta)) s = as_id_array(flow_accum_to_n.make_ordered_node_array_to_n(r, p)) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid["node"]["flow__data_structure_delta"][:] = delta[1:] self._grid["grid"]["flow__data_structure_D"][0] = np.array( [D], dtype=object ) self._grid["node"]["flow__upstream_node_order"][:] = s self._grid["node"]["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_n(s, r, p) return (a, q)
def accumulate_flow(self, update_flow_director=True, update_depression_finder=True): """Function to make FlowAccumulator calculate drainage area and discharge. Running accumulate_flow() results in the following to occur: 1. Flow directions are updated (unless update_flow_director is set as False). This incluldes checking for updated boundary conditions. 2. The depression finder, if present is updated (unless update_depression_finder is set as False). 3. Intermediate steps that analyse the drainage network topology and create datastructures for efficient drainage area and discharge calculations. 4. Calculation of drainage area and discharge. 5. Return of drainage area and discharge. Parameters ---------- update_flow_director : optional, bool Whether to update the flow director. Default is True. update_depression_finder : optional, bool Whether to update the depression finder, if present. Default is True. Returns ------- drainage_area : array At node array which points to the field grid.at_node["drainage_area"]. surface_water__discharge At node array which points to the field grid.at_node["surface_water__discharge"]. """ # set a couple of aliases a = self._grid["node"]["drainage_area"] q = self._grid["node"]["surface_water__discharge"] # step 1. Find flow directions by specified method if update_flow_director: self._flow_director.run_one_step() # further steps vary depending on how many recievers are present # one set of steps is for route to one (D8, Steepest/D4) # step 2. Get r r = as_id_array(self._grid["node"]["flow__receiver_node"]) if self._flow_director._to_n_receivers == "one": # step 2b. Run depression finder if passed # Depression finder reaccumulates flow at the end of its routine. # At the moment, no depression finders work with to-many, so it # lives here if self._depression_finder_provided is not None: if update_depression_finder: self._depression_finder.map_depressions() # if FlowDirectorSteepest is used, update the link directions if self._flow_director._name == "FlowDirectorSteepest": self._flow_director._determine_link_directions() # step 3. Stack, D, delta construction nd = as_id_array(flow_accum_bw._make_number_of_donors_array(r)) delta = as_id_array(flow_accum_bw._make_delta_array(nd)) D = as_id_array(flow_accum_bw._make_array_of_donors(r, delta)) s = as_id_array(flow_accum_bw.make_ordered_node_array(r)) # put these in grid so that depression finder can use it. # store the generated data in the grid self._grid.at_node["flow__data_structure_delta"][:] = delta[1:] self._D_structure = D self._grid.at_node["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_one(s, r) else: # Get p p = self._grid["node"]["flow__receiver_proportions"] # step 3. Stack, D, delta construction nd = as_id_array( flow_accum_to_n._make_number_of_donors_array_to_n(r, p)) delta = as_id_array(flow_accum_to_n._make_delta_array_to_n(nd)) D = as_id_array( flow_accum_to_n._make_array_of_donors_to_n(r, p, delta)) s = as_id_array(flow_accum_to_n.make_ordered_node_array_to_n(r, p)) # put theese in grid so that depression finder can use it. # store the generated data in the grid self._grid["node"]["flow__data_structure_delta"][:] = delta[1:] self._D_structure = D self._grid["node"]["flow__upstream_node_order"][:] = s self._grid["node"]["flow__upstream_node_order"][:] = s # step 4. Accumulate (to one or to N depending on direction method) a[:], q[:] = self._accumulate_A_Q_to_n(s, r, p) return (a, q)