def get_log_text(extra_log): """Write the metadata to file.""" flat_list = [item for sublist in extra_log for item in sublist] log_text = cmdprov.new_log(git_repo=repo_dir, extra_notes=flat_list) return log_text
def main(inargs): """Run the program.""" assert len(inargs.infiles) > 1 if inargs.variables: variable_list = inargs.variables else: cube_list = iris.load(inargs.infiles[0]) variable_list = [cube.long_name for cube in cube_list] cube_list = iris.cube.CubeList([]) for var in variable_list: cube, history = gio.combine_files(inargs.infiles, var) cube_list.append(cube) metadata_dict = {inargs.infiles[-1]: history[-1]} log_entry = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir) if len(cube_list) > 1: iris.util.equalise_attributes(cube_list) for cube in cube_list: cube.attributes['history'] = log_entry else: cube_list = cube_list[0] cube_list.attributes['history'] = log_entry iris.save(cube_list, inargs.outfile)
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.""" coefficient_a_cube = iris.load_cube(inargs.coefficient_file, 'coefficient a') coefficient_b_cube = iris.load_cube(inargs.coefficient_file, 'coefficient b') coefficient_c_cube = iris.load_cube(inargs.coefficient_file, 'coefficient c') coefficient_d_cube = iris.load_cube(inargs.coefficient_file, 'coefficient d') data_cube, data_history = gio.combine_files(inargs.data_files, inargs.var) coord_names = [coord.name() for coord in data_cube.coords(dim_coords=True)] assert coord_names[0] == 'year' if not inargs.branch_year == None: branch_year = inargs.branch_year else: branch_year = get_branch_year(data_cube, inargs.control_time_units) time_values = numpy.arange(branch_year, branch_year + data_cube.shape[0]) drift_signal, start_polynomial = remove_drift.apply_polynomial(time_values, coefficient_a_cube.data, coefficient_b_cube.data, coefficient_c_cube.data, coefficient_d_cube.data, poly_start=None) new_cube = data_cube - drift_signal #remove_drift.check_data(new_cube, data_cube, inargs.data_file) new_cube.metadata = data_cube.metadata metadata_dict = {inargs.data_files[0]: data_history[0], inargs.coefficient_file: coefficient_a_cube.attributes['history']} new_cube.attributes['history'] = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir) iris.save(new_cube, inargs.outfile)
def main(inargs): """Run the program.""" pe_cube, pe_history = gio.combine_files( inargs.pe_files, 'precipitation minus evaporation flux') lat_coord = pe_cube.coord('latitude').points region_data = np.apply_along_axis(get_regional_totals, 1, pe_cube.data, lat_coord) if inargs.cumsum: region_data = np.cumsum(region_data, axis=0) region_coord = create_region_coord() time_coord = pe_cube.coord('time') iris.std_names.STD_NAMES['precipitation_minus_evaporation_flux'] = { 'canonical_units': pe_cube.units } dim_coords_list = [(time_coord, 0), (region_coord, 1)] out_cube = iris.cube.Cube( region_data, standard_name='precipitation_minus_evaporation_flux', long_name=pe_cube.long_name, var_name=pe_cube.var_name, units=pe_cube.units, attributes=pe_cube.attributes, dim_coords_and_dims=dim_coords_list) out_cube.attributes['history'] = cmdprov.new_log( infile_history={inargs.pe_files[0]: pe_history[0]}, git_repo=repo_dir) iris.save(out_cube, inargs.outfile)
def main(inargs): """Run the program.""" metadata_dict = {} if inargs.ref_file: ref_cube = iris.load_cube(inargs.ref_file[0], inargs.ref_file[1]) else: ref_cube = None cube_list = iris.cube.CubeList([]) for fnum, filename in enumerate(inargs.infiles): cube = iris.load_cube(filename, gio.check_iris_var(inargs.var)) history = cube.attributes['history'] #coord_names = [coord.name() for coord in cube.dim_coords] new_aux_coord = iris.coords.AuxCoord(fnum, long_name='ensemble_member', units='no_unit') cube.add_aux_coord(new_aux_coord) if ref_cube: cube = regrid_cube(cube, ref_cube) else: ref_cube = cube.copy() cube_list.append(cube) ensemble_agg = calc_ensemble(cube_list, inargs.aggregation) metadata_dict[filename] = history ensemble_agg.attributes['history'] = cmdprov.new_log( infile_history=metadata_dict, git_repo=repo_dir) iris.save(ensemble_agg, inargs.outfile)
def main(inargs): """Run the program.""" standard_names = { 'thetao': 'sea_water_potential_temperature', 'so': 'sea_water_salinity' } volume_cube = gio.get_ocean_weights(inargs.volfile) output_cubelist = iris.cube.CubeList([]) cube, history = gio.combine_files(inargs.infiles, standard_names[inargs.invar], checks=True) ntsteps = cube.shape[0] for tstep, cube_slice in enumerate(cube.slices_over('time')): print(f'time step {tstep + 1} of {ntsteps}') coord_names = [coord.name() for coord in cube.dim_coords] aux_coord_names = [coord.name() for coord in cube.aux_coords] ga = cube_slice.collapsed(coord_names[1:], iris.analysis.MEAN, weights=volume_cube.data) for coord in coord_names[1:] + aux_coord_names: ga.remove_coord(coord) ga.var_name = inargs.invar + 'ga' output_cubelist.append(ga) outcube = output_cubelist.merge()[0] metadata_dict = {} metadata_dict[inargs.infiles[0]] = history metadata_dict[inargs.volfile] = volume_cube.attributes['history'] outcube.attributes['history'] = cmdprov.new_log( infile_history=metadata_dict, git_repo=repo_dir) iris.save(outcube, inargs.outfile)
def main(inargs): """Run the program.""" ref_cube = iris.load_cube(inargs.ref_file, inargs.ref_var) coord_names = [coord.name() for coord in ref_cube.dim_coords] if ref_cube.ndim == 4: ref_cube = ref_cube[0, 0, ::] ref_cube.remove_coord(coord_names[0]) ref_cube.remove_coord(coord_names[1]) elif ref_cube.ndim == 3: ref_cube = ref_cube[0, ::] ref_cube.remove_coord(coord_names[0]) else: assert ref_cube.ndim == 2 if inargs.sftlf_file: sftlf_cube = iris.load_cube(inargs.sftlf_file, 'land_area_fraction') ref_cube = uconv.apply_land_ocean_mask(ref_cube, sftlf_cube, 'ocean', threshold=inargs.land_threshold) ref_is_basin = ref_cube.var_name == 'basin' basin_array = create_basin_array(ref_cube, ref_is_basin) basin_cube = construct_basin_cube(basin_array, ref_cube.attributes, ref_cube.dim_coords) basin_cube.attributes['history'] = cmdprov.new_log(git_repo=repo_dir) iris.save(basin_cube, inargs.out_file)
def main(inargs): """Run the program.""" standard_names = { 'thetao': 'sea_water_potential_temperature', 'so': 'sea_water_salinity' } volume_cube = gio.get_ocean_weights(inargs.volfile) output_cubelist = iris.cube.CubeList([]) for infile in inargs.infiles: cube = iris.load_cube(infile, standard_names[inargs.invar]) weights = uconv.broadcast_array(volume_cube.data, [1, 3], cube.shape) coord_names = [coord.name() for coord in cube.dim_coords] aux_coord_names = [coord.name() for coord in cube.aux_coords] ga = cube.collapsed(coord_names[1:], iris.analysis.MEAN, weights=weights) for coord in coord_names[1:] + aux_coord_names: ga.remove_coord(coord) ga.var_name = inargs.invar + 'ga' output_cubelist.append(ga) print(infile) outcube = gio.combine_cubes(output_cubelist) metadata_dict = {} metadata_dict[infile] = cube.attributes['history'] metadata_dict[inargs.volfile] = volume_cube.attributes['history'] outcube.attributes['history'] = cmdprov.new_log( infile_history=metadata_dict, git_repo=repo_dir) iris.save(outcube, inargs.outfile)
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 main(inargs): """Run the program.""" assert len(inargs.infiles) == len(inargs.invars) cube_list = iris.cube.CubeList([]) bin_vars = ['tbin', 'sbin', 'tsbin'] bin_names = ['temperature', 'salinity', 'temperature and salinity'] for bin_var, bin_name in zip(bin_vars, bin_names): running_sum = 0 metadata_dict = {} for file_name, base_var in zip(inargs.infiles, inargs.invars): cube = iris.load_cube(file_name, f'{base_var} binned by {bin_name}') metadata_dict[file_name] = cube.attributes['history'] running_sum = running_sum + cube.data cube.data = running_sum if inargs.ref_file: ref_cube = iris.load_cube(inargs.ref_file, inargs.new_var) cube.attributes = ref_cube.attributes cube.var_name = ref_cube.var_name + '_' + bin_var cube.long_name = ref_cube.long_name + ' binned by ' + bin_name else: assert inargs.new_var in long_names.keys() cube.var_name = inargs.new_var + '_' + bin_var cube.long_name = long_names[ inargs.new_var] + ' binned by ' + bin_name assert cube.units == 'W' cube_list.append(cube) log = cmdprov.new_log(infile_history=metadata_dict, git_repo=repo_dir) for cube in cube_list: cube.attributes['history'] = log iris.save(cube_list, inargs.new_file)
def get_log_and_key(pr_file, history_attr, plot_type): """Get key and command line log for image metadata. Different image formats allow different metadata keys. Args: pr_file (str): Input precipitation file history_attr (str): History attribute from pr_file plot_type (str): File format for output image """ valid_keys = { 'png': 'History', 'pdf': 'Title', 'eps': 'Creator', 'ps': 'Creator' } assert plot_type in valid_keys.keys( ), f"Image format not one of: {*[*valid_keys],}" log_key = valid_keys[plot_type] new_log = cmdprov.new_log(infile_history={pr_file: history_attr}) new_log = new_log.replace('\n', ' END ') return log_key, new_log
def main(inargs): """Run the program.""" dset = xr.open_mfdataset(inargs.infiles) if inargs.time_bounds: start, end = inargs.time_bounds dset = dset.sel(time=slice(start, end)) clim_dset = dset.groupby('time.month').mean('time', keep_attrs=True) if 'history' in dset.attrs: history = dset.attrs['history'] log = cmdprov.new_log(infile_history={inargs.infiles[0]: history}, git_repo=repo_dir) else: log = cmdprov.new_log(git_repo=repo_dir) clim_dset.attrs['history'] = log clim_dset.to_netcdf(inargs.outfile)
def main(inargs): """Run the program.""" cube = iris.load_cube(inargs.infile) for bogus_indexes, target_indexes in zip(inargs.bogus_indexes, inargs.target_indexes): exec('cube.data[%s] = cube.data[%s]' %(bogus_indexes, target_indexes)) cube.attributes['history'] = cmdprov.new_log(infile_history={inargs.infile: cube.attributes['history']}, git_repo=repo_dir) iris.save(cube, inargs.outfile)
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.""" 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(args): """Run the command line program.""" temperature_cube, temperature_history = gio.combine_files(args.temperature_file, args.temperature_var, checks=True) salinity_cube, salinity_history = gio.combine_files(args.salinity_file, 'sea_water_salinity', checks=True) assert 'c' in str(temperature_cube.units).lower(), "Input temperature units must be in celsius" # if not 'C' in str(bigthetao_cube.units): # bigthetao_cube.data = bigthetao_cube.data - 273.15 # data_median = np.ma.median(bigthetao_cube.data) # assert data_median < 100 # assert data_median > -10 # bigthetao_cube.units = 'C' target_shape = temperature_cube.shape[1:] depth = temperature_cube.coord('depth').points * -1 broadcast_depth = uconv.broadcast_array(depth, 0, target_shape) broadcast_longitude = uconv.broadcast_array(temperature_cube.coord('longitude').points, [1, 2], target_shape) broadcast_latitude = uconv.broadcast_array(temperature_cube.coord('latitude').points, [1, 2], target_shape) pressure = gsw.p_from_z(broadcast_depth, broadcast_latitude) absolute_salinity = gsw.SA_from_SP(salinity_cube.data, pressure, broadcast_longitude, broadcast_latitude) if args.temperature_var == 'sea_water_conservative_temperature': conservative_temperature = temperature_cube.data elif args.temperature_var == 'sea_water_potential_temperature': conservative_temperature = gsw.CT_from_pt(absolute_salinity, temperature_cube.data) else: raise ValueError('Invalid temperature variable') if args.coefficient == 'alpha': coefficient_data = gsw.alpha(absolute_salinity, conservative_temperature, pressure) var_name = 'alpha' standard_name = 'thermal_expansion_coefficient' long_name = 'thermal expansion coefficient' units = '1/K' elif args.coefficient == 'beta': coefficient_data = gsw.beta(absolute_salinity, conservative_temperature, pressure) var_name = 'beta' standard_name = 'saline_contraction_coefficient' long_name = 'saline contraction coefficient' units = 'kg/g' else: raise ValueError('Coefficient must be alpha or beta') iris.std_names.STD_NAMES[standard_name] = {'canonical_units': units} coefficient_cube = temperature_cube.copy() coefficient_cube.data = coefficient_data coefficient_cube.standard_name = standard_name coefficient_cube.long_name = long_name coefficient_cube.var_name = var_name coefficient_cube.units = units coefficient_cube.attributes['history'] = cmdprov.new_log(git_repo=repo_dir) iris.save(coefficient_cube, args.outfile)
def main(args): """Run the program.""" dset = xr.open_dataset(args.pr_file) clim = dset['pr'].groupby('time.season').mean('time', keep_attrs=True) clim = convert_pr_units(clim) create_plot(clim, dset.attrs['source_id'], args.season) new_log = cmdprov.new_log( infile_logs={args.pr_file: dset.attrs['history']}) plt.savefig(args.output_file, metadata={'History': new_log}, dpi=200)
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.""" 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 set_global_atts(inargs, cube, infile1, history): """Set global attributes.""" atts = copy.copy(cube.attributes) atts['polynomial'] = 'a + bx + cx^2 + dx^3' try: atts['history'] = cmdprov.new_log(infile_history={infile1: history}, git_repo=repo_dir) except IndexError: pass return atts
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.""" cube = iris.load_cube(inargs.infile, inargs.var) cube.data = numpy.ma.masked_invalid(cube.data) if inargs.fill_value: cube.data = numpy.ma.masked_where(cube.data >= cube.data.fill_value, cube.data) if inargs.mask_value: cube.data = numpy.ma.masked_where(cube.data == inargs.mask_value, cube.data) cube.attributes['history'] = cmdprov.new_log(git_repo=repo_dir, infile_history={inargs.infile: cube.attributes['history']}) iris.save(cube, inargs.outfile)
def combine_infiles(inargs, time_constraint, depth_constraint): """Combine multiple input files into one cube""" cube, history = gio.combine_files(inargs.infiles, inargs.var) atts = cube[0].attributes cube = cube.extract(time_constraint & depth_constraint) cube = iris.util.squeeze(cube) log = cmdprov.new_log(infile_history={inargs.infiles[0]: history[0]}, git_repo=repo_dir) cube.attributes['history'] = log return cube
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.""" 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.""" 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 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 get_log_and_key(pr_file, history_attr, plot_type): valid_keys = { 'png': 'History', 'pdf': 'Title', 'eps': 'Creator', 'ps': 'Creator' } assert plot_type in valid_keys.keys( ), f"Image format not one of: {*[*valid_keys],}" log_key = valid_keys[plot_type] new_log = cmdprov.new_log(infile_history={pr_file: history_attr}) new_log = new_log.replace('\n', ' END ') return log_key, new_log
def main(inargs): """Run the program.""" cube = iris.load_cube(inargs.infile, inargs.variable) time_axis = cube.coord('time') new_units = cf_units.Unit(inargs.new_time_units, calendar=time_axis.units.calendar) time_axis.convert_units(new_units) new_log = cmdprov.new_log(infile_history={inargs.infile: cube.attributes['history']}) cube.attributes['history'] = new_log if inargs.infile == inargs.outfile: cube.data # to realise lazy data to allow file overwrite iris.save(cube, inargs.outfile)