Exemplo n.º 1
0
def make_agg_pairs(pour_points, dom_data, fdr_data, config_dict):
    """
    Group pour points by domain grid outlet cell
    """
    lons = pour_points['lons']
    lats = pour_points['lats']
    dom_lon = dom_data[config_dict['DOMAIN']['LONGITUDE_VAR']]
    dom_lat = dom_data[config_dict['DOMAIN']['LATITUDE_VAR']]
    dom_ids = dom_data['cell_ids']
    fdr_lons = fdr_data[config_dict['ROUTING']['LONGITUDE_VAR']]
    fdr_lats = fdr_data[config_dict['ROUTING']['LATITUDE_VAR']]
    fdr_srcarea = fdr_data[config_dict['ROUTING']['SOURCE_AREA_VAR']]

    # ---------------------------------------------------------------- #
    #Find Destination grid cells
    log.info('Finding addresses now...')
    routys, routxs = latlon2yx(plats=lats,
                               plons=lons,
                               glats=fdr_lats,
                               glons=fdr_lons)

    domys, domxs = latlon2yx(plats=lats,
                             plons=lons,
                             glats=dom_lat,
                             glons=dom_lon)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Do the aggregation
    outlets = {}

    for i, (lat, lon) in enumerate(zip(lats, lons)):
        # Define pour point object (on )
        pour_point = Point(lat=lat,
                           lon=lon,
                           domx=domxs[i],
                           domy=domys[i],
                           routx=routxs[i],
                           routy=routys[i],
                           name=None,
                           cell_id=dom_ids[domys[i], domxs[i]])
        pour_point.source_area = fdr_srcarea[pour_point.routy,
                                             pour_point.routx]

        cell_id = dom_ids[domys[i], domxs[i]]

        if cell_id in outlets:
            outlets[cell_id].pour_points.append(pour_point)
            outlets[cell_id].upstream_area += pour_point.source_area
        else:
            # define outlet grid cell (on domain grid)
            outlets[cell_id] = Point(domy=domys[i],
                                     domx=domxs[i],
                                     lat=dom_lat[domys[i], domxs[i]],
                                     lon=dom_lon[domys[i], domxs[i]])
            outlets[cell_id].pour_points = [pour_point]
            outlets[cell_id].cell_id = cell_id
            outlets[cell_id].upstream_area = pour_point.source_area
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Sort based on outlet total source area pour_point.source_area
    outlets = OrderedDict(
        sorted(outlets.items(), key=lambda t: t[1].upstream_area,
               reverse=True))
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Count the pairs
    pp_count = 0
    key_count = 0
    num = len(lons)
    for i, key in enumerate(outlets):
        key_count += 1
        pp_count += len(outlets[key].pour_points)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Print Debug Results
    log.info('\n------------------ SUMMARY OF MakeAggPairs ------------------')
    log.info('NUMBER OF POUR POINTS IN INPUT LIST: %i' % num)
    log.info('NUMBER OF POINTS TO AGGREGATE TO: %i' % key_count)
    log.info('NUMBER OF POUR POINTS AGGREGATED: %i' % pp_count)
    log.info('EFFECIENCY OF: %.2f %%' % (100. * pp_count / num))
    log.info('UNASSIGNED POUR POINTS: %i' % (num - pp_count))
    log.info('-------------------------------------------------------------\n')

    # ---------------------------------------------------------------- #
    return outlets
Exemplo n.º 2
0
def make_agg_pairs(pour_points, dom_data, fdr_data, config_dict):
# def make_agg_pairs(lons, lats, dom_lon, dom_lat, dom_ids,
                   # fdr_lons, fdr_lats, fdr_srcarea, agg_type='agg'):
    """
    Group pour points by domain grid outlet cell
    """
    lons = pour_points['lons']
    lats = pour_points['lats']
    dom_lon = dom_data[config_dict['DOMAIN']['LONGITUDE_VAR']]
    dom_lat = dom_data[config_dict['DOMAIN']['LATITUDE_VAR']]
    dom_ids = dom_data['cell_ids']
    fdr_lons = fdr_data[config_dict['ROUTING']['LONGITUDE_VAR']]
    fdr_lats = fdr_data[config_dict['ROUTING']['LATITUDE_VAR']]
    fdr_srcarea = fdr_data[config_dict['ROUTING']['SOURCE_AREA_VAR']]

    routys, routxs = latlon2yx(plats=lats,
                               plons=lons,
                               glats=fdr_lats,
                               glons=fdr_lons)

    # ---------------------------------------------------------------- #
    #Find Destination grid cells
    log.info('Finding addresses now...')

    if (min(lons) < 0 and dom_lon.min() >= 0):
        posinds = np.nonzero(dom_lon > 180)
        dom_lon[posinds] -= 360
        log.info('adjusted domain lon minimum')

    if (min(lons) < 0 and fdr_lons.min() >= 0):
        posinds = np.nonzero(fdr_lons > 180)
        fdr_lons[posinds] -= 360
        log.info('adjusted fdr lon minimum')

    combined = np.dstack(([dom_lat.ravel(), dom_lon.ravel()]))[0]
    points = list(np.vstack((np.array(lats), np.array(lons))).transpose())

    mytree = cKDTree(combined)
    dist, indexes = mytree.query(points, k=1)
    gridys, gridxs = np.unravel_index(np.array(indexes), dom_lat.shape)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Do the aggregation
    outlets = {}

    for i, ind in enumerate(indexes):
        # Define pour point object (on )
        pour_point = Point(lat=lats[i],
                           lon=lons[i],
                           gridx=gridxs[i],
                           gridy=gridys[i],
                           routx=routxs[i],
                           routy=routys[i],
                           name=None,
                           cell_id=dom_ids[gridys[i], gridxs[i]])
        pour_point.source_area = fdr_srcarea[pour_point.routy, pour_point.routx]

        cell_id = dom_ids[gridys[i], gridxs[i]]

        if cell_id in outlets:
            outlets[cell_id].pour_points.append(pour_point)
            outlets[cell_id].upstream_area += pour_point.source_area
        else:
            # define outlet grid cell (on domain grid)
            outlets[cell_id] = Point(gridy=gridys[i],
                                     gridx=gridxs[i],
                                     lat=combined[ind][0],
                                     lon=combined[ind][1])
            outlets[cell_id].pour_points = [pour_point]
            outlets[cell_id].cell_id = cell_id
            outlets[cell_id].upstream_area = pour_point.source_area
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Sort based on outlet total source area pour_point.source_area
    outlets = OrderedDict(sorted(outlets.items(), key=lambda t: t[1].upstream_area, reverse=True))
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Count the pairs
    pp_count = 0
    key_count = 0
    num = len(lons)
    for i, key in enumerate(outlets):
        key_count += 1
        pp_count += len(outlets[key].pour_points)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Print Debug Results
    log.info('\n------------------ SUMMARY OF MakeAggPairs ------------------')
    log.info('NUMBER OF POUR POINTS IN INPUT LIST: %i' % num)
    log.info('NUMBER OF POINTS TO AGGREGATE TO: %i' % key_count)
    log.info('NUMBER OF POUR POINTS AGGREGATED: %i' % pp_count)
    log.info('EFFECIENCY OF: %.2f %%' % (100.*pp_count / num))
    log.info('UNASSIGNED POUR POINTS: %i \n' % (num-pp_count))
    log.info('---------------------------------------------------------------\n')

    # ---------------------------------------------------------------- #
    return outlets
Exemplo n.º 3
0
def rout(pour_point, uh_box, fdr_data, fdr_atts, rout_dict):
    """
    Make the Unit Hydrograph Grid
    """
    log.info("Starting routing program for point: %s", pour_point)
    # ---------------------------------------------------------------- #
    # Unpack a few structures
    uh_t = uh_box['time']
    uh_box = uh_box['func']
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find Basin Dims and ID
    basin_id = fdr_data[rout_dict['BASIN_ID_VAR']][pour_point.routy, pour_point.routx]

    log.info('Input Latitude: %f', pour_point.lat)
    log.info('Input Longitude: %f', pour_point.lon)
    log.info('Global Basid ID: %i', basin_id)

    y_inds, x_inds = np.nonzero(fdr_data[rout_dict['BASIN_ID_VAR']] == basin_id)
    y = np.arange(len(fdr_data[rout_dict['LATITUDE_VAR']]))
    x = np.arange(len(fdr_data[rout_dict['LONGITUDE_VAR']]))

    x_min = min(x[x_inds])
    x_max = max(x[x_inds])+1
    y_min = min(y[y_inds])
    y_max = max(y[y_inds])+1
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Create the Basin Dictionary, a subset of the fdr_data
    basin = {}
    basin['lat'] = fdr_data[rout_dict['LATITUDE_VAR']][y_min:y_max]
    basin['lon'] = fdr_data[rout_dict['LONGITUDE_VAR']][x_min:x_max]
    basin['basin_id'] = fdr_data[rout_dict['BASIN_ID_VAR']][y_min:y_max, x_min:x_max]
    basin['flow_direction'] = fdr_data[rout_dict['FLOW_DIRECTION_VAR']][y_min:y_max, x_min:x_max]
    basin['flow_distance'] = fdr_data[rout_dict['FLOW_DISTANCE_VAR']][y_min:y_max, x_min:x_max]
    basin['velocity'] = fdr_data['velocity'][y_min:y_max, x_min:x_max]
    basin['diffusion'] = fdr_data['diffusion'][y_min:y_max, x_min:x_max]

    log.debug('Grid cells in subset: %i', basin['velocity'].size)

    pour_point.basiny, pour_point.basinx = latlon2yx(plats=pour_point.lat,
                                                     plons=pour_point.lon,
                                                     glats=basin['lat'],
                                                     glons=basin['lon'])
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Create the rout_data Dictionary
    rout_data = {'lat': basin['lat'], 'lon': basin['lon'],
                 'dom_x_min': x_min, 'dom_y_min': y_min,
                 'dom_x_max': x_max, 'dom_y_max': y_max}
    log.debug('Clipping indicies:')
    log.debug('dom_x_min: %s', rout_data['dom_x_min'])
    log.debug('dom_x_max: %s', rout_data['dom_x_max'])
    log.debug('dom_y_min: %s', rout_data['dom_y_min'])
    log.debug('dom_y_max: %s', rout_data['dom_y_max'])
    # ---------------------------------------------------------------- #
    # Determine/Set flow direction syntax
    # Flow directions {north, northeast, east, southeast,
    # south, southwest, west, northwest}
    if 'VIC' in fdr_atts[rout_dict['FLOW_DIRECTION_VAR']] or \
            fdr_data[rout_dict['FLOW_DIRECTION_VAR']].max() < 10:
        # VIC Directions: http://www.hydro.washington.edu/Lettenmaier/Models/\
        # VIC/Documentation/Routing/FlowDirection.shtml
        dy = {1: -1, 2: -1, 3: 0, 4: 1,
              5: 1, 6: 1, 7: 0, 8: -1}
        dx = {1: 0, 2: 1, 3: 1, 4: 1,
              5: 0, 6: -1, 7: -1, 8: - 1}
        log.debug('Using VIC flow directions (1-8).')
    else:
        # ARCMAP Directions: http://webhelp.esri.com/arcgisdesktop/9.2/\
        # index.cfm?TopicName=flow_direction
        dy = {64: -1, 128: -1, 1: 0, 2: 1,
              4: 1, 8: 1, 16: 0, 32: -1}
        dx = {64: 0, 128: 1, 1: 1, 2: 1,
              4: 0, 8: -1, 16: -1, 32: -1}
        log.debug('Using ARCMAP flow directions (1-128).')
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find timestep (timestep is determined from uh_BOX input file)
    input_interval = find_ts(uh_t)
    rout_data['unit_hydrograph_dt'] = input_interval
    t_cell = int(rout_dict['CELL_FLOWDAYS']*SECSPERDAY/input_interval)
    t_uh = int(rout_dict['BASIN_FLOWDAYS']*SECSPERDAY/input_interval)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Read direction grid and find to_col (to_x) and to_row (to_y)
    to_y, to_x = read_direction(basin['flow_direction'], dy, dx)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find all grid cells upstream of pour point
    catchment, rout_data['fraction'] = search_catchment(to_y, to_x, pour_point,
                                                        basin['basin_id'],
                                                        basin_id)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Make uh for each grid cell upstream of basin pour point
    # (linear routing model - Saint-Venant equation)
    uh = make_uh(input_interval, t_cell, catchment['y_inds'],
                 catchment['x_inds'], basin['velocity'], basin['diffusion'],
                 basin['flow_distance'])
    # ---------------------------------------------------------------- #
    # Make uh_river by incrementally moving upstream comining uh functions
    uh_river = make_grid_uh_river(t_uh, t_cell, uh, to_y, to_x, pour_point,
                                  catchment['y_inds'], catchment['x_inds'],
                                  catchment['count_ds'])
    # ---------------------------------------------------------------- #
    # Make uh_s for each grid cell upstream of basin pour point
    # (combine IRFs for all grid cells in flow path)
    uh_s = make_grid_uh(t_uh, t_cell, uh_river, uh_box, to_y, to_x,
                        catchment['y_inds'], catchment['x_inds'],
                        catchment['count_ds'])
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Agregate to output timestep
    rout_data['unit_hydrograph'], \
        rout_data['timesteps'] = adjust_uh_timestep(uh_s, t_uh,
                                                    input_interval,
                                                    rout_dict['OUTPUT_INTERVAL'],
                                                    catchment['x_inds'],
                                                    catchment['y_inds'])
    # ---------------------------------------------------------------- #
    return rout_data
Exemplo n.º 4
0
def rout(pour_point, uh_box, fdr_data, fdr_atts, rout_dict):
    """
    Make the Unit Hydrograph Grid
    """
    log.info("Starting routing program for point: %s", pour_point)
    # ---------------------------------------------------------------- #
    # Unpack a few structures
    uh_t = uh_box['time']
    uh_box = uh_box['func']
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find Basin Dims and ID
    basin_id = fdr_data[rout_dict['BASIN_ID_VAR']][pour_point.routy,
                                                   pour_point.routx]

    log.info('Input Latitude: %f', pour_point.lat)
    log.info('Input Longitude: %f', pour_point.lon)
    log.info('Global Basid ID: %i', basin_id)

    y_inds, x_inds = np.nonzero(
        fdr_data[rout_dict['BASIN_ID_VAR']] == basin_id)
    y = np.arange(len(fdr_data[rout_dict['LATITUDE_VAR']]))
    x = np.arange(len(fdr_data[rout_dict['LONGITUDE_VAR']]))

    x_min = min(x[x_inds])
    x_max = max(x[x_inds]) + 1
    y_min = min(y[y_inds])
    y_max = max(y[y_inds]) + 1
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Create the Basin Dictionary, a subset of the fdr_data
    basin = {}
    basin['lat'] = fdr_data[rout_dict['LATITUDE_VAR']][y_min:y_max]
    basin['lon'] = fdr_data[rout_dict['LONGITUDE_VAR']][x_min:x_max]
    basin['basin_id'] = fdr_data[rout_dict['BASIN_ID_VAR']][y_min:y_max,
                                                            x_min:x_max]
    basin['flow_direction'] = fdr_data[rout_dict['FLOW_DIRECTION_VAR']][
        y_min:y_max, x_min:x_max]
    basin['flow_distance'] = fdr_data[rout_dict['FLOW_DISTANCE_VAR']][
        y_min:y_max, x_min:x_max]
    basin['velocity'] = fdr_data['velocity'][y_min:y_max, x_min:x_max]
    basin['diffusion'] = fdr_data['diffusion'][y_min:y_max, x_min:x_max]

    log.debug('Grid cells in subset: %i', basin['velocity'].size)

    pour_point.basiny, pour_point.basinx = latlon2yx(plats=pour_point.lat,
                                                     plons=pour_point.lon,
                                                     glats=basin['lat'],
                                                     glons=basin['lon'])
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Create the rout_data Dictionary
    rout_data = {
        'lat': basin['lat'],
        'lon': basin['lon'],
        'dom_x_min': x_min,
        'dom_y_min': y_min,
        'dom_x_max': x_max,
        'dom_y_max': y_max
    }
    log.debug('Clipping indicies:')
    log.debug('dom_x_min: %s', rout_data['dom_x_min'])
    log.debug('dom_x_max: %s', rout_data['dom_x_max'])
    log.debug('dom_y_min: %s', rout_data['dom_y_min'])
    log.debug('dom_y_max: %s', rout_data['dom_y_max'])
    # ---------------------------------------------------------------- #
    # Determine/Set flow direction syntax
    # Flow directions {north, northeast, east, southeast,
    # south, southwest, west, northwest}
    if 'VIC' in fdr_atts[rout_dict['FLOW_DIRECTION_VAR']] or \
            fdr_data[rout_dict['FLOW_DIRECTION_VAR']].max() < 10:
        # VIC Directions: http://www.hydro.washington.edu/Lettenmaier/Models/\
        # VIC/Documentation/Routing/FlowDirection.shtml
        dy = {1: -1, 2: -1, 3: 0, 4: 1, 5: 1, 6: 1, 7: 0, 8: -1}
        dx = {1: 0, 2: 1, 3: 1, 4: 1, 5: 0, 6: -1, 7: -1, 8: -1}
        log.debug('Using VIC flow directions (1-8).')
    else:
        # ARCMAP Directions: http://webhelp.esri.com/arcgisdesktop/9.2/\
        # index.cfm?TopicName=flow_direction
        dy = {64: -1, 128: -1, 1: 0, 2: 1, 4: 1, 8: 1, 16: 0, 32: -1}
        dx = {64: 0, 128: 1, 1: 1, 2: 1, 4: 0, 8: -1, 16: -1, 32: -1}
        log.debug('Using ARCMAP flow directions (1-128).')
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find timestep (timestep is determined from uh_BOX input file)
    input_interval = find_ts(uh_t)
    rout_data['unit_hydrograph_dt'] = input_interval
    t_cell = int(rout_dict['CELL_FLOWDAYS'] * SECSPERDAY / input_interval)
    t_uh = int(rout_dict['BASIN_FLOWDAYS'] * SECSPERDAY / input_interval)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Read direction grid and find to_col (to_x) and to_row (to_y)
    to_y, to_x = read_direction(basin['flow_direction'], dy, dx)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Find all grid cells upstream of pour point
    catchment, rout_data['fraction'] = search_catchment(
        to_y, to_x, pour_point, basin['basin_id'], basin_id)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Make uh for each grid cell upstream of basin pour point
    # (linear routing model - Saint-Venant equation)
    uh = make_uh(input_interval, t_cell, catchment['y_inds'],
                 catchment['x_inds'], basin['velocity'], basin['diffusion'],
                 basin['flow_distance'])
    # ---------------------------------------------------------------- #
    # Make uh_river by incrementally moving upstream comining uh functions
    uh_river = make_grid_uh_river(t_uh, t_cell, uh, to_y, to_x, pour_point,
                                  catchment['y_inds'], catchment['x_inds'],
                                  catchment['count_ds'])
    # ---------------------------------------------------------------- #
    # Make uh_s for each grid cell upstream of basin pour point
    # (combine IRFs for all grid cells in flow path)
    uh_s = make_grid_uh(t_uh, t_cell, uh_river, uh_box, to_y, to_x,
                        catchment['y_inds'], catchment['x_inds'],
                        catchment['count_ds'])
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Agregate to output timestep
    rout_data['unit_hydrograph'], \
        rout_data['timesteps'] = adjust_uh_timestep(uh_s, t_uh,
                                                    input_interval,
                                                    rout_dict['OUTPUT_INTERVAL'],
                                                    catchment['x_inds'],
                                                    catchment['y_inds'])
    # ---------------------------------------------------------------- #
    return rout_data
Exemplo n.º 5
0
def make_agg_pairs(pour_points, dom_data, fdr_data, config_dict):
    """
    Group pour points by domain grid outlet cell
    """
    lons = pour_points["lons"]
    lats = pour_points["lats"]
    dom_lon = dom_data[config_dict["DOMAIN"]["LONGITUDE_VAR"]]
    dom_lat = dom_data[config_dict["DOMAIN"]["LATITUDE_VAR"]]
    dom_ids = dom_data["cell_ids"]
    fdr_lons = fdr_data[config_dict["ROUTING"]["LONGITUDE_VAR"]]
    fdr_lats = fdr_data[config_dict["ROUTING"]["LATITUDE_VAR"]]
    fdr_srcarea = fdr_data[config_dict["ROUTING"]["SOURCE_AREA_VAR"]]

    # ---------------------------------------------------------------- #
    # Find Destination grid cells
    log.info("Finding addresses now...")
    routys, routxs = latlon2yx(plats=lats, plons=lons, glats=fdr_lats, glons=fdr_lons)

    domys, domxs = latlon2yx(plats=lats, plons=lons, glats=dom_lat, glons=dom_lon)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Do the aggregation
    outlets = {}

    for i, (lat, lon) in enumerate(zip(lats, lons)):
        # Define pour point object
        pour_point = Point(
            lat=lat,
            lon=lon,
            domx=domxs[i],
            domy=domys[i],
            routx=routxs[i],
            routy=routys[i],
            name=None,
            cell_id=dom_ids[domys[i], domxs[i]],
        )
        pour_point.source_area = fdr_srcarea[pour_point.routy, pour_point.routx]

        cell_id = dom_ids[domys[i], domxs[i]]

        if cell_id in outlets:
            outlets[cell_id].pour_points.append(pour_point)
            outlets[cell_id].upstream_area += pour_point.source_area
        else:
            # define outlet grid cell (on domain grid)
            outlets[cell_id] = Point(
                domy=domys[i], domx=domxs[i], lat=dom_lat[domys[i], domxs[i]], lon=dom_lon[domys[i], domxs[i]]
            )
            outlets[cell_id].pour_points = [pour_point]
            outlets[cell_id].cell_id = cell_id
            outlets[cell_id].upstream_area = pour_point.source_area
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Sort based on outlet total source area pour_point.source_area
    outlets = OrderedDict(sorted(outlets.items(), key=lambda t: t[1].upstream_area, reverse=True))
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Count the pairs
    pp_count = 0
    key_count = 0
    num = len(lons)
    for i, key in enumerate(outlets):
        key_count += 1
        pp_count += len(outlets[key].pour_points)
    # ---------------------------------------------------------------- #

    # ---------------------------------------------------------------- #
    # Print Debug Results
    log.info("\n------------------ SUMMARY OF MakeAggPairs ------------------")
    log.info("NUMBER OF POUR POINTS IN INPUT LIST: %i" % num)
    log.info("NUMBER OF POINTS TO AGGREGATE TO: %i" % key_count)
    log.info("NUMBER OF POUR POINTS AGGREGATED: %i" % pp_count)
    log.info("EFFECIENCY OF: %.2f %%" % (100.0 * pp_count / num))
    log.info("UNASSIGNED POUR POINTS: %i" % (num - pp_count))
    log.info("-------------------------------------------------------------\n")

    # ---------------------------------------------------------------- #
    return outlets