def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=[8.5, 11.0])
proj = ccrs.PlateCarree(central_longitude=180)
# First two panels
min1 = metrics_dict['test']['min']
mean1 = metrics_dict['test']['mean']
max1 = metrics_dict['test']['max']
plot_panel(0, fig, proj, test, parameter.contour_levels, 'viridis', (parameter.test_name,parameter.test_title,test.units),stats=(max1,mean1,min1))
min2 = metrics_dict['ref']['min']
mean2 = metrics_dict['ref']['mean']
max2 = metrics_dict['ref']['max']
plot_panel(1, fig, proj, reference, parameter.contour_levels, 'viridis', (parameter.reference_name,parameter.reference_title,reference.units),stats=(max2,mean2,min2))
# Third panel
min3 = metrics_dict['diff']['min']
mean3 = metrics_dict['diff']['mean']
max3 = metrics_dict['diff']['max']
r = metrics_dict['misc']['rmse']
c = metrics_dict['misc']['corr']
plot_panel(2, fig, proj, diff, parameter.diff_levels, 'RdBu_r', (None,parameter.diff_title,None), stats=(max3,mean3,min3,r,c))
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.96, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir('5', parameter), parameter.output_file)
plt.savefig(fnm + '.' + f)
print('Plot saved in: ' + fnm + '.' + f)
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=[8.5, 11.0])
# proj = ccrs.PlateCarree(central_longitude=180)
proj = None
ax = fig.add_axes(panel[0])
ax.plot(test.getLatitude()[:], ma.squeeze(test.asma()), 'k', linewidth=2)
ax.plot(reference.getLatitude()[:],
ma.squeeze(reference.asma()),
'r',
linewidth=2)
ax1 = fig.add_axes(panel[1])
ax1.plot(diff.getLatitude()[:], ma.squeeze(diff.asma()), 'k', linewidth=2)
fig.text(panel[0][0],
panel[0][2] + 0.095,
"Test: " + parameter.test_name,
ha='left',
fontdict=plotSideTitle,
color='black')
fig.text(panel[0][0],
panel[0][2] + 0.07,
"Reference: " + parameter.reference_name,
ha='left',
fontdict=plotSideTitle,
color='red')
fig.text(panel[1][0],
panel[0][2] - 0.3,
"Test-Reference",
ha='left',
fontdict=plotSideTitle)
ax.set_xticks([-90, -60, -30, 0, 30, 60, 90]) #crs=ccrs.PlateCarree())
ax.set_xlim(-90, 90)
ax1.set_xticks([-90, -60, -30, 0, 30, 60, 90]) #crs=ccrs.PlateCarree())
ax1.set_xlim(-90, 90)
## lon_formatter = LongitudeFormatter(zero_direction_label=True, number_format='.0f')
lat_formatter = LatitudeFormatter()
# ax.xaxis.set_major_formatter(lon_formatter)
#ax.xaxis.set_major_formatter(lat_formatter)
#ax1.xaxis.set_major_formatter(lat_formatter)
ax.tick_params(labelsize=11.0, direction='out', pad=-2, width=1)
ax1.tick_params(labelsize=11.0, direction='out', pad=-2, width=1)
ax.xaxis.set_ticks_position('bottom')
ax1.xaxis.set_ticks_position('bottom')
ax.set_ylabel(test.long_name + ' (' + test.units + ')')
ax1.set_ylabel(test.long_name + ' (' + test.units + ')')
# ax.yaxis.set_ticks_position('left')
#
fig.suptitle(parameter.main_title, x=0.5, y=0.95, fontsize=18)
# plt.show()
#
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir('3', parameter),
parameter.output_file)
plt.savefig(fnm + '.' + f)
print('Plot saved in: ' + fnm + '.' + f)
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=parameter.figsize, dpi=parameter.dpi)
# proj = ccrs.PlateCarree(central_longitude=180)
ax = fig.add_axes(panel[0])
ax.plot(test.getLatitude()[:], ma.squeeze(test.asma()), 'k', linewidth=2)
ax.plot(reference.getLatitude()[:], ma.squeeze(
reference.asma()), 'r', linewidth=2)
ax1 = fig.add_axes(panel[1])
ax1.plot(diff.getLatitude()[:], ma.squeeze(diff.asma()), 'k', linewidth=2)
ax1.axhline(y=0, color='0.5')
test_title = "Test" if parameter.test_title == '' else parameter.test_title
test_title += ' : {}'.format(parameter.test_name_yrs)
fig.text(panel[0][0], panel[0][2] + 0.095, test_title,
ha='left', fontdict=plotSideTitle, color='black')
ref_title = "Reference" if parameter.reference_title == '' else parameter.reference_title
ref_title += ' : {}'.format(parameter.reference_name)
fig.text(panel[0][0], panel[0][2] + 0.07, ref_title,
ha='left', fontdict=plotSideTitle, color='red')
fig.text(panel[1][0], panel[0][2] - 0.3, parameter.diff_title,
ha='left', fontdict=plotSideTitle)
ax.set_xticks([-90, -60, -30, 0, 30, 60, 90]) # crs=ccrs.PlateCarree())
ax.set_xlim(-90, 90)
ax1.set_xticks([-90, -60, -30, 0, 30, 60, 90]) # crs=ccrs.PlateCarree())
ax1.set_xlim(-90, 90)
# lon_formatter = LongitudeFormatter(zero_direction_label=True, number_format='.0f')
LatitudeFormatter()
# ax.xaxis.set_major_formatter(lon_formatter)
# ax.xaxis.set_major_formatter(lat_formatter)
# ax1.xaxis.set_major_formatter(lat_formatter)
ax.tick_params(labelsize=11.0, direction='out', width=1)
ax1.tick_params(labelsize=11.0, direction='out', width=1)
ax.xaxis.set_ticks_position('bottom')
ax1.xaxis.set_ticks_position('bottom')
ax.set_ylabel(test.long_name + ' (' + test.units + ')')
ax1.set_ylabel(test.long_name + ' (' + test.units + ')')
# ax.yaxis.set_ticks_position('left')
fig.suptitle(parameter.main_title, x=0.5, y=0.95, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(
parameter.current_set, parameter), parameter.output_file)
plt.savefig(fnm + '.' + f)
_chown(fnm + '.' + f, parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=[8.5, 11.0])
# Create projection
print parameter.var_region
if parameter.var_region.find('N') !=-1:
pole = 'N'
proj = ccrs.NorthPolarStereo(central_longitude=0)
elif parameter.var_region.find('S') !=-1:
pole = 'S'
proj = ccrs.SouthPolarStereo(central_longitude=0)
# First two panels
min1 = metrics_dict['test']['min']
mean1 = metrics_dict['test']['mean']
max1 = metrics_dict['test']['max']
if test.count() >1:
plot_panel(0, fig, proj, pole, test, parameter.contour_levels, 'viridis', (parameter.test_name,parameter.test_title,test.units),stats=(max1,mean1,min1))
min2 = metrics_dict['ref']['min']
mean2 = metrics_dict['ref']['mean']
max2 = metrics_dict['ref']['max']
if reference.count() >1:
plot_panel(1, fig, proj, pole, reference, parameter.contour_levels, 'viridis', (parameter.reference_name,parameter.reference_title,reference.units),stats=(max2,mean2,min2))
# Third panel
min3 = metrics_dict['diff']['min']
mean3 = metrics_dict['diff']['mean']
max3 = metrics_dict['diff']['max']
r = metrics_dict['misc']['rmse']
c = metrics_dict['misc']['corr']
if diff.count() >1:
plot_panel(2, fig, proj, pole, diff, parameter.diff_levels, 'RdBu_r', (None,parameter.diff_title,None), stats=(max3,mean3,min3,r,c))
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.97, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir('7', parameter), parameter.output_file)
plt.savefig(fnm + '.' + f)
print('Plot saved in: ' + fnm + '.' + f)
def plot(reference, test, diff, _, parameter):
# Create figure, projection
projection = 'None'
fig = plt.figure(figsize=[8.5, 11.0])
plot_panel(0, fig, _, test, parameter.contour_levels, 'rainbow',
(parameter.test_name, parameter.test_title, test.units),
parameter)
plot_panel(
1, fig, _, reference, parameter.contour_levels, 'rainbow',
(parameter.reference_name, parameter.reference_title, test.units),
parameter)
plot_panel(2, fig, _, diff, parameter.diff_levels, parameter.diff_colormap,
(parameter.diff_name, parameter.diff_title, test.units),
parameter)
# min2 = metrics_dict['ref']['min']
# mean2 = metrics_dict['ref']['mean']
# max2 = metrics_dict['ref']['max']
# plot_panel(1, fig, proj, reference, parameter.contour_levels, 'viridis', (parameter.reference_name,parameter.reference_title,reference.units),stats=(max2,mean2,min2))
#
# # Third panel
# min3 = metrics_dict['diff']['min']
# mean3 = metrics_dict['diff']['mean']
# max3 = metrics_dict['diff']['max']
# r = metrics_dict['misc']['rmse']
# c = metrics_dict['misc']['corr']
# plot_panel(2, fig, proj, diff, parameter.diff_levels, 'RdBu_r', (None,parameter.diff_title,None), stats=(max3,mean3,min3,r,c))
#
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.96, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
plt.savefig(fnm + '.' + f)
_chown(fnm + '.' + f, parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure
fig = plt.figure(figsize=parameter.figsize, dpi=parameter.dpi)
# Top panel
ax1 = fig.add_axes(panel[0])
ax1.plot(test.getLatitude()[:], ma.squeeze(test.asma()), 'k', linewidth=2)
ax1.plot(reference.getLatitude()[:],
ma.squeeze(reference.asma()),
'r',
linewidth=2)
ax1.set_xticks([-90, -60, -30, 0, 30, 60, 90])
ax1.set_xlim(-90, 90)
ax1.tick_params(labelsize=11.0, direction='out', width=1)
ax1.xaxis.set_ticks_position('bottom')
ax1.set_ylabel(test.long_name + ' (' + test.units + ')')
test_title = "Test" if parameter.test_title == '' else parameter.test_title
test_title += ' : {}'.format(parameter.test_name_yrs)
ref_title = "Reference" if parameter.reference_title == '' else parameter.reference_title
ref_title += ' : {}'.format(parameter.reference_name)
fig.text(panel[0][0],
panel[0][1] + panel[0][3] + 0.03,
test_title,
ha='left',
fontdict=plotSideTitle,
color='black')
fig.text(panel[0][0],
panel[0][1] + panel[0][3] + 0.01,
ref_title,
ha='left',
fontdict=plotSideTitle,
color='red')
# Bottom panel
ax2 = fig.add_axes(panel[1])
ax2.plot(diff.getLatitude()[:], ma.squeeze(diff.asma()), 'k', linewidth=2)
ax2.axhline(y=0, color='0.5')
ax2.set_title(parameter.diff_title, fontdict=plotSideTitle, loc='center')
ax2.set_xticks([-90, -60, -30, 0, 30, 60, 90])
ax2.set_xlim(-90, 90)
ax2.tick_params(labelsize=11.0, direction='out', width=1)
ax2.xaxis.set_ticks_position('bottom')
ax2.set_ylabel(test.long_name + ' (' + test.units + ')')
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.95, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file + '.' + f)
plt.savefig(fnm)
# Get the filename that the user has passed in and display that.
# When running in a container, the paths are modified.
fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True),
parameter.output_file + '.' + f)
print('Plot saved in: ' + fnm)
# Save individual subplots
for f in parameter.output_format_subplot:
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
page = fig.get_size_inches()
i = 0
for p in panel:
# Extent of subplot
subpage = np.array(p).reshape(2, 2)
subpage[1, :] = subpage[0, :] + subpage[1, :]
subpage = subpage + np.array(border).reshape(2, 2)
subpage = list(((subpage) * page).flatten())
extent = matplotlib.transforms.Bbox.from_extents(*subpage)
# Save subplot
fname = fnm + '.%i.' % (i) + f
plt.savefig(fname, bbox_inches=extent)
orig_fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True), parameter.output_file)
fname = orig_fnm + '.%i.' % (i) + f
print('Sub-plot saved in: ' + fname)
i += 1
plt.close()
def plot(reference, test, diff, metrics_dict, parameter):
vcs_canvas = vcs.init(bg=True,
geometry=(parameter.canvas_size_w,
parameter.canvas_size_h))
parameter.case_id
file_path = os.path.join(acme_diags.INSTALL_PATH, 'polar')
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_7.json'))
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_7_new.json'))
template_test = vcs_canvas.gettemplate('plotset7_0_x_0')
template_ref = vcs_canvas.gettemplate('plotset7_0_x_1')
template_diff = vcs_canvas.gettemplate('plotset7_0_x_2')
template_test.title.x = 0.01
template_test.dataname.x = 0.01
template_test.dataname.y = template_test.title.y - 0.02
template_test.data.y1 -= 0.025
template_test.data.y2 -= 0.02
template_ref.title.x = 0.01
template_ref.dataname.x = 0.01
template_ref.dataname.y = template_ref.title.y - 0.02
template_ref.data.y1 -= 0.025
template_ref.data.y2 -= 0.025
template_diff.title.x = 0.01
template_diff.dataname.x = 0.01
template_diff.dataname.y = template_diff.title.y - 0.02
template_diff.data.y1 -= 0.025
template_diff.data.y2 -= 0.025
utils.set_units(test, parameter.test_units)
utils.set_units(reference, parameter.reference_units)
utils.set_units(diff, parameter.diff_units)
test.long_name = parameter.test_title
reference.long_name = parameter.reference_title
diff.long_name = parameter.diff_title
test.id = parameter.test_name_yrs
reference.id = parameter.reference_name
diff.id = parameter.diff_name
# model and observation graph
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'test')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict, 'ref')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'diff')
reference_isofill = vcs.getisofill('reference_isofill')
reference_isofill.missing = 'grey'
reference_isofill.xticlabels1 = {
0: "0",
30: "30$^\circ$E",
60: "60$^\circ$E",
90: "90$^\circ$E",
120: "120$^\circ$E",
150: "150$^\circ$E",
180: "180$^\circ$W",
210: "150$^\circ$W",
240: "120$^\circ$W",
270: "90$^\circ$W",
300: "60$^\circ$W",
330: "30$^\circ$W"
}
test_isofill = vcs.getisofill('test_isofill')
test_isofill.missing = 'grey'
test_isofill.xticlabels1 = {
0: "0",
30: "30$^\circ$E",
60: "60$^\circ$E",
90: "90$^\circ$E",
120: "120$^\circ$E",
150: "150$^\circ$E",
180: "180$^\circ$W",
210: "150$^\circ$W",
240: "120$^\circ$W",
270: "90$^\circ$W",
300: "60$^\circ$W",
330: "30$^\circ$W"
}
diff_isofill = vcs.getisofill('diff_isofill')
diff_isofill.missing = 'grey'
diff_isofill.xticlabels1 = {
0: "0",
30: "30$^\circ$E",
60: "60$^\circ$E",
90: "90$^\circ$E",
120: "120$^\circ$E",
150: "150$^\circ$E",
180: "180$^\circ$W",
210: "150$^\circ$W",
240: "120$^\circ$W",
270: "90$^\circ$W",
300: "60$^\circ$W",
330: "30$^\circ$W"
}
if parameter.var_region.lower().find('polar') != -1:
reference_isofill.projection = 'polar'
test_isofill.projection = 'polar'
diff_isofill.projection = 'polar'
if parameter.var_region.find('S') != -1:
lat_y1 = -90
lat_y2 = -55
elif parameter.var_region.find('N') != -1:
lat_y1 = 90
lat_y2 = 50
# this should extracted from selected domain
reference_isofill.datawc_y1 = lat_y1
reference_isofill.datawc_y2 = lat_y2
test_isofill.datawc_y1 = lat_y1 # this should extracted from selected domain
test_isofill.datawc_y2 = lat_y2
diff_isofill.datawc_y1 = lat_y1 # this should extracted from selected domain
diff_isofill.datawc_y2 = lat_y2
utils.set_levels_of_graphics_method(reference_isofill,
parameter.contour_levels, reference,
test)
utils.set_levels_of_graphics_method(test_isofill, parameter.contour_levels,
test, reference)
utils.set_levels_of_graphics_method(diff_isofill, parameter.diff_levels,
diff)
if parameter.arrows:
reference_isofill.ext_1 = True
reference_isofill.ext_2 = True
test_isofill.ext_1 = True
test_isofill.ext_2 = True
diff_isofill.ext_1 = True
diff_isofill.ext_2 = True
utils.set_colormap_of_graphics_method(vcs_canvas,
parameter.reference_colormap,
reference_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.test_colormap,
test_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.diff_colormap,
diff_isofill, parameter)
vcs_canvas.plot(utils.add_cyclic(test), template_test, test_isofill)
vcs_canvas.plot(utils.add_cyclic(reference), template_ref,
reference_isofill)
vcs_canvas.plot(utils.add_cyclic(diff), template_diff, diff_isofill)
utils.plot_rmse_and_corr(textcombined_objs, vcs_canvas, metrics_dict)
# Plotting the main title
main_title = utils.managetextcombined(textcombined_objs, 'main_title',
'main_title', vcs_canvas)
main_title.string = parameter.main_title
main_title.y = [0.985]
# for some reason, this needs to be before a call to vcs_canvas.plot()
vcs_canvas.portrait()
vcs_canvas.plot(main_title)
if not parameter.logo:
vcs_canvas.drawlogooff()
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
for f in parameter.output_format:
f = f.lower().split('.')[-1]
if f == 'png':
vcs_canvas.png(fnm)
_chown(fnm + '.png', parameter.user)
elif f == 'pdf':
vcs_canvas.pdf(fnm)
_chown(fnm + '.pdf', parameter.user)
elif f == 'svg':
vcs_canvas.svg(fnm)
_chown(fnm + '.svg', parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
vcs_canvas.clear()
def plot(reference, test, diff, _, parameter):
# Create figure, projection
fig = plt.figure(figsize=parameter.figsize, dpi=parameter.dpi)
plot_panel(0, fig, _, test, parameter.contour_levels, 'rainbow',
(parameter.test_name_yrs, parameter.test_title, test.units),
parameter)
plot_panel(
1, fig, _, reference, parameter.contour_levels, 'rainbow',
(parameter.reference_name, parameter.reference_title, test.units),
parameter)
plot_panel(2, fig, _, diff, parameter.diff_levels, parameter.diff_colormap,
(parameter.diff_name, parameter.diff_title, test.units),
parameter)
# min2 = metrics_dict['ref']['min']
# mean2 = metrics_dict['ref']['mean']
# max2 = metrics_dict['ref']['max']
# plot_panel(1, fig, proj, reference, parameter.contour_levels, 'viridis',
# (parameter.reference_name,parameter.reference_title,reference.units),stats=(max2,mean2,min2))
#
# # Third panel
# min3 = metrics_dict['diff']['min']
# mean3 = metrics_dict['diff']['mean']
# max3 = metrics_dict['diff']['max']
# r = metrics_dict['misc']['rmse']
# c = metrics_dict['misc']['corr']
# plot_panel(2, fig, proj, diff, parameter.diff_levels, 'RdBu_r', (None,parameter.diff_title,None), stats=(max3,mean3,min3,r,c))
#
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.96, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file + '.' + f)
plt.savefig(fnm)
# Get the filename that the user has passed in and display that.
# When running in a container, the paths are modified.
fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True),
parameter.output_file + '.' + f)
print('Plot saved in: ' + fnm)
# Save individual subplots
for f in parameter.output_format_subplot:
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
page = fig.get_size_inches()
i = 0
for p in panel:
# Extent of subplot
subpage = np.array(p).reshape(2, 2)
subpage[1, :] = subpage[0, :] + subpage[1, :]
subpage = subpage + np.array(border).reshape(2, 2)
subpage = list(((subpage) * page).flatten())
extent = matplotlib.transforms.Bbox.from_extents(*subpage)
# Save subplot
fname = fnm + '.%i.' % (i) + f
plt.savefig(fname, bbox_inches=extent)
orig_fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True), parameter.output_file)
fname = orig_fnm + '.%i.' % (i) + f
print('Sub-plot saved in: ' + fname)
i += 1
plt.close()
def plot(reference, test, diff, metrics_dict, parameter):
vcs_canvas = vcs.init(bg=True,
geometry=(parameter.canvas_size_w,
parameter.canvas_size_h))
parameter.case_id
file_path = os.path.join(acme_diags.INSTALL_PATH, 'lat_lon')
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_5.json'))
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_5_new.json'))
template_test = vcs_canvas.gettemplate('plotset5_0_x_0')
template_ref = vcs_canvas.gettemplate('plotset5_0_x_1')
template_diff = vcs_canvas.gettemplate('plotset5_0_x_2')
utils.set_units(test, parameter.test_units)
utils.set_units(reference, parameter.reference_units)
utils.set_units(diff, parameter.diff_units)
test.long_name = parameter.test_title
reference.long_name = parameter.reference_title
diff.long_name = parameter.diff_title
test.id = parameter.test_name_yrs
reference.id = parameter.reference_name
diff.id = parameter.diff_name
# model and observation graph
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'test')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict, 'ref')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'diff')
reference_isofill = vcs.getisofill('reference_isofill')
reference_isofill.missing = 'grey'
reference_isofill.yticlabels1 = {
-90: "90$^\circ$S",
-60: "60$^\circ$S",
-30: "30$^\circ$S",
0: "0$^\circ$",
30: "30$^\circ$N",
60: "60$^\circ$N",
90: "90$^\circ$N"
}
test_isofill = vcs.getisofill('test_isofill')
test_isofill.missing = 'grey'
test_isofill.yticlabels1 = {
-90: "90$^\circ$S",
-60: "60$^\circ$S",
-30: "30$^\circ$S",
0: "0$^\circ$",
30: "30$^\circ$N",
60: "60$^\circ$N",
90: "90$^\circ$N"
}
diff_isofill = vcs.getisofill('diff_isofill')
diff_isofill.missing = 'grey'
diff_isofill.yticlabels1 = {
-90: "90$^\circ$S",
-60: "60$^\circ$S",
-30: "30$^\circ$S",
0: "0$^\circ$",
30: "30$^\circ$N",
60: "60$^\circ$N",
90: "90$^\circ$N"
}
utils.set_levels_of_graphics_method(reference_isofill,
parameter.contour_levels, reference,
test)
utils.set_levels_of_graphics_method(test_isofill, parameter.contour_levels,
test, reference)
utils.set_levels_of_graphics_method(diff_isofill, parameter.diff_levels,
diff)
if parameter.arrows:
reference_isofill.ext_1 = True
reference_isofill.ext_2 = True
test_isofill.ext_1 = True
test_isofill.ext_2 = True
diff_isofill.ext_1 = True
diff_isofill.ext_2 = True
utils.set_colormap_of_graphics_method(vcs_canvas,
parameter.reference_colormap,
reference_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.test_colormap,
test_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.diff_colormap,
diff_isofill, parameter)
vcs_canvas.plot(utils.add_cyclic(test), template_test, test_isofill)
vcs_canvas.plot(utils.add_cyclic(reference), template_ref,
reference_isofill)
vcs_canvas.plot(utils.add_cyclic(diff), template_diff, diff_isofill)
utils.plot_rmse_and_corr(textcombined_objs, vcs_canvas, metrics_dict)
# for some reason, this needs to be before a call to vcs_canvas.plot()
vcs_canvas.portrait()
# Plotting the main title
main_title = utils.managetextcombined(textcombined_objs, 'main_title',
'main_title', vcs_canvas)
main_title.string = parameter.main_title
vcs_canvas.plot(main_title)
if not parameter.logo:
vcs_canvas.drawlogooff()
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
for f in parameter.output_format:
f = f.lower().split('.')[-1]
if f == 'png':
vcs_canvas.png(fnm)
_chown(fnm + '.png', parameter.user)
elif f == 'pdf':
vcs_canvas.pdf(fnm)
_chown(fnm + '.pdf', parameter.user)
elif f == 'svg':
vcs_canvas.svg(fnm)
_chown(fnm + '.svg', parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
vcs_canvas.clear()
def run_diag(parameter):
parameter.reference_data_path
parameter.test_data_path
variables = parameter.variables
seasons = parameter.seasons
ref_name = parameter.ref_name
regions = parameter.regions
for season in seasons:
try:
filename1 = utils.get_test_filename(parameter, season)
filename2 = utils.get_ref_filename(parameter, season)
except IOError as e:
print(e)
# the file for the current parameters wasn't found, move to next
# parameters
continue
print('test file: {}'.format(filename1))
print('reference file: {}'.format(filename2))
f_mod = cdms2.open(filename1)
f_obs = cdms2.open(filename2)
if parameter.short_test_name:
parameter.test_name_yrs = parameter.short_test_name
else:
parameter.test_name_yrs = parameter.test_name
try:
yrs_averaged = f_mod.getglobal('yrs_averaged')
parameter.test_name_yrs = parameter.test_name_yrs + ' (' + yrs_averaged + ')'
except:
print('No yrs_averaged exists in global attributes')
parameter.test_name_yrs = parameter.test_name_yrs
# save land/ocean fraction for masking
try:
land_frac = f_mod('LANDFRAC')
ocean_frac = f_mod('OCNFRAC')
except BaseException:
mask_path = os.path.join(acme_diags.INSTALL_PATH,
'acme_ne30_ocean_land_mask.nc')
f0 = cdms2.open(mask_path)
land_frac = f0('LANDFRAC')
ocean_frac = f0('OCNFRAC')
f0.close()
for var in variables:
print('Variable: {}'.format(var))
parameter.var_id = var
mv1 = acme.process_derived_var(var, acme.derived_variables, f_mod,
parameter)
mv2 = acme.process_derived_var(var, acme.derived_variables, f_obs,
parameter)
parameter.viewer_descr[var] = mv1.long_name if hasattr(
mv1, 'long_name') else 'No long_name attr in test data.'
# special case, cdms didn't properly convert mask with fill value
# -999.0, filed issue with denise
if ref_name == 'WARREN':
# this is cdms2 for bad mask, denise's fix should fix
mv2 = MV2.masked_where(mv2 == -0.9, mv2)
# following should move to derived variable
if ref_name == 'AIRS':
# mv2=MV2.masked_where(mv2==mv2.fill_value,mv2)
# this is cdms2 for bad mask, denise's fix should fix
mv2 = MV2.masked_where(mv2 > 1e+20, mv2)
if ref_name == 'WILLMOTT' or ref_name == 'CLOUDSAT':
print(mv2.fill_value)
# mv2=MV2.masked_where(mv2==mv2.fill_value,mv2)
# this is cdms2 for bad mask, denise's fix should fix
mv2 = MV2.masked_where(mv2 == -999., mv2)
print(mv2.fill_value)
# following should move to derived variable
if var == 'PRECT_LAND':
days_season = {
'ANN': 365,
'DJF': 90,
'MAM': 92,
'JJA': 92,
'SON': 91
}
# mv1 = mv1 * days_season[season] * 0.1 #following AMWG
# approximate way to convert to seasonal cumulative
# precipitation, need to have solution in derived variable,
# unit convert from mm/day to cm
mv2 = mv2 / days_season[season] / \
0.1 # convert cm to mm/day instead
mv2.units = 'mm/day'
if mv1.getLevel() and mv2.getLevel(): # for variables with z axis:
plev = parameter.plevs
print('Selected pressure level: {}'.format(plev))
f_ins = [f_mod, f_obs]
for f_ind, mv in enumerate([mv1, mv2]):
mv_plv = mv.getLevel()
# var(time,lev,lon,lat) convert from hybrid level to
# pressure
if mv_plv.long_name.lower().find('hybrid') != -1:
f_in = f_ins[f_ind]
hyam = f_in('hyam')
hybm = f_in('hybm')
ps = f_in('PS') # Pa
mv_p = utils.hybrid_to_plevs(mv, hyam, hybm, ps, plev)
# levels are presure levels
elif mv_plv.long_name.lower().find(
'pressure') != -1 or mv_plv.long_name.lower().find(
'isobaric') != -1:
mv_p = utils.pressure_to_plevs(mv, plev)
else:
raise RuntimeError(
"Vertical level is neither hybrid nor pressure. Abort"
)
if f_ind == 0:
mv1_p = mv_p
if f_ind == 1:
mv2_p = mv_p
# select plev
for ilev in range(len(plev)):
mv1 = mv1_p[ilev, ]
mv2 = mv2_p[ilev, ]
# select region
if len(regions) == 0:
regions = ['global']
for region in regions:
print("Selected region: {}".format(region))
mv1_domain, mv2_domain = utils.select_region(
region, mv1, mv2, land_frac, ocean_frac, parameter)
parameter.output_file = '-'.join([
ref_name, var,
str(int(plev[ilev])), season, region
])
parameter.main_title = str(' '.join(
[var,
str(int(plev[ilev])), 'mb', season, region]))
# Regrid towards lower resolution of two variables for
# calculating difference
mv1_reg, mv2_reg = utils.regrid_to_lower_res(
mv1_domain, mv2_domain, parameter.regrid_tool,
parameter.regrid_method)
# Plotting
diff = mv1_reg - mv2_reg
metrics_dict = create_metrics(mv2_domain, mv1_domain,
mv2_reg, mv1_reg, diff)
metrics_dict['unit'] = mv1_reg.units
fnm = os.path.join(
get_output_dir(parameter.current_set, parameter),
parameter.output_file + '.json')
with open(fnm, 'w') as outfile:
json.dump(metrics_dict, outfile)
# Get the filename that the user has passed in and display that.
# When running in a container, the paths are modified.
fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True),
parameter.output_file + '.json')
print('Metrics saved in: ' + fnm)
parameter.var_region = region
plot(parameter.current_set, mv2_domain, mv1_domain,
diff, metrics_dict, parameter)
utils.save_ncfiles(parameter.current_set, mv1_domain,
mv2_domain, diff, parameter)
# f_in.close()
# for variables without z axis:
elif mv1.getLevel() is None and mv2.getLevel() is None:
# select region
if len(regions) == 0:
regions = ['global']
for region in regions:
print("Selected region: {}".format(region))
mv1_domain, mv2_domain = utils.select_region(
region, mv1, mv2, land_frac, ocean_frac, parameter)
parameter.output_file = '-'.join(
[ref_name, var, season, region])
parameter.main_title = str(' '.join([var, season, region]))
# regrid towards lower resolution of two variables for
# calculating difference
mv1_reg, mv2_reg = utils.regrid_to_lower_res(
mv1_domain, mv2_domain, parameter.regrid_tool,
parameter.regrid_method)
# if var is 'SST' or var is 'TREFHT_LAND': #special case
if var == 'TREFHT_LAND' or var == 'SST': # use "==" instead of "is"
if ref_name == 'WILLMOTT':
mv2_reg = MV2.masked_where(
mv2_reg == mv2_reg.fill_value, mv2_reg)
print(ref_name)
# if mv.mask is False:
# mv = MV2.masked_less_equal(mv, mv._FillValue)
# print("*************",mv.count())
land_mask = MV2.logical_or(mv1_reg.mask, mv2_reg.mask)
mv1_reg = MV2.masked_where(land_mask, mv1_reg)
mv2_reg = MV2.masked_where(land_mask, mv2_reg)
diff = mv1_reg - mv2_reg
metrics_dict = create_metrics(mv2_domain, mv1_domain,
mv2_reg, mv1_reg, diff)
metrics_dict['unit'] = mv1_reg.units
fnm = os.path.join(
get_output_dir(parameter.current_set, parameter),
parameter.output_file + '.json')
with open(fnm, 'w') as outfile:
json.dump(metrics_dict, outfile)
# Get the filename that the user has passed in and display that.
# When running in a container, the paths are modified.
fnm = os.path.join(
get_output_dir(parameter.current_set,
parameter,
ignore_container=True),
parameter.output_file + '.json')
print('Metrics saved in: ' + fnm)
parameter.var_region = region
plot(parameter.current_set, mv2_domain, mv1_domain, diff,
metrics_dict, parameter)
utils.save_ncfiles(parameter.current_set, mv1_domain,
mv2_domain, diff, parameter)
else:
raise RuntimeError(
"Dimensions of two variables are difference. Abort")
f_obs.close()
f_mod.close()
return parameter
def create_viewer(root_dir, parameters, ext):
"""Based of the parameters, find the files with
extension ext and create the viewer in root_dir."""
viewer = OutputViewer(path=root_dir, index_name='ACME Diagnostics')
_add_pages_and_top_row(viewer, parameters)
for parameter in parameters:
for set_num in parameter.sets:
set_num = get_set_name(set_num)
# Add all of the files with extension ext from the case_id/ folder'
pth = get_output_dir(set_num, parameter) # ex: myresults/lat_lon
# Filenames are like:
# ref_name-variable-season-region
# or
# ref_name-variable-plev'mb'-season-region
ref_name = parameter.ref_name
for var in parameter.variables:
for season in parameter.seasons:
for region in parameter.regions:
row_name_and_fnm = [
] # because some parameters have plevs, there might be more than one row_name, fnm pair
if parameter.plevs == []: # 2d variables
row_name = '{} {}'.format(var, region)
fnm = '{}-{}-{}-{}'.format(ref_name, var, season,
region)
row_name_and_fnm.append((row_name, fnm))
else: # 3d variables
for plev in parameter.plevs:
row_name = '{} {} {}'.format(
var,
str(int(plev)) + ' mb', region)
fnm = '{}-{}-{}-{}-{}'.format(
ref_name, var, int(plev), season, region)
row_name_and_fnm.append((row_name, fnm))
for row_name, fnm in row_name_and_fnm:
if parameter.case_id not in ROW_INFO[set_num]:
ROW_INFO[set_num][
parameter.
case_id] = collections.OrderedDict()
if row_name not in ROW_INFO[set_num][
parameter.case_id]:
ROW_INFO[set_num][parameter.case_id][
row_name] = collections.OrderedDict()
ROW_INFO[set_num][parameter.case_id][row_name][
'descr'] = _get_description(
var, parameter)
# format fnm to support relative paths
ROW_INFO[set_num][parameter.case_id][row_name][
season] = os.path.join('..',
'{}'.format(set_num),
parameter.case_id, fnm)
# add all of the files in from the case_id/ folder in ANN, DJF, MAM, JJA, SON order
for set_num in ROW_INFO:
viewer.set_page("{}".format(_better_page_name(set_num)))
for group in ROW_INFO[set_num]:
try:
viewer.set_group(group)
except RuntimeError:
viewer.add_group(group)
for row_name in ROW_INFO[set_num][group]:
try:
viewer.set_row(row_name)
except RuntimeError:
# row of row_name wasn't in the viewer, so add it
viewer.add_row(row_name)
viewer.add_col(
ROW_INFO[set_num][group][row_name]
['descr']) # the description, currently the var
for col_season in viewer.page.columns[
1:]: # [1:] is to ignore 'Description' col
fnm = ROW_INFO[set_num][group][row_name][col_season]
formatted_files = []
if parameters[0].save_netcdf:
nc_files = [
fnm + nc_ext
for nc_ext in ['_test.nc', '_ref.nc', '_diff.nc']
]
formatted_files = [{
'url': f,
'title': f
} for f in nc_files]
viewer.add_col(fnm + '.' + ext,
is_file=True,
title=col_season,
other_files=formatted_files)
viewer.generate_viewer(prompt_user=False)
_extras(root_dir, parameters)
def plot(ref, test, diff, metrics_dict, parameters):
vcs_canvas = vcs.init(bg=True,
geometry=(parameters.canvas_size_w,
parameters.canvas_size_h))
# Line options, see here: https://uvcdat.llnl.gov/documentation/vcs/vcs-10.html
# Other options not in the above link: https://uvcdat.llnl.gov/docs/vcs/graphics/unified1D.html
ref_plot_linetype = 0
ref_plot_color = 215 # 6 to 239
ref_plot_width = 3 # 1 to 100
ref_plot_marker = 1
ref_plot_markersize = 1
ref_plot_markercolor = 215
test_plot_linetype = 0
test_plot_color = 1
test_plot_width = 3
test_plot_marker = 1
test_plot_markersize = 1
test_plot_markercolor = 1
diff_plot_linetype = 0
diff_plot_color = 1
diff_plot_width = 3
diff_plot_marker = 1
diff_plot_markersize = 1
diff_plot_markercolor = 1
file_path = os.path.join(sys.prefix, 'share', 'acme_diags', 'set3')
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_3.json'))
set_units(test, parameters.test_units)
set_units(ref, parameters.reference_units)
set_units(diff, parameters.diff_units)
if hasattr(test, 'long_name'):
test.long_name = parameters.test_title if parameters.test_title is not '' else test.long_name
if hasattr(ref, 'long_name'):
ref.long_name = parameters.reference_title if parameters.reference_title is not '' else ref.long_name
if hasattr(diff, 'long_name'):
diff.long_name = parameters.diff_title if parameters.diff_title is not '' else diff.long_name
test.id = str(
parameters.test_name) if parameters.test_name is not '' else test.id
ref.id = str(parameters.reference_name
) if parameters.reference_name is not '' else ref.id
diff.id = str(
parameters.diff_name) if parameters.diff_name is not '' else diff.id
# use vcs_canvas.show('colormap') to view all colormaps
vcs_canvas.setcolormap(
'rainbow') # 6 to 239 are purple to red in rainbow order
ref_test_template = vcs.gettemplate('ref_test_template')
ref_test_yaxis_title = managetextcombined('ref_test_yaxis_title',
'ref_test_yaxis_title',
vcs_canvas)
ref_test_yaxis_title.angle = 270
ref_test_yaxis_title.halign = 'center'
ref_test_yaxis_title.y = (ref_test_template.data.y1 +
ref_test_template.data.y2) / 2
ref_test_yaxis_title.x = ref_test_template.data.x1 - 0.08
ref_test_yaxis_title.string = test.long_name + ' (' + test.units + ')'
vcs_canvas.plot(ref_test_yaxis_title)
ref_test_template.legend.priority = 0
ref_test_template.title.priority = 0
# make all of the elements listed have priority = 0
# ref_test_template.blank(["mean", "max", "min", "zvalue", "crtime", "ytic2", "xtic2"])
# the actual box around the plot
ref_test_template.box1.x1 = 0.1223
ref_test_template.box1.x2 = 0.96
ref_test_template.box1.y1 = 0.55
ref_test_template.box1.y2 = 0.90
# data (the lines) need to be offset accordingly
ref_test_template.data.x1 = 0.1223
ref_test_template.data.x2 = 0.96
ref_test_template.data.y1 = 0.55
ref_test_template.data.y2 = 0.90
# ref_test_template.legend.x1 = 0.88
# ref_test_template.legend.x2 = 0.98
# ref_test_template.legend.y1 = 0.96
# ref_test_template.legend.y2 = 0.88
# ref_test_template.legend.textorientation = 'defright'
# ref_test_template.title.x = 0.5
# ref_test_template.title.textorientation = 'defcenter'
ref_test_template.units.textorientation = 'defright'
ref_test_template.units.x = 0.96
ref_test_template.units.y = 0.91
# labels on xaxis
ref_test_template.xlabel1.y = (0.55) - 0.02 # no xlabel1.x attribute
# actual ticks on xaxis
ref_test_template.xtic1.y1 = (0.55 - 0.005) + 0.01
ref_test_template.xtic1.y2 = (0.55 - 0.005)
# name of xaxis
# ref_test_template.xname.y += 0.29
# labels on yaxis
ref_test_template.ylabel1.x = 0.11 # no ylabel1.y attribute
# actual ticks on yaxis
ref_test_template.ytic1.x1 = (0.1223 - 0.006) + 0.01
ref_test_template.ytic1.x2 = (0.1223 - 0.006)
diff_template = vcs.gettemplate('diff_template')
diff_yaxis_title = managetextcombined('diff_yaxis_title',
'diff_yaxis_title', vcs_canvas)
diff_yaxis_title.angle = 270
diff_yaxis_title.halign = 'center'
diff_yaxis_title.y = (diff_template.data.y1 + diff_template.data.y2) / 2
diff_yaxis_title.x = diff_template.data.x1 - 0.08
diff_yaxis_title.string = test.long_name + ' (' + test.units + ')'
vcs_canvas.plot(diff_yaxis_title)
diff_template.units.textorientation = 'defright'
diff_template.units.x += 0.01
diff_template.legend.priority = 0
diff_template.ytic1.x1 = (0.1223 - 0.006) + 0.01
diff_template.ytic1.x2 = (0.1223 - 0.006)
diff_template.ylabel1.x = 0.11 # no ylabel1.y attribute
diff_template.units.textorientation = 'defright'
diff_template.units.x = 0.96
'''
diff_template.box1.y1 -= 0.47
diff_template.box1.y2 -= 0.47
diff_template.data.y1 -= 0.47
diff_template.data.y2 -= 0.47
diff_template.legend.y1 -= 0.47
diff_template.legend.y2 -= 0.47
diff_template.title.y -= 0.47
diff_template.units.y -= 0.47
diff_template.xlabel1.y -= 0.47
diff_template.xtic1.y1 -= 0.47
diff_template.xtic1.y2 -= 0.47
diff_template.xname.y -= 0.47
diff_template.yname.y -= 0.47
'''
ref_line = vcs_canvas.getxvsy('ref_plot')
ref_line.datawc_y1 = min(ref.min(), test.min())
ref_line.datawc_y2 = max(ref.max(), test.max())
ref_line.datawc_x1 = -90
ref_line.datawc_x2 = 90
ref_line.xticlabels1 = {
-90: "90S",
-60: "60S",
-30: "30S",
0: "Eq",
30: "30N",
60: "60N",
90: "90N"
}
test_line = vcs_canvas.getxvsy('test_plot')
test_line.datawc_y1 = min(ref.min(), test.min())
test_line.datawc_y2 = max(ref.max(), test.max())
test_line.datawc_x1 = -90
test_line.datawc_x2 = 90
diff_line = vcs_canvas.getxvsy('diff_plot')
diff_line.datawc_y1 = diff.min()
diff_line.datawc_y2 = diff.max()
diff_line.datawc_x1 = -90
diff_line.datawc_x2 = 90
diff_line.xticlabels1 = {
-90: "90S",
-60: "60S",
-30: "30S",
0: "Eq",
30: "30N",
60: "60N",
90: "90N"
}
#ref_line.line = ref_plot_linetype
ref_line.linetype = ref_plot_linetype
ref_line.linecolor = ref_plot_color
ref_line.linewidth = ref_plot_width
ref_line.marker = ref_plot_marker
ref_line.markersize = ref_plot_markersize
ref_line.markercolor = ref_plot_markercolor
#test_line.line = test_plot_linetype
test_line.linetype = test_plot_linetype
test_line.linecolor = test_plot_color
test_line.linewidth = test_plot_width
test_line.marker = test_plot_marker
test_line.markersize = test_plot_markersize
test_line.markercolor = test_plot_markercolor
# test_line.smooth = 1
#diff_line.line = diff_plot_linetype
diff_line.linetype = diff_plot_linetype
diff_line.linecolor = diff_plot_color
diff_line.linewidth = diff_plot_width
diff_line.marker = diff_plot_marker
diff_line.markersize = diff_plot_markersize
diff_line.markercolor = diff_plot_markercolor
blank_template = vcs_canvas.gettemplate('blank_template')
blank_template.legend.priority = 0
#blank_template.blank()
#blank_template.legend.priority = 1
#blank_template.legend.y1 -= 0.05
#blank_template.legend.y2 -= 0.05
# vcs_canvas.plot(ref, ref_line, ref_test_template, xname='Latitude')
vcs_canvas.plot(ref, ref_line, ref_test_template)
vcs_canvas.plot(test, test_line, blank_template)
# vcs_canvas.plot(diff, diff_line, diff_template, xname='Latitude')
vcs_canvas.plot(diff, diff_line, diff_template)
# Plot the main title
main_title = managetextcombined('main_title', 'main_title', vcs_canvas)
main_title.string = parameters.main_title
vcs_canvas.portrait(
) # for some reason, this needs to be before a call to vcs_canvas.plot()
vcs_canvas.plot(main_title)
test_title = managetextcombined('test_title', 'test_title', vcs_canvas)
test_title.string = "Test: " + str(parameters.test_name)
test_title.color = 1
test_title.x = ref_test_template.data.x1 - 0.05
test_title.y = ref_test_template.data.y2 + 0.045
test_title.height = 12
vcs_canvas.plot(test_title)
ref_title = managetextcombined('ref_title', 'ref_title', vcs_canvas)
ref_title.string = "Reference: " + str(parameters.reference_name)
ref_title.color = 215
ref_title.x = ref_test_template.data.x1 - 0.05
ref_title.y = ref_test_template.data.y2 + 0.025
ref_title.height = 12
vcs_canvas.plot(ref_title)
if not parameters.logo:
vcs_canvas.drawlogooff()
# ref_test_template.script('plot_set_3.json')
# blank_template.script('plot_set_3.json')
# diff_template.script('plot_set_3.json')
# ref_line.script('plot_set_3.json')
# test_line.script('plot_set_3.json')
# diff_line.script('plot_set_3.json')
# main_title.script('plot_set_3.json')
# ref_test_yaxis_title.script('plot_set_3.json')
# diff_yaxis_title.script('plot_set_3.json')
# test_title.script('plot_set_3.json')
# ref_title.script('plot_set_3.json')
fnm = os.path.join(get_output_dir('3', parameters), parameters.output_file)
for f in parameters.output_format:
f = f.lower().split('.')[-1]
if f == 'png':
vcs_canvas.png(fnm)
elif f == 'pdf':
vcs_canvas.pdf(fnm)
elif f == 'svg':
vcs_canvas.svg(fnm)
print('Plot saved in: ' + fnm + '.' + f)
vcs_canvas.clear()
def plot(reference, test, diff, metrics_dict, parameter):
vcs_canvas = vcs.init(bg=True, geometry=(parameter.canvas_size_w, parameter.canvas_size_h))
case_id = parameter.case_id
file_path = os.path.join(sys.prefix, 'share', 'acme_diags', 'set7')
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_7.json'))
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_7_new.json'))
template_test = vcs_canvas.gettemplate('plotset7_0_x_0')
template_ref = vcs_canvas.gettemplate('plotset7_0_x_1')
template_diff = vcs_canvas.gettemplate('plotset7_0_x_2')
template_test.title.x = 0.01
template_test.dataname.x = 0.01
template_test.dataname.y = template_test.title.y - 0.02
template_test.data.y1 -= 0.025
template_test.data.y2 -= 0.02
template_ref.title.x = 0.01
template_ref.dataname.x = 0.01
template_ref.dataname.y = template_ref.title.y - 0.02
template_ref.data.y1 -= 0.025
template_ref.data.y2 -= 0.025
template_diff.title.x = 0.01
template_diff.dataname.x = 0.01
template_diff.dataname.y = template_diff.title.y - 0.02
template_diff.data.y1 -= 0.025
template_diff.data.y2 -= 0.025
set_units(test, parameter.test_units)
set_units(reference, parameter.reference_units)
set_units(diff, parameter.diff_units)
test.long_name = parameter.test_title
reference.long_name = parameter.reference_title
diff.long_name = parameter.diff_title
test.id = parameter.test_name
reference.id = parameter.reference_name
diff.id = parameter.diff_name
# model and observation graph
plot_min_max_mean(vcs_canvas, metrics_dict, 'test')
plot_min_max_mean(vcs_canvas, metrics_dict, 'ref')
plot_min_max_mean(vcs_canvas, metrics_dict, 'diff')
reference_isofill = vcs.getisofill('reference_isofill')
reference_isofill.missing = 'grey'
test_isofill = vcs.getisofill('test_isofill')
test_isofill.missing = 'grey'
diff_isofill = vcs.getisofill('diff_isofill')
diff_isofill.missing = 'grey'
if parameter.var_region.lower().find('polar') !=-1:
reference_isofill.projection = 'polar'
test_isofill.projection = 'polar'
diff_isofill.projection = 'polar'
if parameter.var_region.find('S') !=-1:
lat_y1 = -90
lat_y2 = -55
elif parameter.var_region.find('N') !=-1:
lat_y1 = 90
lat_y2 = 50
reference_isofill.datawc_y1 = lat_y1 # this should extracted from selected domain
reference_isofill.datawc_y2 = lat_y2
test_isofill.datawc_y1 = lat_y1 # this should extracted from selected domain
test_isofill.datawc_y2 = lat_y2
diff_isofill.datawc_y1 = lat_y1 # this should extracted from selected domain
diff_isofill.datawc_y2 = lat_y2
set_levels_of_graphics_method(reference_isofill, parameter.contour_levels, reference, test)
set_levels_of_graphics_method(test_isofill, parameter.contour_levels, test, reference)
set_levels_of_graphics_method(diff_isofill, parameter.diff_levels, diff)
if parameter.arrows:
reference_isofill.ext_1 = True
reference_isofill.ext_2 = True
test_isofill.ext_1 = True
test_isofill.ext_2 = True
diff_isofill.ext_1 = True
diff_isofill.ext_2 = True
set_colormap_of_graphics_method(vcs_canvas, parameter.reference_colormap, reference_isofill)
set_colormap_of_graphics_method(vcs_canvas, parameter.test_colormap, test_isofill)
set_colormap_of_graphics_method(vcs_canvas, parameter.diff_colormap, diff_isofill)
vcs_canvas.plot(add_cyclic(test), template_test, test_isofill)
vcs_canvas.plot(add_cyclic(reference), template_ref, reference_isofill)
vcs_canvas.plot(add_cyclic(diff), template_diff, diff_isofill)
plot_rmse_and_corr(vcs_canvas, metrics_dict)
# Plotting the main title
main_title = managetextcombined('main_title', 'main_title', vcs_canvas)
main_title.string = parameter.main_title
main_title.y = [0.985]
vcs_canvas.portrait() # for some reason, this needs to be before a call to vcs_canvas.plot()
vcs_canvas.plot(main_title)
if not parameter.logo:
vcs_canvas.drawlogooff()
fnm = os.path.join(get_output_dir('7', parameter), parameter.output_file)
for f in parameter.output_format:
f = f.lower().split('.')[-1]
if f == 'png':
vcs_canvas.png(fnm)
elif f == 'pdf':
vcs_canvas.pdf(fnm)
elif f == 'svg':
vcs_canvas.svg(fnm)
print('Plot saved in: ' + fnm + '.' + f)
vcs_canvas.clear()
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=parameter.figsize, dpi=parameter.dpi)
# Create projection
print(parameter.var_region)
if parameter.var_region.find('N') != -1:
pole = 'N'
proj = ccrs.NorthPolarStereo(central_longitude=0)
elif parameter.var_region.find('S') != -1:
pole = 'S'
proj = ccrs.SouthPolarStereo(central_longitude=0)
# First two panels
min1 = metrics_dict['test']['min']
mean1 = metrics_dict['test']['mean']
max1 = metrics_dict['test']['max']
if test.count() > 1:
plot_panel(0, fig, proj, pole, test, parameter.contour_levels, parameter.test_colormap, [
parameter.test_name_yrs, parameter.test_title, test.units], parameter, stats=(max1, mean1, min1))
min2 = metrics_dict['ref']['min']
mean2 = metrics_dict['ref']['mean']
max2 = metrics_dict['ref']['max']
if reference.count() > 1:
plot_panel(1, fig, proj, pole, reference, parameter.contour_levels, parameter.reference_colormap, [
parameter.reference_name, parameter.reference_title, reference.units], parameter, stats=(max2, mean2, min2))
# Third panel
min3 = metrics_dict['diff']['min']
mean3 = metrics_dict['diff']['mean']
max3 = metrics_dict['diff']['max']
r = metrics_dict['misc']['rmse']
c = metrics_dict['misc']['corr']
if diff.count() > 1:
plot_panel(2, fig, proj, pole, diff, parameter.diff_levels, parameter.diff_colormap, [
None, parameter.diff_title, None], parameter, stats=(max3, mean3, min3, r, c))
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.97, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(parameter.current_set,
parameter), parameter.output_file + '.' + f)
plt.savefig(fnm)
# Get the filename that the user has passed in and display that.
# When running in a container, the paths are modified.
fnm = os.path.join(get_output_dir(parameter.current_set, parameter,
ignore_container=True), parameter.output_file + '.' + f)
print('Plot saved in: ' + fnm)
# Save individual subplots
for f in parameter.output_format_subplot:
fnm = os.path.join(get_output_dir(
parameter.current_set, parameter), parameter.output_file)
page = fig.get_size_inches()
i = 0
for p in panel:
# Extent of subplot
subpage = np.array(p).reshape(2,2)
subpage[1,:] = subpage[0,:] + subpage[1,:]
subpage = subpage + np.array(border).reshape(2,2)
subpage = list(((subpage)*page).flatten())
extent = matplotlib.transforms.Bbox.from_extents(*subpage)
# Save subplot
fname = fnm + '.%i.' %(i) + f
plt.savefig(fname, bbox_inches=extent)
orig_fnm = os.path.join(get_output_dir(parameter.current_set, parameter,
ignore_container=True), parameter.output_file)
fname = orig_fnm + '.%i.' %(i) + f
print('Sub-plot saved in: ' + fname)
i += 1
plt.close()
def plot(reference, test, diff, metrics_dict, parameter):
# Create figure, projection
fig = plt.figure(figsize=parameter.figsize, dpi=parameter.dpi)
# proj = ccrs.PlateCarree(central_longitude=180)
proj = None
# First two panels
min1 = metrics_dict['test']['min']
mean1 = metrics_dict['test']['mean']
max1 = metrics_dict['test']['max']
plot_panel(0,
fig,
proj,
test,
parameter.contour_levels,
parameter.test_colormap,
(parameter.test_name_yrs, parameter.test_title, test.units),
parameter,
stats=(max1, mean1, min1))
min2 = metrics_dict['ref']['min']
mean2 = metrics_dict['ref']['mean']
max2 = metrics_dict['ref']['max']
plot_panel(
1,
fig,
proj,
reference,
parameter.contour_levels,
parameter.reference_colormap,
(parameter.reference_name, parameter.reference_title, reference.units),
parameter,
stats=(max2, mean2, min2))
# Third panel
min3 = metrics_dict['diff']['min']
mean3 = metrics_dict['diff']['mean']
max3 = metrics_dict['diff']['max']
r = metrics_dict['misc']['rmse']
c = metrics_dict['misc']['corr']
plot_panel(2,
fig,
proj,
diff,
parameter.diff_levels,
parameter.diff_colormap, (None, parameter.diff_title, None),
parameter,
stats=(max3, mean3, min3, r, c))
# Figure title
fig.suptitle(parameter.main_title, x=0.5, y=0.96, fontsize=18)
# Save figure
for f in parameter.output_format:
f = f.lower().split('.')[-1]
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
plt.savefig(fnm + '.' + f)
_chown(fnm + '.' + f, parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
# Save individual subplots
for f in parameter.output_format_subplot:
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
page = fig.get_size_inches()
i = 0
for p in panel:
# Extent of subplot
subpage = np.array(p).reshape(2, 2)
subpage[1, :] = subpage[0, :] + subpage[1, :]
subpage = subpage + np.array(border).reshape(2, 2)
subpage = list(((subpage) * page).flatten())
extent = matplotlib.transforms.Bbox.from_extents(*subpage)
# Save suplot
fname = fnm + '.%i.' % (i) + f
plt.savefig(fname, bbox_inches=extent)
_chown(fname, parameter.user)
print('Sub-plot saved in: ' + fname)
i += 1
plt.close()
def create_viewer(root_dir, parameters, ext):
"""Based of the parameters, find the files with
extension ext and create the viewer in root_dir."""
viewer = OutputViewer(path=root_dir, index_name='ACME Diagnostics')
add_pages_and_top_row(viewer, parameters)
for parameter in parameters:
for set_num in parameter.sets:
viewer.set_page("Set-{}".format(set_num))
try:
viewer.set_group(parameter.case_id)
except RuntimeError:
viewer.add_group(parameter.case_id)
# Add all of the files with extension ext from the case_id/ folder'
pth = get_output_dir(set_num, parameter)
files = glob.glob(
pth + '/*.' + ext
) # ex: files[0] = myresults/set5/set5_SST_HadISST/HadISST_CL-SST-SON-global.png
for ext_fnm in files:
fnm = ext_fnm.replace('.' + ext, '')
fnm = fnm.split('/')[-1] # ex: HadISST_CL-SST-SON-global
keywords = fnm.split('-')
# 2d vars, format is [ref_name, var, season, region]
# 3d vars, format is [ref_name, var, plev, season, region]
# ref_name and/or var can be something_like_this, so we always use negative indices
ref_name = keywords[0]
region = keywords[-1]
season = keywords[-2]
if keywords[-3].isdigit(
): # for when we have a 3d variable, ex: keywords[-3] = 880
plev = keywords[-3]
var = keywords[-4]
else:
plev = None
var = keywords[-3]
if plev is None: # 2d variable
#row_name = '%s %s %s' % (ref_name, var, region)
row_name = '%s %s' % (var, region)
else: # 3d variable
#row_name = '%s %s %s %s' % (ref_name, var, plev + ' mb ', region)
row_name = '%s %s %s' % (var, plev + ' mb ', region)
try:
viewer.set_row(row_name)
except RuntimeError:
# row of row_name wasn't in the viewer, so add it
viewer.add_row(row_name)
viewer.add_col(var) # the description
if parameter.case_id not in ROW_INFO[set_num]:
ROW_INFO[set_num][parameter.case_id] = {}
if row_name not in ROW_INFO[set_num][parameter.case_id]:
ROW_INFO[set_num][parameter.case_id][row_name] = {}
# format fnm to support relative paths
ROW_INFO[set_num][
parameter.case_id][row_name][season] = os.path.join(
'set{}'.format(set_num), parameter.case_id, fnm)
# add all of the files in from the case_id/ folder in ANN, DJF, MAM, JJA, SON order
for set_num in ROW_INFO:
viewer.set_page("Set-{}".format(set_num))
for group in ROW_INFO[set_num]:
viewer.set_group(group)
for row_name in ROW_INFO[set_num][group]:
viewer.set_row(row_name)
for col_season in viewer.page.columns[
1:]: # [1:] is to ignore 'Description' col
if col_season in ROW_INFO[set_num][group][row_name]:
fnm = ROW_INFO[set_num][group][row_name][col_season]
nc_files = [
fnm + nc_ext
for nc_ext in ['_test.nc', '_ref.nc', '_diff.nc']
]
formatted_files = [{
'url': f,
'title': f
} for f in nc_files]
viewer.add_col(fnm + '.' + ext,
is_file=True,
title=col_season,
other_files=formatted_files)
else:
# insert a blank value
# is_file must be True, otherwise OutputViewer indexes incorrectly
viewer.add_col('-----', is_file=True)
viewer.generate_viewer(prompt_user=False)
def plot(reference, test, diff, metrics_dict, parameter):
vcs_canvas = vcs.init(bg=True,
geometry=(parameter.canvas_size_w,
parameter.canvas_size_h))
case_id = parameter.case_id
reference = rotate_180(reference)
test = rotate_180(test)
diff = rotate_180(diff)
file_path = os.path.join(sys.prefix, 'share', 'acme_diags',
'zonal_mean_2d')
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_4.json'))
vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_4_new.json'))
template_test = vcs_canvas.gettemplate('plotset4_0_x_0')
template_ref = vcs_canvas.gettemplate('plotset4_0_x_1')
template_diff = vcs_canvas.gettemplate('plotset4_0_x_2')
utils.set_units(test, parameter.test_units)
utils.set_units(reference, parameter.reference_units)
utils.set_units(diff, parameter.diff_units)
test.long_name = parameter.test_title
reference.long_name = parameter.reference_title
diff.long_name = parameter.diff_title
test.id = parameter.test_name
reference.id = parameter.reference_name
diff.id = parameter.diff_name
# model and observation graph
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'test')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict, 'ref')
utils.plot_min_max_mean(textcombined_objs, vcs_canvas, metrics_dict,
'diff')
reference_isofill = vcs.getisofill('reference_isofill')
reference_isofill.missing = 'grey'
reference = log_yaxis(reference, reference_isofill)
test_isofill = vcs.getisofill('test_isofill')
test_isofill.missing = 'grey'
test = log_yaxis(test, test_isofill)
diff_isofill = vcs.getisofill('diff_isofill')
diff_isofill.missing = 'grey'
diff = log_yaxis(diff, diff_isofill)
utils.set_levels_of_graphics_method(reference_isofill,
parameter.contour_levels, reference,
test)
utils.set_levels_of_graphics_method(test_isofill, parameter.contour_levels,
test, reference)
utils.set_levels_of_graphics_method(diff_isofill, parameter.diff_levels,
diff)
if parameter.arrows:
reference_isofill.ext_1 = True
reference_isofill.ext_2 = True
test_isofill.ext_1 = True
test_isofill.ext_2 = True
diff_isofill.ext_1 = True
diff_isofill.ext_2 = True
utils.set_colormap_of_graphics_method(vcs_canvas,
parameter.reference_colormap,
reference_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.test_colormap,
test_isofill, parameter)
utils.set_colormap_of_graphics_method(vcs_canvas, parameter.diff_colormap,
diff_isofill, parameter)
vcs_canvas.plot(test, template_test, test_isofill)
vcs_canvas.plot(reference, template_ref, reference_isofill)
vcs_canvas.plot(diff, template_diff, diff_isofill)
utils.plot_rmse_and_corr(textcombined_objs, vcs_canvas, metrics_dict)
# Plotting the main title
main_title = utils.managetextcombined(textcombined_objs, 'main_title',
'main_title', vcs_canvas)
main_title.string = parameter.main_title
vcs_canvas.portrait(
) # for some reason, this needs to be before a call to vcs_canvas.plot()
vcs_canvas.plot(main_title)
if not parameter.logo:
vcs_canvas.drawlogooff()
fnm = os.path.join(get_output_dir(parameter.current_set, parameter),
parameter.output_file)
for f in parameter.output_format:
f = f.lower().split('.')[-1]
if f == 'png':
vcs_canvas.png(fnm)
_chown(fnm + '.png', parameter.user)
elif f == 'pdf':
vcs_canvas.pdf(fnm)
_chown(fnm + '.pdf', parameter.user)
elif f == 'svg':
vcs_canvas.svg(fnm)
_chown(fnm + '.svg', parameter.user)
print('Plot saved in: ' + fnm + '.' + f)
vcs_canvas.clear()
