Esempio n. 1
0
def read_station_file(file_name, dom_data, config_dict):
    """
    Read a standard routing station file
    http://www.hydro.washington.edu/Lettenmaier/Models/VIC/Documentation/Routing/StationLocation.shtml
    """
    outlets = {}

    f = open(file_name, 'r')
    i = -1
    while True:
        i += 1
        line1 = re.sub(' +', ' ', f.readline())
        if not line1:
            break
        active, name, x, y, area = line1.split(' ')
        uhs_file = f.readline().strip()

        # move to zero based index
        y = int(y) - 1
        x = int(x) - 1

        # make sure files exist
        log.info('On station: %s, active: %s', name, active)
        uhs2_file = os.path.join(config_dict['UHS_FILES']['ROUT_DIR'],
                                 name + '.uh_s2')
        if active == '1':
            if os.path.isfile(uhs_file):
                active = True
            elif os.path.isfile(uhs2_file):
                active = True
            else:
                raise ValueError('missing uhs_file: (%s or %s)', uhs_file,
                                 uhs2_file)
        else:
            active = False

        if active:
            outlets[i] = Point(domx=x, domy=y)
            outlets[i].name = name
            outlets[i].area = float(area)
            outlets[i].uhs_file = uhs_file
            outlets[i].cell_id = i
            outlets[i].outlet_decomp_ind = dom_data['cell_ids'][y, x]
            outlets[i].lon = dom_data[config_dict['DOMAIN']['LONGITUDE_VAR']][
                y, x]
            outlets[i].lat = dom_data[config_dict['DOMAIN']['LATITUDE_VAR']][y,
                                                                             x]
        else:
            log.info('%s not active... skipping', name)
    f.close()
    return outlets
Esempio n. 2
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