def lcp_rast(knights):
if(knights):
r.cost(crmap, output=cumul16, outdir=dir16, start_points=startmap, stop_points=targetmap, overwrite = True,flags = 'k')
v.what_rast(targetmap,raster=cumul16, column=trg_c16)
r.drain( cumul16,direction=dir16, output=pr16, drain=pv16, start_points=targetmap, flags = 'dc', overwrite = True)
v.overlay(ainput=pv16, binput=csmap, operator='and', output=pvc16,overwrite=True)
v.overlay(ainput=pv16, binput=csmap, operator='not', output=nogo16,overwrite=True)
else:
r.cost(crmap, output=cumul8, outdir=dir8, start_points=startmap, stop_points=targetmap, overwrite = True)
v.what_rast(targetmap,raster=cumul8, column=trg_c8)
r.drain( cumul8,direction=dir8, output=pr8, drain=pv8, start_points=targetmap, flags = 'dc', overwrite = True)
v.overlay(ainput=pv8, binput=csmap, operator='and', output=pvc8,overwrite=True)
v.overlay(ainput=pv8, binput=csmap, operator='and', output=nogo8,overwrite=True)
def main():
# Get options
vmap = options["map"] # Vector points
layer = options["layer"]
vtype = options["type"]
rasters = options["raster"].split(',') # List of rasters to sample
columns = options["columns"].split(',') # List of column names
where = options["where"]
# If length(columns) != length(rasters), throw error
if columns != ['']:
if len(columns) != len(rasters):
grass.fatal(_(
"The number of rasters and the number of column names do not match"
))
# Get flags
if flags["i"]:
fl = "i"
else:
fl = ""
# For each raster
for i in range(len(rasters)):
r = rasters[i]
if columns != ['']:
c = columns[i]
else:
c = r
# Sample using v.what.rast
v.what_rast(
map=vmap,
layer=layer,
type=vtype,
raster=r,
column=c,
where=where,
flags=fl
)
return 0
def main():
"""
Builds a grid for the MODFLOW component of the USGS hydrologic model,
GSFLOW.
"""
options, flags = gscript.parser()
basin = options['basin']
pp = options['pour_point']
raster_input = options['raster_input']
dx = options['dx']
dy = options['dy']
grid = options['output']
mask = options['mask_output']
bc_cell = options['bc_cell']
# basin='basins_tmp_onebasin'; pp='pp_tmp'; raster_input='DEM'; raster_output='DEM_coarse'; dx=dy='500'; grid='grid_tmp'; mask='mask_tmp'
"""
# Fatal if raster input and output are not both set
_lena0 = (len(raster_input) == 0)
_lenb0 = (len(raster_output) == 0)
if _lena0 + _lenb0 == 1:
gscript.fatal("You must set both raster input and output, or neither.")
"""
# Fatal if bc_cell set but mask and grid are false
if bc_cell != '':
if (mask == '') or (pp == ''):
gscript.fatal(
'Mask and pour point must be set to define b.c. cell')
# Create grid -- overlaps DEM, three cells of padding
gscript.use_temp_region()
reg = gscript.region()
reg_grid_edges_sn = np.linspace(reg['s'], reg['n'], reg['rows'])
reg_grid_edges_we = np.linspace(reg['w'], reg['e'], reg['cols'])
g.region(vector=basin, ewres=dx, nsres=dy)
regnew = gscript.region()
# Use a grid ratio -- don't match exactly the desired MODFLOW resolution
grid_ratio_ns = np.round(regnew['nsres'] / reg['nsres'])
grid_ratio_ew = np.round(regnew['ewres'] / reg['ewres'])
# Get S, W, and then move the unit number of grid cells over to get N and E
# and include 3 cells of padding around the whole watershed
_s_dist = np.abs(reg_grid_edges_sn - (regnew['s'] - 3. * regnew['nsres']))
_s_idx = np.where(_s_dist == np.min(_s_dist))[0][0]
_s = float(reg_grid_edges_sn[_s_idx])
_n_grid = np.arange(_s, reg['n'] + 3 * grid_ratio_ns * reg['nsres'],
grid_ratio_ns * reg['nsres'])
_n_dist = np.abs(_n_grid - (regnew['n'] + 3. * regnew['nsres']))
_n_idx = np.where(_n_dist == np.min(_n_dist))[0][0]
_n = float(_n_grid[_n_idx])
_w_dist = np.abs(reg_grid_edges_we - (regnew['w'] - 3. * regnew['ewres']))
_w_idx = np.where(_w_dist == np.min(_w_dist))[0][0]
_w = float(reg_grid_edges_we[_w_idx])
_e_grid = np.arange(_w, reg['e'] + 3 * grid_ratio_ew * reg['ewres'],
grid_ratio_ew * reg['ewres'])
_e_dist = np.abs(_e_grid - (regnew['e'] + 3. * regnew['ewres']))
_e_idx = np.where(_e_dist == np.min(_e_dist))[0][0]
_e = float(_e_grid[_e_idx])
# Finally make the region
g.region(w=str(_w),
e=str(_e),
s=str(_s),
n=str(_n),
nsres=str(grid_ratio_ns * reg['nsres']),
ewres=str(grid_ratio_ew * reg['ewres']))
# And then make the grid
v.mkgrid(map=grid, overwrite=gscript.overwrite())
# Cell numbers (row, column, continuous ID)
v.db_addcolumn(map=grid, columns='id int', quiet=True)
colNames = np.array(gscript.vector_db_select(grid, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(grid, layer=1)['values'].values())
cats = colValues[:, colNames == 'cat'].astype(int).squeeze()
rows = colValues[:, colNames == 'row'].astype(int).squeeze()
cols = colValues[:, colNames == 'col'].astype(int).squeeze()
nrows = np.max(rows)
ncols = np.max(cols)
cats = np.ravel([cats])
_id = np.ravel([ncols * (rows - 1) + cols])
_id_cat = []
for i in range(len(_id)):
_id_cat.append((_id[i], cats[i]))
gridTopo = VectorTopo(grid)
gridTopo.open('rw')
cur = gridTopo.table.conn.cursor()
cur.executemany("update " + grid + " set id=? where cat=?", _id_cat)
gridTopo.table.conn.commit()
gridTopo.close()
# Cell area
v.db_addcolumn(map=grid, columns='area_m2', quiet=True)
v.to_db(map=grid,
option='area',
units='meters',
columns='area_m2',
quiet=True)
# Basin mask
if len(mask) > 0:
# Fine resolution region:
g.region(n=reg['n'],
s=reg['s'],
w=reg['w'],
e=reg['e'],
nsres=reg['nsres'],
ewres=reg['ewres'])
# Rasterize basin
v.to_rast(input=basin,
output=mask,
use='val',
value=1,
overwrite=gscript.overwrite(),
quiet=True)
# Coarse resolution region:
g.region(w=str(_w),
e=str(_e),
s=str(_s),
n=str(_n),
nsres=str(grid_ratio_ns * reg['nsres']),
ewres=str(grid_ratio_ew * reg['ewres']))
r.resamp_stats(input=mask,
output=mask,
method='sum',
overwrite=True,
quiet=True)
r.mapcalc('tmp' + ' = ' + mask + ' > 0', overwrite=True, quiet=True)
g.rename(raster=('tmp', mask), overwrite=True, quiet=True)
r.null(map=mask, null=0, quiet=True)
# Add mask location (1 vs 0) in the MODFLOW grid
v.db_addcolumn(map=grid,
columns='basinmask double precision',
quiet=True)
v.what_rast(map=grid, type='centroid', raster=mask, column='basinmask')
"""
# Resampled raster
if len(raster_output) > 0:
r.resamp_stats(input=raster_input, output=raster_output, method='average', overwrite=gscript.overwrite(), quiet=True)
"""
# Pour point
if len(pp) > 0:
v.db_addcolumn(map=pp,
columns=('row integer', 'col integer'),
quiet=True)
v.build(map=pp, quiet=True)
v.what_vect(map=pp,
query_map=grid,
column='row',
query_column='row',
quiet=True)
v.what_vect(map=pp,
query_map=grid,
column='col',
query_column='col',
quiet=True)
# Next point downstream of the pour point
# Requires pp (always) and mask (sometimes)
# Dependency set above w/ gscript.fatal
if len(bc_cell) > 0:
########## NEED TO USE TRUE TEMPORARY FILE ##########
# May not work with dx != dy!
v.to_rast(input=pp, output='tmp', use='val', value=1, overwrite=True)
r.buffer(input='tmp',
output='tmp',
distances=float(dx) * 1.5,
overwrite=True)
r.mapcalc('tmp2 = if(tmp==2,1,null()) * ' + raster_input,
overwrite=True)
g.rename(raster=('tmp2', 'tmp'), overwrite=True, quiet=True)
#r.mapcalc('tmp = if(isnull('+raster_input+',0,(tmp == 2)))', overwrite=True)
#g.region(rast='tmp')
#r.null(map=raster_input,
r.drain(input=raster_input,
start_points=pp,
output='tmp2',
overwrite=True)
r.mapcalc('tmp3 = tmp2 * tmp', overwrite=True, quiet=True)
g.rename(raster=('tmp3', 'tmp'), overwrite=True, quiet=True)
#r.null(map='tmp', setnull=0) # Not necessary: center point removed above
r.to_vect(input='tmp',
output=bc_cell,
type='point',
column='z',
overwrite=gscript.overwrite(),
quiet=True)
v.db_addcolumn(map=bc_cell,
columns=('row integer', 'col integer',
'x double precision', 'y double precision'),
quiet=True)
v.build(map=bc_cell, quiet=True)
v.what_vect(map=bc_cell, query_map=grid, column='row', \
query_column='row', quiet=True)
v.what_vect(map=bc_cell, query_map=grid, column='col', \
query_column='col', quiet=True)
v.to_db(map=bc_cell, option='coor', columns=('x,y'))
# Find out if this is diagonal: finite difference works only N-S, W-E
colNames = np.array(gscript.vector_db_select(pp, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(pp, layer=1)['values'].values())
pp_row = int(colValues[:, colNames == 'row'].astype(int).squeeze())
pp_col = int(colValues[:, colNames == 'col'].astype(int).squeeze())
colNames = np.array(
gscript.vector_db_select(bc_cell, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(bc_cell, layer=1)['values'].values())
bc_row = int(colValues[:, colNames == 'row'].astype(int).squeeze())
bc_col = int(colValues[:, colNames == 'col'].astype(int).squeeze())
# Also get x and y while we are at it: may be needed later
bc_x = float(colValues[:, colNames == 'x'].astype(float).squeeze())
bc_y = float(colValues[:, colNames == 'y'].astype(float).squeeze())
if (bc_row != pp_row) and (bc_col != pp_col):
# If not diagonal, two possible locations that are adjacent
# to the pour point
_col1, _row1 = str(bc_col), str(pp_row)
_col2, _row2 = str(pp_col), str(bc_row)
# Check if either of these is covered by the basin mask
_ismask_1 = gscript.vector_db_select(grid,
layer=1,
where='(row == ' + _row1 +
') AND (col ==' + _col1 + ')',
columns='basinmask')
_ismask_1 = int(_ismask_1['values'].values()[0][0])
_ismask_2 = gscript.vector_db_select(grid,
layer=1,
where='(row == ' + _row2 +
') AND (col ==' + _col2 + ')',
columns='basinmask')
_ismask_2 = int(_ismask_2['values'].values()[0][0])
# If both covered by mask, error
if _ismask_1 and _ismask_2:
gscript.fatal(
'All possible b.c. cells covered by basin mask.\n\
Contact the developer: awickert (at) umn(.)edu')
# Otherwise, those that keep those that are not covered by basin
# mask and set ...
# ... wait, do we want the point that touches as few interior
# cells as possible?
# maybe just try setting both and seeing what happens for now!
else:
# Get dx and dy
dx = gscript.region()['ewres']
dy = gscript.region()['nsres']
# Build tool to handle multiple b.c. cells?
bcvect = vector.Vector(bc_cell)
bcvect.open('rw')
_cat_i = 2
if not _ismask_1:
# _x should always be bc_x, but writing generalized code
_x = bc_x + dx * (int(_col1) - bc_col) # col 1 at w edge
_y = bc_y - dy * (int(_row1) - bc_row) # row 1 at n edge
point0 = Point(_x, _y)
bcvect.write(
point0,
cat=_cat_i,
attrs=(None, _row1, _col1, _x, _y),
)
bcvect.table.conn.commit()
_cat_i += 1
if not _ismask_2:
# _y should always be bc_y, but writing generalized code
_x = bc_x + dx * (int(_col2) - bc_col) # col 1 at w edge
_y = bc_y - dy * (int(_row2) - bc_row) # row 1 at n edge
point0 = Point(_x, _y)
bcvect.write(
point0,
cat=_cat_i,
attrs=(None, _row2, _col2, _x, _y),
)
bcvect.table.conn.commit()
# Build database table and vector geometry
bcvect.build()
bcvect.close()
g.region(n=reg['n'],
s=reg['s'],
w=reg['w'],
e=reg['e'],
nsres=reg['nsres'],
ewres=reg['ewres'])
def main():
"""
Builds river reaches for input to the USGS hydrologic model, GSFLOW.
These reaches link the PRMS stream segments to the MODFLOW grid cells.
"""
##################
# OPTION PARSING #
##################
options, flags = gscript.parser()
segments = options["segment_input"]
grid = options["grid_input"]
reaches = options["output"]
elevation = options["elevation"]
Smin = options["s_min"]
h_stream = options["h_stream"]
x1 = options["upstream_easting_column_seg"]
y1 = options["upstream_northing_column_seg"]
x2 = options["downstream_easting_column_seg"]
y2 = options["downstream_northing_column_seg"]
tostream = options["tostream_cat_column_seg"]
# Hydraulic paramters
STRTHICK = options["strthick"]
STRHC1 = options["strhc1"]
THTS = options["thts"]
THTI = options["thti"]
EPS = options["eps"]
UHC = options["uhc"]
# Build reach maps by overlaying segments on grid
if len(gscript.find_file(segments, element="vector")["name"]) > 0:
v.extract(
input=segments,
output="GSFLOW_TEMP__",
type="line",
quiet=True,
overwrite=True,
)
v.overlay(
ainput="GSFLOW_TEMP__",
atype="line",
binput=grid,
output=reaches,
operator="and",
overwrite=gscript.overwrite(),
quiet=True,
)
g.remove(type="vector", name="GSFLOW_TEMP__", quiet=True, flags="f")
else:
gscript.fatal('No vector file "' + segments + '" found.')
# Start editing database table
reachesTopo = VectorTopo(reaches)
reachesTopo.open("rw")
# Rename a,b columns
reachesTopo.table.columns.rename("a_" + x1, "x1")
reachesTopo.table.columns.rename("a_" + x2, "x2")
reachesTopo.table.columns.rename("a_" + y1, "y1")
reachesTopo.table.columns.rename("a_" + y2, "y2")
reachesTopo.table.columns.rename("a_NSEG", "NSEG")
reachesTopo.table.columns.rename("a_ISEG", "ISEG")
reachesTopo.table.columns.rename("a_stream_type", "stream_type")
reachesTopo.table.columns.rename("a_type_code", "type_code")
reachesTopo.table.columns.rename("a_cat", "rnum_cat")
reachesTopo.table.columns.rename("a_" + tostream, "tostream")
reachesTopo.table.columns.rename("a_id", "segment_id")
reachesTopo.table.columns.rename("a_OUTSEG", "OUTSEG")
reachesTopo.table.columns.rename("b_row", "row")
reachesTopo.table.columns.rename("b_col", "col")
reachesTopo.table.columns.rename("b_id", "cell_id")
# Drop unnecessary columns
cols = reachesTopo.table.columns.names()
for col in cols:
if (col[:2] == "a_") or (col[:2] == "b_"):
reachesTopo.table.columns.drop(col)
# Add new columns to 'reaches'
reachesTopo.table.columns.add("KRCH", "integer")
reachesTopo.table.columns.add("IRCH", "integer")
reachesTopo.table.columns.add("JRCH", "integer")
reachesTopo.table.columns.add("IREACH", "integer")
reachesTopo.table.columns.add("RCHLEN", "double precision")
reachesTopo.table.columns.add("STRTOP", "double precision")
reachesTopo.table.columns.add("SLOPE", "double precision")
reachesTopo.table.columns.add("STRTHICK", "double precision")
reachesTopo.table.columns.add("STRHC1", "double precision")
reachesTopo.table.columns.add("THTS", "double precision")
reachesTopo.table.columns.add("THTI", "double precision")
reachesTopo.table.columns.add("EPS", "double precision")
reachesTopo.table.columns.add("UHC", "double precision")
reachesTopo.table.columns.add("xr1", "double precision")
reachesTopo.table.columns.add("xr2", "double precision")
reachesTopo.table.columns.add("yr1", "double precision")
reachesTopo.table.columns.add("yr2", "double precision")
# Commit columns before editing (necessary?)
reachesTopo.table.conn.commit()
reachesTopo.close()
# Update some columns that can be done now
reachesTopo.open("rw")
colNames = np.array(gscript.vector_db_select(reaches, layer=1)["columns"])
colValues = np.array(gscript.vector_db_select(reaches, layer=1)["values"].values())
cats = colValues[:, colNames == "cat"].astype(int).squeeze()
nseg = np.arange(1, len(cats) + 1)
nseg_cats = []
for i in range(len(cats)):
nseg_cats.append((nseg[i], cats[i]))
cur = reachesTopo.table.conn.cursor()
# Hydrogeologic properties
cur.execute("update " + reaches + " set STRTHICK=" + str(STRTHICK))
cur.execute("update " + reaches + " set STRHC1=" + str(STRHC1))
cur.execute("update " + reaches + " set THTS=" + str(THTS))
cur.execute("update " + reaches + " set THTI=" + str(THTI))
cur.execute("update " + reaches + " set EPS=" + str(EPS))
cur.execute("update " + reaches + " set UHC=" + str(UHC))
# Grid properties
cur.execute("update " + reaches + " set KRCH=1") # Top layer: unchangable
cur.executemany("update " + reaches + " set IRCH=? where row=?", nseg_cats)
cur.executemany("update " + reaches + " set JRCH=? where col=?", nseg_cats)
reachesTopo.table.conn.commit()
reachesTopo.close()
v.to_db(map=reaches, columns="RCHLEN", option="length", quiet=True)
# Still to go after these:
# STRTOP (added with slope)
# IREACH (whole next section dedicated to this)
# SLOPE (need z_start and z_end)
# Now, the light stuff is over: time to build the reach order
v.to_db(map=reaches, option="start", columns="xr1,yr1")
v.to_db(map=reaches, option="end", columns="xr2,yr2")
# Now just sort by category, find which stream has the same xr1 and yr1 as
# x1 and y1 (or a_x1, a_y1) and then find where its endpoint matches another
# starting point and move down the line.
# v.db.select reaches col=cat,a_id,xr1,xr2 where="a_x1 = xr1"
# First, get the starting coordinates of each stream segment
# and a set of river ID's (ordered from 1...N)
colNames = np.array(gscript.vector_db_select(segments, layer=1)["columns"])
colValues = np.array(gscript.vector_db_select(segments, layer=1)["values"].values())
number_of_segments = colValues.shape[0]
segment_x1s = colValues[:, colNames == "x1"].astype(float).squeeze()
segment_y1s = colValues[:, colNames == "y1"].astype(float).squeeze()
segment_ids = colValues[:, colNames == "id"].astype(float).squeeze()
# Then move back to the reaches map to produce the ordering
colNames = np.array(gscript.vector_db_select(reaches, layer=1)["columns"])
colValues = np.array(gscript.vector_db_select(reaches, layer=1)["values"].values())
reach_cats = colValues[:, colNames == "cat"].astype(int).squeeze()
reach_x1s = colValues[:, colNames == "xr1"].astype(float).squeeze()
reach_y1s = colValues[:, colNames == "yr1"].astype(float).squeeze()
reach_x2s = colValues[:, colNames == "xr2"].astype(float).squeeze()
reach_y2s = colValues[:, colNames == "yr2"].astype(float).squeeze()
segment_ids__reach = colValues[:, colNames == "segment_id"].astype(float).squeeze()
for segment_id in segment_ids:
reach_order_cats = []
downstream_directed = []
ssel = segment_ids == segment_id
rsel = segment_ids__reach == segment_id # selector
# Find first segment: x1y1 first here, but not necessarily later
downstream_directed.append(1)
_x_match = reach_x1s[rsel] == segment_x1s[ssel]
_y_match = reach_y1s[rsel] == segment_y1s[ssel]
_i_match = _x_match * _y_match
x1y1 = True # false if x2y2
# Find cat
_cat = int(reach_cats[rsel][_x_match * _y_match])
reach_order_cats.append(_cat)
# Get end of reach = start of next one
reach_x_end = float(reach_x2s[reach_cats == _cat])
reach_y_end = float(reach_y2s[reach_cats == _cat])
while _i_match.any():
_x_match = reach_x1s[rsel] == reach_x_end
_y_match = reach_y1s[rsel] == reach_y_end
_i_match = _x_match * _y_match
if _i_match.any():
_cat = int(reach_cats[rsel][_x_match * _y_match])
reach_x_end = float(reach_x2s[reach_cats == _cat])
reach_y_end = float(reach_y2s[reach_cats == _cat])
reach_order_cats.append(_cat)
_message = str(len(reach_order_cats)) + " " + str(len(reach_cats[rsel]))
gscript.message(_message)
# Reach order to database table
reach_number__reach_order_cats = []
for i in range(len(reach_order_cats)):
reach_number__reach_order_cats.append((i + 1, reach_order_cats[i]))
reachesTopo = VectorTopo(reaches)
reachesTopo.open("rw")
cur = reachesTopo.table.conn.cursor()
cur.executemany(
"update " + reaches + " set IREACH=? where cat=?",
reach_number__reach_order_cats,
)
reachesTopo.table.conn.commit()
reachesTopo.close()
# TOP AND BOTTOM ARE OUT OF ORDER: SOME SEGS ARE BACKWARDS. UGH!!!!
# NEED TO GET THEM IN ORDER TO GET THE Z VALUES AT START AND END
# 2018.10.01: Updating this to use the computational region for the DEM
g.region(raster=elevation)
# Compute slope and starting elevations from the elevations at the start and
# end of the reaches and the length of each reach]
gscript.message("Obtaining elevation values from raster: may take time.")
v.db_addcolumn(map=reaches, columns="zr1 double precision, zr2 double precision")
zr1 = []
zr2 = []
for i in range(len(reach_cats)):
_x = reach_x1s[i]
_y = reach_y1s[i]
# print _x, _y
_z = float(
gscript.parse_command(
"r.what", map=elevation, coordinates=str(_x) + "," + str(_y)
)
.keys()[0]
.split("|")[-1]
)
zr1.append(_z)
_x = reach_x2s[i]
_y = reach_y2s[i]
_z = float(
gscript.parse_command(
"r.what", map=elevation, coordinates=str(_x) + "," + str(_y)
)
.keys()[0]
.split("|")[-1]
)
zr2.append(_z)
zr1_cats = []
zr2_cats = []
for i in range(len(reach_cats)):
zr1_cats.append((zr1[i], reach_cats[i]))
zr2_cats.append((zr2[i], reach_cats[i]))
reachesTopo = VectorTopo(reaches)
reachesTopo.open("rw")
cur = reachesTopo.table.conn.cursor()
cur.executemany("update " + reaches + " set zr1=? where cat=?", zr1_cats)
cur.executemany("update " + reaches + " set zr2=? where cat=?", zr2_cats)
reachesTopo.table.conn.commit()
reachesTopo.close()
# Use these to create slope -- backwards possible on DEM!
v.db_update(map=reaches, column="SLOPE", value="(zr1 - zr2)/RCHLEN")
v.db_update(map=reaches, column="SLOPE", value=Smin, where="SLOPE <= " + str(Smin))
# srtm_local_filled_grid = srtm_local_filled @ 200m (i.e. current grid)
# resolution
# r.to.vect in=srtm_local_filled_grid out=srtm_local_filled_grid col=z type=area --o#
# NOT SURE IF IT IS BEST TO USE MEAN ELEVATION OR TOP ELEVATION!!!!!!!!!!!!!!!!!!!!!!!
v.db_addcolumn(map=reaches, columns="z_topo_mean double precision")
v.what_rast(
map=reaches, raster=elevation, column="z_topo_mean"
) # , query_column='z')
v.db_update(
map=reaches, column="STRTOP", value="z_topo_mean -" + str(h_stream), quiet=True
)
def main():
"""
Builds river reaches for input to the USGS hydrologic model, GSFLOW.
These reaches link the PRMS stream segments to the MODFLOW grid cells.
"""
##################
# OPTION PARSING #
##################
options, flags = gscript.parser()
segments = options['segment_input']
grid = options['grid_input']
reaches = options['output']
elevation = options['elevation']
Smin = options['s_min']
h_stream = options['h_stream']
x1 = options['upstream_easting_column_seg']
y1 = options['upstream_northing_column_seg']
x2 = options['downstream_easting_column_seg']
y2 = options['downstream_northing_column_seg']
tostream = options['tostream_cat_column_seg']
# Hydraulic paramters
STRTHICK = options['strthick']
STRHC1 = options['strhc1']
THTS = options['thts']
THTI = options['thti']
EPS = options['eps']
UHC = options['uhc']
# Build reach maps by overlaying segments on grid
if len(gscript.find_file(segments, element='vector')['name']) > 0:
v.extract(input=segments,
output='GSFLOW_TEMP__',
type='line',
quiet=True,
overwrite=True)
v.overlay(ainput='GSFLOW_TEMP__',
atype='line',
binput=grid,
output=reaches,
operator='and',
overwrite=gscript.overwrite(),
quiet=True)
g.remove(type='vector', name='GSFLOW_TEMP__', quiet=True, flags='f')
else:
gscript.fatal('No vector file "' + segments + '" found.')
# Start editing database table
reachesTopo = VectorTopo(reaches)
reachesTopo.open('rw')
# Rename a,b columns
reachesTopo.table.columns.rename('a_' + x1, 'x1')
reachesTopo.table.columns.rename('a_' + x2, 'x2')
reachesTopo.table.columns.rename('a_' + y1, 'y1')
reachesTopo.table.columns.rename('a_' + y2, 'y2')
reachesTopo.table.columns.rename('a_NSEG', 'NSEG')
reachesTopo.table.columns.rename('a_ISEG', 'ISEG')
reachesTopo.table.columns.rename('a_stream_type', 'stream_type')
reachesTopo.table.columns.rename('a_type_code', 'type_code')
reachesTopo.table.columns.rename('a_cat', 'rnum_cat')
reachesTopo.table.columns.rename('a_' + tostream, 'tostream')
reachesTopo.table.columns.rename('a_id', 'segment_id')
reachesTopo.table.columns.rename('a_OUTSEG', 'OUTSEG')
reachesTopo.table.columns.rename('b_row', 'row')
reachesTopo.table.columns.rename('b_col', 'col')
reachesTopo.table.columns.rename('b_id', 'cell_id')
# Drop unnecessary columns
cols = reachesTopo.table.columns.names()
for col in cols:
if (col[:2] == 'a_') or (col[:2] == 'b_'):
reachesTopo.table.columns.drop(col)
# Add new columns to 'reaches'
reachesTopo.table.columns.add('KRCH', 'integer')
reachesTopo.table.columns.add('IRCH', 'integer')
reachesTopo.table.columns.add('JRCH', 'integer')
reachesTopo.table.columns.add('IREACH', 'integer')
reachesTopo.table.columns.add('RCHLEN', 'double precision')
reachesTopo.table.columns.add('STRTOP', 'double precision')
reachesTopo.table.columns.add('SLOPE', 'double precision')
reachesTopo.table.columns.add('STRTHICK', 'double precision')
reachesTopo.table.columns.add('STRHC1', 'double precision')
reachesTopo.table.columns.add('THTS', 'double precision')
reachesTopo.table.columns.add('THTI', 'double precision')
reachesTopo.table.columns.add('EPS', 'double precision')
reachesTopo.table.columns.add('UHC', 'double precision')
reachesTopo.table.columns.add('xr1', 'double precision')
reachesTopo.table.columns.add('xr2', 'double precision')
reachesTopo.table.columns.add('yr1', 'double precision')
reachesTopo.table.columns.add('yr2', 'double precision')
# Commit columns before editing (necessary?)
reachesTopo.table.conn.commit()
reachesTopo.close()
# Update some columns that can be done now
reachesTopo.open('rw')
colNames = np.array(gscript.vector_db_select(reaches, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(reaches, layer=1)['values'].values())
cats = colValues[:, colNames == 'cat'].astype(int).squeeze()
nseg = np.arange(1, len(cats) + 1)
nseg_cats = []
for i in range(len(cats)):
nseg_cats.append((nseg[i], cats[i]))
cur = reachesTopo.table.conn.cursor()
# Hydrogeologic properties
cur.execute("update " + reaches + " set STRTHICK=" + str(STRTHICK))
cur.execute("update " + reaches + " set STRHC1=" + str(STRHC1))
cur.execute("update " + reaches + " set THTS=" + str(THTS))
cur.execute("update " + reaches + " set THTI=" + str(THTI))
cur.execute("update " + reaches + " set EPS=" + str(EPS))
cur.execute("update " + reaches + " set UHC=" + str(UHC))
# Grid properties
cur.execute("update " + reaches + " set KRCH=1") # Top layer: unchangable
cur.executemany("update " + reaches + " set IRCH=? where row=?", nseg_cats)
cur.executemany("update " + reaches + " set JRCH=? where col=?", nseg_cats)
reachesTopo.table.conn.commit()
reachesTopo.close()
v.to_db(map=reaches, columns='RCHLEN', option='length', quiet=True)
# Still to go after these:
# STRTOP (added with slope)
# IREACH (whole next section dedicated to this)
# SLOPE (need z_start and z_end)
# Now, the light stuff is over: time to build the reach order
v.to_db(map=reaches, option='start', columns='xr1,yr1')
v.to_db(map=reaches, option='end', columns='xr2,yr2')
# Now just sort by category, find which stream has the same xr1 and yr1 as
# x1 and y1 (or a_x1, a_y1) and then find where its endpoint matches another
# starting point and move down the line.
# v.db.select reaches col=cat,a_id,xr1,xr2 where="a_x1 = xr1"
# First, get the starting coordinates of each stream segment
# and a set of river ID's (ordered from 1...N)
colNames = np.array(gscript.vector_db_select(segments, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(segments, layer=1)['values'].values())
number_of_segments = colValues.shape[0]
segment_x1s = colValues[:, colNames == 'x1'].astype(float).squeeze()
segment_y1s = colValues[:, colNames == 'y1'].astype(float).squeeze()
segment_ids = colValues[:, colNames == 'id'].astype(float).squeeze()
# Then move back to the reaches map to produce the ordering
colNames = np.array(gscript.vector_db_select(reaches, layer=1)['columns'])
colValues = np.array(
gscript.vector_db_select(reaches, layer=1)['values'].values())
reach_cats = colValues[:, colNames == 'cat'].astype(int).squeeze()
reach_x1s = colValues[:, colNames == 'xr1'].astype(float).squeeze()
reach_y1s = colValues[:, colNames == 'yr1'].astype(float).squeeze()
reach_x2s = colValues[:, colNames == 'xr2'].astype(float).squeeze()
reach_y2s = colValues[:, colNames == 'yr2'].astype(float).squeeze()
segment_ids__reach = colValues[:, colNames == 'segment_id'].astype(
float).squeeze()
for segment_id in segment_ids:
reach_order_cats = []
downstream_directed = []
ssel = segment_ids == segment_id
rsel = segment_ids__reach == segment_id # selector
# Find first segment: x1y1 first here, but not necessarily later
downstream_directed.append(1)
_x_match = reach_x1s[rsel] == segment_x1s[ssel]
_y_match = reach_y1s[rsel] == segment_y1s[ssel]
_i_match = _x_match * _y_match
x1y1 = True # false if x2y2
# Find cat
_cat = int(reach_cats[rsel][_x_match * _y_match])
reach_order_cats.append(_cat)
# Get end of reach = start of next one
reach_x_end = float(reach_x2s[reach_cats == _cat])
reach_y_end = float(reach_y2s[reach_cats == _cat])
while _i_match.any():
_x_match = reach_x1s[rsel] == reach_x_end
_y_match = reach_y1s[rsel] == reach_y_end
_i_match = _x_match * _y_match
if _i_match.any():
_cat = int(reach_cats[rsel][_x_match * _y_match])
reach_x_end = float(reach_x2s[reach_cats == _cat])
reach_y_end = float(reach_y2s[reach_cats == _cat])
reach_order_cats.append(_cat)
print len(reach_order_cats), len(reach_cats[rsel])
# Reach order to database table
reach_number__reach_order_cats = []
for i in range(len(reach_order_cats)):
reach_number__reach_order_cats.append((i + 1, reach_order_cats[i]))
reachesTopo = VectorTopo(reaches)
reachesTopo.open('rw')
cur = reachesTopo.table.conn.cursor()
cur.executemany("update " + reaches + " set IREACH=? where cat=?",
reach_number__reach_order_cats)
reachesTopo.table.conn.commit()
reachesTopo.close()
# TOP AND BOTTOM ARE OUT OF ORDER: SOME SEGS ARE BACKWARDS. UGH!!!!
# NEED TO GET THEM IN ORDER TO GET THE Z VALUES AT START AND END
# 2018.10.01: Updating this to use the computational region for the DEM
g.region(raster=elevation)
# Compute slope and starting elevations from the elevations at the start and
# end of the reaches and the length of each reach]
gscript.message('Obtaining elevation values from raster: may take time.')
v.db_addcolumn(map=reaches,
columns='zr1 double precision, zr2 double precision')
zr1 = []
zr2 = []
for i in range(len(reach_cats)):
_x = reach_x1s[i]
_y = reach_y1s[i]
#print _x, _y
_z = float(
gscript.parse_command('r.what',
map=elevation,
coordinates=str(_x) + ',' +
str(_y)).keys()[0].split('|')[-1])
zr1.append(_z)
_x = reach_x2s[i]
_y = reach_y2s[i]
_z = float(
gscript.parse_command('r.what',
map=elevation,
coordinates=str(_x) + ',' +
str(_y)).keys()[0].split('|')[-1])
zr2.append(_z)
zr1_cats = []
zr2_cats = []
for i in range(len(reach_cats)):
zr1_cats.append((zr1[i], reach_cats[i]))
zr2_cats.append((zr2[i], reach_cats[i]))
reachesTopo = VectorTopo(reaches)
reachesTopo.open('rw')
cur = reachesTopo.table.conn.cursor()
cur.executemany("update " + reaches + " set zr1=? where cat=?", zr1_cats)
cur.executemany("update " + reaches + " set zr2=? where cat=?", zr2_cats)
reachesTopo.table.conn.commit()
reachesTopo.close()
# Use these to create slope -- backwards possible on DEM!
v.db_update(map=reaches, column='SLOPE', value='(zr1 - zr2)/RCHLEN')
v.db_update(map=reaches,
column='SLOPE',
value=Smin,
where='SLOPE <= ' + str(Smin))
# srtm_local_filled_grid = srtm_local_filled @ 200m (i.e. current grid)
# resolution
# r.to.vect in=srtm_local_filled_grid out=srtm_local_filled_grid col=z type=area --o#
# NOT SURE IF IT IS BEST TO USE MEAN ELEVATION OR TOP ELEVATION!!!!!!!!!!!!!!!!!!!!!!!
v.db_addcolumn(map=reaches, columns='z_topo_mean double precision')
v.what_rast(map=reaches, raster=elevation,
column='z_topo_mean') #, query_column='z')
v.db_update(map=reaches,
column='STRTOP',
value='z_topo_mean -' + str(h_stream),
quiet=True)
def main():
"""
Adds GSFLOW parameters to a set of HRU sub-basins
"""
##################
# OPTION PARSING #
##################
options, flags = gscript.parser()
basins = options['input']
HRU = options['output']
slope = options['slope']
aspect = options['aspect']
elevation = options['elevation']
land_cover = options['cov_type']
soil = options['soil_type']
################################
# CREATE HRUs FROM SUB-BASINS #
################################
g.copy(vector=(basins,HRU), overwrite=gscript.overwrite())
############################################
# ATTRIBUTE COLUMNS (IN ORDER FROM MANUAL) #
############################################
# HRU
hru_columns = []
# Self ID
hru_columns.append('id integer') # nhru
# Basic Physical Attributes (Geometry)
hru_columns.append('hru_area double precision') # acres (!!!!)
hru_columns.append('hru_area_m2 double precision') # [not for GSFLOW: for me!]
hru_columns.append('hru_aspect double precision') # Mean aspect [degrees]
hru_columns.append('hru_elev double precision') # Mean elevation
hru_columns.append('hru_lat double precision') # Latitude of centroid
hru_columns.append('hru_lon double precision') # Longitude of centroid
# unnecessary but why not?
hru_columns.append('hru_slope double precision') # Mean slope [percent]
# Basic Physical Attributes (Other)
#hru_columns.append('hru_type integer') # 0=inactive; 1=land; 2=lake; 3=swale; almost all will be 1
#hru_columns.append('elev_units integer') # 0=feet; 1=meters. 0=default. I think I will set this to 1 by default.
# Measured input
hru_columns.append('outlet_sta integer') # Index of streamflow station at basin outlet:
# station number if it has one, 0 if not
# Note that the below specify projections and note lat/lon; they really seem
# to work for any projected coordinates, with _x, _y, in meters, and _xlong,
# _ylat, in feet (i.e. they are just northing and easting). The meters and feet
# are not just simple conversions, but actually are required for different
# modules in the code, and are hence redundant but intentional.
hru_columns.append('hru_x double precision') # Easting [m]
hru_columns.append('hru_xlong double precision') # Easting [feet]
hru_columns.append('hru_y double precision') # Northing [m]
hru_columns.append('hru_ylat double precision') # Northing [feet]
# Streamflow and lake routing
hru_columns.append('K_coef double precision') # Travel time of flood wave to next downstream segment;
# this is the Muskingum storage coefficient
# 1.0 for reservoirs, diversions, and segments flowing
# out of the basin
hru_columns.append('x_coef double precision') # Amount of attenuation of flow wave;
# this is the Muskingum routing weighting factor
# range: 0.0--0.5; default 0.2
# 0 for all segments flowing out of the basin
hru_columns.append('hru_segment integer') # ID of stream segment to which flow will be routed
# this is for non-cascade routing (flow goes directly
# from HRU to stream segment)
hru_columns.append('obsin_segment integer') # Index of measured streamflow station that replaces
# inflow to a segment
hru_columns.append('cov_type integer') # 0=bare soil;1=grasses; 2=shrubs; 3=trees; 4=coniferous
hru_columns.append('soil_type integer') # 1=sand; 2=loam; 3=clay
# Create strings
hru_columns = ",".join(hru_columns)
# Add columns to tables
v.db_addcolumn(map=HRU, columns=hru_columns, quiet=True)
###########################
# UPDATE DATABASE ENTRIES #
###########################
colNames = np.array(gscript.vector_db_select(HRU, layer=1)['columns'])
colValues = np.array(gscript.vector_db_select(HRU, layer=1)['values'].values())
number_of_hrus = colValues.shape[0]
cats = colValues[:,colNames == 'cat'].astype(int).squeeze()
rnums = colValues[:,colNames == 'rnum'].astype(int).squeeze()
nhru = np.arange(1, number_of_hrus + 1)
nhrut = []
for i in range(len(nhru)):
nhrut.append( (nhru[i], cats[i]) )
# Access the HRUs
hru = VectorTopo(HRU)
# Open the map with topology:
hru.open('rw')
# Create a cursor
cur = hru.table.conn.cursor()
# Use it to loop across the table
cur.executemany("update "+HRU+" set id=? where cat=?", nhrut)
# Commit changes to the table
hru.table.conn.commit()
# Close the table
hru.close()
"""
# Do the same for basins <-------------- DO THIS OR SIMPLY HAVE HRUs OVERLAIN WITH GRID CELLS? IN THIS CASE, RMV AREA ADDITION TO GRAVRES
v.db_addcolumn(map=basins, columns='id int', quiet=True)
basins = VectorTopo(basins)
basins.open('rw')
cur = basins.table.conn.cursor()
cur.executemany("update basins set id=? where cat=?", nhrut)
basins.table.conn.commit()
basins.close()
"""
# if you want to append to table
# cur.executemany("update HRU(id) values(?)", nhrut) # "insert into" will add rows
#hru_columns.append('hru_area double precision')
# Acres b/c USGS
v.to_db(map=HRU, option='area', columns='hru_area', units='acres', quiet=True)
v.to_db(map=HRU, option='area', columns='hru_area_m2', units='meters', quiet=True)
# GET MEAN VALUES FOR THESE NEXT ONES, ACROSS THE BASIN
# SLOPE (and aspect)
#####################
v.rast_stats(map=HRU, raster=slope, method='average', column_prefix='tmp', flags='c', quiet=True)
v.db_update(map=HRU, column='hru_slope', query_column='tmp_average', quiet=True)
# ASPECT
#########
v.db_dropcolumn(map=HRU, columns='tmp_average', quiet=True)
# Dealing with conversion from degrees (no good average) to something I can
# average -- x- and y-vectors
# Geographic coordinates, so sin=x, cos=y.... not that it matters so long
# as I am consistent in how I return to degrees
r.mapcalc('aspect_x = sin(' + aspect + ')', overwrite=gscript.overwrite(), quiet=True)
r.mapcalc('aspect_y = cos(' + aspect + ')', overwrite=gscript.overwrite(), quiet=True)
#grass.run_command('v.db.addcolumn', map=HRU, columns='aspect_x_sum double precision, aspect_y_sum double precision, ncells_in_hru integer')
v.rast_stats(map=HRU, raster='aspect_x', method='sum', column_prefix='aspect_x', flags='c', quiet=True)
v.rast_stats(map=HRU, raster='aspect_y', method='sum', column_prefix='aspect_y', flags='c', quiet=True)
hru = VectorTopo(HRU)
hru.open('rw')
cur = hru.table.conn.cursor()
cur.execute("SELECT cat,aspect_x_sum,aspect_y_sum FROM %s" %hru.name)
_arr = np.array(cur.fetchall()).astype(float)
_cat = _arr[:,0]
_aspect_x_sum = _arr[:,1]
_aspect_y_sum = _arr[:,2]
aspect_angle = np.arctan2(_aspect_y_sum, _aspect_x_sum) * 180. / np.pi
aspect_angle[aspect_angle < 0] += 360 # all positive
aspect_angle_cat = np.vstack((aspect_angle, _cat)).transpose()
cur.executemany("update "+ HRU +" set hru_aspect=? where cat=?", aspect_angle_cat)
hru.table.conn.commit()
hru.close()
# ELEVATION
############
v.rast_stats(map=HRU, raster=elevation, method='average', column_prefix='tmp', flags='c', quiet=True)
v.db_update(map=HRU, column='hru_elev', query_column='tmp_average', quiet=True)
v.db_dropcolumn(map=HRU, columns='tmp_average', quiet=True)
# CENTROIDS
############
# get x,y of centroid -- but have areas not in database table, that do have
# centroids, and having a hard time finding a good way to get rid of them!
# They have duplicate category values!
# Perhaps these are little dangles on the edges of the vectorization where
# the raster value was the same but pinched out into 1-a few cells?
# From looking at map, lots of extra centroids on area boundaries, and removing
# small areas (though threshold hard to guess) gets rid of these
hru = VectorTopo(HRU)
hru.open('rw')
hru_cats = []
hru_coords = []
for hru_i in hru:
if type(hru_i) is vector.geometry.Centroid:
hru_cats.append(hru_i.cat)
hru_coords.append(hru_i.coords())
hru_cats = np.array(hru_cats)
hru_coords = np.array(hru_coords)
hru.rewind()
hru_area_ids = []
for coor in hru_coords:
_area = hru.find_by_point.area(Point(coor[0], coor[1]))
hru_area_ids.append(_area)
hru_area_ids = np.array(hru_area_ids)
hru.rewind()
hru_areas = []
for _area_id in hru_area_ids:
hru_areas.append(_area_id.area())
hru_areas = np.array(hru_areas)
hru.rewind()
allcats = sorted(list(set(list(hru_cats))))
# Now create weighted mean
hru_centroid_locations = []
for cat in allcats:
hrus_with_cat = hru_cats[hru_cats == cat]
if len(hrus_with_cat) == 1:
hru_centroid_locations.append((hru_coords[hru_cats == cat]).squeeze())
else:
_centroids = hru_coords[hru_cats == cat]
#print _centroids
_areas = hru_areas[hru_cats == cat]
#print _areas
_x = np.average(_centroids[:,0], weights=_areas)
_y = np.average(_centroids[:,1], weights=_areas)
#print _x, _y
hru_centroid_locations.append(np.array([_x, _y]))
# Now upload weighted mean to database table
# allcats and hru_centroid_locations are co-indexed
index__cats = create_iterator(HRU)
cur = hru.table.conn.cursor()
for i in range(len(allcats)):
# meters
cur.execute('update '+HRU
+' set hru_x='+str(hru_centroid_locations[i][0])
+' where cat='+str(allcats[i]))
cur.execute('update '+HRU
+' set hru_y='+str(hru_centroid_locations[i][1])
+' where cat='+str(allcats[i]))
# feet
cur.execute('update '+HRU
+' set hru_xlong='+str(hru_centroid_locations[i][0]*3.28084)
+' where cat='+str(allcats[i]))
cur.execute('update '+HRU
+' set hru_ylat='+str(hru_centroid_locations[i][1]*3.28084)
+' where cat='+str(allcats[i]))
# (un)Project to lat/lon
_centroid_ll = gscript.parse_command('m.proj',
coordinates=
list(hru_centroid_locations[i]),
flags='od').keys()[0]
_lon, _lat, _z = _centroid_ll.split('|')
cur.execute('update '+HRU
+' set hru_lon='+_lon
+' where cat='+str(allcats[i]))
cur.execute('update '+HRU
+' set hru_lat='+_lat
+' where cat='+str(allcats[i]))
# feet -- not working.
# Probably an issue with index__cats -- maybe fix later, if needed
# But currently not a major speed issue
"""
cur.executemany("update "+HRU+" set hru_xlong=?*3.28084 where hru_x=?",
index__cats)
cur.executemany("update "+HRU+" set hru_ylat=?*3.28084 where hru_y=?",
index__cats)
"""
cur.close()
hru.table.conn.commit()
hru.close()
# ID NUMBER
############
#cur.executemany("update "+HRU+" set hru_segment=? where id=?",
# index__cats)
# Segment number = HRU ID number
v.db_update(map=HRU, column='hru_segment', query_column='id', quiet=True)
# LAND USE/COVER
############
try:
land_cover = int(land_cover)
except:
pass
if type(land_cover) is int:
if land_cover <= 3:
v.db_update(map=HRU, column='cov_type', value=land_cover, quiet=True)
else:
sys.exit("WARNING: INVALID LAND COVER TYPE. CHECK INTEGER VALUES.\n"
"EXITING TO ALLOW USER TO CHANGE BEFORE RUNNING GSFLOW")
else:
# NEED TO UPDATE THIS TO MODAL VALUE!!!!
gscript.message("Warning: values taken from HRU centroids. Code should be updated to")
gscript.message("acquire modal values")
v.what_rast(map=HRU, type='centroid', raster=land_cover, column='cov_type', quiet=True)
#v.rast_stats(map=HRU, raster=land_cover, method='average', column_prefix='tmp', flags='c', quiet=True)
#v.db_update(map=HRU, column='cov_type', query_column='tmp_average', quiet=True)
#v.db_dropcolumn(map=HRU, columns='tmp_average', quiet=True)
# SOIL
############
try:
soil = int(soil)
except:
pass
if type(soil) is int:
if (soil > 0) and (soil <= 3):
v.db_update(map=HRU, column='soil_type', value=soil, quiet=True)
else:
sys.exit("WARNING: INVALID SOIL TYPE. CHECK INTEGER VALUES.\n"
"EXITING TO ALLOW USER TO CHANGE BEFORE RUNNING GSFLOW")
else:
# NEED TO UPDATE THIS TO MODAL VALUE!!!!
gscript.message("Warning: values taken from HRU centroids. Code should be updated to")
gscript.message("acquire modal values")
v.what_rast(map=HRU, type='centroid', raster=soil, column='soil_type', quiet=True)
def main():
"""
Builds a grid for the MODFLOW component of the USGS hydrologic model,
GSFLOW.
"""
options, flags = gscript.parser()
basin = options["basin"]
pp = options["pour_point"]
raster_input = options["raster_input"]
dx = options["dx"]
dy = options["dy"]
grid = options["output"]
mask = options["mask_output"]
bc_cell = options["bc_cell"]
# basin='basins_tmp_onebasin'; pp='pp_tmp'; raster_input='DEM'; raster_output='DEM_coarse'; dx=dy='500'; grid='grid_tmp'; mask='mask_tmp'
"""
# Fatal if raster input and output are not both set
_lena0 = (len(raster_input) == 0)
_lenb0 = (len(raster_output) == 0)
if _lena0 + _lenb0 == 1:
gscript.fatal("You must set both raster input and output, or neither.")
"""
# Fatal if bc_cell set but mask and grid are false
if bc_cell != "":
if (mask == "") or (pp == ""):
gscript.fatal(
"Mask and pour point must be set to define b.c. cell")
# Create grid -- overlaps DEM, three cells of padding
g.region(raster=raster_input, ewres=dx, nsres=dy)
gscript.use_temp_region()
reg = gscript.region()
reg_grid_edges_sn = np.linspace(reg["s"], reg["n"], reg["rows"])
reg_grid_edges_we = np.linspace(reg["w"], reg["e"], reg["cols"])
g.region(vector=basin, ewres=dx, nsres=dy)
regnew = gscript.region()
# Use a grid ratio -- don't match exactly the desired MODFLOW resolution
grid_ratio_ns = np.round(regnew["nsres"] / reg["nsres"])
grid_ratio_ew = np.round(regnew["ewres"] / reg["ewres"])
# Get S, W, and then move the unit number of grid cells over to get N and E
# and include 3 cells of padding around the whole watershed
_s_dist = np.abs(reg_grid_edges_sn - (regnew["s"] - 3.0 * regnew["nsres"]))
_s_idx = np.where(_s_dist == np.min(_s_dist))[0][0]
_s = float(reg_grid_edges_sn[_s_idx])
_n_grid = np.arange(_s, reg["n"] + 3 * grid_ratio_ns * reg["nsres"],
grid_ratio_ns * reg["nsres"])
_n_dist = np.abs(_n_grid - (regnew["n"] + 3.0 * regnew["nsres"]))
_n_idx = np.where(_n_dist == np.min(_n_dist))[0][0]
_n = float(_n_grid[_n_idx])
_w_dist = np.abs(reg_grid_edges_we - (regnew["w"] - 3.0 * regnew["ewres"]))
_w_idx = np.where(_w_dist == np.min(_w_dist))[0][0]
_w = float(reg_grid_edges_we[_w_idx])
_e_grid = np.arange(_w, reg["e"] + 3 * grid_ratio_ew * reg["ewres"],
grid_ratio_ew * reg["ewres"])
_e_dist = np.abs(_e_grid - (regnew["e"] + 3.0 * regnew["ewres"]))
_e_idx = np.where(_e_dist == np.min(_e_dist))[0][0]
_e = float(_e_grid[_e_idx])
# Finally make the region
g.region(
w=str(_w),
e=str(_e),
s=str(_s),
n=str(_n),
nsres=str(grid_ratio_ns * reg["nsres"]),
ewres=str(grid_ratio_ew * reg["ewres"]),
)
# And then make the grid
v.mkgrid(map=grid, overwrite=gscript.overwrite())
# Cell numbers (row, column, continuous ID)
v.db_addcolumn(map=grid, columns="id int", quiet=True)
colNames = np.array(gscript.vector_db_select(grid, layer=1)["columns"])
colValues = np.array(
gscript.vector_db_select(grid, layer=1)["values"].values())
cats = colValues[:, colNames == "cat"].astype(int).squeeze()
rows = colValues[:, colNames == "row"].astype(int).squeeze()
cols = colValues[:, colNames == "col"].astype(int).squeeze()
nrows = np.max(rows)
ncols = np.max(cols)
cats = np.ravel([cats])
_id = np.ravel([ncols * (rows - 1) + cols])
_id_cat = []
for i in range(len(_id)):
_id_cat.append((_id[i], cats[i]))
gridTopo = VectorTopo(grid)
gridTopo.open("rw")
cur = gridTopo.table.conn.cursor()
cur.executemany("update " + grid + " set id=? where cat=?", _id_cat)
gridTopo.table.conn.commit()
gridTopo.close()
# Cell area
v.db_addcolumn(map=grid, columns="area_m2 double precision", quiet=True)
v.to_db(map=grid,
option="area",
units="meters",
columns="area_m2",
quiet=True)
# Basin mask
if len(mask) > 0:
# Fine resolution region:
g.region(
n=reg["n"],
s=reg["s"],
w=reg["w"],
e=reg["e"],
nsres=reg["nsres"],
ewres=reg["ewres"],
)
# Rasterize basin
v.to_rast(
input=basin,
output=mask,
use="val",
value=1,
overwrite=gscript.overwrite(),
quiet=True,
)
# Coarse resolution region:
g.region(
w=str(_w),
e=str(_e),
s=str(_s),
n=str(_n),
nsres=str(grid_ratio_ns * reg["nsres"]),
ewres=str(grid_ratio_ew * reg["ewres"]),
)
r.resamp_stats(input=mask,
output=mask,
method="sum",
overwrite=True,
quiet=True)
r.mapcalc("tmp" + " = " + mask + " > 0", overwrite=True, quiet=True)
g.rename(raster=("tmp", mask), overwrite=True, quiet=True)
r.null(map=mask, null=0, quiet=True)
# Add mask location (1 vs 0) in the MODFLOW grid
v.db_addcolumn(map=grid,
columns="basinmask double precision",
quiet=True)
v.what_rast(map=grid, type="centroid", raster=mask, column="basinmask")
"""
# Resampled raster
if len(raster_output) > 0:
r.resamp_stats(input=raster_input, output=raster_output, method='average', overwrite=gscript.overwrite(), quiet=True)
"""
# Pour point
if len(pp) > 0:
v.db_addcolumn(map=pp,
columns=("row integer", "col integer"),
quiet=True)
v.build(map=pp, quiet=True)
v.what_vect(map=pp,
query_map=grid,
column="row",
query_column="row",
quiet=True)
v.what_vect(map=pp,
query_map=grid,
column="col",
query_column="col",
quiet=True)
# Next point downstream of the pour point
# Requires pp (always) and mask (sometimes)
# Dependency set above w/ gscript.fatal
# g.region(raster='DEM')
# dx = gscript.region()['ewres']
# dy = gscript.region()['nsres']
if len(bc_cell) > 0:
########## NEED TO USE TRUE TEMPORARY FILE ##########
# May not work with dx != dy!
v.to_rast(input=pp, output="tmp", use="val", value=1, overwrite=True)
r.buffer(input="tmp",
output="tmp",
distances=float(dx) * 1.5,
overwrite=True)
r.mapcalc("tmp2 = if(tmp==2,1,null()) * " + raster_input,
overwrite=True)
# r.mapcalc('tmp = if(isnull('+raster_input+',0,(tmp == 2)))', overwrite=True)
# g.region(rast='tmp')
# r.null(map=raster_input,
# g.region(raster=raster_input)
# r.resample(input=raster_input, output='tmp3', overwrite=True)
r.resamp_stats(input=raster_input,
output="tmp3",
method="minimum",
overwrite=True)
r.drain(input="tmp3", start_points=pp, output="tmp", overwrite=True)
# g.region(w=str(_w), e=str(_e), s=str(_s), n=str(_n), nsres=str(grid_ratio_ns*reg['nsres']), ewres=str(grid_ratio_ew*reg['ewres']))
# r.resamp_stats(input='tmp2', output='tmp3', overwrite=True)
# g.rename(raster=('tmp3','tmp2'), overwrite=True, quiet=True)
r.mapcalc("tmp3 = tmp2 * tmp", overwrite=True, quiet=True)
g.rename(raster=("tmp3", "tmp"), overwrite=True, quiet=True)
# r.null(map='tmp', setnull=0) # Not necessary: center point removed above
r.to_vect(
input="tmp",
output=bc_cell,
type="point",
column="z",
overwrite=gscript.overwrite(),
quiet=True,
)
v.db_addcolumn(
map=bc_cell,
columns=(
"row integer",
"col integer",
"x double precision",
"y double precision",
),
quiet=True,
)
v.build(map=bc_cell, quiet=True)
v.what_vect(map=bc_cell,
query_map=grid,
column="row",
query_column="row",
quiet=True)
v.what_vect(map=bc_cell,
query_map=grid,
column="col",
query_column="col",
quiet=True)
v.to_db(map=bc_cell, option="coor", columns=("x,y"))
# Of the candidates, the pour point is the closest one
# v.db_addcolumn(map=bc_cell, columns=('dist_to_pp double precision'), quiet=True)
# v.distance(from_=bc_cell, to=pp, upload='dist', column='dist_to_pp')
# Find out if this is diagonal: finite difference works only N-S, W-E
colNames = np.array(gscript.vector_db_select(pp, layer=1)["columns"])
colValues = np.array(
gscript.vector_db_select(pp, layer=1)["values"].values())
pp_row = colValues[:, colNames == "row"].astype(int).squeeze()
pp_col = colValues[:, colNames == "col"].astype(int).squeeze()
colNames = np.array(
gscript.vector_db_select(bc_cell, layer=1)["columns"])
colValues = np.array(
gscript.vector_db_select(bc_cell, layer=1)["values"].values())
bc_row = colValues[:, colNames == "row"].astype(int).squeeze()
bc_col = colValues[:, colNames == "col"].astype(int).squeeze()
# Also get x and y while we are at it: may be needed later
bc_x = colValues[:, colNames == "x"].astype(float).squeeze()
bc_y = colValues[:, colNames == "y"].astype(float).squeeze()
if (bc_row != pp_row).all() and (bc_col != pp_col).all():
if bc_row.ndim > 0:
if len(bc_row) > 1:
for i in range(len(bc_row)):
"""
UNTESTED!!!!
And probably unimportant -- having 2 cells with river
going through them is most likely going to happen with
two adjacent cells -- so a side and a corner
"""
_col1, _row1 = str(bc_col[i]), str(pp_row[i])
_col2, _row2 = str(pp_col[i]), str(bc_row[i])
# Check if either of these is covered by the basin mask
_ismask_1 = gscript.vector_db_select(
grid,
layer=1,
where="(row == " + _row1 + ") AND (col ==" +
_col1 + ")",
columns="basinmask",
)
_ismask_1 = int(_ismask_1["values"].values()[0][0])
_ismask_2 = gscript.vector_db_select(
grid,
layer=1,
where="(row == " + _row2 + ") AND (col ==" +
_col2 + ")",
columns="basinmask",
)
_ismask_2 = int(_ismask_2["values"].values()[0][0])
# check if either of these is the other point
"""
NOT DOING THIS YET -- HAVEN'T THOUGHT THROUGH IF
ACTUALLY NECESSARY. (And this is an edge case anyway)
"""
# If both covered by mask, error
if _ismask_1 and _ismask_2:
gscript.fatal(
"All possible b.c. cells covered by basin mask.\n\
Contact the developer: awickert (at) umn(.)edu"
)
# If not diagonal, two possible locations that are adjacent
# to the pour point
_col1, _row1 = str(bc_col), str(pp_row)
_col2, _row2 = str(pp_col), str(bc_row)
# Check if either of these is covered by the basin mask
_ismask_1 = gscript.vector_db_select(
grid,
layer=1,
where="(row == " + _row1 + ") AND (col ==" + _col1 + ")",
columns="basinmask",
)
_ismask_1 = int(_ismask_1["values"].values()[0][0])
_ismask_2 = gscript.vector_db_select(
grid,
layer=1,
where="(row == " + _row2 + ") AND (col ==" + _col2 + ")",
columns="basinmask",
)
_ismask_2 = int(_ismask_2["values"].values()[0][0])
# If both covered by mask, error
if _ismask_1 and _ismask_2:
gscript.fatal(
"All possible b.c. cells covered by basin mask.\n\
Contact the developer: awickert (at) umn(.)edu")
# Otherwise, those that keep those that are not covered by basin
# mask and set ...
# ... wait, do we want the point that touches as few interior
# cells as possible?
# maybe just try setting both and seeing what happens for now!
else:
# Get dx and dy
# dx = gscript.region()['ewres']
# dy = gscript.region()['nsres']
# Build tool to handle multiple b.c. cells?
bcvect = vector.Vector(bc_cell)
bcvect.open("rw")
_cat_i = 2
if _ismask_1 != 0:
# _x should always be bc_x, but writing generalized code
_x = bc_x + float(dx) * (int(_col1) - bc_col
) # col 1 at w edge
_y = bc_y - float(dy) * (int(_row1) - bc_row
) # row 1 at n edge
point0 = Point(_x, _y)
bcvect.write(
point0,
cat=_cat_i,
attrs=(None, _row1, _col1, _x, _y),
)
bcvect.table.conn.commit()
_cat_i += 1
if _ismask_2 != 0:
# _y should always be bc_y, but writing generalized code
_x = bc_x + float(dx) * (int(_col2) - bc_col
) # col 1 at w edge
_y = bc_y - float(dy) * (int(_row2) - bc_row
) # row 1 at n edge
point0 = Point(_x, _y)
bcvect.write(
point0,
cat=_cat_i,
attrs=(None, _row2, _col2, _x, _y),
)
bcvect.table.conn.commit()
# Build database table and vector geometry
bcvect.build()
bcvect.close()
g.region(
n=reg["n"],
s=reg["s"],
w=reg["w"],
e=reg["e"],
nsres=reg["nsres"],
ewres=reg["ewres"],
)
# Prepare the stream lines and the points version of the same
r.thin(input='streams_tmp', output='streams', overwrite=True)
r.to_vect(input='streams', output='streams', type='line', overwrite=True)
v.db_dropcolumn(map='streams', columns='label')
v.db_renamecolumn(map='streams', column=('value', 'river_number'))
r.to_vect(input='streams',
output='streams_points',
type='point',
overwrite=True)
v.db_dropcolumn(map='streams_points', columns='label')
v.db_renamecolumn(map='streams_points', column=('value', 'river_number'))
# Get slope and area
v.db_addcolumn(map='streams_points',
columns=('slope double precision, area_km2 double precision'))
v.what_rast(map='streams_points', type='point', raster='slope', column='slope')
v.what_rast(map='streams_points',
type='point',
raster='drainageArea_km2',
column='area_km2')
# The following is not following upstream/downstream conventions.
# Time to do this the hard way.
# 1. Get vectorTopo
# 2. Get coordinates
# 3. Get areas at coordinates
# 4. Sort points to go from small A to large A -- but not yet uploading
# 5. Upload small area as x1, y1; large area as x2, y2
from grass.pygrass.vector import Vector, VectorTopo
from grass.pygrass.raster import RasterRow
def extract_points(self, vect_name, fields, na_rm=True, as_df=False):
"""Samples a list of GRASS rasters using a point dataset
Parameters
----------
vect_name : str
Name of GRASS GIS vector containing point features.
fields : list, str
Name of attribute(s) containing the vect_name variable(s).
na_rm : bool (opt). Default is True
Whether to remove samples containing NaNs.
as_df : bool (opt). Default is False.
Whether to return the extracted RasterStack values as a Pandas
DataFrame.
Returns
-------
X : ndarray
2d array containing the extracted raster values with the dimensions
ordered by (n_samples, n_features).
y : ndarray
1d or 2d array of labels with the dimensions ordered by
(n_samples, n_fields).
df : pandas.DataFrame
Extracted raster values as Pandas DataFrame if as_df = True.
"""
# some checks
try:
vname, mapset = vect_name.split("@")
except ValueError:
vname = vect_name
mapset = (g.mapset(flags="p", stdout_=PIPE).outputs.stdout.split(
os.linesep)[0])
if VectorTopo(name=vname, mapset=mapset).exist() is False:
gs.fatal("The supplied vector map does not exist")
if isinstance(fields, str):
fields = [fields]
# open grass vector
with VectorTopo(name=vname, mapset=mapset, mode="r") as points:
# retrieve key column
key_col = points.table.key
# read attribute table (ignores region)
df = pd.read_sql_query(
sql="select * from {name}".format(name=points.table.name),
con=points.table.conn)
for i in fields:
if i not in df.columns.tolist():
gs.fatal(i + " not present in the attribute table")
df = df.loc[:, fields + [points.table.key]]
# extract raster data
Xs = []
for name, layer in self.loc.items():
rast_data = v.what_rast(
map=vect_name,
raster=layer.fullname(),
flags="p",
quiet=True,
stdout_=PIPE,
).outputs.stdout.strip().split(os.linesep)
with RasterRow(layer.fullname()) as src:
if src.mtype == "CELL":
nodata = self._cell_nodata
dtype = pd.Int64Dtype()
else:
nodata = np.nan
dtype = np.float32
if len(list(itertools.chain(*rast_data))) == 0:
gs.fatal("There are no training point geometries in "
"the supplied vector dataset")
X = [
k.split("|")[1] if k.split("|")[1] != "*" else nodata
for k in rast_data
]
X = np.asarray(X)
cat = np.asarray([int(k.split("|")[0]) for k in rast_data])
if src.mtype == "CELL":
X = [int(i) for i in X]
else:
X = [float(i) for i in X]
X = pd.DataFrame(data=np.column_stack((X, cat)),
columns=[name, key_col])
X[name] = X[name].astype(dtype)
Xs.append(X)
for X in Xs:
df = df.merge(X, on=key_col)
# set any grass integer nodata values to NaN
df = df.replace(self._cell_nodata, np.nan)
# remove rows with missing response data
df = df.dropna(subset=fields)
# remove samples containing NaNs
if na_rm is True:
gs.message("Removing samples with NaN values in the raster "
"feature variables...")
df = df.dropna()
if as_df is False:
if len(fields) == 1:
fields = fields[0]
X = df.loc[:, df.columns.isin(self.loc.keys())].values
y = np.asarray(df.loc[:, fields].values)
cat = np.asarray(df.loc[:, key_col].values)
return X, y, cat
return df
print DEM
g.rename(vector=['Line__'+DEM,'channel_centerline_'+DEM.split('_')[-1]])
#(input='tmpStreamZ', output='channel_centerline_'+DEM.split('_')[-1], type='line', quiet=True, overwrite=True)
"""
channels = sorted(
gscript.parse_command('g.list',
type='vector',
pattern='channel_centerline_0*').keys())
for channel in channels:
channel_points = channel[:-7] + 'points_' + channel[-7:]
v.to_points(input=channel,
output=channel_points,
type='line',
dmax=0.002,
overwrite=True)
v.db_addcolumn(
map=channel_points,
layer=2,
columns='x double precision, y double precision, z double precision')
v.to_db(map=channel_points, option='coor', columns='x,y', layer=2)
v.what_rast(map=channel_points,
layer=2,
raster='DEM_' + channel[-7:],
column='z')
v.db_select(map=channel_points,
layer=2,
separator=',',
file=channel_points + '.csv',
overwrite=True)
