def calc_coefficients(cube,
coord_names,
masked_array=True,
convert_annual=False,
chunk_annual=False,
outlier_threshold=None):
"""Calculate the polynomial coefficients.
Can select to convert data to annual timescale first.
Choices are made to avoid memory errors on large arrays.
"""
time_var = coord_names[0]
if 'depth' in coord_names:
assert coord_names[
1] == 'depth', 'coordinate order must be time, depth, ...'
out_shape = list(cube.shape)
out_shape[0] = 4
coefficients = numpy.zeros(out_shape) #, dtype=numpy.float32)
for d, cube_slice in enumerate(cube.slices_over('depth')):
print('Depth:', cube_slice.coord('depth').points[0])
if convert_annual:
cube_slice = timeseries.convert_to_annual(cube_slice,
chunk=chunk_annual)
time_axis = cube_slice.coord(
time_var).points #.astype(numpy.float32)
coefficients[:, d, ::] = numpy.ma.apply_along_axis(
polyfit, 0, cube_slice.data, time_axis, masked_array,
outlier_threshold)
fill_value = cube_slice.data.fill_value
coefficients = numpy.ma.masked_values(coefficients, fill_value)
else:
if convert_annual:
cube = timeseries.convert_to_annual(cube)
time_axis = cube.coord(time_var).points # .astype(numpy.float32)
if cube.ndim == 1:
coefficients = polyfit(cube.data, time_axis, masked_array,
outlier_threshold)
else:
coefficients = numpy.ma.apply_along_axis(polyfit, 0, cube.data,
time_axis, masked_array,
outlier_threshold)
if masked_array:
fill_value = cube.data.fill_value
coefficients = numpy.ma.masked_values(coefficients, fill_value)
time_start = time_axis[0]
time_end = time_axis[-1]
return coefficients, time_start, time_end
def read_data(infiles, variable, calc_annual=False, chunk=False):
"""Load the input data."""
cube = iris.load(infiles,
gio.check_iris_var(variable),
callback=save_history)
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
if calc_annual:
cube = timeseries.convert_to_annual(cube, chunk=chunk)
coord_names = [coord.name() for coord in cube.dim_coords]
aux_coord_names = [coord.name() for coord in cube.aux_coords]
assert 'time' in coord_names
assert len(coord_names) == 3
grid_type = 'curvilinear' if aux_coord_names == ['latitude', 'longitude'
] else 'latlon'
infile_history = {}
infile_history[infiles[0]] = history[0]
cube.attributes['history'] = gio.write_metadata(file_info=infile_history)
return cube, coord_names, aux_coord_names, grid_type
def process_cube(cube, inargs, sftlf_cube):
"""Process a data cube"""
if inargs.annual:
cube = timeseries.convert_to_annual(cube, full_months=True)
if inargs.aggregation:
cube = get_agg_cube(cube, inargs.aggregation, remove_outliers=inargs.remove_outliers)
if 'salinity' in inargs.var:
cube = gio.salinity_unit_check(cube)
if inargs.regrid:
before_sum = cube.data.sum()
before_mean = cube.data.mean()
cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(cube)
if regrid_status:
print('Warning: Data has been regridded')
print('Before sum:', '%.2E' % Decimal(before_sum) )
print('After sum:', '%.2E' % Decimal(cube.data.sum()) )
print('Before mean:', '%.2E' % Decimal(before_mean) )
print('After mean:', '%.2E' % Decimal(cube.data.mean()) )
if sftlf_cube:
cube = uconv.apply_land_ocean_mask(cube, sftlf_cube, 'ocean')
return cube
def read_data(infile_list, var, model, basin_cube):
"""Read the data files.
The CSIRO-Mk3-6-0 model seems to be formatted incorrectly
and you can't select the "global_ocean" by name
"""
cube = iris.load(infile_list,
gio.check_iris_var(var),
callback=save_history)
atts = cube[0].attributes
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube.attributes = atts
cube.attributes['history'] = history[0]
if var == 'northward_ocean_heat_transport':
if model == 'CSIRO-Mk3-6-0':
cube = cube[:, 2, :]
else:
cube = cube.extract(iris.Constraint(region='global_ocean'))
cube = timeseries.convert_to_annual(cube, full_months=True)
if basin_cube:
cube = uconv.mask_marginal_seas(cube, basin_cube)
return cube
def read_data(infiles, variable, time_constraint):
"""Load the input data."""
cube = iris.load(infiles,
gio.check_iris_var(variable),
callback=save_history)
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube = cube.extract(time_constraint)
if not 'J' in str(cube.units):
cube = convert_to_joules(cube)
if variable == 'surface_downward_heat_flux_in_sea_water':
agg_method = 'sum'
elif variable == 'ocean_heat_content':
agg_method = 'mean'
cube = timeseries.convert_to_annual(cube, aggregation=agg_method)
coord_names = [coord.name() for coord in cube.dim_coords]
aux_coord_names = [coord.name() for coord in cube.aux_coords]
assert 'time' in coord_names
assert len(coord_names) == 3
grid_type = 'curvilinear' if aux_coord_names == ['latitude', 'longitude'
] else 'latlon'
return cube, coord_names, aux_coord_names, grid_type
def get_htc_data(htc_file, metadata_dict, rolling_window=None):
"""Read ocean heat transport convergence data and calculate mean and trend.
A hfbasin-convengence or hfy-convergence file is expected.
Input: units = W, timescale = monhtly
Output: units = W s-1, timescale = annual
"""
if htc_file:
if 'hfy' in htc_file:
htc_cube = iris.load_cube(
htc_file, 'zonal sum ocean heat y transport convergence globe')
else:
htc_cube = iris.load_cube(htc_file)
metadata_dict[htc_file] = htc_cube.attributes['history']
htc_cube = timeseries.convert_to_annual(htc_cube)
if rolling_window:
y_axis_name = get_y_axis_name(htc_cube)
htc_cube = htc_cube.rolling_window(y_axis_name, iris.analysis.MEAN,
rolling_window)
htc_trend = calc_trend_cube(htc_cube)
htc_mean = htc_cube.collapsed('time', iris.analysis.MEAN)
htc_trend.attributes = htc_cube.attributes
htc_mean.atributes = htc_cube.attributes
else:
htc_trend = None
htc_mean = None
return htc_trend, htc_mean, metadata_dict
def main(inargs):
"""Run the program."""
cube, history = gio.combine_files(inargs.infiles, inargs.var, checks=True)
if inargs.annual:
cube = timeseries.convert_to_annual(cube, chunk=False)
if inargs.aggregation == 'sum':
cube = cube.collapsed('depth', iris.analysis.SUM)
else:
dim_coord_names = [coord.name() for coord in cube.dim_coords]
depth_coord = cube.coord('depth')
assert depth_coord.units in ['m', 'dbar'], "Unrecognised depth axis units"
if depth_coord.units == 'm':
vert_extents = spatial_weights.calc_vertical_weights_1D(depth_coord, dim_coord_names, cube.shape)
elif depth_coord.units == 'dbar':
vert_extents = spatial_weights.calc_vertical_weights_2D(depth_coord, cube.coord('latitude'), dim_coord_names, cube.shape)
cube = cube.collapsed('depth', iris.analysis.MEAN, weights=vert_extents)
cube.remove_coord('depth')
metadata_dict = {}
metadata_dict[inargs.infiles[0]] = history
cube.attributes['history'] = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
iris.save(cube, inargs.outfile)
def load_data(infile, basin):
"""Load, temporally aggregate and spatially slice input data"""
try:
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(
infile,
'ocean_meridional_overturning_mass_streamfunction',
callback=save_history)
equalise_attributes(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube = cube[:, basin_index[basin], :, :]
cube = timeseries.convert_to_annual(cube)
experiment = cube.attributes['experiment_id']
if experiment == 'historicalMisc':
experiment = 'historicalAA'
depth_constraint = iris.Constraint(depth=lambda cell: cell <= 250)
sh_constraint = iris.Constraint(
latitude=lambda cell: -30.0 <= cell < 0.0)
nh_constraint = iris.Constraint(
latitude=lambda cell: 0.0 < cell <= 30.0)
sh_cube = cube.extract(depth_constraint & sh_constraint)
nh_cube = cube.extract(depth_constraint & nh_constraint)
except OSError:
sh_cube = nh_cube = experiment = None
return sh_cube, nh_cube, experiment
def read_data(infile_list, var, basin_cube, region):
"""Read the data files.
The CSIRO-Mk3-6-0 model seems to be formatted incorrectly
and you can't select the regioins by name.
"""
cube, history = gio.combine_files(infile_list, var)
cube.attributes = atts
cube.attributes['history'] = history[0]
model = atts['model_id']
if var == 'northward_ocean_heat_transport':
region_index = {}
region_index['atlantic_arctic_ocean'] = 0
region_index['indian_pacific_ocean'] = 1
region_index['global_ocean'] = 2
if model == 'CSIRO-Mk3-6-0':
cube = cube[:, region_index[region], :]
else:
cube = cube.extract(iris.Constraint(region=region))
cube = timeseries.convert_to_annual(cube, full_months=True)
if basin_cube:
cube = uconv.mask_marginal_seas(cube, basin_cube)
if region != 'global_ocean':
basin_numbers = {}
basin_numbers['atlantic_arctic_ocean'] = [2, 4]
basin_numbers['indian_pacific_ocean'] = [3, 5]
cube = uconv.mask_unwanted_seas(cube, basin_cube, basin_numbers[region])
return cube
def main(inargs):
"""Run the program."""
cube = iris.load(inargs.infiles, gio.check_iris_var(inargs.var), callback=save_history)
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
if inargs.annual:
cube = timeseries.convert_to_annual(cube, full_months=True)
cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(cube)
if inargs.area:
cube = multiply_by_area(cube)
if inargs.sftlf_file and inargs.realm:
sftlf_cube = iris.load_cube(inargs.sftlf_file, 'land_area_fraction')
cube = uconv.apply_land_ocean_mask(cube, sftlf_cube, inargs.realm)
zonal_aggregate = cube.collapsed('longitude', aggregation_functions[inargs.aggregation])
zonal_aggregate.remove_coord('longitude')
zonal_aggregate.attributes['history'] = gio.write_metadata(file_info={inargs.infiles[0]: history[0]})
iris.save(zonal_aggregate, inargs.outfile)
def read_data(infiles,
var,
area_cube,
annual=False,
multiply_by_area=False,
chunk_annual=False):
"""Read the input data."""
cube, history = gio.combine_files(infiles, var)
if annual:
cube = timeseries.convert_to_annual(cube,
days_in_month=True,
chunk=chunk_annual)
cube = uconv.flux_to_magnitude(cube)
if multiply_by_area:
cube = spatial_weights.multiply_by_area(cube, area_cube=area_cube)
coord_names = [coord.name() for coord in cube.coords(dim_coords=True)]
assert cube.ndim == 3
lats = cube.coord('latitude').points
if lats.ndim == 1:
lat_pos = coord_names.index('latitude')
lats = uconv.broadcast_array(lats, lat_pos - 1, cube.shape[1:])
else:
assert lats.shape == cube.shape[1:]
return cube, lats, history
def read_data(file_list, var, grid_point, convert_to_annual=False):
"""Read input data."""
cube, history = gio.combine_files(file_list, var)
if grid_point:
cube = select_point(cube, grid_point, timeseries=True)
if convert_to_annual:
cube = timeseries.convert_to_annual(cube)
return cube, history[0]
def main(inargs):
"""Run the program."""
cube, history = gio.combine_files(inargs.infiles, inargs.var, checks=True)
if inargs.surface:
coord_names = [coord.name() for coord in cube.dim_coords]
if 'depth' in coord_names:
cube = cube.extract(iris.Constraint(depth=0))
else:
print('no depth axis for surface extraction')
if inargs.annual:
cube = timeseries.convert_to_annual(cube, chunk=inargs.chunk)
log = cmdprov.new_log(infile_history={inargs.infiles[0]: history[0]},
git_repo=repo_dir)
dim_vals = {}
dim_vals['latitude'] = get_dim_vals(inargs.lats)
dim_vals['longitude'] = get_dim_vals(inargs.lons)
if inargs.levs:
dim_vals['depth'] = get_dim_vals(inargs.levs)
else:
dim_vals['depth'] = get_dim_vals(inargs.depth_bnds, bounds=True)
# Regrid from curvilinear to rectilinear if necessary
regrid_status = False
if inargs.lats:
horizontal_grid = grids.make_grid(dim_vals['latitude'],
dim_vals['longitude'])
cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(
cube, target_grid_cube=horizontal_grid)
# Regrid to new grid
if dim_vals['depth'] or not regrid_status:
sample_points = get_sample_points(cube, dim_vals)
cube = cube.interpolate(sample_points, iris.analysis.Linear())
coord_names = [coord.name() for coord in cube.dim_coords]
if 'latitude' in coord_names:
cube.coord('latitude').guess_bounds()
if 'longitude' in coord_names:
cube.coord('longitude').guess_bounds()
if inargs.levs:
cube = spatial_weights.guess_depth_bounds(cube)
else:
cube.coord('depth').bounds = get_depth_bounds(inargs.depth_bnds)
if numpy.isnan(numpy.min(cube.data)):
cube = remove_nans(cube)
# Reinstate time dim_coord if necessary
aux_coord_names = [coord.name() for coord in cube.aux_coords]
if 'time' in aux_coord_names:
cube = iris.util.new_axis(cube, 'time')
cube.attributes['history'] = log
iris.save(cube, inargs.outfile, fill_value=1e20)
def main(inargs):
"""Run the program."""
# Read data
cube = iris.load(inargs.infiles,
'surface_downward_eastward_stress',
callback=save_history)
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
# Prepare data
cube = timeseries.convert_to_annual(cube)
sftlf_cube = iris.load_cube(inargs.sftlf_file, 'land_area_fraction')
mask = create_land_mask(sftlf_cube, cube.shape)
cube.data = numpy.ma.asarray(cube.data)
cube.data.mask = mask
cube = cube.collapsed('longitude', iris.analysis.MEAN)
# Calculate metrics
xdata = cube.coord('latitude').points
xnew = numpy.linspace(xdata[0], xdata[-1], num=1000, endpoint=True)
hemispheres = ['sh', 'nh']
directions = ['easterly', 'westerly']
metric_dict = {}
for hemisphere, direction in itertools.product(hemispheres, directions):
metric_dict[(hemisphere, direction, 'location')] = []
metric_dict[(hemisphere, direction, 'magnitude')] = []
for ycube in cube.slices(['latitude']):
func = interp1d(xdata, ycube.data, kind='cubic')
ynew = func(xnew)
for hemisphere, direction in itertools.product(hemispheres,
directions):
loc, mag = wind_stress_metrics(xnew, ynew, hemisphere, direction)
metric_dict[(hemisphere, direction, 'location')].append(loc)
metric_dict[(hemisphere, direction, 'magnitude')].append(mag)
# Write the output file
atts = cube.attributes
infile_history = {inargs.infiles[0]: history[0]}
atts['history'] = gio.write_metadata(file_info=infile_history)
units_dict = {
'magnitude': cube.units,
'location': cube.coord('latitude').units
}
cube_list = create_outcubes(metric_dict, cube.attributes, units_dict,
cube.coord('time'))
iris.save(cube_list, inargs.outfile)
def smooth_data(cube, smooth_type):
"""Apply temporal smoothing to a data cube."""
assert smooth_type in ['annual', 'annual_running_mean']
if smooth_type == 'annual_running_mean':
cube = cube.rolling_window('time', iris.analysis.MEAN, 12)
elif smooth_type == 'annual':
cube = timeseries.convert_to_annual(cube)
return cube
def get_data(filenames,
var,
metadata_dict,
time_constraint,
sftlf_cube=None,
realm=None):
"""Read, merge, temporally aggregate and calculate zonal sum.
Positive is defined as down.
"""
if filenames:
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(filenames, gio.check_iris_var(var))
metadata_dict[filenames[0]] = 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 = cube.extract(time_constraint)
coord_names = [coord.name() for coord in cube.dim_coords]
if 'depth' in coord_names:
depth_constraint = iris.Constraint(depth=0)
cube = cube.extract(depth_constraint)
cube = timeseries.convert_to_annual(cube, full_months=True)
cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(
cube)
cube = multiply_by_area(cube)
if 'up' in cube.standard_name:
cube.data = cube.data * -1
if sftlf_cube and realm in ['ocean', 'land']:
cube = uconv.apply_land_ocean_mask(cube, sftlf_cube, realm)
zonal_sum = cube.collapsed('longitude', iris.analysis.SUM)
zonal_sum.remove_coord('longitude')
grid_spacing = grids.get_grid_spacing(zonal_sum)
zonal_sum.data = zonal_sum.data / grid_spacing
else:
zonal_sum = None
return zonal_sum, metadata_dict
def main(inargs):
"""Run the program."""
tas_cube, history = gio.combine_files(inargs.tas_files, inargs.var)
if inargs.annual:
tas_cube = timeseries.convert_to_annual(tas_cube)
area_data = spatial_weights.area_array(tas_cube)
coord_names = [coord.name() for coord in tas_cube.dim_coords]
tasga_cube = tas_cube.collapsed(coord_names[1:], iris.analysis.MEAN, weights=area_data)
tasga_cube.remove_coord(coord_names[1])
tasga_cube.remove_coord(coord_names[2])
tasga_cube.attributes['history'] = cmdprov.new_log(git_repo=repo_dir)
iris.save(tasga_cube, inargs.outfile)
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 main(inargs):
"""Run the program."""
cube = iris.load_cube(inargs.infile, inargs.var)
cube = timeseries.convert_to_annual(cube, chunk=inargs.chunk)
log = cmdprov.new_log(
infile_history={inargs.infile: cube.attributes['history']},
git_repo=repo_dir)
cube.attributes['history'] = log
#assert cube.data.dtype == numpy.float32
#iris.save(cube, outfile, netcdf_format='NETCDF3_CLASSIC')
iris.save(cube, inargs.outfile)
def main(inargs):
"""Run the program."""
cube, history = gio.combine_files(inargs.infiles, inargs.var)
if inargs.annual:
cube = timeseries.convert_to_annual(cube, aggregation='mean', days_in_month=True)
if inargs.flux_to_mag:
cube = uconv.flux_to_magnitude(cube)
dim_coord_names = [coord.name() for coord in cube.dim_coords]
assert dim_coord_names[0] in ['time', 'year']
cube.data = numpy.cumsum(cube.data, axis=0)
cube.attributes['history'] = cmdprov.new_log(git_repo=repo_dir, infile_history={inargs.infiles[0]: history[0]})
iris.save(cube, inargs.outfile)
def main(inargs):
"""Run the program."""
region_constraint = iris.Constraint(
region='atlantic_arctic_ocean'
) # "atlantic_arctic_ocean", "indian_pacific_ocean ", "global_ocean "
cube = iris.load(inargs.infiles,
'ocean_meridional_overturning_mass_streamfunction'
& region_constraint,
callback=save_history)
if not cube:
cube = iris.load(inargs.infiles,
'ocean_meridional_overturning_mass_streamfunction',
callback=save_history)
equalise_attributes(cube)
cube = cube.concatenate_cube()
cube = cube[:, 0, :, :] # index for Atlantic
else:
equalise_attributes(cube)
cube = cube.concatenate_cube()
cube.remove_coord('region')
cube = gio.check_time_units(cube)
cube = timeseries.convert_to_annual(cube)
target_lat, error = uconv.find_nearest(cube.coord('latitude').points,
30,
index=False)
cube = cube.extract(iris.Constraint(latitude=target_lat))
cube.remove_coord('latitude')
assert str(cube.units) == 'kg s-1'
cube.data = (cube.data / 1023) / 1e+6
cube.units = 'Sv'
#dim_coord_names = [coord.name() for coord in cube.dim_coords]
#vert_extents = spatial_weights.calc_vertical_weights_1D(cube.coord('depth'), dim_coord_names, cube.shape)
metric = cube.collapsed('depth', iris.analysis.MAX)
metric.remove_coord('depth')
try:
metric.attributes['history'] = gio.write_metadata(
file_info={inargs.infiles[0]: cube.attributes['history']})
except KeyError:
pass
iris.save(metric, inargs.outfile)
def read_data(infile, variable, calc_annual=False, chunk=False):
"""Load the input data."""
cube = iris.load_cube(infile, gio.check_iris_var(variable))
cube = gio.check_time_units(cube)
if calc_annual:
cube = timeseries.convert_to_annual(cube, chunk=chunk)
coord_names = [coord.name() for coord in cube.dim_coords]
aux_coord_names = [coord.name() for coord in cube.aux_coords]
assert 'time' in coord_names
grid_type = 'curvilinear' if aux_coord_names == ['latitude', 'longitude'
] else 'latlon'
return cube, coord_names, aux_coord_names, grid_type
def main(inargs):
"""Run the program."""
temperature_cube, history = gio.combine_files(inargs.temperature_files,
inargs.var)
temperature_atts = temperature_cube.attributes
metadata_dict = {inargs.temperature_files[0]: history[0]}
level_subset = gio.iris_vertical_constraint(inargs.min_depth,
inargs.max_depth)
temperature_cube = temperature_cube.extract(level_subset)
if inargs.annual:
temperature_cube = timeseries.convert_to_annual(temperature_cube,
chunk=inargs.chunk)
if inargs.regrid:
area_cube = read_area_file(inargs.regrid)
temperature_cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(
temperature_cube, weights=area_cube.data)
volume_data = spatial_weights.volume_array(temperature_cube)
grid = 'y72x144'
else:
assert inargs.volume_file, "Must provide volume file if not regridding data"
volume_data, metadata_dict = get_volume(inargs.volume_file,
temperature_cube, level_subset,
metadata_dict)
coord_names = [coord.name() for coord in temperature_cube.dim_coords]
grid = None
ohc_cube = ohc(temperature_cube,
volume_data,
inargs.density,
inargs.specific_heat,
coord_names,
vertical_integral=inargs.vertical_integral,
chunk=inargs.chunk)
ohc_cube = add_metadata(temperature_cube, temperature_atts, ohc_cube,
inargs)
log = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir)
ohc_cube.attributes['history'] = log
iris.save(ohc_cube, inargs.outfile)
def read_global_variable(model, variable, ensemble, manual_files):
"""Read data for a global variable"""
manual = file_match(manual_files, model, variable, ensemble)
if manual or variable == 'massa':
file_list = manual
else:
file_list = clef_search(model, variable, ensemble)
if file_list:
cube, history = gio.combine_files(file_list, names[variable])
cube = timeseries.convert_to_annual(cube)
cube = time_check(cube)
extra_log.append(file_list)
else:
cube = None
return cube
def main(inargs):
"""Run the program."""
for infile in inargs.infiles:
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load_cube(infile, inargs.var)
cube = timeseries.convert_to_annual(cube)
metadata_dict = {infile: cube.attributes['history']}
cube.attributes['history'] = gio.write_metadata(
file_info=metadata_dict)
outfile = infile.replace('mon', 'yr')
outfile = outfile.replace('ua6', 'r87/dbi599')
#assert cube.data.dtype == numpy.float32
iris.save(cube, outfile, netcdf_format='NETCDF3_CLASSIC')
print(outfile)
del cube
def load_data(infiles, basin):
"""Load, temporally aggregate and spatially slice input data"""
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(infiles, 'ocean_meridional_overturning_mass_streamfunction', callback=save_history)
equalise_attributes(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube = cube[:, basin_index[basin], : ,:]
cube = timeseries.convert_to_annual(cube)
experiment = cube.attributes['experiment_id']
depth_constraint = iris.Constraint(depth=lambda cell: cell <= 250)
lat_constraint = iris.Constraint(latitude=lambda cell: -30.0 <= cell < 30.0)
cube = cube.extract(depth_constraint & lat_constraint)
return cube, experiment
def load_data(infile, basin_cube, basin_name):
"""Load, temporally aggregate and spatially slice input data"""
cube = iris.load_cube(infile, 'surface_downward_x_stress')
cube = timeseries.convert_to_annual(cube)
experiment = cube.attributes['experiment_id']
if experiment == 'historicalMisc':
experiment = 'historicalAA'
if not basin_name == 'globe':
if basin_cube:
ndim = cube.ndim
basin_array = uconv.broadcast_array(basin_cube.data,
[ndim - 2, ndim - 1],
cube.shape)
else:
basin_array = uconv.create_basin_array(cube)
cube.data.mask = numpy.where(
(cube.data.mask == False) & (basin_array == basins[basin_name]),
False, True)
sh_constraint = iris.Constraint(latitude=lambda cell: -30.0 <= cell < 0.0)
nh_constraint = iris.Constraint(latitude=lambda cell: 0.0 < cell <= 30.0)
scrit_constraint = iris.Constraint(
latitude=lambda cell: -17.0 <= cell < -13.0)
ncrit_constraint = iris.Constraint(
latitude=lambda cell: 13.0 < cell <= 17.0)
sh_cube = cube.extract(sh_constraint)
nh_cube = cube.extract(nh_constraint)
scrit_cube = cube.extract(scrit_constraint)
ncrit_cube = cube.extract(ncrit_constraint)
sh_mean = sh_cube.collapsed(['longitude', 'latitude'], iris.analysis.MEAN)
nh_mean = nh_cube.collapsed(['longitude', 'latitude'], iris.analysis.MEAN)
scrit_mean = scrit_cube.collapsed(['longitude', 'latitude'],
iris.analysis.MEAN)
ncrit_mean = ncrit_cube.collapsed(['longitude', 'latitude'],
iris.analysis.MEAN)
return sh_mean, nh_mean, scrit_mean, ncrit_mean, experiment
def get_data(filenames,
var,
metadata_dict,
time_constraint,
area=False,
invert_evap=False):
"""Read, merge, temporally aggregate and calculate zonal mean."""
if filenames:
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(filenames, gio.check_iris_var(var))
metadata_dict[filenames[0]] = 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 = cube.extract(time_constraint)
cube = timeseries.convert_to_annual(cube, full_months=True)
cube, coord_names, regrid_status = grids.curvilinear_to_rectilinear(
cube)
assert cube.units == 'kg m-2 s-1'
cube.data = cube.data * 86400
units = 'mm/day'
if invert_evap and (var == 'water_evaporation_flux'):
cube.data = cube.data * -1
if area:
cube = spatial_weights.multiply_by_area(cube)
zonal_mean = cube.collapsed('longitude', iris.analysis.MEAN)
zonal_mean.remove_coord('longitude')
else:
zonal_mean = None
return zonal_mean, metadata_dict
def main(inargs):
"""Run the program."""
level_subset = gio.iris_vertical_constraint(inargs.min_depth,
inargs.max_depth)
for temperature_file in inargs.temperature_files:
temperature_cube = iris.load_cube(
temperature_file, inargs.temperature_var & level_subset)
temperature_cube = gio.check_time_units(temperature_cube)
metadata_dict = {
temperature_file: temperature_cube.attributes['history']
}
temperature_atts = temperature_cube.attributes
if inargs.annual:
temperature_cube = timeseries.convert_to_annual(temperature_cube,
chunk=inargs.chunk)
coord_names = [coord.name() for coord in temperature_cube.dim_coords]
assert coord_names[0] == 'time'
assert coord_names[1] == 'depth'
volume_data, metadata_dict = get_volume(inargs.volume_file,
inargs.area_file,
temperature_cube,
metadata_dict)
ohc_cube = calc_ohc_vertical_integral(temperature_cube,
volume_data,
inargs.density,
inargs.specific_heat,
coord_names,
chunk=inargs.chunk)
ohc_cube = add_metadata(temperature_cube, temperature_atts, ohc_cube,
metadata_dict, inargs)
ohc_file = get_outfile_name(temperature_file, annual=inargs.annual)
iris.save(ohc_cube, ohc_file)
print(ohc_file)
def load_data(filenames, standard_name, time_constraint, metadata_dict,
input_timescale):
"""Basic data loading and temporal smoothing"""
with iris.FUTURE.context(cell_datetime_objects=True):
cube = iris.load(filenames, gio.check_iris_var(standard_name))
assert cube, "files do not exist: %s" % (filenames[0])
metadata_dict[filenames[0]] = cube[0].attributes['history']
equalise_attributes(cube)
iris.util.unify_time_units(cube)
cube = cube.concatenate_cube()
cube = gio.check_time_units(cube)
cube = cube.extract(time_constraint)
cube = iris.util.squeeze(cube)
attributes = cube.attributes
if not input_timescale == 'annual':
cube = timeseries.convert_to_annual(cube, full_months=True)
return cube, metadata_dict, attributes
