def main(inargs):
"""Run the program."""
df = pd.read_csv(inargs.infile)
fig, axes =plt.subplots(1,2)
sns.set(style="whitegrid")
sns.boxplot(x="project", y="regression coefficient", hue="comparison",
data=df[df['realm'] == 'energy'], ax=axes[0], palette='hot')
axes[0].set_title('(a) energy budget')
axes[0].set_ylim(-0.25, 1.75)
axes[0].axhline(y=1.0, color='0.5', linewidth=0.2)
axes[0].xaxis.label.set_visible(False)
set_legend(axes[0])
sns.boxplot(x="project", y="regression coefficient", hue="comparison",
data=df[df['realm'] == 'mass'], ax=axes[1], palette='GnBu_r')
axes[1].set_title('(b) mass budget')
axes[1].set_ylim(-0.25, 1.75)
axes[1].axhline(y=1.0, color='0.5', linewidth=0.2)
axes[1].xaxis.label.set_visible(False)
set_legend(axes[1])
for ax in axes.flat:
ax.label_outer()
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=400)
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(git_repo=repo_dir)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
df = pandas.read_csv(inargs.infile)
colors = {'historical': 'black', 'GHG-only': 'red', 'AA-only': 'blue'}
fig, ax = plt.subplots(figsize=(16, 10))
offset = lambda p: transforms.ScaledTranslation(p / 72., 0,
plt.gcf().dpi_scale_trans)
trans = plt.gca().transData
for experiment in ['historical', 'GHG-only', 'AA-only']:
toa_vals = numpy.array(
df.loc[(df['variable'] == 'netTOA')
& (df['experiment'] == experiment)]['accumulated_heat'])
ohu_vals = numpy.array(
df.loc[(df['variable'] == 'OHU')
& (df['experiment'] == experiment)]['accumulated_heat'])
ohc_vals = numpy.array(
df.loc[(df['variable'] == 'OHC')
& (df['experiment'] == experiment)]['accumulated_heat'])
xvals = numpy.arange(toa_vals.shape[0])
plt.scatter(xvals,
toa_vals,
c=colors[experiment],
marker='s',
transform=trans + offset(-5))
plt.scatter(xvals, ohu_vals, c=colors[experiment])
plt.scatter(xvals,
ohc_vals,
c=colors[experiment],
marker='D',
transform=trans + offset(5))
plt.ticklabel_format(style='sci',
axis='y',
scilimits=(0, 0),
useMathText=True)
ax.yaxis.major.formatter._useMathText = True
plt.xticks(xvals, list(df.model.unique()), rotation=40, ha='right')
ax.axhline(y=0, color='0.5', linestyle='--', linewidth=0.5)
add_legends()
plt.ylabel('J')
plt.savefig(inargs.outfile, bbox_inches='tight')
log_text = cmdprov.new_log(git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
metadata_dict = {}
time_constraint = gio.get_time_constraint(
[inargs.start_date, inargs.end_date])
fig = plt.figure(figsize=[11, 10])
if inargs.rndt_files:
rndt_nh, rndt_sh = read_hemisphere_data(inargs.rndt_files, 'rndt',
time_constraint, inargs.ensagg)
iplt.plot(rndt_nh, label='netTOA, NH', color='red', linestyle='solid')
iplt.plot(rndt_sh, label='netTOA, SH', color='red', linestyle='dashed')
if inargs.hfds_files:
hfds_nh, hfds_sh = read_hemisphere_data(inargs.hfds_files, 'hfds',
time_constraint, inargs.ensagg)
iplt.plot(hfds_nh, label='OHU, NH', color='orange', linestyle='solid')
iplt.plot(hfds_sh, label='OHU, SH', color='orange', linestyle='dashed')
if inargs.ohc_files:
ohc_nh, ohc_sh = read_hemisphere_data(inargs.ohc_files, 'ohc',
time_constraint, inargs.ensagg)
iplt.plot(ohc_nh, label='OHC, NH', color='blue', linestyle='solid')
iplt.plot(ohc_sh, label='OHC, SH', color='blue', linestyle='dashed')
if inargs.ohc_guide_files:
guide_nh, guide_sh = read_guide_data(inargs.ohc_guide_files, 'ohc',
time_constraint, inargs.ensagg)
iplt.plot(guide_nh,
label='OHC guide, NH',
color='0.5',
linestyle='solid')
iplt.plot(guide_sh,
label='OHC guide, SH',
color='0.5',
linestyle='dashed')
plt.legend()
if inargs.ybounds:
ymin, ymax = inargs.ybounds
plt.ylim([ymin, ymax])
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = cmdprov.new_log(
git_repo=repo_dir) # infile_history={nh_file: history}
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time_bounds)
basin_names = ['atlantic', 'indian', 'pacific', 'land']
anomaly_data = {}
start_data = {}
data = []
model_list = []
for filenum, infile in enumerate(inargs.infiles):
cube, anomaly_data, start = get_data(infile, inargs.var,
time_constraint)
units = cube.units
cum_change = anomaly_data[-1, :]
model = cube.attributes[
'source_id'] if 'source_id' in cube.attributes else cube.attributes[
'model_id']
ntimes = anomaly_data.shape[0]
pct_change = ((cum_change / ntimes) / np.absolute(start)) * 100
total_cum_change = cum_change.sum()
total_start = start.sum()
total_pct_change = ((total_cum_change / ntimes) / total_start) * 100
pct_change_anomaly = pct_change - total_pct_change
model_list.append(model)
for basin in range(4):
data.append([
model, basin_names[basin], start[basin], cum_change[basin],
pct_change[basin], pct_change_anomaly[basin]
])
df = pd.DataFrame(data,
columns=[
'model', 'basin', 'start', 'cumulative_change',
'percentage_change', 'percentage_change_anomaly'
])
model_list.sort()
experiment = cube.attributes['experiment_id']
plot_ensemble_lines(df, inargs.var, model_list, experiment, str(units),
inargs.ymax)
plt.savefig(inargs.outfile, bbox_inches='tight')
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(
infile_history={inargs.infiles[-1]: cube.attributes['history']},
git_repo=repo_dir)
cmdprov.write_log(log_file, log_text)
csv_file = re.sub('.png', '.csv', inargs.outfile)
df.to_csv(csv_file)
def main(inargs):
"""Run the program."""
metadata_dict = {}
nplots = len(inargs.contourf_files)
if inargs.contour_files:
assert len(inargs.contour_files) == nplots
fig, cbar_ax, gs = grid_config(nplots)
for pnum in range(nplots):
contourf_cube = iris.load_cube(inargs.contourf_files[pnum],
inargs.variable)
metadata_dict[
inargs.contourf_files[pnum]] = contourf_cube.attributes['history']
if inargs.rescale:
depth_values = numpy.arange(0.5, 5500, 1)
lat_values = numpy.arange(-89.5, 90.5, 1)
ref_cube = make_grid(depth_values, lat_values)
contourf_cube = regrid(contourf_cube, ref_cube)
if inargs.contour_files:
contour_cube = iris.load_cube(inargs.contour_files[pnum],
inargs.variable)
metadata_dict[inargs.contour_files[
pnum]] = contour_cube.attributes['history']
else:
contour_cube = None
title = inargs.titles[pnum] if inargs.titles else None
create_plot(gs[pnum],
cbar_ax,
contourf_cube,
contour_cube,
inargs.scale_factor,
inargs.nyrs,
title,
ticks=inargs.ticks,
rescale=inargs.rescale)
# Save output
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def write_rec_file(root: str, main_extension=None, infiles=[]):
'''
Write log file for input extension.
root: input file root
main_extension: input file extension
infiles: list of all input files that may have logs attached
'''
inlogs = {}
for file in infiles:
get_inlog(file, inlogs)
outlog = cmdprov.new_log(infile_history=inlogs)
outlog_file = get_rec_file_root(root, main_extension)
print('writing', outlog_file)
cmdprov.write_log(outlog_file, outlog)
def main(inargs):
"""Run the program."""
df = pd.read_csv(inargs.infile)
df.set_index(df['model'] + ' (' + df['run'] + ')', drop=True, inplace=True)
if inargs.domain == 'energy':
plot_energy_conservation(df, inargs.cmip_line)
elif inargs.domain == 'mass':
plot_mass_conservation(df, inargs.cmip_line)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=200)
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(git_repo=repo_dir)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
assert inargs.var in [
'precipitation_minus_evaporation_flux', 'water_flux_into_sea_water',
'water_evapotranspiration_flux', 'precipitation_flux'
]
cmap = 'BrBG'
basins_to_plot = [
'Atlantic', 'Indian', 'Pacific', 'Land', 'Ocean', 'Globe'
]
if inargs.var == 'precipitation_minus_evaporation_flux':
var_abbrev = 'P-E'
elif inargs.var == 'water_evapotranspiration_flux':
var_abbrev = 'evaporation'
cmap = 'BrBG_r'
elif inargs.var == 'precipitation_flux':
var_abbrev = 'precipitation'
elif inargs.var == 'water_flux_into_sea_water':
var_abbrev = 'net mositure import/export (i.e. P-E+R)'
basins_to_plot = ['Atlantic', 'Indian', 'Pacific', 'Arctic', 'Globe']
time_constraint = gio.get_time_constraint(inargs.time_bounds)
input_files = [
inargs.control_files, inargs.ghg_files, inargs.aa_files,
inargs.hist_files
]
experiments = ['piControl', 'GHG-only', 'AA-only', 'historical']
metadata_dict = {}
fig, axes = plt.subplots(2, 2, figsize=(24, 12))
axes = axes.flatten()
for plotnum, exp_files in enumerate(input_files):
if exp_files:
experiment = experiments[plotnum]
print(f"Number of {experiment} models = {len(exp_files)}")
time_selector = None if experiment == 'piControl' else time_constraint
file_history = plot_data(axes[plotnum], exp_files, inargs,
experiment, var_abbrev, time_selector,
inargs.scale_factor[plotnum],
basins_to_plot, cmap)
metadata_dict[exp_files[0]] = file_history[0]
plt.savefig(inargs.outfile, bbox_inches='tight')
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
time_constraints = {'historical-rcp85': gio.get_time_constraint(inargs.rcp_time),
'historical': gio.get_time_constraint(inargs.historical_time),
'GHG-only': gio.get_time_constraint(inargs.historical_time),
'AA-only': gio.get_time_constraint(inargs.historical_time),
'1pctCO2': gio.get_time_constraint(inargs.pctCO2_time)}
fig = plt.figure(figsize=[20, 7])
ax1 = fig.add_subplot(1, 2, 1)
ax2 = fig.add_subplot(1, 2, 2)
for experiment_num, experiment in enumerate(inargs.experiment_list):
time_constraint = time_constraints[experiment]
ita_cube_list = iris.cube.CubeList([])
eei_cube_list = iris.cube.CubeList([])
for model_num in range(0, len(inargs.toa_files[experiment_num])):
toa_file = inargs.toa_files[experiment_num][model_num]
thetao_sh_file = inargs.thetao_sh_files[experiment_num][model_num]
thetao_nh_file = inargs.thetao_nh_files[experiment_num][model_num]
ita_cube, ita_history = calc_ita(thetao_sh_file, thetao_nh_file, time_constraint, model_num)
ita_cube_list.append(ita_cube)
eei_cube, eei_history = calc_eei(toa_file, time_constraint, model_num)
eei_cube_list.append(eei_cube)
ita_ensemble_agg = ensemble_aggregation(ita_cube_list, inargs.ensagg)
ita_ensemble_spread = ensemble_aggregation(ita_cube_list, 'percentile')
eei_ensemble_agg = ensemble_aggregation(eei_cube_list, inargs.ensagg)
temporal_plot(ax1, ita_ensemble_agg, ita_ensemble_spread, experiment)
eei_plot(ax2, eei_ensemble_agg, ita_ensemble_agg, experiment)
ylim = temporal_plot_features(ax1)
eei_plot_features(ax2, ylim)
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams']['figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
infile_metadata = {thetao_nh_file: ita_history, toa_file: eei_history}
log_text = cmdprov.new_log(infile_history=infile_metadata, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
df = pd.read_csv(inargs.infile)
df.set_index(df['model'], drop=True, inplace=True)
#df.set_index(df['model'] + ' (' + df['run'] + ')', drop=True, inplace=True)
x = np.arange(df.shape[0])
ncmip5 = df['project'].value_counts()['cmip5']
df_ohc = df[[
'OHC (J yr-1)', 'thermal OHC (J yr-1)', 'barystatic OHC (J yr-1)'
]]
sec_in_year = 365.25 * 24 * 60 * 60
earth_surface_area = 5.1e14
df_ohc = (df_ohc / sec_in_year) / earth_surface_area
df_ohc = df_ohc.rename(
columns={
"OHC (J yr-1)":
"change in OHC ($dH/dt$)",
"thermal OHC (J yr-1)":
"change in OHC temperature component ($dH_T/dt$)",
"barystatic OHC (J yr-1)":
"change in OHC barystatic component ($dH_m/dt$)"
})
df_ohc.plot.bar(figsize=(18, 6),
color=['#272727', 'tab:red', 'tab:blue'],
width=0.9,
zorder=2)
plt.axhspan(0.4, 1.0, color='0.95', zorder=1)
plt.axvline(x=ncmip5 - 0.5, color='0.5', linewidth=2.0)
units = 'equivalent planetary energy imbalance (W m$^{-2}$)'
plt.ylabel(units)
plt.axvline(x=x[0] - 0.5, color='0.5', linewidth=0.1)
for val in x:
plt.axvline(x=val + 0.5, color='0.5', linewidth=0.1)
quartiles = get_quartiles(df_ohc, "change in OHC ($dH/dt$)", df['project'],
units)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=400)
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(git_repo=repo_dir, extra_notes=quartiles)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
warnings.filterwarnings('ignore')
assert inargs.mask[1] in ['ocean', 'land'], "domain must be ocean or land"
cube = read_data(inargs.infile, inargs.month)
cube = apply_mask(cube, inargs.mask[0], inargs.mask[1])
#pdb.set_trace()
cube = convert_pr_units(cube)
clim = cube.collapsed('time', iris.analysis.MEAN)
plot_data(clim,
inargs.month,
gridlines=inargs.gridlines,
levels=inargs.cbar_levs)
plt.savefig(inargs.outfile)
new_log = cmdprov.new_log(
infile_history={inargs.infile: cube.attributes['history']})
fname, extension = inargs.outfile.split('.')
cmdprov.write_log(fname + '.txt', new_log)
def main(inargs):
"""Run the program."""
inlogs = {}
my_log = cmdprov.new_log()
cube = read_data(inargs.infile, inargs.month)
inlogs[inargs.infile] = cube.attributes['history'] #add data history
cube = convert_pr_units(cube)
if type(inargs.mask) is list:
assert inargs.mask[1] == 'land' or inargs.mask[
1] == 'ocean', 'mask should specify land or ocean'
cube = mask_data(cube, inargs.mask[0], inargs.mask[1])
inlogs[inargs.mask[0]] = cube.attributes['history'] #add mask history
clim = cube.collapsed('time', iris.analysis.MEAN)
plot_data(clim, inargs.month, inargs.gridlines, inargs.cbar_levels)
plt.savefig(inargs.outfile + '.png')
my_log = cmdprov.new_log(infile_history=inlogs, git_repo='.')
cmdprov.write_log(inargs.outfile + '.log', my_log)
def main(inargs):
"""Run the program."""
dset = xr.open_dataset(inargs.pr_file)
clim = dset['pr'].groupby('time.season').mean('time', keep_attrs=True)
clim = convert_pr_units(clim)
if inargs.mask:
sftlf_file, realm = inargs.mask
clim = apply_mask(clim, sftlf_file, realm)
create_plot(clim, dset.attrs['model_id'], inargs.season,
gridlines=inargs.gridlines, levels=inargs.cbar_levels)
plt.savefig(inargs.output_file, dpi=200)
new_log = cmdprov.new_log(infile_history={inargs.pr_file: dset.attrs['history']})
fname, extension = inargs.output_file.split('.')
cmdprov.write_log(fname+'.txt', new_log)
def main(inargs):
"""Run the program."""
cube = read_data(inargs.infile, inargs.month)
cube = convert_pr_units(cube)
clim = cube.collapsed('time', iris.analysis.MEAN)
if inargs.mask:
sftlf_file, realm = inargs.mask
sftlf_cube = iris.load_cube(sftlf_file, 'land_area_fraction')
clim = apply_mask(clim, sftlf_cube, realm)
plot_data(clim, inargs.month, gridlines=inargs.gridlines,
levels=inargs.cbar_levels)
plt.savefig(inargs.outfile)
new_log = cmdprov.new_log(infile_history={inargs.infile: cube.attributes['history']})
fname, extension = inargs.outfile.split('.')
cmdprov.write_log(fname+'.txt', new_log)
def main(args):
"""Run the program."""
experiments = ['GHG-only', 'AA-only', 'historical']
letters = ['(a) ', '(b) ', '(c) ']
file_dict, nfiles = sort_files(args)
start_year = args.time_bounds[0][0:4]
end_year = args.time_bounds[1][0:4]
var_names = {
'precipitation_flux': 'precipitation',
'water_evapotranspiration_flux': 'evaporation',
'precipitation_minus_evaporation_flux': 'P-E'
}
var_name = var_names[args.var]
ylabel = f"time integrated {var_name} anomaly, {start_year}-{end_year} (kg)"
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
time_constraint = gio.get_time_constraint(args.time_bounds)
for plotnum, exp in enumerate(experiments):
data = []
for modelnum, infile in enumerate(file_dict[exp]):
cube, history = get_data(infile, args.var, time_constraint)
try:
model = cube.attributes['model_id']
except KeyError:
model = cube.attributes['source_id']
data.append([model, 'Atlantic', cube.data[0]])
data.append([model, 'Indian', cube.data[2]])
data.append([model, 'Pacific', cube.data[1]])
data.append([model, 'Land', cube.data[5]])
df = pd.DataFrame(data, columns=['model', 'basin', ylabel])
title = letters[plotnum] + exp
plot_data(axes[plotnum], df, title, ylabel, model_dots=args.dots)
plt.savefig(args.outfile, bbox_inches='tight')
metadata_dict = {file_dict['historical'][-1]: history}
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', args.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
metadata_dict = {}
# Read data
control_cube, control_history = read_data(inargs.control_files, inargs.variable,
inargs.grid_point, convert_to_annual=inargs.annual)
metadata_dict[inargs.control_files[0]] = control_history
coord_names = [coord.name() for coord in control_cube.dim_coords]
time_var = coord_names[0]
assert time_var in ['time', 'year']
experiment_cube, experiment_history = read_data(inargs.experiment_files, inargs.variable,
inargs.grid_point, convert_to_annual=inargs.annual)
metadata_dict[inargs.experiment_files[0]] = experiment_history
if inargs.dedrifted_files:
dedrifted_cube, dedrifted_history = read_data(inargs.dedrifted_files, inargs.variable,
inargs.grid_point, convert_to_annual=inargs.annual)
metadata_dict[inargs.dedrifted_files[0]] = dedrifted_history
if inargs.coefficient_file:
cubic_data, a_cube = cubic_fit(inargs.coefficient_file, inargs.grid_point,
control_cube.coord(time_var).points)
#TODO: coeff metadata
# Time axis adjustment
if time_var == 'time':
first_data_cube = iris.load_cube(inargs.experiment_files[0], gio.check_iris_var(inargs.variable))
if inargs.grid_point:
first_data_cube = select_point(first_data_cube, inargs.grid_point, timeseries=True)
if inargs.annual:
first_data_cube = timeseries.convert_to_annual(first_data_cube)
time_diff, branch_time, new_time_unit = remove_drift.time_adjustment(first_data_cube, control_cube, 'annual',
branch_time=inargs.branch_time)
print(f'branch time: {branch_time - 182.5}')
time_coord = experiment_cube.coord('time')
time_coord.convert_units(new_time_unit)
experiment_time_values = time_coord.points.astype(numpy.float32) - time_diff
elif time_var == 'year':
if not inargs.branch_year == None:
branch_year = inargs.branch_year
else:
if not inargs.control_time_units:
control_time_units = gio.fix_time_descriptor(experiment_cube.attributes['parent_time_units'])
else:
control_time_units = inargs.control_time_units.replace("_", " ")
branch_time = experiment_cube.attributes['branch_time_in_parent']
branch_datetime = cf_units.num2date(branch_time, control_time_units, cf_units.CALENDAR_STANDARD)
branch_year = branch_datetime.year
print(f'branch year: {branch_year}')
experiment_time_values = numpy.arange(branch_year, branch_year + experiment_cube.shape[0])
# Plot
fig = plt.figure(figsize=[14, 7])
plt.plot(control_cube.coord(time_var).points, control_cube.data, label='control')
plt.plot(experiment_time_values, experiment_cube.data, label='experiment')
if inargs.dedrifted_files:
plt.plot(experiment_time_values, dedrifted_cube.data, label='dedrifted')
if inargs.coefficient_file:
plt.plot(control_cube.coord(time_var).points, cubic_data, label='cubic fit')
if inargs.outlier_threshold:
data, outlier_idx = timeseries.outlier_removal(control_cube.data, inargs.outlier_threshold)
plt.plot(control_cube.coord(time_var).points[outlier_idx], control_cube.data[outlier_idx],
marker='o', linestyle='none', color='r', alpha=0.3)
if inargs.ylim:
ymin, ymax = inargs.ylim
plt.ylim(ymin, ymax)
plt.ylabel(f"{gio.check_iris_var(inargs.variable)} ({control_cube.units})")
if time_var == 'time':
plt.xlabel(str(new_time_unit))
else:
plt.xlabel('control run year')
plt.legend()
if inargs.grid_point:
title = get_title(inargs.control_files[0], inargs.variable, inargs.grid_point)
plt.title(title)
# Save output
plt.savefig(inargs.outfile, bbox_inches='tight')
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(args):
"""Run the program."""
infiles = sorted(args.infiles)
var_names = {
'precipitation_flux': 'precipitation',
'water_evapotranspiration_flux': 'evaporation',
'precipitation_minus_evaporation_flux': 'P-E'
}
var_name = var_names[args.var]
ylabel = f"annual mean {var_name} (kg)"
fig, axes = plt.subplots(1, 2, figsize=(12, 6))
region_data = []
basin_data = []
nfiles = len(infiles)
print(f"Number models: {nfiles}")
for modelnum in range(nfiles):
cube, history = gio.combine_files(infiles[modelnum], args.var)
cube = cube.collapsed('time', iris.analysis.MEAN)
cube.remove_coord('time')
try:
model = cube.attributes['model_id']
except KeyError:
model = cube.attributes['source_id']
# cube(time, pereg, basin)
# pereg: SH_precip SH_evap tropical_precip NH_evap NH_precip globe
# basin: atlantic pacific indian arctic marginal_seas land ocean globe
region_data.append([model, 'SH-P', cube.data[0, -1]])
region_data.append([model, 'SH-E', cube.data[1, -1]])
region_data.append([model, 'T-P', cube.data[2, -1]])
region_data.append([model, 'NH-E', cube.data[3, -1]])
region_data.append([model, 'NH-P', cube.data[4, -1]])
basin_data.append([model, 'Atlantic', cube.data[-1, 0]])
basin_data.append([model, 'Indian', cube.data[-1, 2]])
basin_data.append([model, 'Pacific', cube.data[-1, 1]])
basin_data.append([model, 'Land', cube.data[-1, 5]])
region_df = pd.DataFrame(region_data,
columns=['model', 'P-E region', ylabel])
basin_df = pd.DataFrame(basin_data, columns=['model', 'basin', ylabel])
plot_data(axes[0],
region_df,
'P-E region',
ylabel,
'(a) meridional climatology',
model_dots=args.dots)
plot_data(axes[1],
basin_df,
'basin',
ylabel,
'(b) zonal climatology',
model_dots=args.dots)
plt.savefig(args.outfile, bbox_inches='tight')
metadata_dict = {infiles[-1]: history[0]}
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', args.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
volo_models = [
'CNRM-CM6-1', 'CNRM-ESM2-1', 'E3SM-1-0', 'E3SM-1-1', 'EC-Earth3',
'EC-Earth3-Veg', 'IPSL-CM6A-LR'
]
cpocean_dict = {'HadGEM3-GC31-LL': 3991.867957, 'UKESM1-0-LL': 3991.867957}
rhozero_dict = {'HadGEM3-GC31-LL': 1026, 'UKESM1-0-LL': 1026}
if inargs.colors:
colors = iter(inargs.colors)
else:
colors = iter(plt.cm.rainbow(numpy.linspace(0, 1, len(inargs.models))))
if inargs.linestyles:
styles = iter(inargs.linestyles)
else:
styles = iter([
'-', '--', ':', '-', '--', ':', '-', '--', ':', '-', '--', ':',
'-', '--', ':'
])
if inargs.manual_files:
with open(inargs.manual_files, 'r') as reader:
manual_files = yaml.load(reader)
else:
manual_files = {}
fig = plt.figure(figsize=[14, 8])
nrows = 2
ncols = 2
ax_ohc = fig.add_subplot(nrows, ncols, 1)
ax_ohcd = fig.add_subplot(nrows, ncols, 2)
ax_masso = fig.add_subplot(nrows, ncols, 3)
ax_massod = fig.add_subplot(nrows, ncols, 4)
#ax_massa = fig.add_subplot(nrows, ncols, 5)
#ax_massad = fig.add_subplot(nrows, ncols, 6)
max_time = 0
count = 0
for model, run in zip(inargs.models, inargs.runs):
print(model, run)
extra_log.append(['# ' + model + ', ' + run])
# OHC and masso
if model in volo_models:
volo = read_global_variable(model, 'volo', run, manual_files)
rhozero = 1026
masso = volo * rhozero
else:
masso = read_global_variable(model, 'masso', run, manual_files)
thetaoga = read_global_variable(model, 'thetaoga', run, manual_files)
thetaoga = gio.temperature_unit_check(thetaoga, 'K')
masso, thetaoga = common_time_period(masso, thetaoga)
cp = cpocean_dict[model] if model in cpocean_dict.keys() else 4000
ohc = masso.data * thetaoga.data * cp
if inargs.ohc_outlier:
ohc, outlier_idx = timeseries.outlier_removal(
ohc, inargs.ohc_outlier)
if outlier_idx:
print('%s (%s) outliers:' % (model, run), outlier_idx)
if inargs.runmean_window:
ohc = timeseries.runmean(ohc, inargs.runmean_window)
masso = timeseries.runmean(masso.data, inargs.runmean_window)
ohc_anomaly = ohc - ohc[0]
masso_anomaly = masso - masso[0]
ohc_dedrifted = dedrift_data(ohc_anomaly)
masso_dedrifted = dedrift_data(masso_anomaly)
ohc_dedrifted_anomaly = ohc_dedrifted - ohc_dedrifted[0]
masso_dedrifted_anomaly = masso_dedrifted - masso_dedrifted[0]
label = model #'%s (%s)' %(model, run)
color = next(colors)
style = next(styles)
ax_ohc.plot(ohc_anomaly, color=color, label=label, linestyle=style)
record_trend(ohc_anomaly, 'OHC linear trend', 'C/yr')
ax_ohcd.plot(ohc_dedrifted_anomaly,
color=color,
label=label,
linestyle=style)
ax_masso.plot(masso_anomaly, color=color, label=label, linestyle=style)
record_trend(masso_anomaly, 'Mass linear trend', 'kg/yr')
ax_massod.plot(masso_dedrifted_anomaly,
color=color,
label=label,
linestyle=style)
if len(ohc) > max_time:
max_time = len(ohc)
# massa
#massa = read_global_variable(model, 'massa', run, manual_files)
#if inargs.runmean_window:
# massa = timeseries.runmean(massa.data, inargs.runmean_window)
#massa_anomaly = massa - massa[0]
#massa_dedrifted = dedrift_data(massa_anomaly)
#massa_dedrifted_anomaly = massa_dedrifted - massa_dedrifted[0]
#ax_massa.plot(massa_anomaly, color=color, label=label, linestyle=style)
#record_trend(massa_anomaly, 'Atmospheric water mass linear trend', 'kg/yr')
#ax_massad.plot(massa_dedrifted_anomaly, color=color, label=label, linestyle=style)
ax_ohc.plot()
ax_ohc.set_title('(a) OHC')
ax_ohc.set_ylabel('OHC anomaly (J)')
ax_ohc.grid(linestyle=':')
ax_ohc.ticklabel_format(useOffset=False)
ax_ohc.yaxis.major.formatter._useMathText = True
plot_reference_eei(ax_ohc, 0.4, max_time)
plot_reference_eei(ax_ohc, 0.2, max_time)
plot_reference_eei(ax_ohc, 0.1, max_time)
plot_reference_eei(ax_ohc, -0.4, max_time)
plot_reference_eei(ax_ohc, -0.2, max_time)
plot_reference_eei(ax_ohc, -0.1, max_time)
ax_ohcd.set_title('(b) OHC (linear trend removed)')
ax_ohcd.set_ylabel('OHC anomaly (J)')
ax_ohcd.grid(linestyle=':')
ax_ohcd.ticklabel_format(useOffset=False)
ax_ohcd.yaxis.major.formatter._useMathText = True
ax_masso.set_title('(c) ocean mass')
ax_masso.set_xlabel('year')
ax_masso.set_ylabel('ocean mass anomaly (kg)')
ax_masso.grid(linestyle=':')
ax_masso.ticklabel_format(useOffset=False)
ax_masso.yaxis.major.formatter._useMathText = True
plot_reference_mass(ax_masso, 0.0018, max_time)
plot_reference_mass(ax_masso, 0.0009, max_time)
plot_reference_mass(ax_masso, 0.00045, max_time)
plot_reference_mass(ax_masso, -0.0018, max_time)
plot_reference_mass(ax_masso, -0.0009, max_time)
plot_reference_mass(ax_masso, -0.00045, max_time)
ax_massod.set_title('(d) ocean mass (linear trend removed)')
ax_massod.set_xlabel('year')
ax_massod.set_ylabel('ocean mass anomaly (kg)')
ax_massod.grid(linestyle=':')
ax_massod.ticklabel_format(useOffset=False)
ax_massod.yaxis.major.formatter._useMathText = True
ax_massod.legend(loc='center left', bbox_to_anchor=(1, 1))
#ax_massa.set_title('(e) atmos water mass')
#ax_massa.set_xlabel('year')
#ax_massa.set_ylabel('kg')
#ax_massa.grid(linestyle=':')
#ax_massa.ticklabel_format(useOffset=False)
#ax_massa.yaxis.major.formatter._useMathText = True
#ax_massad.set_title('(f) atmos water mass (linear trend removed)')
#ax_massad.set_xlabel('year')
#ax_massad.set_ylabel('kg')
#ax_massad.grid(linestyle=':')
#ax_massad.ticklabel_format(useOffset=False)
#ax_massad.yaxis.major.formatter._useMathText = True
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = get_log_text(extra_log)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
# Process data
bmin, bmax = inargs.bin_bounds
bin_edges = numpy.arange(bmin, bmax + inargs.bin_width, inargs.bin_width)
xvals = (bin_edges[1:] + bin_edges[:-1]) / 2
label_counts = initialise_label_counts(inargs.labels)
ref_datasets = ['EN4']
hist_dict = collections.OrderedDict()
metadata_dict = {}
for groupnum, infiles in enumerate(inargs.data_files):
label = inargs.labels[groupnum]
print(label)
vfile = inargs.volume_files[groupnum]
bfile = inargs.basin_files[groupnum]
ref = (label in ref_datasets) and len(inargs.labels) > 1
vcube, bcube, time_constraint = read_supporting_inputs(vfile,
bfile,
inargs,
ref=ref)
dcube = combine_infiles(infiles, inargs, time_constraint)
metadata_dict = update_metadata(metadata_dict, vfile, vcube, bfile,
bcube, infiles[0], dcube)
voldist_timeseries = numpy.array([])
V_timeseries = numpy.array([])
for time_slice in dcube.slices_over('time'):
df = create_df(time_slice,
inargs.variable,
vcube,
bcube,
basin=inargs.basin,
abort=operator.not_(inargs.no_abort))
voldist, edges, binnum = scipy.stats.binned_statistic(
df[inargs.variable].values,
df['volume'].values,
statistic='sum',
bins=bin_edges)
V = voldist.cumsum()
voldist_timeseries = numpy.vstack([
voldist_timeseries, voldist
]) if voldist_timeseries.size else voldist
V_timeseries = numpy.vstack([V_timeseries, V
]) if V_timeseries.size else V
for metric in inargs.metrics:
hist_dict[(label, metric, label_counts[label])] = calc_metric(
voldist_timeseries, V_timeseries, metric)
label_counts[label] = label_counts[label] + 1
# Plot individual model/run results
nrows, ncols = inargs.subplot_config
fig, axes = plt.subplots(nrows, ncols, figsize=(9 * ncols, 6 * nrows))
for plotnum, metric in enumerate(inargs.metrics):
ax = axes.flatten()[plotnum] if type(axes) == numpy.ndarray else axes
labelnum = 0
labelled = []
for key, yvals in hist_dict.items():
label, dict_metric, count = key
if dict_metric == metric:
if not ((label in ref_datasets) and
(metric not in ['dV/dT', 'dV/dS'])):
plot_label = label if not label in labelled else None
ax.plot(xvals,
yvals,
'o-',
color=inargs.colors[labelnum],
label=plot_label)
labelled.append(label)
labelnum = labelnum + 1
ax.set_title(metric_names[metric])
xlabel, ylabel = get_labels(time_slice, inargs.variable, metric)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.grid(True)
set_axis_limits(ax, plotnum, inargs.xlim, inargs.ylim)
if metric in ['dVdt/dVdT', 'dVdt/dVdS']:
ax.legend(loc=2)
else:
ax.legend(loc=1)
plt.ticklabel_format(style='sci',
axis='y',
scilimits=(0, 0),
useMathText=True)
ax.yaxis.major.formatter._useMathText = True
title = get_title(dcube, inargs.basin)
plt.suptitle(title)
# Save output
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
# Metadata
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
metadata_dict = {}
ensemble_dict = {
'historical': iris.cube.CubeList([]),
'historicalGHG': iris.cube.CubeList([]),
'historicalMisc': iris.cube.CubeList([])
}
depth_constraint = gio.iris_vertical_constraint(inargs.min_depth,
inargs.max_depth)
new_grid = make_grid(
numpy.arange(inargs.min_depth + 0.5, inargs.max_depth, 1))
experiment_list = []
for infile in inargs.infiles:
cube = iris.load_cube(
infile,
gio.check_iris_var(inargs.var) & depth_constraint)
depth_cube = collapse_dims(cube, inargs.dimagg)
experiment = cube.attributes['experiment_id']
experiment_list.append(experiment)
ensemble_number = experiment_list.count(experiment)
new_aux_coord = iris.coords.AuxCoord(ensemble_number,
long_name='ensemble_member',
units='no_unit')
depth_cube.add_aux_coord(new_aux_coord)
if inargs.regrid or inargs.ensagg:
new_depth_cube = regrid(depth_cube, new_grid)
else:
new_depth_cube = depth_cube
ensemble_dict[experiment].append(new_depth_cube)
fig = plt.figure(figsize=[10, 30])
enswidth = 2.0
ilinewidth = enswidth * 0.25 if inargs.ensagg else enswidth
for experiment in ['historical', 'historicalGHG', 'historicalMisc']:
for num, cube in enumerate(ensemble_dict[experiment]):
label = experiment if (num == 1) and not inargs.ensagg else False
plot_data(cube, experiment, label=label, linewidth=ilinewidth)
if inargs.ensagg:
ensagg_cube = ensemble_aggregate(ensemble_dict[experiment],
inargs.ensagg)
plot_data(ensagg_cube, experiment, label=experiment, linewidth=2.0)
plt.gca().invert_yaxis()
plt.ylim([inargs.max_depth, inargs.min_depth])
plt.legend()
if inargs.xbounds:
xmin, xmax = inargs.xbounds
plt.xlim([xmin, xmax])
plt.grid(True)
plt.xlabel(str(cube.units))
plt.ylabel('Depth (m)')
plt.title('Excess heat storage, 1861-2005')
# Save output
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
fig, ax = plt.subplots(figsize=[14, 7])
nexperiments = len(inargs.hist_files) + len(inargs.rcp_files) + len(
inargs.control_files)
# Plot historical data
for infiles in inargs.hist_files:
data_dict, experiment, ylabel, metadata_dict = plot_file(
infiles, inargs.hist_time, inargs, nexperiments)
# Plot control data
if inargs.control_files:
assert inargs.hist_files, 'Control plot requires branch time information from historical files'
ref_cube = data_dict.popitem()[1]
if inargs.full_control:
time_bounds = None
else:
plot_start_time = inargs.hist_time[0]
plot_end_time = inargs.rcp_time[
-1] if inargs.rcp_files else inargs.hist_time[-1]
time_bounds = [plot_start_time, plot_end_time]
for infiles in inargs.control_files:
data_dict, experiment, ylabel, metadata_dict = plot_file(
infiles,
time_bounds,
inargs,
nexperiments,
ref_cube=ref_cube,
branch_index=inargs.branch_index,
branch_time=inargs.branch_time)
# Plot rcp data
for infiles in inargs.rcp_files:
data_dict, experiment, ylabel, metadata_dict = plot_file(
infiles, inargs.rcp_time, inargs, nexperiments)
if inargs.title:
plt.title(inargs.title)
else:
title = get_title(inargs.var, experiment, nexperiments)
plt.title(title)
if inargs.ylim:
ymin, ymax = inargs.ylim
plt.ylim(ymin, ymax)
#plt.ylim(-4e+23, 8e+23)
if inargs.scientific:
plt.ticklabel_format(style='sci',
axis='y',
scilimits=(0, 0),
useMathText=True,
useOffset=False)
ax.yaxis.major.formatter._useMathText = True
ax.set_ylabel(ylabel)
ax.yaxis.major.formatter._useOffset = False
if inargs.zero_line:
plt.axhline(y=0, color='0.5', linestyle='--')
if inargs.legloc:
ax.legend(loc=inargs.legloc)
else:
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
ax.legend(loc='center left', bbox_to_anchor=(1.0, 0.5))
ymin, ymax = plt.ylim()
print('ymin:', ymin)
print('ymax:', ymax)
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
fname, extension = inargs.outfile.split('.')
new_log = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
cmdprov.write_log(fname + '.met', new_log)
def main(inargs):
"""Run the program."""
time_constraints = {
'historical': gio.get_time_constraint(inargs.hist_time),
'historical-rcp85': gio.get_time_constraint(inargs.hist_time),
'historicalGHG': gio.get_time_constraint(inargs.hist_time),
'historicalMisc': gio.get_time_constraint(inargs.hist_time),
'1pctCO2': gio.get_time_constraint(inargs.pctCO2_time)
}
file_variables = ['rndt', 'hfds', 'ohc']
column_list = []
ylabel = get_ylabel(inargs.toa_files, inargs.ohu_files, inargs.ohc_files)
nregions = len(inargs.regions)
figtype = '.' + inargs.outfile.split('.')[-1]
for var_index, var_files in enumerate(
[inargs.toa_files, inargs.ohu_files, inargs.ohc_files]):
var = file_variables[var_index]
for model_files in var_files:
for exp_index, file_group in enumerate([
model_files[i:i + nregions]
for i in range(0, len(model_files), nregions)
]):
experiment = inargs.experiments[exp_index]
time_constraint = time_constraints[experiment]
values, model, history = calc_hemispheric_heat(
file_group, inargs.regions, var, experiment,
time_constraint)
column_list = generate_heat_row_dicts(column_list, values,
inargs.regions, model,
experiment, var, ylabel)
heat_df = pandas.DataFrame(column_list)
write_values(heat_df, ylabel, file_variables, inargs.experiments,
inargs.regions, inargs.outfile, figtype)
color_list = get_colors(inargs.experiments)
seaborn.set_style("whitegrid")
fig, ax = plt.subplots(figsize=(16, 10))
g = seaborn.catplot(x="hemisphere",
y=ylabel,
hue="experiment",
col="variable",
data=heat_df,
kind="bar",
palette=color_list)
g.set_titles("{col_name}")
plt.ticklabel_format(style='sci',
axis='y',
scilimits=(0, 0),
useMathText=True)
ax.yaxis.major.formatter._useMathText = True
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = cmdprov.new_log(infile_history={file_group[-1]: history},
git_repo=repo_dir)
log_file = re.sub(figtype, '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
df = pd.read_csv(inargs.infile)
#df.set_index(df['model'] + ' (' + df['run'] + ')', drop=True, inplace=True)
df.set_index(df['model'], drop=True, inplace=True)
if inargs.cmip_line:
cmip_line = inargs.cmip_line
else:
ncmip5 = df['project'].value_counts()['cmip5']
cmip_line = ncmip5 - 0.5
print('x-value for CMIP dividing line:', cmip_line)
df['atmos energy leakage (J yr-1)'] = df['netTOA (J yr-1)'] - df[
'hfdsgeou (J yr-1)']
df['ocean energy leakage (J yr-1)'] = df['hfdsgeou (J yr-1)'] - df[
'thermal OHC (J yr-1)']
df['total energy leakage (J yr-1)'] = df['netTOA (J yr-1)'] - df[
'thermal OHC (J yr-1)']
df_leakage = df[[
'total energy leakage (J yr-1)', 'atmos energy leakage (J yr-1)',
'ocean energy leakage (J yr-1)'
]]
df_leakage = df_leakage.dropna(axis=0, how='all')
x = np.arange(df_leakage.shape[0])
sec_in_year = 365.25 * 24 * 60 * 60
earth_surface_area = 5.1e14
df_leakage = (df_leakage / sec_in_year) / earth_surface_area
df_leakage = df_leakage.rename(
columns={
"total energy leakage (J yr-1)":
"total leakage ($dQ_r/dt - dH_T/dt$)",
"ocean energy leakage (J yr-1)":
"ocean leakage ($dQ_h/dt - dH_T/dt$)",
"atmos energy leakage (J yr-1)":
"non-ocean leakage ($dQ_r/dt - dQ_h/dt$)"
})
if inargs.split_axes:
fig, (ax1, ax2,
ax3) = plt.subplots(3,
1,
sharex=True,
figsize=(18, 8),
gridspec_kw={'height_ratios': [1, 5, 1]})
ax1.spines['bottom'].set_visible(False)
ax2.spines['bottom'].set_visible(False)
ax1.tick_params(axis='x', which='both', bottom=False)
ax2.tick_params(axis='x', which='both', bottom=False)
ax2.spines['top'].set_visible(False)
ax3.spines['top'].set_visible(False)
ax1.set_ylim(30, 45)
ax2.set_ylim(-1.5, 2.5)
ax3.set_ylim(-45, -30)
df_leakage.plot(ax=ax3,
kind='bar',
color=['tab:olive', 'tab:green', 'tab:blue'],
width=0.9,
legend=False)
df_leakage.plot(ax=ax2,
kind='bar',
color=['tab:olive', 'tab:green', 'tab:blue'],
width=0.9,
legend=False)
df_leakage.plot(ax=ax1,
kind='bar',
color=['tab:olive', 'tab:green', 'tab:blue'],
width=0.9)
for tick in ax3.get_xticklabels():
tick.set_rotation(90)
plt.subplots_adjust(hspace=0.15)
ax1.axvline(x=cmip_line, color='0.5', linewidth=2.0)
ax2.axvline(x=cmip_line, color='0.5', linewidth=2.0)
ax3.axvline(x=cmip_line, color='0.5', linewidth=2.0)
ax2.axhline(y=-0.5, color='0.5', linewidth=0.5, linestyle='--')
ax2.axhline(y=0.5, color='0.5', linewidth=0.5, linestyle='--')
ax2.set_ylabel('$W \; m^{-2}$')
ax1.axvline(x=x[0] - 0.5, color='0.5', linewidth=0.1)
ax2.axvline(x=x[0] - 0.5, color='0.5', linewidth=0.1)
ax3.axvline(x=x[0] - 0.5, color='0.5', linewidth=0.1)
for val in x:
ax1.axvline(x=val + 0.5, color='0.5', linewidth=0.1)
ax2.axvline(x=val + 0.5, color='0.5', linewidth=0.1)
ax3.axvline(x=val + 0.5, color='0.5', linewidth=0.1)
else:
df_leakage.plot.bar(figsize=(18, 6),
color=['tab:olive', 'tab:green', 'tab:blue'],
width=0.9,
zorder=2)
plt.axvline(x=cmip_line, color='0.5', linewidth=2.0)
plt.axhspan(0.4, 1.0, color='0.95', zorder=1)
plt.axhspan(-0.4, -1.0, color='0.95', zorder=1)
units = 'equivalent planetary energy imbalance (W m$^{-2}$)'
plt.ylabel(units)
plt.axvline(x=x[0] - 0.5, color='0.5', linewidth=0.1)
for val in x:
plt.axvline(x=val + 0.5, color='0.5', linewidth=0.1)
plt.ylim(-1.5, 2.5)
column_names = [
"total leakage ($dQ_r/dt - dH_T/dt$)",
"ocean leakage ($dQ_h/dt - dH_T/dt$)",
"non-ocean leakage ($dQ_r/dt - dQ_h/dt$)"
]
quartiles = get_quartiles(df_leakage, column_names, df['project'], units)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=400)
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(git_repo=repo_dir, extra_notes=quartiles)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
plot_vars, plot_files = get_plot_vars(inargs)
nvars = len(plot_vars)
nrows, ncols = grid_configs[nvars]
fig = plt.figure(figsize=[11 * ncols, 7 * nrows])
gs = gridspec.GridSpec(nrows, ncols, wspace=0.27, hspace=0.25)
axes = []
for index in range(nvars):
axes.append(plt.subplot(gs[index]))
time_constraints = {
'historical-rcp85': gio.get_time_constraint(inargs.rcp_time),
'historical': gio.get_time_constraint(inargs.historical_time),
'GHG-only': gio.get_time_constraint(inargs.historical_time),
'AA-only': gio.get_time_constraint(inargs.historical_time),
'1pctCO2': gio.get_time_constraint(inargs.pctCO2_time)
}
for experiment_num, experiment in enumerate(inargs.experiment_list):
time_constraint = time_constraints[experiment]
ensemble_agg_dict = {}
ensemble_spread_dict = {}
for var_index, var_files in enumerate(plot_files):
var = plot_vars[var_index]
cube_list = iris.cube.CubeList([])
for model_num, model_files in enumerate(var_files):
start = experiment_num * 2
sh_file, nh_file = model_files[start:start + 2]
value, history = calc_hemispheric_value(
sh_file, nh_file, inargs.metric, var, time_constraint,
model_num)
if model_num == 0:
first_model = value.attributes['model_id']
cube_list.append(value)
if inargs.individual:
plt.sca(axes[var_index])
iplt.plot(value,
color=exp_colors[experiment],
linewidth=0.3)
ensemble_agg_dict[var], ensemble_spread_dict[
var] = ensemble_aggregation(cube_list, inargs.ensagg)
plt.sca(axes[var_index])
iplt.plot(ensemble_agg_dict[var],
label=experiment,
color=exp_colors[experiment])
if inargs.spread and ensemble_spread_dict[var]:
time_values = ensemble_spread_dict[var][0, ::].coord(
'time').points + scale_factors[first_model]
upper_bound = ensemble_spread_dict[var][0, ::].data
lower_bound = ensemble_spread_dict[var][-1, ::].data
iplt.plt.fill_between(time_values,
upper_bound,
lower_bound,
facecolor=exp_colors[experiment],
alpha=0.15)
if inargs.title:
plt.suptitle('interhemispheric difference in accumulated heat')
for index, var in enumerate(plot_vars):
plt.sca(axes[index])
if nvars > 1:
plt.title(titles[var])
set_plot_features(inargs, axes[index], index, var, nvars)
dpi = inargs.dpi if inargs.dpi else plt.savefig.__globals__['rcParams'][
'figure.dpi']
print('dpi =', dpi)
plt.savefig(inargs.outfile, bbox_inches='tight', dpi=dpi)
log_text = cmdprov.new_log(infile_history={nh_file: history},
git_repo=repo_dir)
log_file = re.sub('.png', '.met', inargs.outfile)
cmdprov.write_log(log_file, log_text)
def main(args):
"""Run the program."""
clim_cube_list, clim_history = get_cube_list(args.clim_files,
'clim',
quick=args.quick)
clim_ensemble_mean, clim_ensemble_agreement = ensemble_stats(
clim_cube_list)
clim_ensemble_mean.data = clim_ensemble_mean.data * 86400
ghg_cube_list, ghg_history = get_cube_list(args.ghg_files,
'anom',
time_bounds=args.time_bounds)
ghg_ensemble_mean, ghg_ensemble_agreement = ensemble_stats(ghg_cube_list)
aa_cube_list, aa_history = get_cube_list(args.aa_files,
'anom',
time_bounds=args.time_bounds)
aa_ensemble_mean, aa_ensemble_agreement = ensemble_stats(aa_cube_list)
hist_cube_list, hist_history = get_cube_list(args.hist_files,
'anom',
time_bounds=args.time_bounds)
hist_ensemble_mean, hist_ensemble_agreement = ensemble_stats(
hist_cube_list)
width = 25
height = 10
fig = plt.figure(figsize=[width, height])
outproj = ccrs.PlateCarree(central_longitude=180.0)
nrows = 2
ncols = 2
ax1 = plt.subplot(nrows, ncols, 1, projection=outproj)
plot_data(ax1,
clim_ensemble_mean,
clim_ensemble_agreement,
'clim',
'(a) piControl',
agreement_bounds=[0.33, 0.66])
ax2 = plt.subplot(nrows, ncols, 2, projection=outproj)
plot_data(ax2,
ghg_ensemble_mean,
ghg_ensemble_agreement,
'anom',
'(b) GHG-only',
agreement_bounds=[0.33, 0.66],
clim=clim_ensemble_mean)
ax3 = plt.subplot(nrows, ncols, 3, projection=outproj)
plot_data(ax3,
aa_ensemble_mean,
aa_ensemble_agreement,
'anom',
'(c) AA-only',
agreement_bounds=[0.33, 0.66],
clim=clim_ensemble_mean)
ax4 = plt.subplot(nrows, ncols, 4, projection=outproj)
plot_data(ax4,
hist_ensemble_mean,
hist_ensemble_agreement,
'anom',
'(d) historical',
agreement_bounds=[0.33, 0.66],
clim=clim_ensemble_mean)
fig.tight_layout()
fig.subplots_adjust(wspace=-0.15, hspace=0.2)
plt.savefig(args.outfile, bbox_inches='tight', dpi=300)
metadata_dict = {
args.ghg_files[-1]: ghg_history[-1],
args.clim_files[-1]: clim_history[-1]
}
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', args.outfile)
cmdprov.write_log(log_file, log_text)
def main(inargs):
"""Run the program."""
df = pd.read_csv(inargs.infile)
#df.set_index(df['model'] + ' (' + df['run'] + ')', drop=True, inplace=True)
df.set_index(df['model'], drop=True, inplace=True)
fig = plt.figure(figsize=[18.5, 21]) # width, height
gs = GridSpec(3, 2)
# EEI conservation
eei_ax = fig.add_subplot(gs[0, 0])
plot_broken_comparison(eei_ax,
df,
'(a) planetary energy imbalance',
'netTOA (J yr-1)',
'thermal OHC (J yr-1)',
'W m-2',
legend=True)
handles, labels = get_legend_info(
eei_ax, df[['netTOA (J yr-1)', 'thermal OHC (J yr-1)']])
# Ocean energy conservation
xlims = [(-41.05, -40.82), (-0.55, 0.71)]
ylims = [(-0.55, 0.66)]
wspace = hspace = 0.08
ocean_energy_ax = brokenaxes(xlims=xlims,
ylims=ylims,
hspace=hspace,
wspace=wspace,
subplot_spec=gs[0, 1],
d=0.0)
#ocean_energy_ax = fig.add_subplot(gs[0, 1])
plot_broken_comparison(ocean_energy_ax,
df,
'(b) ocean energy conservation',
'hfdsgeou (J yr-1)',
'thermal OHC (J yr-1)',
'W m-2',
xpad=25,
ypad=45,
broken=True)
handles, labels = update_legend_info(
ocean_energy_ax, df[['hfdsgeou (J yr-1)', 'thermal OHC (J yr-1)']],
handles, labels)
# Ocean mass conservation
xlims = [(-7, 4), (472, 474), (492, 495)]
ylims = [(-0.7, 0.25)]
hspace = 0.1
ocean_mass_ax = brokenaxes(xlims=xlims,
ylims=ylims,
hspace=hspace,
subplot_spec=gs[1, 0],
d=0.0)
#ocean_mass_ax = fig.add_subplot(gs[1, 0])
plot_broken_comparison(ocean_mass_ax,
df,
'(c) ocean mass conservation',
'wfo (kg yr-1)',
'masso (kg yr-1)',
'kg yr-1',
scale_factor=-15,
broken=True,
xpad=30,
ypad=50)
handles, labels = update_legend_info(
ocean_mass_ax, df[['wfo (kg yr-1)', 'masso (kg yr-1)']], handles,
labels)
# Salt conservation
xlims = [(-0.73, 0.35), (3.55, 3.7)]
ylims = [(-0.8, 3.1)]
hspace = wspace = 0.1
salt_ax = brokenaxes(xlims=xlims,
ylims=ylims,
hspace=hspace,
wspace=wspace,
subplot_spec=gs[1, 1],
d=0.0)
#salt_ax = fig.add_subplot(gs[1, 1])
plot_broken_comparison(salt_ax,
df,
'(d) salt conservation',
'masso (kg yr-1)',
'soga (kg yr-1)',
'kg yr-1',
scale_factor=-15,
xpad=30,
ypad=40,
broken=True)
handles, labels = update_legend_info(
salt_ax, df[['masso (kg yr-1)', 'soga (kg yr-1)']], handles, labels)
# Atmosphere mass conservation
atmos_mass_ax = fig.add_subplot(gs[2, :])
plot_broken_comparison(atmos_mass_ax,
df,
'(e) atmospheric mass conservation',
'massa (kg yr-1)',
'wfa (kg yr-1)',
'kg yr-1',
scale_factor=-12,
ypad=20)
handles, labels = update_legend_info(atmos_mass_ax, df[['wfa (kg yr-1)']],
handles, labels)
fig.legend(handles, labels, loc='center left', bbox_to_anchor=(0.815, 0.5))
plt.tight_layout(rect=(0, 0, 0.8, 1))
for variable, data in cmip6_data_points.items():
record_quartiles(variable, data, 'cmip6')
for variable, data in cmip5_data_points.items():
record_quartiles(variable, data, 'cmip5')
plt.savefig(inargs.outfile, dpi=400)
log_file = re.sub('.png', '.met', inargs.outfile)
log_text = cmdprov.new_log(git_repo=repo_dir, extra_notes=quartiles)
cmdprov.write_log(log_file, log_text)
def main(args):
"""Run the program."""
experiments = ['GHG-only', 'AA-only', 'historical']
letters = ['(a) ', '(b) ', '(c) ']
area_bar_files, flux_bar_files, file_dict, nfiles = sort_files(args)
start_year = args.time_bounds[0][0:4]
end_year = args.time_bounds[1][0:4]
var_names = {'precipitation_flux': 'precipitation',
'water_evapotranspiration_flux': 'evaporation',
'precipitation_minus_evaporation_flux': 'P-E'}
var_name = var_names[args.var]
ylabel = f"time integrated {var_name} anomaly, {start_year}-{end_year} (kg)"
time_constraint = gio.get_time_constraint(args.time_bounds)
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
for plotnum, exp in enumerate(experiments):
total_files, flux_dashed_files, area_dashed_files = file_dict[exp]
data = []
for modelnum in range(nfiles):
total_cube, history = get_data(total_files[modelnum], args.var, time_constraint, 'anomaly', ref_model=None)
try:
model = total_cube.attributes['model_id']
except KeyError:
model = total_cube.attributes['source_id']
flux_bar_cube, history = get_data(flux_bar_files[modelnum], args.var, None, 'mean', ref_model=model)
flux_dashed_integral_cube, history = get_data(flux_dashed_files[modelnum], args.var, time_constraint, 'anomaly', ref_model=model)
area_bar_cube, area_bar_history = get_data(area_bar_files[modelnum], 'cell_area', None, 'mean', ref_model=model)
area_dashed_integral_cube, area_dashed_integral_history = get_data(area_dashed_files[modelnum], 'cell_area',
time_constraint, 'anomaly', ref_model=model)
area_component = flux_bar_cube.data * area_dashed_integral_cube.data
intensity_component = area_bar_cube.data * flux_dashed_integral_cube.data
data.append([model, 'total', 'SH-P', total_cube.data[0]])
data.append([model, 'total', 'SH-E', total_cube.data[1]])
data.append([model, 'total', 'T-P', total_cube.data[2]])
data.append([model, 'total', 'NH-E', total_cube.data[3]])
data.append([model, 'total', 'NH-P', total_cube.data[4]])
data.append([model, 'intensity', 'SH-P', intensity_component[0]])
data.append([model, 'intensity', 'SH-E', intensity_component[1]])
data.append([model, 'intensity', 'T-P', intensity_component[2]])
data.append([model, 'intensity', 'NH-E', intensity_component[3]])
data.append([model, 'intensity', 'NH-P', intensity_component[4]])
data.append([model, 'area', 'SH-P', area_component[0]])
data.append([model, 'area', 'SH-E', area_component[1]])
data.append([model, 'area', 'T-P', area_component[2]])
data.append([model, 'area', 'NH-E', area_component[3]])
data.append([model, 'area', 'NH-P', area_component[4]])
df = pd.DataFrame(data, columns=['model', 'component', 'P-E region', ylabel])
title = letters[plotnum] + exp
plot_data(axes[plotnum], df, title, ylabel, args.ymax, model_dots=args.dots)
plt.savefig(args.outfile, bbox_inches='tight')
metadata_dict = {area_bar_files[0]: area_bar_history[0],
area_dashed_files[0]: area_dashed_integral_history[0]}
log_text = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
log_file = re.sub('.png', '.met', args.outfile)
cmdprov.write_log(log_file, log_text)
