def main(inargs):
"""Run the program."""
time_constraints = {}
time_constraints['historical'] = gio.get_time_constraint(inargs.hist_time)
time_constraints['rcp'] = gio.get_time_constraint(inargs.rcp_time)
if inargs.basin_file:
basin_cube = iris.load_cube(inargs.basin_file)
else:
basin_cube = None
width = 20
height = 21
fig = plt.figure(figsize=(width, height))
ax_dict = {}
ax_dict[('tropics', 'atlantic')] = fig.add_subplot(3, 2, 1)
ax_dict[('critical', 'atlantic')] = fig.add_subplot(3, 2, 2)
ax_dict[('tropics', 'pacific')] = fig.add_subplot(3, 2, 3)
ax_dict[('critical', 'pacific')] = fig.add_subplot(3, 2, 4)
ax_dict[('tropics', 'globe')] = fig.add_subplot(3, 2, 5)
ax_dict[('critical', 'globe')] = fig.add_subplot(3, 2, 6)
previous_experiments = []
for filenum, infile in enumerate(inargs.infiles):
for basin in ['atlantic', 'pacific', 'globe']:
sh_mean, nh_mean, scrit_mean, ncrit_mean, experiment = load_data(
infile, basin_cube, basin)
plot_data(ax_dict[('tropics', basin)],
sh_mean,
nh_mean,
experiment,
previous_experiments,
basin,
crit=False,
plot_type=inargs.plot_type)
plot_data(ax_dict[('critical', basin)],
scrit_mean,
ncrit_mean,
experiment,
previous_experiments,
basin,
crit=True,
plot_type=inargs.plot_type)
previous_experiments.append(experiment)
title = 'Annual Mean Surface Downward X Stress, %s' % (
sh_mean.attributes['model_id'])
plt.suptitle(title, size='large')
# plt.subplots_adjust(top=0.90)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(
inargs.outfile,
file_info={inargs.infiles[-1]: sh_mean.attributes['history']})
def main(inargs):
"""Run the program."""
hist_time_constraint = gio.get_time_constraint(['1850-01-01', '2005-12-31'])
outcubes = iris.cube.CubeList([])
for var in inargs.variables:
metadata_dict = {}
hist_cube = iris.load_cube(inargs.hist_file, gio.check_iris_var(var) & hist_time_constraint)
hist_cube = clean_attributes(hist_cube)
branch_time = hist_cube.attributes['branch_time']
history = hist_cube.attributes['history']
rcp_cube = iris.load_cube(inargs.rcp_file, gio.check_iris_var(var))
rcp_cube = clean_attributes(rcp_cube)
rcp_experiment = rcp_cube.attributes['experiment_id']
if inargs.cumsum:
rcp_cube.data = rcp_cube.data + hist_cube.data[-1]
cube_list = iris.cube.CubeList([hist_cube, rcp_cube])
equalise_attributes(cube_list)
iris.util.unify_time_units(cube_list)
cube = cube_list.concatenate_cube()
cube.attributes['branch_time'] = branch_time
cube.attributes['experiment_id'] = 'historical-' + rcp_experiment
outcubes.append(cube.copy())
for cube in outcubes:
cube.attributes['history'] = gio.write_metadata(file_info={inargs.hist_file: history})
equalise_attributes(outcubes)
iris.save(outcubes, inargs.outfile)
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time)
nfiles = check_inputs(inargs)
for fnum in range(nfiles):
cube_dict = {}
cube_dict['rsdt'] = get_data(inargs.rsdt_files[fnum],
'toa_incoming_shortwave_flux',
time_constraint)
cube_dict['rsut'] = get_data(inargs.rsut_files[fnum],
'toa_outgoing_shortwave_flux',
time_constraint)
cube_dict['rlut'] = get_data(inargs.rlut_files[fnum],
'toa_outgoing_longwave_flux',
time_constraint)
cube_dict = equalise_time_axes(cube_dict)
cube_dict = calc_rndt(cube_dict)
add_metadata(cube_dict['rndt'], cube_dict['rsdt'].attributes)
if inargs.outfile:
rndt_file = inargs.outfile
else:
assert inargs.time == None
rndt_file = get_outfile_name(inargs.rsdt_files[fnum])
print(rndt_file)
iris.save(cube_dict['rndt'], rndt_file)
def main(inargs):
"""Run the program."""
data_dict = {}
for experiment in list(experiment_colors.keys()):
data_dict[(experiment, 'x_data')] = numpy.ma.array([])
data_dict[(experiment, 'y_data')] = numpy.ma.array([])
metadata_dict = {}
for data_file, basin_file in inargs.file_pair:
try:
time_constraint = gio.get_time_constraint(inargs.time)
except AttributeError:
time_constraint = iris.Constraint()
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load_cube(data_file,
'sea_surface_salinity' & time_constraint)
basin_cube = read_basin(basin_file)
ndim = cube.ndim
basin_array = uconv.broadcast_array(basin_cube.data,
[ndim - 2, ndim - 1], cube.shape)
metadata_dict[data_file] = cube.attributes['history']
metadata_dict[basin_file] = basin_cube.attributes['history']
model, experiment = get_experiment_details(cube)
for basin in list(basins.keys()):
zonal_climatology, zonal_trends = calc_zonal_stats(
cube.copy(), basin_array, basin)
data_dict[(experiment, 'x_data')] = numpy.ma.append(
data_dict[(experiment, 'x_data')], zonal_climatology)
data_dict[(experiment, 'y_data')] = numpy.ma.append(
data_dict[(experiment, 'y_data')], zonal_trends)
fig = plt.figure(figsize=(12, 8))
for experiment, color in experiment_colors.items():
x_data = data_dict[(experiment, 'x_data')]
y_data = data_dict[(experiment, 'y_data')]
if numpy.any(x_data):
plt.scatter(x_data[::inargs.thin],
y_data[::inargs.thin],
facecolors='none',
edgecolors=color,
label=experiment)
if experiment in ['AA', 'noAA']:
x_trend, y_trend = calc_trend(x_data, y_data, experiment)
plt.plot(x_trend, y_trend, color=color)
plt.legend(loc=4)
plt.xlabel('Climatological mean salinity')
plt.ylabel('Salinity trend (per 50 years)')
plt.title(model)
# Write output
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile, file_info=metadata_dict)
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time)
nh_lower, nh_upper = inargs.nh_lat_bounds
nh_constraint = iris.Constraint(
latitude=lambda cell: nh_lower <= cell < nh_upper)
sh_lower, sh_upper = inargs.sh_lat_bounds
sh_constraint = iris.Constraint(
latitude=lambda cell: sh_lower <= cell < sh_upper)
data_dict = {}
plot_details_list = []
for infiles in inargs.experiment_files:
cube, model, experiment, orig_units = get_data(
infiles, inargs.variable, nh_constraint, sh_constraint,
time_constraint, inargs.area_file)
iplt.plot(cube, label=experiment, color=experiment_colors[experiment])
plt.legend()
plt.xlabel('year')
plt.ylabel('NH / SH')
title = '%s interhemispheric %s comparison' % (
model, inargs.variable.replace('_', ' '))
plt.title(title)
#plt.subplots_adjust(top=0.90)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile,
file_info={inargs.experiment_files[0][0]: history[0]})
def main(inargs):
"""Run the program."""
assert len(inargs.xfiles) == len(inargs.yfiles)
time_constraint = gio.get_time_constraint(inargs.time)
fig, ax = plt.subplots()
plt.axhline(y=inargs.hline, color='0.5', linestyle='--')
plt.axvline(x=0, color='0.5', linestyle='--')
color_dict = get_colors(inargs.xfiles)
legend_models = []
xtrends = {'historicalGHG': [], 'historicalMisc': [], 'historical': []}
ytrends = {'historicalGHG': [], 'historicalMisc': [], 'historical': []}
for xfile, yfile in zip(inargs.xfiles, inargs.yfiles):
with iris.FUTURE.context(cell_datetime_objects=True):
ytrend, ycube, ymodel, yexperiment, yrip = load_data(
yfile, inargs.yvar, time_constraint)
xtrend, xcube, xmodel, xexperiment, xrip = load_data(
xfile, [inargs.xvar], time_constraint)
assert (xmodel, xexperiment, xrip) == (ymodel, yexperiment, yrip)
if xmodel not in legend_models:
label = xmodel
legend_models.append(xmodel)
else:
label = None
plt.plot(xtrend,
ytrend,
markers[xexperiment],
label=label,
color=color_dict[xmodel])
xtrends[xexperiment].append(xtrend)
ytrends[xexperiment].append(ytrend)
if inargs.best_fit:
for experiment in ['historicalGHG', 'historicalMisc', 'historical']:
if xtrends[experiment]:
plot_line_of_best_fit(xtrends[experiment], ytrends[experiment])
title = 'linear trend, %s-%s' % (inargs.time[0][0:4], inargs.time[1][0:4])
plt.title(title)
xlabel, ylabel = set_axis_labels(inargs, xcube.units, ycube.units)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
handles, labels = ax.get_legend_handles_labels()
labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
ax.legend(handles, labels, loc='center left', bbox_to_anchor=(1, 0.5))
plt.savefig(inargs.outfile, bbox_inches='tight')
metadata_dict = {
xfile: xcube.attributes['history'],
yfile: ycube.attributes['history']
}
gio.write_metadata(inargs.outfile, file_info=metadata_dict)
def main(inargs):
"""Run the program."""
if inargs.area_file:
area_cube = iris.load_cube(inargs.area_file, 'cell_area')
else:
area_cube = None
time_constraint = gio.get_time_constraint(inargs.time)
hfds_cube_list = calc_regional_values(
inargs.hfds_files, 'surface_downward_heat_flux_in_sea_water',
time_constraint, area_cube)
ohc_cube_list = calc_regional_values(inargs.ohc_files,
'ocean_heat_content', time_constraint,
area_cube)
cube_list = ohc_cube_list + hfds_cube_list
infile_history = {}
infile_history[inargs.ohc_files[0]] = history[0]
infile_history[inargs.hfds_files[-1]] = history[-1]
cube_list = update_metadata(cube_list, infile_history)
iris.save(cube_list, inargs.outfile)
def main(inargs):
"""Run the program."""
# Read data
try:
time_constraint = gio.get_time_constraint(inargs.time)
except AttributeError:
time_constraint = iris.Constraint()
diff_trends = {}
metadata_dict = {}
for infile in inargs.infiles:
with iris.FUTURE.context(cell_datetime_objects=True):
cube_sthext = iris.load_cube(
infile,
'ocean heat content southern extratropics60' & time_constraint)
cube_notsthext = iris.load_cube(
infile,
'ocean heat content northern extratropics60' & time_constraint)
model, experiment, run = gio.get_cmip5_file_details(cube_sthext)
run_ri = run[:-2]
run_p = run[-2:]
update_lists(model, experiment, run_ri, run_p)
cube_sthext = cube_sthext.rolling_window('time', iris.analysis.MEAN,
12)
cube_notsthext = cube_notsthext.rolling_window('time',
iris.analysis.MEAN, 12)
diff_trends[(model, experiment, run_ri,
run_p)] = calc_diff_trends(cube_sthext, cube_notsthext)
metadata_dict[infile] = cube_sthext.attributes['history']
# Plot
fig = plt.figure() #figsize=[15, 7])
tex_units, exponent = uconv.units_info(str(cube_sthext.units))
for model in models:
for experiment in experiments:
for run_p in run_ps:
data_compilation = numpy.array([])
for run_ri in run_ris:
try:
data = diff_trends[(model, experiment, run_ri, run_p)]
data_compilation = numpy.concatenate(
(data_compilation, data))
except KeyError:
pass
if data_compilation.any():
plot_trend_distribution(data_compilation, exponent, model,
experiment, run_p)
if inargs.reference_trend:
plt.axvline(x=inargs.reference_trend, linestyle='--', color='0.5')
plt.title('10-year trends in hemispheric OHC difference')
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile, file_info=metadata_dict)
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."""
time_constraints = {}
time_constraints['historical'] = gio.get_time_constraint(inargs.hist_time)
time_constraints['rcp'] = gio.get_time_constraint(inargs.rcp_time)
width = 10
height = 20
fig = plt.figure(figsize=(width, height))
ax_dict = {}
ax1 = fig.add_subplot(3, 1, 1)
ax2 = fig.add_subplot(3, 1, 2)
ax3 = fig.add_subplot(3, 1, 3)
valid_files = []
for infiles in inargs.experiment_files:
spacific_cube, npacific_cube, experiment = load_data(
infiles, 'pacific')
satlantic_cube, natlantic_cube, experiment = load_data(
infiles, 'atlantic')
if experiment:
spacific_metric, npacific_metric = calc_metrics(
spacific_cube, npacific_cube)
satlantic_metric, natlantic_metric = calc_metrics(
satlantic_cube, natlantic_cube)
plot_hemispheres(ax1, npacific_metric, spacific_metric, experiment,
'pacific')
plot_comparison(ax2, npacific_metric, spacific_metric, experiment,
'pacific')
plot_hemispheres(ax3, natlantic_metric, satlantic_metric,
experiment, 'atlantic')
model = spacific_cube.attributes['model_id']
valid_files.append(infiles)
title = 'Annual Mean Meridional Overturning Mass Streamfunction, %s' % (
model)
plt.suptitle(title, size='large')
# plt.subplots_adjust(top=0.90)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile,
file_info={valid_files[0][0]: history[0]})
def main(inargs):
"""Run the program."""
if inargs.time:
try:
time_constraint = gio.get_time_constraint(inargs.time)
except AttributeError:
time_constraint = iris.Constraint()
else:
time_constraint = iris.Constraint()
fig, axes = setup_plot(inargs.nregions)
bar_width = 0.7
hfds_values = {}
for region in region_names[inargs.nregions]:
plot_atmos(axes,
inargs.infile,
region,
bar_width,
inargs.aggregation,
time_constraint,
branch=inargs.branch_time)
hfds_values[region] = plot_surface(axes,
inargs.infile,
region,
bar_width,
inargs.aggregation,
time_constraint,
branch=inargs.branch_time)
ohc_values, transport_values, ohc_inferred_values, transport_inferred_values = get_ocean_values(
inargs.infile,
inargs.aggregation,
time_constraint,
hfds_values,
inargs.nregions,
branch=inargs.branch_time,
infer_ohc=inargs.infer_ohc,
infer_hfbasin=inargs.infer_hfbasin)
for region in region_names[inargs.nregions]:
plot_ocean(axes, region, bar_width, inargs.aggregation, hfds_values,
ohc_values, transport_values, ohc_inferred_values,
transport_inferred_values)
set_title(inargs.infile)
fig.tight_layout(rect=[0, 0, 1, 0.93]) # (left, bottom, right, top)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile,
file_info={
inargs.infile:
iris.load(inargs.infile)[0].attributes['history']
})
def calculate_climatology(cube, time_bounds, experiment):
"""Calculate annual mean climatology"""
if not experiment == 'piControl':
time_constraint = gio.get_time_constraint(time_bounds)
cube = cube.extract(time_constraint)
cube = cube.collapsed('time', iris.analysis.MEAN)
cube.remove_coord('time')
return cube
def get_constraints(inargs):
"""Get the time, depth and mask information"""
time_constraint = gio.get_time_constraint(inargs.time_bounds)
depth_constraint = gio.iris_vertical_constraint(0.0, inargs.max_depth)
if inargs.land_mask:
sftlf_cube = iris.load_cube(inargs.land_mask, 'land_area_fraction')
else:
sftlf_cube = None
return time_constraint, depth_constraint, sftlf_cube
def get_time_constraint(time_bounds):
"""Get the iris time constraint for given time bounds."""
if time_bounds:
try:
time_constraint = gio.get_time_constraint(time_bounds)
except AttributeError:
time_constraint = iris.Constraint()
else:
time_constraint = iris.Constraint()
return time_constraint
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 period_mean(cube, time_period):
"""Calculate the mean for a particular time period."""
time_constraint = gio.get_time_constraint(time_period)
cube = cube.extract(time_constraint)
coord_names = [coord.name() for coord in cube.dim_coords]
if 'time' in coord_names:
cube = cube.collapsed('time', iris.analysis.MEAN)
cube.remove_coord('time')
return cube
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 read_supporting_inputs(vfile, bfile, inargs, ref=False):
"""Read the supporting volume, basin and time bounds information."""
if ref:
time_bounds = inargs.ref_time_bounds if inargs.ref_time_bounds else inargs.time_bounds
else:
time_bounds = inargs.time_bounds
vcube = iris.load_cube(vfile)
bcube = iris.load_cube(bfile)
time_constraint = gio.get_time_constraint(time_bounds)
return vcube, bcube, time_constraint
def main(inargs):
"""Run the program."""
hist_cube_list = iris.load(inargs.historical_file)
control_cube_list = iris.load(inargs.control_file)
total_time = (inargs.start_time[0], inargs.end_time[-1])
hist_start_constraint = gio.get_time_constraint(inargs.start_time)
hist_end_constraint = gio.get_time_constraint(inargs.end_time)
hist_total_constraint = gio.get_time_constraint(total_time)
control_start_constraint = timeseries.get_control_time_constraint(control_cube_list[0], hist_cube_list[0], inargs.start_time)
control_end_constraint = timeseries.get_control_time_constraint(control_cube_list[0], hist_cube_list[0], inargs.end_time)
control_total_constraint = timeseries.get_control_time_constraint(control_cube_list[0], hist_cube_list[0], total_time)
column_headers = ['model', 'experiment', 'rip', 'period',
'hfds-globe-sum', 'hfds-nh-sum', 'hfds-sh-sum', 'hfds-nhext-sum', 'hfds-tropics-sum', 'hfds-shext-sum',
'ohc-globe-sum', 'ohc-nh-sum', 'ohc-sh-sum', 'ohc-nhext-sum', 'ohc-tropics-sum', 'ohc-shext-sum']
data_dict = collections.OrderedDict()
for column in column_headers:
data_dict[column] = []
data_dict = generate_results(data_dict, hist_cube_list, hist_start_constraint, inargs.start_time)
data_dict = generate_results(data_dict, hist_cube_list, hist_end_constraint, inargs.end_time)
data_dict = generate_results(data_dict, hist_cube_list, hist_total_constraint, total_time)
data_dict = generate_results(data_dict, control_cube_list, control_start_constraint, inargs.start_time)
data_dict = generate_results(data_dict, control_cube_list, control_end_constraint, inargs.end_time)
data_dict = generate_results(data_dict, control_cube_list, control_total_constraint, total_time)
data_df = pandas.DataFrame.from_dict(data_dict)
data_df.to_csv(inargs.outfile)
metadata_dict = {inargs.historical_file: hist_cube_list[0].attributes['history'],
inargs.control_file: control_cube_list[0].attributes['history']}
gio.write_metadata(inargs.outfile, file_info=metadata_dict)
def main(inargs):
"""Run the program."""
if inargs.sftlf_file:
sftlf_cube = iris.load_cube(inargs.sftlf_file, 'land_area_fraction')
else:
sftlf_cube = None
try:
time_constraint = gio.get_time_constraint(inargs.time)
except AttributeError:
time_constraint = iris.Constraint()
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(inargs.infiles, gio.check_iris_var(inargs.var))
history = cube[0].attributes['history']
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube = iris.util.squeeze(cube)
cube.attributes['history'] = gio.write_metadata(
file_info={inargs.infiles[0]: history})
cube = cube.extract(time_constraint)
cube = timeseries.convert_to_annual(cube, full_months=True)
output = {}
output['full'] = calc_fields(cube,
sftlf_cube,
inargs.aggregation,
realm=None,
area=inargs.area)
if inargs.sftlf_file:
for realm in ['ocean', 'land']:
output[realm] = calc_fields(cube,
sftlf_cube,
inargs.aggregation,
realm=realm,
area=inargs.area)
cube_list = iris.cube.CubeList()
for realm, output_cubes in output.items():
for cube in output_cubes:
cube_list.append(cube)
iris.FUTURE.netcdf_no_unlimited = True
iris.save(cube_list, inargs.outfile, netcdf_format='NETCDF3_CLASSIC')
def get_control_time_constraint(control_cube,
ref_cube,
time_bounds,
branch_time=None):
"""Define the time constraint for control data.
Args:
control_cube (iris.cube.Cube): cube for piControl experiment
ref_cube (iris.cube.Cube): reference cube (e.g. from historical experiment)
time_bounds (list): selected time periods from reference cube
(e.g. ['1861-01-01', '2005-12-31'])
branch_time (float): Override the branch time in the ref_cube attributes
"""
_check_attributes(ref_cube.attributes, control_cube.attributes)
iris.coord_categorisation.add_year(control_cube, 'time')
iris.coord_categorisation.add_year(ref_cube, 'time')
if not branch_time:
branch_time = ref_cube.attributes['branch_time']
index = 0
for bounds in control_cube.coord('time').bounds:
lower, upper = bounds
if lower <= float(branch_time) < upper:
break
else:
index = index + 1
branch_year = control_cube.coord('year').points[index]
ref_start_year = ref_cube.coord('year').points[0]
start_gap = int(time_bounds[0].split('-')[0]) - ref_start_year
end_gap = int(time_bounds[1].split('-')[0]) - ref_start_year
control_start_year = branch_year + start_gap
control_end_year = branch_year + end_gap
control_start_date = str(control_start_year).zfill(4) + '-01-01'
control_end_date = str(control_end_year).zfill(4) + '-12-31'
time_constraint = gio.get_time_constraint(
[control_start_date, control_end_date])
control_cube.remove_coord('year')
ref_cube.remove_coord('year')
return time_constraint
def read_data(inargs, infiles, time_bounds, ref_cube=None, anomaly=False, branch_index=None, branch_time=None):
"""Read data."""
data_dict = {}
file_count = 0
for infile in infiles:
try:
cube = iris.load_cube(infile, gio.check_iris_var(inargs.var))
except iris.exceptions.ConstraintMismatchError:
print('using inferred value for', infile)
cube = iris.load_cube(infile, gio.check_iris_var('Inferred_' + inargs.var))
cube.long_name = inargs.var.replace('_', ' ')
cube.var_name = cube.var_name.replace('-inferred', '')
if ref_cube:
cube = timeseries.adjust_control_time(cube, ref_cube, branch_index=branch_index, branch_time=branch_time)
if not (ref_cube and inargs.full_control):
time_constraint = gio.get_time_constraint(time_bounds)
cube = cube.extract(time_constraint)
if anomaly:
cube.data = cube.data - cube.data[0:20].mean()
cube.data = cube.data.astype(numpy.float64)
cube.cell_methods = ()
for aux_coord in ['latitude', 'longitude']:
try:
cube.remove_coord(aux_coord)
except iris.exceptions.CoordinateNotFoundError:
pass
new_aux_coord = iris.coords.AuxCoord(file_count, long_name='ensemble_member', units='no_unit')
cube.add_aux_coord(new_aux_coord)
model = cube.attributes['model_id']
realization = 'r' + str(cube.attributes['realization'])
physics = 'p' + str(cube.attributes['physics_version'])
experiment = cube.attributes['experiment_id']
key = (model, physics, realization)
data_dict[key] = cube
file_count = file_count + 1
ylabel = get_ylabel(cube, inargs)
experiment = 'historicalAA' if experiment == "historicalMisc" else experiment
metadata_dict = {infile: cube.attributes['history']}
return data_dict, experiment, ylabel, metadata_dict
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time_bounds)
ensemble_cube_list = iris.cube.CubeList([])
for ensnum, ensemble_member in enumerate(inargs.ensemble_member):
cube, history = read_infiles(ensemble_member, inargs.var, time_constraint, ensnum)
ensemble_cube_list.append(cube)
ensagg = calc_ensagg(ensemble_cube_list)
log = cmdprov.new_log(infile_history={ensemble_member[0]: history}, git_repo=repo_dir)
ensagg.attributes['history'] = log
iris.save(ensagg, inargs.outfile)
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time)
metadata_dict = {}
results_dict = {}
fig, ax = plt.subplots()
metadata_dict, results_dict, ohc_cube = plot_files(inargs.ohc_file,
inargs.hfds_file,
inargs.rndt_file,
inargs.hemisphere,
metadata_dict,
results_dict,
time_constraint,
dedrifted=True)
if inargs.orig_ohc_file and inargs.orig_hfds_file and inargs.orig_rndt_file:
metadata_dict, results_dict, ohc_cube = plot_files(
inargs.orig_ohc_file,
inargs.orig_hfds_file,
inargs.orig_rndt_file,
inargs.hemisphere,
metadata_dict,
results_dict,
time_constraint,
dedrifted=False)
plt.ylabel(ohc_cube.units)
plt.ticklabel_format(style='sci',
axis='y',
scilimits=(0, 0),
useMathText=True,
useOffset=False)
ax.yaxis.major.formatter._useMathText = True
#plt.ylim(-5e+24, 9e+24)
ymin, ymax = plt.ylim()
print('ymin:', ymin)
print('ymax:', ymax)
title, legloc = get_title(ohc_cube, inargs.hemisphere)
plt.title(title)
plt.legend(loc=legloc)
write_result(inargs.outfile, results_dict)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile, file_info=metadata_dict)
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 read_data(inargs, infiles, ref_cube=None):
"""Read data."""
clim_dict = {}
trend_dict = {}
file_count = 0
for infile in infiles:
print(infile)
cube = iris.load_cube(infile, gio.check_iris_var(inargs.var))
if ref_cube:
time_constraint = timeseries.get_control_time_constraint(
cube, ref_cube, inargs.time, branch_time=inargs.branch_time)
cube = cube.extract(time_constraint)
iris.util.unify_time_units([ref_cube, cube])
cube.replace_coord(ref_cube.coord('time'))
else:
time_constraint = gio.get_time_constraint(inargs.time)
cube = cube.extract(time_constraint)
if inargs.perlat:
grid_spacing = grids.get_grid_spacing(cube)
cube.data = cube.data / grid_spacing
trend_cube = calc_trend_cube(cube.copy())
clim_cube = cube.collapsed('time', iris.analysis.MEAN)
clim_cube.remove_coord('time')
model = cube.attributes['model_id']
realization = 'r' + str(cube.attributes['realization'])
physics = 'p' + str(cube.attributes['physics_version'])
key = (model, physics, realization)
trend_dict[key] = trend_cube
clim_dict[key] = clim_cube
file_count = file_count + 1
experiment = cube.attributes['experiment_id']
experiment = 'historicalAA' if experiment == "historicalMisc" else experiment
trend_ylabel = get_ylabel(cube, 'trend', inargs)
clim_ylabel = get_ylabel(cube, 'climatology', inargs)
metadata_dict = {infile: cube.attributes['history']}
return cube, trend_dict, clim_dict, experiment, trend_ylabel, clim_ylabel, metadata_dict
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time)
#metadata_dict = {}
fig, ax = plt.subplots()
plt.axvline(x=0, color='0.5', linestyle='--')
data_list = []
for nh_file, sh_file in inargs.rndt_files:
diff, model, experiment, mip = calc_interhemispheric_diff(
nh_file, sh_file, 'netTOA', time_constraint)
data_list.append(
generate_data_dict(diff, model, experiment, mip, 'netTOA'))
for nh_file, sh_file in inargs.hfds_files:
diff, model, experiment, mip = calc_interhemispheric_diff(
nh_file, sh_file, 'OHU', time_constraint)
data_list.append(
generate_data_dict(diff, model, experiment, mip, 'OHU'))
for nh_file, sh_file in inargs.ohc_files:
diff, model, experiment, mip = calc_interhemispheric_diff(
nh_file, sh_file, 'OHC', time_constraint)
data_list.append(
generate_data_dict(diff, model, experiment, mip, 'OHC'))
data_df = pandas.DataFrame(data_list)
seaborn.boxplot(data=data_df[columns],
orient="h",
palette=[
'red', '#FFDDDD', '#FFDDDD', 'yellow', '#fdffdd',
'#fdffdd', 'blue', '#ddddff', '#ddddff'
])
plt.ticklabel_format(style='sci',
axis='x',
scilimits=(0, 0),
useMathText=True)
ax.xaxis.major.formatter._useMathText = True
ax.set_xlabel('Northern Hemisphere minus Southern Hemisphere (Joules)')
plt.title('Interhemispheric difference in accumulated heat, 1861-2005')
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile)
def main(inargs):
"""Run the program."""
data_files = {'historicalGHG': inargs.ghg_files,
'historicalAA': inargs.aa_files}
spatial_cubes = {'historicalGHG': read_spatial_file(inargs.ghg_spatial_file),
'historicalAA': read_spatial_file(inargs.aa_spatial_file)}
time_periods = {'early': inargs.early_period,
'late': inargs.late_period}
hist = {}
for experiment in ['historicalGHG', 'historicalAA']:
with iris.FUTURE.context(cell_datetime_objects=True):
data_cubes = iris.load(data_files[experiment], inargs.var, callback=save_history)
equalise_attributes(data_cubes)
for period_name, period_dates in time_periods.iteritems():
time_constraint = gio.get_time_constraint(period_dates)
data_cube_list = data_cubes.extract(time_constraint)
data_cube = concat_cubes(data_cube_list)
if inargs.annual_smoothing:
data_cube = data_cube.rolling_window('time', iris.analysis.MEAN, 12)
#data_cube = timeseries.convert_to_annual(data_cube)
hist[(experiment, period_name)], bin_edges = calc_histogram(data_cube, spatial_cubes[experiment])
hist[(experiment, 'diff')] = hist[(experiment, 'late')] - hist[(experiment, 'early')]
fig = plt.figure(figsize=[15, 10])
gs = gridspec.GridSpec(2, 2, height_ratios=[4,1])
ax0 = plt.subplot(gs[0])
create_upper_plot(ax0, hist, bin_edges[0:-1], 'historicalAA')
ax1 = plt.subplot(gs[1])
create_upper_plot(ax1, hist, bin_edges[0:-1], 'historicalGHG')
ax2 = plt.subplot(gs[2])
create_lower_plot(ax2, hist, bin_edges[0:-1], 'historicalAA')
ax3 = plt.subplot(gs[3])
create_lower_plot(ax3, hist, bin_edges[0:-1], 'historicalGHG')
fig.suptitle('Salinity distribution')
plt.savefig(inargs.outfile, bbox_inches='tight')
write_met_file(inargs, spatial_cubes, inargs.outfile)
def main(inargs):
"""Run the program."""
# Read data
try:
time_constraint = gio.get_time_constraint(inargs.time)
except AttributeError:
time_constraint = iris.Constraint()
with iris.FUTURE.context(cell_datetime_objects=True):
ohc_3D_cube = iris.load_cube(inargs.infile, 'ocean heat content 3D' & time_constraint)
ohc_2D_cube = iris.load_cube(inargs.infile, 'ocean heat content 2D' & time_constraint)
lons = ohc_3D_cube.coord('longitude').points
lats = ohc_3D_cube.coord('latitude').points
infile_history = ohc_3D_cube.attributes['history']
# Calculate seasonal cycle
running_mean = True
if inargs.seasonal_cycle:
ohc_3D_cube = timeseries.calc_seasonal_cycle(ohc_3D_cube)
ohc_2D_cube = timeseries.calc_seasonal_cycle(ohc_2D_cube)
running_mean = False
# Calculate trend
ohc_3D_trend = timeseries.calc_trend(ohc_3D_cube, running_mean=running_mean,
per_yr=False, remove_scaling=True)
ohc_2D_trend = timeseries.calc_trend(ohc_2D_cube, running_mean=running_mean,
per_yr=False, remove_scaling=True)
# Plot
fig = plt.figure(figsize=[15, 3])
gs = gridspec.GridSpec(1, 2, width_ratios=[4, 1])
cbar_tick_max, cbar_tick_step = inargs.ticks
yticks = set_yticks(inargs.max_lat)
plot_3D_trend(ohc_3D_trend, lons, lats, gs,
cbar_tick_max, cbar_tick_step, yticks)
plot_2D_trend(ohc_2D_trend, lats, gs,
yticks)
# Write output
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile, file_info={inargs.outfile:infile_history})
def main(inargs):
"""Run the program."""
time_constraint = gio.get_time_constraint(inargs.time)
trend_dict = {}
models = []
for infile in inargs.infiles:
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load_cube(infile, 'air_temperature' & time_constraint)
experiment, model, metric_name = get_file_info(infile)
trend_dict[(model,
experiment)] = timeseries.calc_trend(cube, per_yr=True)
models.append(model)
models = sort_list(models)
hist_data, ghg_data, aa_data = order_data(trend_dict, models)
ant_data = numpy.array(ghg_data) + numpy.array(aa_data)
ind = numpy.arange(len(hist_data)) # the x locations for the groups
width = 0.2 # the width of the bars
fig, ax = plt.subplots(figsize=(20, 8))
rects1 = ax.bar(ind, ghg_data, width, color='red')
rects2 = ax.bar(ind + width, aa_data, width, color='blue')
rects3 = ax.bar(ind + 2 * width, ant_data, width, color='purple')
rects4 = ax.bar(ind + 3 * width, hist_data, width, color='green')
ax.set_ylabel('$K yr^{-1}$')
start_year = inargs.time[0].split('-')[0]
end_year = inargs.time[1].split('-')[0]
ax.set_title('Trend in %s, %s-%s' % (metric_name, start_year, end_year))
ax.set_xticks(ind + 1.5 * width)
ax.set_xticklabels(models)
ax.legend((rects1[0], rects2[0], rects3[0], rects4[0]),
('historicalGHG', 'historicalAA', 'GHG + AA', 'historical'),
loc=1)
plt.savefig(inargs.outfile, bbox_inches='tight')
gio.write_metadata(inargs.outfile,
file_info={infile: cube.attributes['history']})
