def plotPath(resAB, name, flags):
""" Plot and save results depending on flags options"""
splitPoint = resAB['splitPoint']
header = resAB['dem']['header']
rasterdata = resAB['dem']['rasterData']
x = resAB[name]['x']
y = resAB[name]['y']
indSplit = resAB[name]['indSplit']
if flags.getboolean('plotPath'):
# Plot raster and path
fig, ax = plt.subplots(figsize=(pU.figW, pU.figH))
titleText = name
plt.title(titleText)
cmap = copy.copy(mpl.cm.get_cmap("Greys"))
cmap.set_bad(color='white')
im = plt.imshow(rasterdata, cmap, origin='lower')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.1)
fig.colorbar(im, cax=cax)
# path1 = ax1.plot((x-header.xllcorner)/header.cellsize,
# (y-header.yllcorner)/header.cellsize)
ax.plot((x - header.xllcorner) / header.cellsize,
(y - header.yllcorner) / header.cellsize,
'k',
label='avapath')
ax.plot((splitPoint['x'] - header.xllcorner) / header.cellsize,
(splitPoint['y'] - header.yllcorner) / header.cellsize,
'.',
color='0.3',
label='Split points')
ax.plot((x[indSplit] - header.xllcorner) / header.cellsize,
(y[indSplit] - header.yllcorner) / header.cellsize,
'.',
color='0.6',
label='Projection of Split Point on ava path')
fig.legend(frameon=False, loc='lower center')
pU.putAvaNameOnPlot(ax, name)
plt.show(block=False)
def resultVisu(cfgSetup, cfgPath, cfgFlags, rasterTransfo, resAnalysis):
"""
Visualize results in a nice way
"""
####################################
# Get input data
resType = cfgSetup['resType']
unit = pU.cfgPlotUtils['unit' + resType]
name = pU.cfgPlotUtils['name' + resType]
fnames = cfgPath[resType]
maxMaxDPPR = resAnalysis['MM' + resType.upper()]
thresholdValue = cfgSetup['thresholdValue']
nRef = cfgPath['referenceFile']
flag = float(cfgFlags['typeFlag'])
zPath = rasterTransfo['z']
sPath = rasterTransfo['s']
indStartOfRunout = rasterTransfo['indStartOfRunout']
sStart = sPath[indStartOfRunout]
runout = resAnalysis['runout'][0]
# prepare for plot
if flag == 2:
title = 'Visualizing EGU growth index data'
tipo = 'growthInd'
GI = resAnalysis['growthIndex']
data = GI
yaxis_label = 'growth index [GI]'
elif flag == 3:
title = 'Visualizing max ' + name + ' data'
tipo = 'relMax' + resType + '_thresholdValue' + str(
thresholdValue).replace('.', 'p')
data = maxMaxDPPR / maxMaxDPPR[nRef]
yaxis_label = 'relative max ' + name + ' [-]'
else:
log.error('Wrong flag')
return None
log.info(title)
# If more than 100 files are provided, add a density plot
plotDensity = 0
if (len(fnames) > 100):
plotDensity = 1
color = pU.cmapAimec(np.linspace(1, 0, len(runout) + 3, dtype=float))
mk = 0
#######################################
# Final result diagram - z_profile+data
fig = plt.figure(figsize=(pU.figW * 2, pU.figH))
# show flow path
ax1 = fig.add_subplot(111)
ax1.set_title(title)
ax1.set_ylabel(yaxis_label, color=color[-3])
ax1.spines['left'].set_color(color[-3])
ax1.tick_params(axis='y', colors=color[-3])
ax1.set_xlabel(''.join(
['s [m] - runout with ',
str(thresholdValue), ' kPa threshold']))
pU.putAvaNameOnPlot(ax1, cfgPath['projectName'])
if plotDensity: # estimate 2D histogram --> create pcolormesh
nbins = 100
H, xedges, yedges = np.histogram2d(runout, data, bins=nbins)
H = np.flipud(np.rot90(H))
Hmasked = np.ma.masked_where(H == 0, H)
dataDensity = plt.pcolormesh(xedges, yedges, Hmasked, cmap=cm.Blues)
cbar = plt.colorbar(dataDensity, orientation='horizontal')
cbar.ax.set_ylabel('Counts')
ax2 = ax1.twinx()
ax2.set_ylabel('z [m]')
ax2.spines['left'].set_color(color[-3])
ax2.tick_params(axis='y', colors='k')
ax2.plot(sPath, zPath, color='k', label='path', linestyle='--')
plt.xlim([0, max(sPath) + 50])
plt.ylim(
[math.floor(min(zPath) / 10) * 10,
math.ceil(max(zPath) / 10) * 10])
if not plotDensity:
for k in range(len(runout)):
topoName = cfgPath['projectName']
pfarbe = color[k + 1]
if k == 0:
ax1.plot(runout[k],
data[k],
marker='+',
linestyle='None',
markersize=2 * pU.ms,
color='g',
label='Reference')
elif k == 1:
ax1.plot(runout[k],
data[k],
marker=pU.markers,
label='sims',
color=pfarbe,
linestyle='None')
else:
ax1.plot(runout[k],
data[k],
marker=pU.markers,
color=pfarbe,
linestyle='None')
mk = mk + 1
if mk == len(pU.markers):
mk = 1
ax1.legend(loc=4)
ax1.grid('on')
outFileName = '_'.join([cfgPath['projectName'], tipo])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
############################################
# Final result diagram - roc-plots
rTP = resAnalysis['TP'] / (resAnalysis['TP'][nRef] +
resAnalysis['FN'][nRef])
rFP = resAnalysis['FP'] / (resAnalysis['TP'][nRef] +
resAnalysis['FN'][nRef])
fig = plt.figure(figsize=(pU.figW, pU.figH))
mk = 0
ax1 = fig.add_subplot(111)
ax1.set_title('Normalized difference compared to reference')
ax1.set_ylabel('True positive rate')
ax1.set_xlabel('False positive rate')
pU.putAvaNameOnPlot(ax1, cfgPath['projectName'])
if plotDensity: # estimate 2D histogram --> create pcolormesh
nbins = 100
H, xedges, yedges = np.histogram2d(rFP, rTP, bins=nbins)
H = np.flipud(np.rot90(H))
Hmasked = np.ma.masked_where(H == 0, H)
dataDensity = plt.pcolormesh(xedges, yedges, Hmasked, cmap=cm.cool)
cbar = plt.colorbar(dataDensity, orientation='horizontal')
cbar.ax.set_ylabel('hit rate density')
else:
for k in range(len(rTP)):
pfarbe = color[k + 1] # colorvar(float(k), len(rTP), colorflag)
if k == 0:
ax1.plot(rFP[k],
rTP[k],
color='g',
label='Reference',
marker='+',
markersize=2 * pU.ms,
linestyle='None')
elif k == 1:
ax1.plot(rFP[k],
rTP[k],
marker=pU.markers,
label='sims',
color=pfarbe,
linestyle='None')
else:
ax1.plot(rFP[k],
rTP[k],
marker=pU.markers,
color=pfarbe,
linestyle='None')
mk = mk + 1
if mk == len(pU.markers):
mk = 0
ax1.legend(loc=4)
plt.xlim([-0.03, max(1, max(rFP) + 0.03)])
plt.ylim([-0.03, 1.03])
plt.grid('on')
outFileName = '_'.join([
cfgPath['projectName'], resType, 'thresholdValue',
str(thresholdValue).replace('.', 'p'), 'ROC'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
return
def visuComparison(rasterTransfo, inputs, cfgPath, cfgFlags):
"""
Plot and save the comparison between current simulation and Reference
in the run-out area
"""
####################################
# Get input data
# read paths
projectName = cfgPath['projectName']
# read data
s = rasterTransfo['s']
l = rasterTransfo['l']
indStartOfRunout = rasterTransfo['indStartOfRunout']
sStart = s[indStartOfRunout]
runoutLength = inputs['runoutLength']
refData = inputs['refData']
compData = inputs['compData']
refRasterMask = inputs['refRasterMask']
newRasterMask = inputs['newRasterMask']
i = inputs['i']
resType = inputs['resType']
unit = pU.cfgPlotUtils['unit' + resType]
name = pU.cfgPlotUtils['name' + resType]
thresholdArray = inputs['thresholdArray']
thresholdValue = thresholdArray[-1]
contCmap = cfgPath['contCmap']
############################################
# Figure: Raster comparison (mask for the pThreshold given in the ini file)
fig = plt.figure(figsize=(pU.figW * 2, pU.figH))
ax1 = plt.subplot2grid((1, 2), (0, 0))
# get color map
cmap, _, _, norm, ticks = makePalette.makeColorMap(pU.cmapPres,
thresholdValue,
np.nanmax((refData)),
continuous=contCmap)
cmap.set_bad(color='w')
refDataPlot = np.ma.masked_where(refData == 0.0, refData)
ref0, im = pU.NonUnifIm(ax1,
l,
s,
refDataPlot,
'l [m]',
's [m]',
extent=[l.min(),
l.max(),
s.min(),
s.max()],
cmap=cmap,
norm=norm)
ax1.axhline(y=s[indStartOfRunout],
color='k',
linestyle='--',
label='start of run-out area point : %.1f °' %
rasterTransfo['startOfRunoutAreaAngle'])
ax1.set_title('Reference %s in the RunOut area' % name + '\n' +
'%s threshold: %.1f %s' % (name, thresholdValue, unit))
pU.addColorBar(im, ax1, ticks, unit)
yLim = s[max(np.max(np.nonzero(np.any(refData != 0, axis=1))[0]),
np.max(np.nonzero(np.any(compData != 0, axis=1))[0]))]
ax1.set_ylim([0, yLim])
ax1.legend(loc='lower right')
pU.putAvaNameOnPlot(ax1, projectName)
ax2 = plt.subplot2grid((1, 2), (0, 1))
colorsList = [[0, 0, 1], [1, 1, 1], [1, 0, 0]]
cmap = matplotlib.colors.ListedColormap(colorsList)
cmap.set_under(color='b')
cmap.set_over(color='r')
cmap.set_bad(alpha=0)
data = newRasterMask - refRasterMask
data = np.ma.masked_where(data == 0.0, data)
ref1, im1 = pU.NonUnifIm(ax2,
l,
s,
data,
'l [m]',
's [m]',
extent=[l.min(),
l.max(),
s.min(),
s.max()],
cmap=cmap)
if cfgPath['compType'][0] == 'comModules':
namePrint = 'refMod:' + cfgPath['compType'][
1] + '_' + 'compMod:' + cfgPath['compType'][2]
pU.putAvaNameOnPlot(ax2, namePrint)
ax2.set_ylim([s[indStartOfRunout], yLim])
ax2.set_title('Difference %s current - reference in runout area' %
resType + '\n' + 'Blue = FN, Red = FP')
outFileName = '_'.join([
projectName, 'thresholdValue',
str(thresholdValue).replace('.', 'p'), 'sim',
str(i), 'AreaComparisonToReference'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
############################################
# Figure: Raster comparison
fig = plt.figure(figsize=(pU.figW * 3,
pU.figH * 2)) #, constrained_layout=True)
ax1 = plt.subplot2grid((3, 3), (0, 0), rowspan=3)
# get color map
cmap, _, _, norm, ticks = makePalette.makeColorMap(pU.cmapPres,
thresholdValue,
np.nanmax((refData)),
continuous=pU.contCmap)
cmap.set_bad(color='w')
refDataPlot = np.ma.masked_where(refData == 0.0, refData)
ref0, im = pU.NonUnifIm(ax1,
l,
s,
refDataPlot,
'l [m]',
's [m]',
extent=[l.min(), l.max(), 0, yLim],
cmap=cmap,
norm=norm)
ax1.axhline(y=s[indStartOfRunout],
color='k',
linestyle='--',
label='start of run-out area point : %.1f °' %
rasterTransfo['startOfRunoutAreaAngle'])
ax1.set_title('Reference %s' % name)
pU.addColorBar(im, ax1, ticks, unit)
ax1.set_ylim([0, yLim])
ax1.legend(loc='lower right')
pU.putAvaNameOnPlot(ax1, projectName)
compData = compData[indStartOfRunout:, :]
refData = refData[indStartOfRunout:, :]
dataDiff = compData - refData
dataDiff = np.where((refData == 0) & (compData == 0), np.nan, dataDiff)
dataDiffPlot = dataDiff[np.isnan(dataDiff) == False]
# only plot hist and CDF if there is a difference in the data
if dataDiffPlot.size:
indDiff = dataDiffPlot > 0
if indDiff.any():
ax2 = plt.subplot2grid((3, 3), (0, 1), rowspan=2, colspan=2)
else:
ax2 = plt.subplot2grid((3, 3), (0, 1), rowspan=3, colspan=3)
cmap = pU.cmapdiv
cmap.set_bad(color='w')
elev_max = inputs['diffLim']
ref0, im3 = pU.NonUnifIm(
ax2,
l,
s[indStartOfRunout:], (dataDiff),
'l [m]',
's [m]',
extent=[l.min(), l.max(), s[indStartOfRunout:].min(), yLim],
cmap=cmap)
im3.set_clim(vmin=-elev_max, vmax=elev_max)
L, S = np.meshgrid(l, s[indStartOfRunout:])
colorsP = pU.cmapPres['colors'][1:5]
contourRef = ax2.contour(L,
S,
refData,
levels=thresholdArray[:-1],
linewidths=1,
colors=colorsP)
contourComp = ax2.contour(L,
S,
compData,
levels=thresholdArray[:-1],
linewidths=1,
colors=colorsP,
linestyles='dashed')
labels = [str(level) + unit for level in thresholdArray[:-1]]
for j in range(len(contourRef.collections)):
contourRef.collections[j].set_label(labels[j])
ax2.set_title('%s difference and contour lines' % name + '\n' +
'refMod = full, compMod = dashed line')
if cfgPath['compType'][0] == 'comModules':
namePrint = 'refMod:' + cfgPath['compType'][
1] + '_' + 'compMod:' + cfgPath['compType'][2]
pU.putAvaNameOnPlot(ax2, namePrint)
ax2.set_ylim([s[indStartOfRunout], yLim])
ax2.legend(loc='lower right')
pU.addColorBar(im3, ax2, ticks, unit, title=name, extend='both')
# only plot hist and CDF if there is a difference in the data
if dataDiffPlot.size:
indDiff = dataDiffPlot > 0
if indDiff.any():
ax3 = plt.subplot2grid((3, 3), (2, 1))
ax4 = plt.subplot2grid((3, 3), (2, 2))
# there is data to compare in the run out area
centiles = sPlot.plotHistCDFDiff(
dataDiffPlot,
ax4,
ax3,
insert='False',
title=[
'%s diff histogram' % name,
'%s diff CDF (95%% and 99%% centiles)' % name
])
else:
log.warning('No data in the run out area!')
fig.subplots_adjust(hspace=0.3, wspace=0.3)
outFileName = '_'.join([
projectName, 'plim',
str(thresholdValue).replace('.', 'p'), 'sim',
str(i), 'ContourComparisonToReference'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
outFilePath = os.path.join(cfgPath['pathResult'], 'pics',
outFileName + '.png')
return outFilePath
def visuSimple(rasterTransfo, resAnalysis, newRasters, cfgPath, cfgFlags):
"""
Plot and save the Peak Pressure Peak Flow depth and Peak speed
fields after coord transfo
"""
####################################
# Get input data
# read paths
projectName = cfgPath['projectName']
nRef = cfgPath['referenceFile']
# read data
plim = resAnalysis['thresholdValue']
s = rasterTransfo['s']
l = rasterTransfo['l']
indStartOfRunout = rasterTransfo['indStartOfRunout']
dataPressure = newRasters['newRasterPPR']
rasterdataPres = dataPressure[nRef]
dataDepth = newRasters['newRasterPFD']
rasterdataDepth = dataDepth[nRef]
dataSpeed = newRasters['newRasterPFV']
rasterdataSpeed = dataSpeed[nRef]
runout = resAnalysis['runout'][0]
############################################
# prepare for plot
Cmap = [pU.cmapPres, pU.cmapDepth, pU.cmapSpeed]
Title = ['Peak Pressure', 'Peak Flow Depth', 'Peak Speed']
Unit = [
pU.cfgPlotUtils['unitppr'], pU.cfgPlotUtils['unitpfd'],
pU.cfgPlotUtils['unitpfv']
]
Data = np.array(([None] * 3))
Data[0] = rasterdataPres
Data[1] = rasterdataDepth
Data[2] = rasterdataSpeed
############################################
# Figure: Pressure depth speed
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(pU.figW * 3, pU.figH))
fig.subplots_adjust(left=0.05,
bottom=0.05,
right=0.95,
top=0.95,
hspace=0.3)
for ax, cmap, data, title, unit in zip(axes.flatten(), Cmap, Data, Title,
Unit):
maskedArray = np.ma.masked_where(data == 0, data)
cmap, _, _, norm, ticks = makePalette.makeColorMap(
cmap, 0.0, np.nanmax(maskedArray), continuous=pU.contCmap)
cmap.set_bad('w', 1.)
ax.axhline(y=runout[0], color='k', linestyle='-', label='runout')
ax.axhline(y=s[indStartOfRunout],
color='k',
linestyle='--',
label='Start or run-out point : %.1f °' %
resAnalysis['startOfRunoutAreaAngle'])
ref3, im = pU.NonUnifIm(ax,
l,
s,
maskedArray,
'l [m]',
's [m]',
extent=[l.min(),
l.max(),
s.min(),
s.max()],
cmap=cmap,
norm=norm)
ax.set_title(title)
ax.legend(loc=4)
pU.addColorBar(im, ax, ticks, unit)
pU.putAvaNameOnPlot(ax, cfgPath['projectName'])
outFileName = '_'.join([
projectName, 'plim',
str((plim)).replace('.', 'p'), 'referenceFields'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
def visuMass(resAnalysis, cfgPath, cfgFlags):
"""
Plot and save the results from mass analysis
"""
####################################
# Get input data
# read paths
projectName = cfgPath['projectName']
# read data
entMassFlowArray = resAnalysis['entMassFlowArray']
totalMassArray = resAnalysis['totalMassArray']
entMass = resAnalysis['entMass']
finalMass = resAnalysis['finalMass']
time = resAnalysis['time']
############################################
# prepare for plot
Title = ['Entrained Mass Flow', 'Total Mass']
Unit = ['Entrained Mass Flow [$kg.s{^-1}$]', 'Total Mass [kg]']
DataMass = np.array(([None] * 2))
DataMass[0] = entMassFlowArray
DataMass[1] = totalMassArray
############################################
# Figure: Pressure depth speed
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(pU.figW * 2, pU.figH))
fig.subplots_adjust(left=0.05,
bottom=0.05,
right=0.95,
top=0.95,
hspace=0.3)
for ax, dataMass, title, unit in zip(axes.flatten(), DataMass, Title,
Unit):
ax.plot(time, dataMass[0, :], '-k', label='Reference')
ax.plot(time, dataMass[1, :], '-b', label='Simulation')
ax.set_title(title + ' function of time')
ax.legend(loc=4)
ax.set_xlabel('t [s]')
ax.set_ylabel(unit)
ax2 = axes.flatten()[1].twinx()
# ax2.set_ylabel('z [m]')
ax2.spines['right'].set_color('r')
ax2.tick_params(axis='y', colors='r')
ax2.plot(time, (dataMass[1, :] - dataMass[0, :]) / dataMass[0, :] * 100,
'r',
label='total mass')
if np.any(entMass):
axes.flatten()[1].text(
time[-1] / 4,
(np.nanmin(dataMass[0, :]) + np.nanmax(dataMass[0, :])) / 2,
'Entrained Mass Difference : %.2f kg \n Relative to entrained mass : %.2f %% \n Relative to total mass : %.2f %% '
% ((entMass[0] - entMass[1]),
(entMass[0] - entMass[1]) / entMass[0] * 100,
(entMass[0] - entMass[1]) / finalMass[0] * 100),
bbox=dict(boxstyle="square", ec='white', fc='white'),
horizontalalignment='left',
verticalalignment='bottom')
ax2.set_ylabel('Entrained Mass Difference relative to total mass[%]',
color='r')
outFileName = '_'.join([projectName, 'massAnalysis'])
pU.putAvaNameOnPlot(ax2, cfgPath['projectName'])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
outFilePath = os.path.join(cfgPath['pathResult'], 'pics',
outFileName + '.png')
return outFilePath
def visuTransfo(rasterTransfo, inputData, cfgSetup, cfgPath, cfgFlags):
"""
Plot and save the domain transformation figure
"""
####################################
# Get input data
resType = cfgSetup['resType']
unit = pU.cfgPlotUtils['unit' + resType]
# read paths
projectName = cfgPath['projectName']
# read rasterdata
slRaster = inputData['slRaster']
xyRaster = inputData['xyRaster']
# read avaPath with scale
xPath = rasterTransfo['x']
yPath = rasterTransfo['y']
# read domain boundarries with scale
xllc = rasterTransfo['xllc']
yllc = rasterTransfo['yllc']
cellSize = rasterTransfo['cellSize']
DBXl = rasterTransfo['DBXl'] * cellSize + xllc
DBXr = rasterTransfo['DBXr'] * cellSize + xllc
DBYl = rasterTransfo['DBYl'] * cellSize + yllc
DBYr = rasterTransfo['DBYr'] * cellSize + yllc
############################################
# prepare for plot
n, m = np.shape(xyRaster)
x = np.arange(m) * cellSize + xllc
y = np.arange(n) * cellSize + yllc
indStartOfRunout = rasterTransfo['indStartOfRunout']
xx = rasterTransfo['x'][indStartOfRunout]
yy = rasterTransfo['y'][indStartOfRunout]
l = rasterTransfo['l']
s = rasterTransfo['s']
maskedArray = np.ma.masked_where(xyRaster == 0, xyRaster)
maskedArraySL = np.ma.masked_where(slRaster == 0, slRaster)
cmap, _, _, norm, ticks = makePalette.makeColorMap(pU.cmapPres,
0.0,
np.nanmax(maskedArray),
continuous=pU.contCmap)
cmap.set_under(color='w')
############################################
# Figure: Raster transformation
fig = plt.figure(figsize=(pU.figW * 2, pU.figH))
ax1 = plt.subplot(121)
ref0, im = pU.NonUnifIm(ax1,
x,
y,
maskedArray,
'x [m]',
'y [m]',
extent=[x.min(),
x.max(),
y.min(),
y.max()],
cmap=cmap,
norm=norm)
plt.plot(xx,
yy,
'k+',
label='start of run-out area point : %.1f °' %
rasterTransfo['startOfRunoutAreaAngle'])
plt.plot(xPath, yPath, 'k--', label='flow path')
plt.plot(DBXl, DBYl, 'k-', label='domain')
plt.plot(DBXr, DBYr, 'k-')
plt.plot([DBXl, DBXr], [DBYl, DBYr], 'k-')
ax1.set_title('XY Domain')
ax1.legend(loc=4)
pU.putAvaNameOnPlot(ax1, cfgPath['projectName'])
ax2 = plt.subplot(122)
ref0, im = pU.NonUnifIm(ax2,
l,
s,
maskedArraySL,
'l [m]',
's [m]',
extent=[l.min(),
l.max(),
s.min(),
s.max()],
cmap=cmap,
norm=norm)
ax2.axhline(y=s[indStartOfRunout],
color='k',
linestyle='--',
label='start of run-out area point : %.1f °' %
rasterTransfo['startOfRunoutAreaAngle'])
ax2.set_title('sl Domain' + '\n' + 'Black = out of raster')
ax2.legend(loc=4)
pU.addColorBar(im, ax2, ticks, unit)
outFileName = '_'.join([projectName, 'DomainTransformation'])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
def visuRunoutStat(rasterTransfo, resAnalysis, newRasters, cfgSetup, cfgPath,
cfgFlags):
"""
Plot and save the Peak field distribution after coord transfo
used when more then 2 simulations are compared
"""
####################################
# Get input data
resType = cfgSetup['resType']
thresholdValue = cfgSetup['thresholdValue']
unit = pU.cfgPlotUtils['unit' + resType]
name = pU.cfgPlotUtils['name' + resType]
# read paths
projectName = cfgPath['projectName']
nRef = cfgPath['referenceFile']
# read data
s = rasterTransfo['s']
l = rasterTransfo['l']
indStartOfRunout = rasterTransfo['indStartOfRunout']
dataPressure = newRasters['newRaster' + resType.upper()]
rasterdataPres = dataPressure[nRef]
runout = resAnalysis['runout'][0]
PPRCrossMax = resAnalysis[resType.upper() + 'CrossMax']
############################################
# prepare for plot
pMean = np.mean(PPRCrossMax, axis=0)
pMedian = np.median(PPRCrossMax, axis=0)
pPercentile = np.percentile(PPRCrossMax, [2.5, 50, 97.5], axis=0)
maskedArray = np.ma.masked_where(rasterdataPres == 0, rasterdataPres)
cmap, _, _, norm, ticks = makePalette.makeColorMap(pU.cmapPres,
0.0,
np.nanmax(maskedArray),
continuous=pU.contCmap)
cmap.set_bad('w', 1.)
############################################
# Figure: Analysis runout
fig = plt.figure(figsize=(pU.figW * 2, pU.figH))
ax1 = plt.subplot(121)
ax1.axhline(y=np.max(runout),
color='k',
linestyle='-.',
label='runout max')
ax1.axhline(y=np.average(runout),
color='k',
linestyle='-',
label='runout mean')
ax1.axhline(y=np.min(runout), color='k', linestyle=':', label='runout min')
ax1.axhline(y=s[indStartOfRunout],
color='k',
linestyle='--',
label='start of run-out area point : %.1f °' %
resAnalysis['startOfRunoutAreaAngle'])
ref5, im = pU.NonUnifIm(ax1,
l,
s,
maskedArray,
'l [m]',
's [m]',
extent=[l.min(),
l.max(),
s.min(),
s.max()],
cmap=cmap,
norm=norm)
ax1.set_title('Peak Pressure 2D plot for the reference')
ax1.legend(loc=4)
pU.putAvaNameOnPlot(ax1, projectName)
pU.addColorBar(im, ax1, ticks, unit)
ax2 = plt.subplot(122)
ax2.fill_betweenx(s,
pPercentile[2],
pPercentile[0],
facecolor=[.8, .8, .8],
alpha=0.5,
label='quantiles')
matplotlib.patches.Patch(alpha=0.5, color=[.8, .8, .8])
ax2.plot(pMedian, s, color='r', label='median')
ax2.plot(pMean, s, color='b', label='mean')
ax2.set_title('%s distribution along the path between runs' % name)
ax2.legend(loc=4)
ax2.set_ylabel('s [m]')
ax2.set_ylim([s.min(), s.max()])
ax2.set_xlim(auto=True)
ax2.set_xlabel('$P_{max}(s)$ [%s]' % unit)
outFileName = '_'.join([
projectName, resType, 'thresholdValue',
str(thresholdValue).replace('.', 'p'), 'slComparisonStat'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
def visuRunoutComp(rasterTransfo, resAnalysis, newRasters, cfgSetup, cfgPath,
cfgFlags):
"""
Plot and save the Peak Fields distribution (max mean per cross section)
after coordinate transformation
"""
####################################
# Get input data
resType = cfgSetup['resType']
thresholdValue = cfgSetup['thresholdValue']
# read paths
projectName = cfgPath['projectName']
# read data
s = rasterTransfo['s']
l = rasterTransfo['l']
PPRCrossMax = resAnalysis['PPRCrossMax']
PPRCrossMean = resAnalysis['PPRCrossMean']
PFDCrossMax = resAnalysis['PFDCrossMax']
PFDCrossMean = resAnalysis['PFDCrossMean']
PFVCrossMax = resAnalysis['PFVCrossMax']
PFVCrossMean = resAnalysis['PFVCrossMean']
############################################
# prepare for plot
title = ['Pressure ', 'Flow Depth ', 'Flow Velocity ']
unit = ['$P(s)$ [kPa]', '$fd(s)$ [m]', '$v(s) [m.s^{-1}]$']
dataMax = np.array(([None] * 3))
dataMax[0] = PPRCrossMax
dataMax[1] = PFDCrossMax
dataMax[2] = PFVCrossMax
dataMean = np.array(([None] * 3))
dataMean[0] = PPRCrossMean
dataMean[1] = PFDCrossMean
dataMean[2] = PFVCrossMean
############################################
# Figure: Pressure depth speed
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(pU.figW * 3, pU.figH))
fig.subplots_adjust(left=0.05,
bottom=0.05,
right=0.95,
top=0.95,
hspace=0.3)
for ax, maxVal, meanVal, titleVal, unitVal in zip(axes.flatten(), dataMax,
dataMean, title, unit):
ax.plot(maxVal[0, :], s, '--k', label='Max Reference')
ax.plot(meanVal[0, :], s, '-k', label='Mean Reference')
ax.plot(maxVal[1, :], s, '--b', label='Max Simulation')
ax.plot(meanVal[1, :], s, '-b', label='Mean Simulation')
ax.set_title(titleVal + 'distribution along path')
ax.legend(loc='best')
ax.set_ylabel('s [m]')
ax.set_ylim([s.min(), s.max()])
ax.set_xlim(auto=True)
ax.set_xlabel(unitVal)
pU.putAvaNameOnPlot(ax, projectName)
outFileName = '_'.join([
projectName, resType, 'thresholdValue',
str(thresholdValue).replace('.', 'p'), 'slComparison'
])
pU.saveAndOrPlot(cfgPath, cfgFlags, outFileName, fig)
outFilePath = os.path.join(cfgPath['pathResult'], 'pics',
outFileName + '.png')
return outFilePath
def plotAllPeakFields(avaDir, cfg, cfgFLAGS, modName):
""" Plot all peak fields and return dictionary with paths to plots
Parameters
----------
avaDir : str
path to avalanche directoy
cfg : dict
configuration used to perform simulations
cfgFLAGS : str
general configuration, required to define if plots saved to reports directoy
modName : str
name of module that has been used to produce data to be plotted
Returns
-------
plotDict : dict
dictionary with info on plots, like path to plot
"""
# Load all infos on simulations
inputDir = os.path.join(avaDir, 'Outputs', modName, 'peakFiles')
peakFiles = fU.makeSimDict(inputDir, '', avaDir)
demFile = gI.getDEMPath(avaDir)
demData = IOf.readRaster(demFile)
demField = demData['rasterData']
# Output directory
if cfgFLAGS.getboolean('ReportDir'):
outDir = os.path.join(avaDir, 'Outputs', modName, 'reports')
fU.makeADir(outDir)
else:
outDir = os.path.join(avaDir, 'Outputs', 'out1Peak')
fU.makeADir(outDir)
# Initialise plot dictionary with simulation names
plotDict = {}
for sName in peakFiles['simName']:
plotDict[sName] = {}
# Loop through peakFiles and generate plot
for m in range(len(peakFiles['names'])):
# Load names and paths of peakFiles
name = peakFiles['names'][m]
fileName = peakFiles['files'][m]
avaName = peakFiles['avaName'][m]
log.debug('now plot %s:' % (fileName))
# Load data
raster = IOf.readRaster(fileName)
data = raster['rasterData']
# constrain data to where there is data
cellSize = peakFiles['cellSize'][m]
rowsMin, rowsMax, colsMin, colsMax = pU.constrainPlotsToData(
data, cellSize)
dataConstrained = data[rowsMin:rowsMax + 1, colsMin:colsMax + 1]
demConstrained = demField[rowsMin:rowsMax + 1, colsMin:colsMax + 1]
data = np.ma.masked_where(dataConstrained == 0.0, dataConstrained)
unit = pU.cfgPlotUtils['unit%s' % peakFiles['resType'][m]]
# Set extent of peak file
ny = data.shape[0]
nx = data.shape[1]
Ly = ny * cellSize
Lx = nx * cellSize
# Figure shows the result parameter data
fig = plt.figure(figsize=(pU.figW, pU.figH))
fig, ax = plt.subplots()
# choose colormap
cmap, _, _, norm, ticks = makePalette.makeColorMap(
pU.cmapPres, np.amin(data), np.amax(data), continuous=pU.contCmap)
cmap.set_bad(alpha=0)
rowsMinPlot = rowsMin * cellSize
rowsMaxPlot = (rowsMax + 1) * cellSize
colsMinPlot = colsMin * cellSize
colsMaxPlot = (colsMax + 1) * cellSize
im0 = ax.imshow(
demConstrained,
cmap='Greys',
extent=[colsMinPlot, colsMaxPlot, rowsMinPlot, rowsMaxPlot],
origin='lower',
aspect='equal')
im1 = ax.imshow(
data,
cmap=cmap,
extent=[colsMinPlot, colsMaxPlot, rowsMinPlot, rowsMaxPlot],
origin='lower',
aspect='equal')
pU.addColorBar(im1, ax, ticks, unit)
title = str('%s' % name)
ax.set_title(title)
ax.set_xlabel('x [m]')
ax.set_ylabel('y [m]')
plotName = os.path.join(outDir, '%s.%s' % (name, pU.outputFormat))
pU.putAvaNameOnPlot(ax, avaDir)
fig.savefig(plotName)
if cfgFLAGS.getboolean('showPlot'):
plt.show()
plotPath = os.path.join(os.getcwd(), plotName)
plotDict[peakFiles['simName'][m]].update(
{peakFiles['resType'][m]: plotPath})
plt.close('all')
return plotDict
def plotAllFields(avaDir, inputDir, outDir, cfg):
""" Plot all fields within given directory and save to outDir
Parameters
----------
avaDir : str
path to avalanche directoy
inputDir : str
path to input directoy
outDir : str
path to directoy where plots shall be saved to
cfg : dict
configuration settings
"""
# Load all infos on simulations
peakFiles = glob.glob(inputDir + os.sep + '*.asc')
# create out dir if not allready existing
fU.makeADir(outDir)
# Loop through peakFiles and generate plot
for filename in peakFiles:
# Load data
raster = IOf.readRaster(filename)
data = raster['rasterData']
data = np.ma.masked_where(data == 0.0, data)
name = os.path.splitext(os.path.basename(filename))[0]
# get header info for file writing
header = raster['header']
cellSize = header.cellsize
# Set extent of peak file
ny = data.shape[0]
nx = data.shape[1]
Ly = ny * cellSize
Lx = nx * cellSize
unit = pU.cfgPlotUtils['unit%s' % cfg['GENERAL']['peakVar']]
# Figure shows the result parameter data
fig = plt.figure(figsize=(pU.figW, pU.figH))
fig, ax = plt.subplots()
# choose colormap
cmap, _, _, norm, ticks = makePalette.makeColorMap(
pU.cmapPres, np.amin(data), np.amax(data), continuous=pU.contCmap)
cmap.set_bad('w')
im1 = ax.imshow(data,
cmap=cmap,
extent=[0, Lx, 0, Ly],
origin='lower',
aspect=nx / ny)
pU.addColorBar(im1, ax, ticks, unit)
title = str('%s' % name)
ax.set_title(title)
ax.set_xlabel('x [m]')
ax.set_ylabel('y [m]')
plotName = os.path.join(outDir, '%s.%s' % (name, pU.outputFormat))
pU.putAvaNameOnPlot(ax, avaDir)
fig.savefig(plotName)
plt.close('all')