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
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
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
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
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
