def __init__(self):
super(Stream, self).__init__()
Logger.info('Stream: ON')
self.streams = Gl.streams
self.nReaches = len(self.streams[0])
self.cell_stream = Gl.cell_stream
self.reach = []
for i in range(self.nReaches):
self.reach.append(
Reach(self.streams[0][i], self.streams[1][i],
self.streams[2][i], self.streams[3][i],
self.streams[4][i], self.streams[5][i],
self.streams[6][i], self.streams[7][i],
self.streams[8][i], self.streams[9][i],
self.streams[10][i], self.streams[11][i],
self.streams[12][i], self.streams[13][i],
self.streams[14][i]))
self.streams_loc = Gl.streams_loc
self.mat_stream_reach = Gl.mat_stream_reach
for i in self.rr:
for j in self.rc[i]:
self.arr[i][j].state += self.mat_stream_reach[i][j]
self.STREAM_RATIO = Gl.STREAM_RATIO
def __init__(self):
"""The constructor
Make all numpy arrays and establish the inflow procedure based
on D8 or Multi Flow Direction Algorithm method.
"""
GridGlobals.__init__(self)
Logger.info("Surface: ON")
self.n = 15
# assign array objects
for i in range(self.r):
for j in range(self.c):
self.arr[i][j] = SurArrs(Globals.get_mat_reten(i, j),
Globals.get_mat_inf_index(i, j),
Globals.get_mat_hcrit(i, j),
Globals.get_mat_aa(i, j),
Globals.get_mat_b(i, j))
Stream.__init__(self)
Logger.info(
"\tRill flow: {}".format('ON' if Globals.isRill else 'OFF'))
def _print_array_stats(arr, file_output):
"""Print array stats.
"""
Logger.info("Raster ASCII output file {} saved".format(file_output))
Logger.info("\tArray stats: min={} max={} mean={}".format(
np.min(arr), np.max(arr), np.mean(arr)))
def prt(self, time, dt, sur):
if not self.fTimes:
return
if self.__n == len(self.times):
return
if (time < self.times[self.__n]) and (self.times[self.__n] <=
time + dt):
cas = '%015.2f' % (time + dt)
filen = os.path.join(Globals.outdir, self.outsubrid,
'H' + str(cas).replace('.', '_') + '.asc')
Logger.info("Printing total H into file {}".format(filein))
tmp = np.zeros([Globals.r, Globals.c], float)
for i in Globalsobals.rr:
for j in Globals.rc[i]:
tmp[i][j] = sur.arr[i][j].h_total_new
make_ASC_raster(filen, tmp, Globals)
# pro pripat, ze v dt by bylo vice pozadovanych tisku, v takovem pripade udela jen jeden
# a skoci prvni cas, ktery je mimo
while (time < self.times[self.__n]) and (self.times[self.__n] <=
time + dt):
self.__n += 1
if self.__n == len(self.times):
return
def __init__(self):
Logger.info("Diffuse approach")
if (Globals.r is None or Globals.r is None):
exit("Global variables are not assigned")
r = Globals.r
c = Globals.c
self.H = np.zeros([r, c], float)
def __init__(self, L_sub, Ks, vg_n, vg_l):
super(SubsurfacePass, self).__init__()
# jj
self.n = 0
self.q_subsurface = None
# self.arr = np.zeros([0],float)
Logger.info("Subsurface: OFF")
def removeCellsWithSameHeightNeighborhood(
mat_dem, mat_nan, rows, cols
): # function determines if cell neighborhood has exactly same values of height a and than it save that cell as NoData
"Returns an array with the values of heights, adjusted for the value of NoData cells"
bad_cells = []
# finding problem cells with same height neogborhood
for i in range(rows):
for j in range(cols):
c = [i, j]
count_nbrs = 0
point_m = mat_dem[i][j]
if i > 0 and i < (rows - 1) and j > 0 and j < (
cols - 1
): # non edge cells - edge cells are excluded thanks to slope trimming
nbrs = [
mat_dem[i - 1][j - 1], mat_dem[i - 1][j],
mat_dem[i - 1][j + 1], mat_dem[i][j - 1],
mat_dem[i][j + 1], mat_dem[i + 1][j - 1],
mat_dem[i + 1][j], mat_dem[i + 1][j + 1]
]
for k in range(8):
if point_m > 0 and point_m == nbrs[k]:
count_nbrs = count_nbrs + 1
if count_nbrs >= 7: # compare number of neighbours with the same height
bad_cells.append(c)
bc = 1
Logger.info(
"Possible water circulation! Check the input DTM raster for flat areas with the same height neighborhood."
)
# all problem cells set as NoData
if len(bad_cells) > 0:
for i in range(rows):
for j in range(cols):
if bc == 1:
bc_i = bad_cells[0][0]
bc_j = bad_cells[0][1]
if bc_i == i and bc_j == j:
mat_dem[i][j] = -3.40282346639e+038
mat_nan[i][j] = -3.40282346639e+038
bad_cells.pop(0)
if len(bad_cells) == 0:
bc = 0
else:
break
return mat_dem, mat_nan
def _save_data(data, filename):
"""Save data into pickle.
"""
if filename is None:
raise ProviderError('Output file for saving data not defined')
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
os.makedirs(dirname)
with open(filename, 'wb') as fd:
pickle.dump(data, fd, protocol=2)
Logger.info('Pickle file created in <{}> ({} bytes)'.format(
filename, sys.getsizeof(data)))
def __init__(self):
super(Cumulative, self).__init__()
Logger.info('Save cumulative and maximum values from: Surface')
# Dictionary stores the python arrays identification.
self.data.update({
# cumulative infiltrated volume [m3]
'infiltration' : CumulativeData('core', 'cInfil_m3'), # 1
# cumulative precipitation volume [m3]
'precipitation': CumulativeData('core', 'cRain_m3'), # 2
# maximum surface water level [m]
'h_sur_tot' : CumulativeData('control', 'mWLevel_m'), # 3
# maximum sheet discharge [m3s-1]
'q_sheet' : CumulativeData('control', 'mQsheet_m3_s'), # 4
# cumulative sheet runoff volume [m3]
'vol_sheet' : CumulativeData('control', 'cSheetVOutM3'), # 5
# maximum sheet velocity [ms-1]
'v_sheet' : CumulativeData('control', 'mVel_m_s'), # 6
# maximum sheet shear stress [Pa]
'shear_sheet' : CumulativeData('control', 'mrSearStr_Pa'), # 7
# maximum water level in rills [m]
'h_rill' : CumulativeData('control', 'mWLevelRill_m'), # 8
# maximum discharge in rills [m3s-1]
'q_rill' : CumulativeData('control', 'mQRill_m3_s'), # 9
# cumulative runoff volume in rills [m3]
'vol_rill' : CumulativeData('control', 'cRillVOut_m3'), # 10
# maximum rill width [m]
'b_rill' : CumulativeData('control', 'widthRill'), # 11
# cumulative surface inflow volume [m3]
'inflow_sur' : CumulativeData('control', 'cVIn_M3'), # 12
# maximum surface retention [m]
'sur_ret' : CumulativeData('control', 'surRet_M'), # 13
# cumulative surface runoff volume [m3]
'vol_sur_r' : CumulativeData('control', 'CumVRestL3'), # 14
# maximal total surface flow [m3/s]
'q_sur_tot' : CumulativeData('core', 'mQsur_m3_s'), # 15
# cumulative total surface flow [m3/s]
'vol_sur_tot' : CumulativeData('core', 'cVsur_m3') # 16
})
# define arrays class attributes
for item in self.data.keys():
setattr(self,
item,
np.zeros([GridGlobals.r, GridGlobals.c], float)
)
def __init__(self):
super(CumulativeSubsurface, self).__init__()
Logger.info('Subsurface')
self.data.update({
# cumulative exfiltration volume [m3]
'exfiltration': CumulativeData('core', 'cExfiltr_m3'), # 1
# cumulative percolation volume [m3]
'percolation' : CumulativeData('core', 'cPercol_m3'), # 2
# maximum water level in the subsurface soil layer [m]
'h_sub' : CumulativeData('core', 'mWLevelSub_M'), # 3
# maximum subsurface flux [m3s-1]
'q_sub' : CumulativeData('core', 'mQSub_m3_s'), # 4
# cumulative outflow volume in subsurface soil layer [m3]
'vol_sub' : CumulativeData('core', 'cVOutSub_m3') # 5
})
def __init__(self, id_, point_x, point_y, point_x_1, point_y_1, to_node,
length, sklon, smoderp, number, shape, b, m, roughness, q365):
self.id_ = id_
self.pointsFrom = [point_x, point_y]
self.pointsTo = [point_x_1, point_y_1]
self.to_node = to_node
self.length = length
if sklon < 0:
Logger.info(
"Slope in reach part {} indicated minus slope in stream".
format(id_))
self.slope = abs(sklon)
self.smoderp = smoderp
self.no = number
self.shape = shape
self.b = b
self.m = m
self.roughness = roughness
self.q365 = q365
self.V_in_from_field = 0.0
self.V_in_from_field_cum = 0.0
self.V_in_from_reach = 0.0
self.V_out_cum = 0.0 # L^3
self.vol_rest = 0.0
self.h = 0.0 # jj mozna pocatecni podminka? ikdyz to je asi q365 co...
self.h_max = 0.0
self.timeh_max = 0.0
self.V_out = 0.0
self.vs = 0.0
self.Q_out = 0.0
self.Q_max = 0.0
self.timeQ_max = 0.0
self.V_out_domain = 0.0
if shape == 0: # obdelnik
self.outflow_method = stream_f.rectangle
elif shape == 1: # trapezoid
self.outflow_method = stream_f.trapezoid
elif shape == 2: # triangle
self.outflow_method = stream_f.triangle
elif shape == 3: # parabola
self.outflow_method = stream_f.parabola
else:
self.outflow_method = stream_f.rectangle
def new_mfda(mat_dem, mat_nan, mat_fd, vpix, spix, rows, cols):
state = 0
state2 = 0
val_array = np.zeros([rows, cols, 8], float)
val_array2 = np.zeros([rows, cols], float)
fd_rill = np.zeros([rows, cols], float)
Logger.info("Computing multiple flow direction algorithm...")
# for i in range(rows):
# for j in range(cols):
# print i,j,mat_dem[i][j]
# function determines if cell neighborhood has miltiple cell with exactly
# same values of height and than it saves that cell as NoData
mat_dem, mat_nan = removeCellsWithSameHeightNeighborhood(
mat_dem, mat_nan, rows, cols)
# for i in range(rows):
# for j in range(cols):
# print i,j,mat_dem[i][j]
# main multiple-flow direction algorithm calculation
for i in range(rows):
for j in range(cols):
point_m = mat_dem[i][j]
if point_m < 0 or i == 0 or j == 0 or i == (rows - 1) or j == (cols - 1):
# jj nemely by ty byt nuly?
for m in range(8):
val_array[i][j][m] = 0.0 # -3.40282346639e+38
val_array2[i][j] = -3.40282346639e+38
else:
possible_circulation = 0
nbrs = neighbors(i, j, mat_dem, rows, cols)
fldir, flsp = dirSlope(point_m, nbrs, vpix, spix)
flprop = np.zeros(8, float)
sum_slgr = 0
pc = 0
# checking for cells with same height as neighbors
for k in range(8):
if abs(point_m - nbrs[k]) < 1e-5:
pc = pc + 1
if pc > 1:
possible_circulation = 1
# circulation is not possible
if possible_circulation == 0:
for k in range(8):
slgr = flsp[k] # slope gradient
if slgr < 0:
continue
else:
sum_slgr = math.pow(
slgr,
VE) + sum_slgr # sum of slope gradient
if sum_slgr == 0:
for m in range(8):
if fldir[m] == 0:
if m == 0:
val_array[i][j][5] = 1.0
val_array2[i][j] = 32
fd_rill[i][j] = 32
if m == 1:
val_array[i][j][6] = 1.0
val_array2[i][j] = 64
fd_rill[i][j] = 64
if m == 2:
val_array[i][j][7] = 1.0
val_array2[i][j] = 128
fd_rill[i][j] = 128
if m == 3:
val_array[i][j][0] = 1.0
val_array2[i][j] = 1
fd_rill[i][j] = 1
if m == 4:
val_array[i][j][1] = 1.0
val_array2[i][j] = 2
fd_rill[i][j] = 2
if m == 5:
val_array[i][j][2] = 1.0
val_array2[i][j] = 4
fd_rill[i][j] = 4
if m == 6:
val_array[i][j][3] = 1.0
val_array2[i][j] = 8
fd_rill[i][j] = 8
if m == 7:
val_array[i][j][4] = 1.0
val_array2[i][j] = 16
fd_rill[i][j] = 16
continue
else:
for k in range(8):
slgr = flsp[k] # slope gradient
if slgr < 0:
flprop[k] = 0
else:
fl_prop = math.pow(
slgr,
VE) / sum_slgr # flow proportions
flprop[k] = fl_prop
flow_amount_cell = np.zeros(8, float)
for l in range(8):
flowcells = flprop[l]
if flowcells > 0:
prop = (fldir[l] / FB ) * \
flowcells # percentage part into 1st cell
prop2 = (
1 - fldir[l] / FB) * flowcells # to second cell
if l == 0 and fldir[l] > 0 and fldir[l] < FB: # division to two cells
flow_amount_cell[0] = prop2
flow_amount_cell[1] = prop
state2 = 1 # because of last cell in the loop
elif l == 0 and fldir[l] == 0: # only to one cell division
flow_amount_cell[0] = flowcells
if l == 1 and fldir[l] > 0 and fldir[l] < FB:
if state2 == 1:
flow_amount_cell[
1] = flow_amount_cell[
1] + prop2
else:
flow_amount_cell[1] = prop2
flow_amount_cell[2] = prop
state = 2
elif l == 1 and fldir[l] == 0:
flow_amount_cell[1] = flowcells
if l == 2 and fldir[l] > 0 and fldir[l] < FB:
if state == 2:
flow_amount_cell[
2] = flow_amount_cell[
2] + prop2
else:
flow_amount_cell[2] = prop2
flow_amount_cell[4] = prop
state = 3
elif l == 2 and fldir[l] == 0:
flow_amount_cell[2] = flowcells
if l == 3 and fldir[l] > 0 and fldir[l] < FB:
if state == 3:
flow_amount_cell[
4] = flow_amount_cell[
4] + prop2
else:
flow_amount_cell[4] = prop2
flow_amount_cell[7] = prop
state = 4
elif l == 3 and fldir[l] == 0:
flow_amount_cell[4] = flowcells
if l == 4 and fldir[l] > 0 and fldir[l] < FB:
if state == 4:
flow_amount_cell[
7] = flow_amount_cell[
7] + prop2
else:
flow_amount_cell[7] = prop2
flow_amount_cell[6] = prop
state = 5
elif l == 4 and fldir[l] == 0:
flow_amount_cell[7] = flowcells
if l == 5 and fldir[l] > 0 and fldir[l] < FB:
if state == 5:
flow_amount_cell[
6] = flow_amount_cell[
6] + prop2
else:
flow_amount_cell[6] = prop2
flow_amount_cell[5] = prop
state = 6
elif l == 5 and fldir[l] == 0:
flow_amount_cell[6] = flowcells
if l == 6 and fldir[l] > 0 and fldir[l] < FB:
if state == 6:
flow_amount_cell[
5] = flow_amount_cell[
5] + prop2
else:
flow_amount_cell[5] = prop2
flow_amount_cell[3] = prop
state = 7
elif l == 6 and fldir[l] == 0:
flow_amount_cell[5] = flowcells
if l == 7 and fldir[l] > 0 and fldir[l] < FB:
if state == 7:
flow_amount_cell[
3] = flow_amount_cell[
3] + prop2
else:
flow_amount_cell[3] = prop2
if state2 == 1:
flow_amount_cell[
0] = flow_amount_cell[
0] + prop
else:
flow_amount_cell[0] = prop
elif l == 7 and fldir[l] == 0:
flow_amount_cell[3] = flowcells
state = 0
if (abs(sum(flprop) - 1.0) > 1e-5):
Logger.info("Error - sum of flow proportions is not eqaul to 1.0")
Logger.info(sum(flprop), i, j)
if (abs(sum(flow_amount_cell) - 1.0) > 1e-5):
Logger.info("Error - sum of flow amount in cell is not eqaul to 1.0")
Logger.info(sum(flow_amount_cell), i, j)
# same direction as in ArcGIS
flow_direction = [
flow_amount_cell[4], flow_amount_cell[
7], flow_amount_cell[6], flow_amount_cell[5],
flow_amount_cell[3], flow_amount_cell[0], flow_amount_cell[1], flow_amount_cell[2]]
fldirr = np.zeros(8)
for n in range(8):
if flow_direction[n] > 0:
fldirr[n] = 1
else:
fldirr[n] = 0
int_val = boolToInt(fldirr)
val_array2[i][j] = int_val
val_array[i][j] = flow_direction
# getting outfall maximum of flow direction amount from
# each cell to determine outfall for rill
ind = np.argmax(flow_direction)
if ind == 0:
fd_rill[i][j] = 1
if ind == 1:
fd_rill[i][j] = 2
if ind == 2:
fd_rill[i][j] = 4
if ind == 3:
fd_rill[i][j] = 8
if ind == 4:
fd_rill[i][j] = 16
if ind == 5:
fd_rill[i][j] = 32
if ind == 6:
fd_rill[i][j] = 64
if ind == 7:
fd_rill[i][j] = 128
# case that in raster are places where more than one neighbor
# has exact same height value so circulation is possible
else:
if mat_fd[i][j] == 1:
val_array[i][j][0] = 1.0
val_array2[i][j] = 1
fd_rill[i][j] = 1
if mat_fd[i][j] == 2:
val_array[i][j][1] = 1.0
val_array2[i][j] = 2
fd_rill[i][j] = 2
if mat_fd[i][j] == 4:
val_array[i][j][2] = 1.0
val_array2[i][j] = 4
fd_rill[i][j] = 4
if mat_fd[i][j] == 8:
val_array[i][j][3] = 1.0
val_array2[i][j] = 8
fd_rill[i][j] = 8
if mat_fd[i][j] == 16:
val_array[i][j][4] = 1.0
val_array2[i][j] = 16
fd_rill[i][j] = 16
if mat_fd[i][j] == 32:
val_array[i][j][5] = 1.0
val_array2[i][j] = 32
fd_rill[i][j] = 32
if mat_fd[i][j] == 64:
val_array[i][j][6] = 1.0
val_array2[i][j] = 64
fd_rill[i][j] = 64
if mat_fd[i][j] == 128:
val_array[i][j][7] = 1.0
val_array2[i][j] = 128
fd_rill[i][j] = 128
return val_array, fd_rill
def __init__(self, item='core'):
points = Globals.get_array_points()
ipi = points.shape[0]
jpj = 5
point_int = [[0] * jpj for i in range(ipi)]
rr, rc = GridGlobals.get_region_dim()
pixel_area = GridGlobals.get_pixel_area()
self.inSurface = []
self.inStream = []
for ip in range(ipi):
for jp in [0, 1, 2]:
point_int[ip][jp] = int(points[ip][jp])
for ip in range(ipi):
for jp in [3, 4]:
point_int[ip][jp] = points[ip][jp]
# tento cylkus meze budy, ktere jsou
# v i,j cylku o jednu vedle rrows a rcols
outsideDomain = False
del_ = []
for ip in range(ipi):
l = point_int[ip][1]
m = point_int[ip][2]
for ipp in rr:
if l == ipp:
for jpp in rc[ipp]:
if m == jpp:
outsideDomain = True
if not (outsideDomain):
del_.append(ip)
outsideDomain = False
point_int = [i for j, i in enumerate(point_int) if j not in del_]
ipi -= len(del_)
counter = 0
# mat_stream_seg is alway presented if stream == True
# if (mat_stream_seg != None) and (stream == True):
if Globals.isStream:
for ip in range(ipi):
l = point_int[ip][1]
m = point_int[ip][2]
if Globals.get_mat_stream_reach(l, m) >= 1000:
self.inStream.append(counter)
counter += 1
else:
self.inSurface.append(counter)
counter += 1
else:
self.inSurface = [i for i in range(ipi)]
self.inStream.append(-99)
self.inSurface.append(-99)
self.n = ipi
self.point_int = point_int
self.subflow = Globals.subflow
self.rill = Globals.isRill
self.stream = Globals.isStream
self.pixel_area = pixel_area
iStream = 0
iSurface = 0
self.header = []
for i in range(self.n):
header = '# Hydrograph at the point with coordinates: {} {}{}'.format(
self.point_int[i][3], self.point_int[i][4], os.linesep)
header += '# A pixel size is [m2]: {}{}'.format(
GridGlobals.pixel_area, os.linesep)
if i == self.inStream[iStream]:
if not Globals.extraOut:
header += '# time[s];deltaTime[s];rainfall[m];reachWaterLevel[m];reachFlow[m3/s];reachVolRunoff[m3]'
else:
header += '# time[s];deltaTime[s];Rainfall[m];Waterlevel[m];V_runoff[m3];Q[m3/s];V_from_field[m3];V_rests_in_stream[m3]'
header += os.linesep
iStream += 1
self.header.append(header)
elif i == self.inSurface[iSurface]:
if not Globals.extraOut:
header += '# time[s];deltaTime[s];rainfall[m];totalWaterLevel[m];surfaceFlow[m3/s];surfaceVolRunoff[m3]{}'.format(
os.linesep)
else:
header += '# time[s];deltaTime[s];Rainfall[m];Water_level_[m];Sheet_Flow[m3/s];Sheet_V_runoff[m3];Sheet_V_rest[m3];Infiltration[m];Surface_retetion[m];State;V_inflow[m3];WlevelTotal[m]{}'
if Globals.isRill:
header += ';WlevelRill[m];Rill_width[m];Rill_flow[m3/s];Rill_V_runoff[m3];Rill_V_rest;Surface_Flow[m3/s];Surface_V_runoff[m3]'
header += ';SurfaceBil[m3]'
if Globals.subflow:
header += ';Sub_Water_level_[m];Sub_Flow_[m3/s];Sub_V_runoff[m3];Sub_V_rest[m3];Percolation[];exfiltration[]'
if Globals.extraOut:
header += ';V_to_rill.m3.;ratio;courant;courantrill;iter'
header += os.linesep
iSurface += 1
self.header.append(header)
self.files = []
for i in range(self.n):
filename = 'point{}.csv'.format(str(self.point_int[i][0]).zfill(3))
fd = open(os.path.join(Globals.get_outdir(), filename), 'w')
fd.writelines(self.header[i])
self.files.append(fd)
del self.inStream[-1]
del self.inSurface[-1]
Logger.info("Hydrographs files has been created...")
def __init__(self):
super(StreamPass, self).__init__()
self.reach = None
Logger.info('Stream: OFF')
def __init__(self, L_sub=0.010, Ks=0.001, vg_n=1.5, vg_l=0.5):
Logger.info("Subsurface:")
super(Subsurface, self).__init__(L_sub=L_sub,
Ks=Ks,
vg_n=vg_n,
vg_l=vg_l)
def run(self):
""" The computation of the water level development
is performed here.
The *main loop* which goes through time steps
has *nested loop* for iterations (in case the
computation does not converge).
The computation has been divided in two parts
First, in iteration (*nested*) loop is calculated
the surface runoff (to which is the time step
sensitive) in a function time_step.do_flow()
Next water balance is performed at each cell of the
raster. Water level in next time step is calculated by
a function time_step.do_next_h().
Selected values are stored in at the end of each loop.
"""
# saves time before the main loop
Logger.info('Start of computing...')
Logger.start_time = time.time()
# main loop: until the end time
i = j = 0 # TODO: rename vars (variable overlap)
while self.flow_control.compare_time(Globals.end_time):
self.flow_control.save_vars()
self.flow_control.refresh_iter()
# iteration loop
while self.flow_control.max_iter_reached():
self.flow_control.update_iter()
self.flow_control.restore_vars()
# reset of the courant condition
self.courant.reset()
self.flow_control.save_ratio()
# time step size
potRain = self.time_step.do_flow(self.surface, self.subsurface,
self.delta_t,
self.flow_control,
self.courant)
# stores current time step
delta_t_tmp = self.delta_t
# update time step size if necessary (based on the courant
# condition)
self.delta_t, self.flow_control.ratio = self.courant.courant(
potRain, self.delta_t, self.flow_control.ratio)
# courant conditions is satisfied (time step did
# change) the iteration loop breaks
if delta_t_tmp == self.delta_t and self.flow_control.compare_ratio(
):
break
# Calculate actual rainfall and adds up interception todo:
# AP - actual is not storred in hydrographs
actRain = self.time_step.do_next_h(self.surface, self.subsurface,
self.rain_arr, self.cumulative,
self.hydrographs,
self.flow_control, self.courant,
potRain, self.delta_t)
# if the iteration exceed the maximal amount of iteration
# last results are stored in hydrographs
# and error is raised
if not self.flow_control.max_iter_reached():
for i in GridGlobals.rr:
for j in GridGlobals.rc[i]:
self.hydrographs.write_hydrographs_record(
i, j, self.flow_control, self.courant,
self.delta_t, self.surface, self.subsurface,
actRain)
# TODO
# post_proc.do(self.cumulative, Globals.mat_slope, Gl, surface.arr)
raise MaxIterationExceeded(self.flow_control.max_iter,
self.flow_control.total_time)
# adjusts the last time step size
if (Globals.end_time - self.flow_control.total_time) < self.delta_t and \
(Globals.end_time - self.flow_control.total_time) > 0:
self.delta_t = Globals.end_time - self.flow_control.total_time
# proceed to next time
self.flow_control.update_total_time(self.delta_t)
# if end time reached the main loop breaks
if self.flow_control.total_time == Globals.end_time:
break
timeperc = 100 * (self.flow_control.total_time +
self.delta_t) / Globals.end_time
Logger.progress(timeperc, self.delta_t, self.flow_control.iter_,
self.flow_control.total_time + self.delta_t)
# calculate outflow from each reach of the stream network
self.surface.stream_reach_outflow(self.delta_t)
# calculate inflow to reaches
self.surface.stream_reach_inflow()
# record cumulative and maximal results of a reach
self.surface.stream_cumulative(self.flow_control.total_time +
self.delta_t)
# set current times to previous time step
self.subsurface.curr_to_pre()
# write hydrographs of reaches
self.hydrographs.write_hydrographs_record(
i, j, self.flow_control, self.courant, self.delta_t,
self.surface, self.subsurface, actRain, True)
# print raster results in given time steps
self.times_prt.prt(self.flow_control.total_time, self.delta_t,
self.surface)
# set current time results to previous time step
# check if rill flow occur
for i in self.surface.rr:
for j in self.surface.rc[i]:
if self.surface.arr[i][j].state == 0:
if self.surface.arr[i][
j].h_total_new > self.surface.arr[i][j].h_crit:
self.surface.arr[i][j].state = 1
if self.surface.arr[i][j].state == 1:
if self.surface.arr[i][
j].h_total_new < self.surface.arr[i][
j].h_total_pre:
self.surface.arr[i][
j].h_last_state1 = self.surface.arr[i][
j].h_total_pre
self.surface.arr[i][j].state = 2
if self.surface.arr[i][j].state == 2:
if self.surface.arr[i][
j].h_total_new > self.surface.arr[i][
j].h_last_state1:
self.surface.arr[i][j].state = 1
self.surface.arr[i][j].h_total_pre = self.surface.arr[i][
j].h_total_new
# perform postprocessing - store results
Logger.info('Saving output data...')
self.provider.postprocessing(self.cumulative, self.surface.arr,
self.surface.reach)
# TODO
# post_proc.stream_table(Globals.outdir + os.sep, self.surface,
# Globals.streams_loc)
Logger.info('-' * 80)
Logger.info('Total computing time: {}'.format(time.time() -
Logger.start_time))
def __init__(self, provider):
"""Initialize main classes.
Method defines instances of classes for rainfall, surface,
stream and subsurface processes handling.
"""
self.provider = provider
# handling print of the solution in given times
self.times_prt = TimesPrt()
# flow control
self.flow_control = FlowControl()
# handling the actual rainfall amount
self.rain_arr = Vegetation()
# handling the surface processes
self.surface = Surface()
# class handling the subsurface processes if desir
# TODO: include in data preprocessing
if Globals.subflow:
self.subsurface = Subsurface(L_sub=0.1,
Ks=0.005,
vg_n=1.5,
vg_l=0.5)
else:
self.subsurface = Subsurface()
# maximal and cumulative values of resulting variables
self.cumulative = Cumulative()
# handle times step changes based on Courant condition
self.courant = Courant()
self.delta_t = self.courant.initial_time_step(self.surface)
self.courant.set_time_step(self.delta_t)
Logger.info('Corrected time step is {} [s]'.format(self.delta_t))
# opens files for storing hydrographs
if Globals.points and Globals.points != "#":
self.hydrographs = wf.Hydrographs()
### TODO
# arcgis = Globals.arcgis
# if not arcgis:
# with open(os.path.join(Globals.outdir, 'points.txt'), 'w') as fd:
# for i in range(len(Globals.array_points)):
# fd.write('{} {} {} {}'.format(
# Globals.array_points[i][0], Globals.array_points[i][3],
# Globals.array_points[i][4], os.linesep
# ))
else:
self.hydrographs = wf.HydrographsPass()
# method for single time step calculation
self.time_step = TimeStep()
# record values into hydrographs at time zero
rr, rc = GridGlobals.get_region_dim()
for i in rr:
for j in rc[i]:
self.hydrographs.write_hydrographs_record(
i, j, self.flow_control, self.courant, self.delta_t,
self.surface, self.subsurface, 0.0)
# record values into stream hydrographs at time zero
self.hydrographs.write_hydrographs_record(i, j, self.flow_control,
self.courant, self.delta_t,
self.surface,
self.subsurface, 0.0, True)
Logger.info('-' * 80)
def __init__(self):
Logger.info("D8 flow algorithm")
self.inflows = D8_.new_inflows(Globals.get_mat_fd())
def __init__(self):
Logger.info("Multiflow direction algorithm")
self.inflows, fd_rill = mfd.new_mfda(mat_dem, mat_nan, mat_fd, vpix,
spix, rows, cols)
self.inflowsRill = D8_.new_inflows(fd_rill)
def __init__(self):
Logger.info("Kinematic approach")
super(Kinematic, self).__init__()