def find_avulsion(riv_i, riv_j, n, super_ratio, current_SL, ch_depth,
short_path, splay_type, splay_dep, dx=1., dy=1.):
new = riv_i, riv_j
old = riv_i, riv_j
avulsion_type = 0
for a in xrange(1, len(riv_i)):
if channel_is_superelevated(n, (riv_i[a], riv_j[a]), ch_depth,
super_ratio):
# if superelevation greater than trigger ratio, determine
# length of new steepest descent path
new = steep_desc.find_course(n, riv_i[:a], riv_j[:a],
sea_level=current_SL)
# if using the shortest path as an avulsion criterion, then
# the lengths of the previous and newly calculated paths will
# be compared
if short_path == 1:
new_length = find_path_length(new, dx=dx, dy=dy)
old_length = find_path_length(old, dx=dx, dy=dy)
if new_length < old_length:
# if new river course < length of old
# river course, then an avulsion will occur
avulsion_type = 1
new, avulsion_type = avulse_to_new_path(n,
(riv_i[a - 1:], riv_j[a - 1:]),
(new[0][a - 1:], new[1][a - 1:]),
current_SL, ch_depth, avulsion_type,
dx=dx, dy=dy)
new = (np.append(riv_i[:a - 1], new[0]),
np.append(riv_j[:a - 1], new[1]))
break
elif splay_type > 0:
avulsion_type = 3
FP.dep_splay(n, (new[0][a], new[1][a]), (riv_i, riv_j),
splay_dep, splay_type=splay_type)
# if shortest path is not an avulsion criterion, then the new
# steepest descent path will become the new course regardless
# of new course length relative to the old course
return new, avulsion_type, a
def find_avulsion(riv_i, riv_j, n, super_ratio, current_SL, ch_depth,
short_path, splay_type, slope, splay_depth,
nu, dt, dx=1., dy=1.):
new = riv_i, riv_j
old = riv_i, riv_j
avulsion_type = 0
a = 0
loc = 0
avulse_length = 0
new_length = 0
new_course_length = 0
avul_locs = np.zeros(0, dtype=np.int)
path_slopes = np.zeros(0)
crevasse_locs = np.zeros(3, dtype=np.int)
path_diff = np.zeros(0)
path_difference = 0
old_length = find_riv_path_length(n, old, current_SL, ch_depth,
slope, dx=dx, dy=dy)
for a in xrange(1, len(riv_i)-1):
if channel_is_superelevated(n, (riv_i[a], riv_j[a]),
(riv_i[a-1], riv_j[a-1]),
ch_depth, super_ratio, current_SL):
# if superelevation greater than trigger ratio, determine
# new steepest descent path
new = steep_desc.find_course(n, riv_i, riv_j, a, ch_depth,
sea_level=current_SL)
if n[new[0][-1], new[1][-1]] < current_SL:
new_length = find_riv_path_length(n, new, current_SL, ch_depth,
slope, dx=dx, dy=dy)
else:
new_length = find_path_length(n, new, current_SL, ch_depth,
slope, dx=dx, dy=dy)
if new_length < old_length:
# calculate slope of new path
if len(new[0][a:]) <= 1:
avulsed_length = find_path_length(n, (new[0][a-1:], new[1][a-1:]),
current_SL, ch_depth, slope,
dx=dx, dy=dy)
slope_new_path = ((n[new[0][-2], new[1][-2]] - n[new[0][-1], new[1][-1]])
/ avulsed_length)
elif n[new[0][-1], new[1][-1]] < current_SL:
avulsed_length = find_riv_path_length(n, (new[0][a:], new[1][a:]),
current_SL, ch_depth,
slope, dx=dx, dy=dy)
slope_new_path = ((n[new[0][a], new[1][a]] - n[new[0][-1], new[1][-1]])
/ avulsed_length)
else:
avulsed_length = find_path_length(n, (new[0][a:], new[1][a:]),
current_SL, ch_depth, slope,
dx=dx, dy=dy)
slope_new_path = ((n[new[0][a], new[1][a]] - n[new[0][-1], new[1][-1]])
/ avulsed_length)
avul_locs = np.append(avul_locs, a)
path_slopes = np.append(path_slopes, slope_new_path)
path_diff = np.append(path_diff, (old_length - new_length))
crevasse_locs = np.vstack((crevasse_locs, [new[0][a], new[1][a], a]))
if (crevasse_locs.sum() > 0):
crevasse_locs = np.delete(crevasse_locs, 0, 0)
if avul_locs.size > 0:
max_slope = np.argmax(path_slopes)
loc = avul_locs[max_slope]
path_difference = path_diff[max_slope]
new = steep_desc.find_course(n, riv_i, riv_j, loc, ch_depth,
sea_level=current_SL)
avulsion_type = 1
new, avulsion_type = avulse_to_new_path(n,
(riv_i[loc - 1:], riv_j[loc - 1:]),
(new[0][loc - 1:], new[1][loc - 1:]),
current_SL, ch_depth, avulsion_type,
slope, dx=dx, dy=dy)
new = (np.append(riv_i[:loc - 1], new[0]),
np.append(riv_j[:loc - 1], new[1]))
avulse_length = find_riv_path_length(n, (riv_i[loc:], riv_j[loc:]),
current_SL, ch_depth,
slope, dx=dx, dy=dy)
# fill up old channel... could be some fraction in the future
# (determines whether channels are repellors or attractors)
fill_abandoned_channel(loc, n, new, riv_i, riv_j, current_SL,
ch_depth, slope, dx)
crevasse_locs = np.delete(crevasse_locs, max_slope, 0)
else:
new = riv_i, riv_j
if (crevasse_locs.sum() > 0) and (splay_type > 0):
n_before_splay = np.copy(n)
# Don' think we need to worry about preserving old river elevations??
# old_river_elevations = n[riv_i, riv_j]
new_river_elevations = n[new[0], new[1]]
for i in xrange(crevasse_locs.shape[0]):
splay_dep = calc_crevasse_dep(dx, dy, nu, dt, ch_depth, riv_i, riv_j, n,
current_SL, slope, crevasse_locs[i][2])
if splay_dep > 0:
FP.dep_splay(n, (crevasse_locs[i][0], crevasse_locs[i][1]),
splay_dep, splay_type=splay_type)
# n[riv_i, riv_j] = old_river_elevations
n[new[0], new[1]] = new_river_elevations
n_splay = n - n_before_splay
splay_depth += n_splay
return (new, avulsion_type, loc, avulse_length, path_difference, splay_depth)
def find_avulsion(dx, dy, imax, jmax, riv_x, riv_y, n, super_ratio, current_SL,
ch_depth, short_path, dn_fp, splay_type, splay_dep):
loc = []
SEL = np.zeros(len(riv_x))
SER = np.zeros(len(riv_x))
avulsion_type = 0
length_new_sum = 0
length_old = 0
for a in range(1, len(riv_x)):
ch_Z = n[riv_x[a]/dx][riv_y[a]/dy] + ch_depth # bankfull elev.
LHS = n[riv_x[a]/dx][(riv_y[a]/dy)-1]
RHS = n[riv_x[a]/dx][(riv_y[a]/dy)+1]
# normalized superelevation ratio on left side
SEL[a] = ((ch_Z - LHS) / ch_depth)
# normalized superelevation ratio on right side
SER[a] = ((ch_Z - RHS) / ch_depth)
if SEL[a] >= super_ratio or SER[a] >= super_ratio:
# if superelevation greater than trigger ratio, determine
# length of new steepest descent path
new_riv_x = riv_x[:a-1]
new_riv_y = riv_y[:a-1]
new_riv_x, new_riv_y = steep_desc.find_new_course(
dx, dy, imax, jmax, n, new_riv_x, new_riv_y, current_SL)
# if using the shortest path as an avulsion criterion, then
# the lengths of the previous and newly calculated paths will
# be compared
if short_path == 1:
# duplicates arrays so that length can be compared below
test_new_x = new_riv_x[a:]
test_new_y = new_riv_y[a:]
test_old_x = riv_x[a:]
test_old_y = riv_y[a:]
length_new = []
for c in range(len(test_new_x)-1):
if (((test_new_x[c+1]/dx) - (test_new_x[c]/dx) == 0) and
(test_new_y[c+1]/dy) - (test_new_y[c]/dy) == -1):
length_new.append(1)
elif (((test_new_x[c+1]/dx) - (test_new_x[c]/dx) == 0)
and (test_new_y[c+1]/dy) - (test_new_y[c]/dy) == 1):
length_new.append(1)
elif (((test_new_x[c+1]/dx) - (test_new_x[c]/dx) == 1)
and (test_new_y[c+1]/dy) - (test_new_y[c]/dy) == 0):
length_new.append(1)
elif (((test_new_x[c+1]/dx) - (test_new_x[c]/dx) == 1)
and (test_new_y[c+1]/dy) - (test_new_y[c]/dy) == -1):
length_new.append(math.sqrt(2))
elif (((test_new_x[c+1]/dx) - (test_new_x[c]/dx) == 1)
and (test_new_y[c+1]/dy) - (test_new_y[c]/dy) == 1):
length_new.append(math.sqrt(2))
c += 1
for b in range(len(test_old_x)-1):
if (((test_old_x[b+1]/dx) - (test_old_x[b]/dx) == 0) and
(test_old_y[b+1]/dy) - (test_old_y[b]/dy) == -1):
length_old += 1
elif (((test_old_x[b+1]/dx) - (test_old_x[b]/dx) == 0)
and (test_old_y[b+1]/dy) - (test_old_y[b]/dy) == 1):
length_old += 1
elif (((test_old_x[b+1]/dx) - (test_old_x[b]/dx) == 1)
and (test_old_y[b+1]/dy) - (test_old_y[b]/dy) == 0):
length_old += 1
elif (((test_old_x[b+1]/dx) - (test_old_x[b]/dx) == 1)
and (test_old_y[b+1]/dy) - (test_old_y[b]/dy) == -1):
length_old += math.sqrt(2)
elif (((test_old_x[b+1]/dx) - (test_old_x[b]/dx) == 1)
and (test_old_y[b+1]/dy) - (test_old_y[b]/dy) == 1):
length_old += math.sqrt(2)
b += 1
# if new river course < length of old
# river course, then an avulsion will occur
length_new_sum = sum(length_new)
if sum(length_new) < length_old:
loc = [a] # avulsion location
avulsion_type = 1 # sets avulsion to be regional, may be
# updated again below (if local)
# maybe this should be len(test_old_x)-1?
for d in range(1,len(test_old_x)):
x_diff = new_riv_x[-1] - riv_x[a+d]
y_diff = new_riv_y[-1] - riv_y[a+d]
if x_diff == 0 and y_diff == 0:
avulsion_type = 2 # local avulsion
riv_x = new_riv_x + riv_x[a+d+1:]
riv_y = new_riv_y + riv_y[a+d+1:]
"""
above doesn't change river mouth location unless it's
a regional avulsion
"""
break
else: d += 1
if avulsion_type == 1:
riv_x = new_riv_x
riv_y = new_riv_y
n = downcut.cut_new(dx, dy, riv_x, riv_y, n, length_new,
current_SL, a, ch_depth)
return (riv_x, riv_y, loc, SEL, SER, n, dn_fp, avulsion_type,
length_new_sum, length_old
)
else:
if splay_type > 0:
n, dn_fp = FP.dep_splay(dy, dx, imax, jmax,
riv_x, riv_y, new_riv_x, new_riv_y,
ch_depth, n, a, dn_fp, splay_type,
splay_dep)
# if shortest path is not an avulsion criterion, then the new
# steepest descent path will become the new course regardless
# of new course length relative to the old course
if short_path == 0:
riv_x = new_riv_x
riv_y = new_riv_y
loc = [a]
a += 1
return (riv_x, riv_y, loc, SEL, SER, n, dn_fp, avulsion_type, length_new_sum,
length_old)
