def make_transect_contours( cfg, metadata, filename, ): """ Make a contour plot of the transect for an indivudual model. This tool loads the cube from the file, checks that the units are sensible BGC units, checks for layers, adjusts the titles accordingly, determines the ultimate file name and format, then saves the image. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata['short_name']) cube = make_depth_safe(cube) # Load threshold/thresholds. plot_details = {} colours = [] thresholds = diagtools.load_thresholds(cfg, metadata) linewidths = [1 for thres in thresholds] linestyles = ['-' for thres in thresholds] cubes = make_cube_region_dict(cube) for region, cube in cubes.items(): for itr, thres in enumerate(thresholds): colour = diagtools.get_colour_from_cmap(itr, len(thresholds)) label = str(thres) + ' ' + str(cube.units) colours.append(colour) plot_details[thres] = { 'c': colour, 'lw': 1, 'ls': '-', 'label': label } qplt.contour(cube, thresholds, colors=colours, linewidths=linewidths, linestyles=linestyles, rasterized=True) # Determine y log scale. if determine_set_y_logscale(cfg, metadata): plt.axes().set_yscale('log') add_sea_floor(cube) # Add legend diagtools.add_legend_outside_right(plot_details, plt.gca(), column_width=0.08, loc='below') # Add title to plot title = ' '.join([ metadata['dataset'], metadata['long_name'], determine_transect_str(cube, region) ]) titlify(title) # Load image format extention image_extention = diagtools.get_image_format(cfg) # Determine image filename: if metadata['dataset'].find('MultiModel') > -1: path = diagtools.folder( cfg['plot_dir']) + os.path.basename(filename) path.replace('.nc', region + '_transect_contour' + image_extention) else: path = diagtools.get_image_path( cfg, metadata, suffix=region + 'transect_contour' + image_extention, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def multi_model_contours( cfg, metadatas, ): """ Make a multi model comparison plot showing several transect contour plots. This tool loads several cubes from the files, checks that the units are sensible BGC units, checks for layers, adjusts the titles accordingly, determines the ultimate file name and format, then saves the image. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadatas: dict The metadatas dictionairy for a specific model. """ #### # Load the data for each layer as a separate cube model_cubes = {} regions = {} thresholds = {} set_y_logscale = True for filename in sorted(metadatas): cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadatas[filename]['short_name']) cube = make_depth_safe(cube) cubes = make_cube_region_dict(cube) model_cubes[filename] = cubes for region in model_cubes[filename]: regions[region] = True # Determine y log scale. set_y_logscale = determine_set_y_logscale(cfg, metadatas[filename]) # Load threshold/thresholds. tmp_thresholds = diagtools.load_thresholds(cfg, metadatas[filename]) for threshold in tmp_thresholds: thresholds[threshold] = True # Load image format extention image_extention = diagtools.get_image_format(cfg) # Make a plot for each layer and each threshold for region, threshold in itertools.product(regions, thresholds): logger.info('plotting threshold: \t%s', threshold) title = '' plot_details = {} # Plot each file in the group for index, filename in enumerate(sorted(metadatas)): color = diagtools.get_colour_from_cmap(index, len(metadatas)) linewidth = 1. linestyle = '-' # Determine line style for MultiModel statistics: if 'MultiModel' in metadatas[filename]['dataset']: linewidth = 2. linestyle = ':' # Determine line style for Observations if metadatas[filename]['project'] in diagtools.get_obs_projects(): color = 'black' linewidth = 1.7 linestyle = '-' qplt.contour(model_cubes[filename][region], [ threshold, ], colors=[ color, ], linewidths=linewidth, linestyles=linestyle, rasterized=True) plot_details[filename] = { 'c': color, 'ls': linestyle, 'lw': linewidth, 'label': metadatas[filename]['dataset'] } if set_y_logscale: plt.axes().set_yscale('log') title = metadatas[filename]['long_name'] units = str(model_cubes[filename][region].units) add_sea_floor(model_cubes[filename][region]) # Add title, threshold, legend to plots title = ' '.join([ title, str(threshold), units, determine_transect_str(model_cubes[filename][region], region) ]) titlify(title) plt.legend(loc='best') # Saving files: if cfg['write_plots']: path = diagtools.get_image_path( cfg, metadatas[filename], prefix='MultipleModels', suffix='_'.join([ 'contour_tramsect', region, str(threshold) + image_extention ]), metadata_id_list=[ 'field', 'short_name', 'preprocessor', 'diagnostic', 'start_year', 'end_year' ], ) # Resize and add legend outside thew axes. plt.gcf().set_size_inches(9., 6.) diagtools.add_legend_outside_right(plot_details, plt.gca(), column_width=0.15) logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_map_extent_plots( cfg, metadata, filename, ): """ Make an extent map plot showing several times for an individual model. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) iris.coord_categorisation.add_year(cube, 'time') cube = diagtools.bgc_units(cube, metadata['short_name']) cube = agregate_by_season(cube) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention image_extention = diagtools.get_image_format(cfg) # Load threshold, pole and season threshold = float(cfg['threshold']) pole = get_pole(cube) season = get_season(cube) # Start making figure for layer_index, (layer, cube_layer) in enumerate(cubes.items()): fig = plt.figure() fig.set_size_inches(7, 7) if pole == 'North': # North Hemisphere projection = cartopy.crs.NorthPolarStereo() ax1 = plt.subplot(111, projection=projection) ax1.set_extent([-180, 180, 50, 90], cartopy.crs.PlateCarree()) if pole == 'South': # South Hemisphere projection = cartopy.crs.SouthPolarStereo() ax1 = plt.subplot(111, projection=projection) ax1.set_extent([-180, 180, -90, -50], cartopy.crs.PlateCarree()) try: ax1.add_feature(cartopy.feature.LAND, zorder=10, facecolor=[0.8, 0.8, 0.8]) except ConnectionRefusedError: logger.error('Cartopy was unable add coastlines due to a ' 'connection error.') ax1.gridlines(linewidth=0.5, color='black', zorder=20, alpha=0.5, linestyle='--') try: plt.gca().coastlines() except AttributeError: logger.warning('make_polar_map: Not able to add coastlines') times = np.array(cube.coord('time').points.astype(float)) plot_desc = {} for time_itr, time in enumerate(times): cube = cube_layer[time_itr] line_width = 1 color = plt.cm.jet(float(time_itr) / float(len(times))) label = get_year(cube) plot_desc[time] = { 'label': label, 'c': [ color, ], 'lw': [ line_width, ], 'ls': [ '-', ] } layer = str(layer) qplt.contour(cube, [ threshold, ], colors=plot_desc[time]['c'], linewidths=plot_desc[time]['lw'], linestyles=plot_desc[time]['ls'], rasterized=True) # Add legend legend_size = len(plot_desc) + 1 ncols = int(legend_size / 25) + 1 ax1.set_position([ ax1.get_position().x0, ax1.get_position().y0, ax1.get_position().width * (1. - 0.1 * ncols), ax1.get_position().height ]) fig.set_size_inches(7 + ncols * 1.2, 7) # Construct dummy plots. for i in sorted(plot_desc): plt.plot( [], [], c=plot_desc[i]['c'][0], lw=plot_desc[i]['lw'][0], ls=plot_desc[i]['ls'][0], label=plot_desc[i]['label'], ) legd = ax1.legend(loc='center left', ncol=ncols, prop={'size': 10}, bbox_to_anchor=(1., 0.5)) legd.draw_frame(False) legd.get_frame().set_alpha(0.) # Add title to plot title = ' '.join([ metadata['dataset'], ]) if layer: title = ' '.join([ title, '(', layer, str(cube_layer.coords('depth')[0].units), ')' ]) plt.title(title) # Determine image filename: suffix = '_'.join(['ortho_map', pole, season, str(layer_index)]) suffix = suffix.replace(' ', '') + image_extention if multi_model: path = diagtools.folder(cfg['plot_dir']) path = path + os.path.basename(filename) path = path.replace('.nc', suffix) else: path = diagtools.get_image_path( cfg, metadata, suffix=suffix, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_transects_plots( cfg, metadata, filename, ): """ Make a simple plot of the transect for an indivudual model. This tool loads the cube from the file, checks that the units are sensible BGC units, checks for layers, adjusts the titles accordingly, determines the ultimate file name and format, then saves the image. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata['short_name']) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 cube = make_depth_safe(cube) cubes = make_cube_region_dict(cube) # Determine y log scale. set_y_logscale = determine_set_y_logscale(cfg, metadata) for region, cube in cubes.items(): # Make a dict of cubes for each layer. qplt.contourf(cube, 15, linewidth=0, rasterized=True) if set_y_logscale: plt.axes().set_yscale('log') if region: region_title = region else: region_title = determine_transect_str(cube, region) # Add title to plot title = ' '.join( [metadata['dataset'], metadata['long_name'], region_title]) titlify(title) # Load image format extention image_extention = diagtools.get_image_format(cfg) # Determine image filename: if multi_model: path = diagtools.folder( cfg['plot_dir']) + os.path.basename(filename).replace( '.nc', region + '_transect' + image_extention) else: path = diagtools.get_image_path( cfg, metadata, suffix=region + 'transect' + image_extention, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_ts_plots( cfg, metadata, filename, ): """ Make a ice extent and ice area time series plot for an individual model. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) iris.coord_categorisation.add_year(cube, 'time') cube = diagtools.bgc_units(cube, metadata['short_name']) cube = agregate_by_season(cube) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention image_extention = diagtools.get_image_format(cfg) # # Load threshold, pole, season. threshold = float(cfg['threshold']) pole = get_pole(cube) season = get_season(cube) # Making plots for each layer for plot_type in ['Ice Extent', 'Ice Area']: for layer_index, (layer, cube_layer) in enumerate(cubes.items()): layer = str(layer) times, data = calculate_area_time_series(cube_layer, plot_type, threshold) plt.plot(times, data) # Add title to plot title = ' '.join( [metadata['dataset'], pole, 'hemisphere', season, plot_type]) if layer: title = ' '.join([ title, '(', layer, str(cube_layer.coords('depth')[0].units), ')' ]) plt.title(title) # y axis label: plt.ylabel(' '.join([plot_type, 'm^2'])) # Determine image filename: suffix = '_'.join(['ts', metadata['preprocessor'], season, pole, plot_type, str(layer_index)])\ + image_extention suffix = suffix.replace(' ', '') if multi_model: path = diagtools.folder( cfg['plot_dir']) + os.path.basename(filename) path = path.replace('.nc', suffix) else: path = diagtools.get_image_path( cfg, metadata, suffix=suffix, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_map_plots( cfg, metadata, filename, ): """ Make a simple map plot for an individual model. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) iris.coord_categorisation.add_year(cube, 'time') cube = diagtools.bgc_units(cube, metadata['short_name']) cube = agregate_by_season(cube) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention and threshold. image_extention = diagtools.get_image_format(cfg) threshold = float(cfg['threshold']) # Making plots for each layer plot_types = ['Fractional cover', 'Ice Extent'] plot_times = [0, -1] for plot_type, plot_time in product(plot_types, plot_times): for layer_index, (layer, cube_layer) in enumerate(cubes.items()): layer = str(layer) if plot_type == 'Fractional cover': cmap = 'Blues_r' if plot_type == 'Ice Extent': cmap = create_ice_cmap(threshold) cube = cube_layer[plot_time] # use cube to determine which hemisphere, season and year. pole = get_pole(cube) time_str = get_time_string(cube) # Make the polar map. make_polar_map(cube, pole=pole, cmap=cmap) # Add title to plot title = ' '.join([metadata['dataset'], plot_type, time_str]) if layer: title = ' '.join([ title, '(', layer, str(cube_layer.coords('depth')[0].units), ')' ]) plt.title(title) # Determine image filename: suffix = '_'.join( ['ortho_map', plot_type, time_str, str(layer_index)]) suffix = suffix.replace(' ', '') + image_extention if multi_model: path = diagtools.folder(cfg['plot_dir']) path = path + os.path.basename(filename) path = path.replace('.nc', suffix) else: path = diagtools.get_image_path( cfg, metadata, suffix=suffix, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def multi_model_time_series( cfg, metadata, ): """ Make a time series plot showing several preprocesssed datasets. This tool loads several cubes from the files, checks that the units are sensible BGC units, checks for layers, adjusts the titles accordingly, determines the ultimate file name and format, then saves the image. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. """ #### # Load the data for each layer as a separate cube model_cubes = {} layers = {} for filename in sorted(metadata): if metadata[filename]['frequency'] != 'fx': cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata[filename]['short_name']) cubes = diagtools.make_cube_layer_dict(cube) model_cubes[filename] = cubes for layer in cubes: layers[layer] = True # Load image format extention image_extention = diagtools.get_image_format(cfg) # Make a plot for each layer for layer in layers: title = '' z_units = '' plot_details = {} cmap = plt.cm.get_cmap('viridis') # Plot each file in the group for index, filename in enumerate(sorted(metadata)): if len(metadata) > 1: color = cmap(index / (len(metadata) - 1.)) else: color = 'blue' # Take a moving average, if needed. if 'moving_average' in cfg: cube = moving_average(model_cubes[filename][layer], cfg['moving_average']) else: cube = model_cubes[filename][layer] if 'MultiModel' in metadata[filename]['dataset']: timeplot( cube, c=color, # label=metadata[filename]['dataset'], ls=':', lw=2., ) plot_details[filename] = { 'c': color, 'ls': ':', 'lw': 2., 'label': metadata[filename]['dataset'] } else: timeplot( cube, c=color, # label=metadata[filename]['dataset']) ls='-', lw=2., ) plot_details[filename] = { 'c': color, 'ls': '-', 'lw': 2., 'label': metadata[filename]['dataset'] } title = metadata[filename]['long_name'] if layer != '': if model_cubes[filename][layer].coords('depth'): z_units = model_cubes[filename][layer].coord('depth').units else: z_units = '' # Add title, legend to plots if layer: title = ' '.join([title, '(', str(layer), str(z_units), ')']) plt.title(title) plt.legend(loc='best') plt.ylabel(str(model_cubes[filename][layer].units)) # Saving files: if cfg['write_plots']: path = diagtools.get_image_path( cfg, metadata[filename], prefix='MultipleModels_', suffix='_'.join(['timeseries', str(layer) + image_extention]), metadata_id_list=[ 'field', 'short_name', 'preprocessor', 'diagnostic', 'start_year', 'end_year' ], ) # Resize and add legend outside thew axes. plt.gcf().set_size_inches(9., 6.) diagtools.add_legend_outside_right(plot_details, plt.gca(), column_width=0.15) logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_time_series_plots( cfg, metadata, filename, ): """ Make a simple time series plot for an indivudual model 1D cube. This tool loads the cube from the file, checks that the units are sensible BGC units, checks for layers, adjusts the titles accordingly, determines the ultimate file name and format, then saves the image. Parameters ---------- cfg: dict the opened global config dictionairy, passed by ESMValTool. metadata: dict The metadata dictionairy for a specific model. filename: str The preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata['short_name']) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention image_extention = diagtools.get_image_format(cfg) # Making plots for each layer for layer_index, (layer, cube_layer) in enumerate(cubes.items()): layer = str(layer) if 'moving_average' in cfg: cube_layer = moving_average(cube_layer, cfg['moving_average']) if multi_model: timeplot(cube_layer, label=metadata['dataset'], ls=':') else: timeplot(cube_layer, label=metadata['dataset']) # Add title, legend to plots title = ' '.join([metadata['dataset'], metadata['long_name']]) if layer != '': if cube_layer.coords('depth'): z_units = cube_layer.coord('depth').units else: z_units = '' title = ' '.join([title, '(', layer, str(z_units), ')']) plt.title(title) plt.legend(loc='best') plt.ylabel(str(cube_layer.units)) # Determine image filename: if multi_model: path = diagtools.get_image_path( cfg, metadata, prefix='MultiModel', suffix='_'.join(['timeseries', str(layer) + image_extention]), metadata_id_list=[ 'field', 'short_name', 'preprocessor', 'diagnostic', 'start_year', 'end_year' ], ) else: path = diagtools.get_image_path( cfg, metadata, suffix='timeseries_' + str(layer_index) + image_extention, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_map_plots( cfg, metadata, filename, ): """ Make a simple map plot for an individual model. Parameters ---------- cfg: dict the opened global config dictionary, passed by ESMValTool. metadata: dict the metadata dictionary filename: str the preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata['short_name']) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention image_extention = diagtools.get_image_format(cfg) # Making plots for each layer for layer_index, (layer, cube_layer) in enumerate(cubes.items()): layer = str(layer) qplt.contourf(cube_layer, 25, linewidth=0, rasterized=True) try: plt.gca().coastlines() except AttributeError: logger.warning('Not able to add coastlines') # Add title to plot title = ' '.join([metadata['dataset'], metadata['long_name']]) if layer: title = ' '.join([ title, '(', layer, str(cube_layer.coords('depth')[0].units), ')' ]) plt.title(title) # Determine image filename: if multi_model: path = diagtools.folder( cfg['plot_dir']) + os.path.basename(filename).replace( '.nc', '_map_' + str(layer_index) + image_extention) else: path = diagtools.get_image_path( cfg, metadata, suffix='map_' + str(layer_index) + image_extention, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def multi_model_contours( cfg, metadata, ): """ Make a contour map showing several models. Parameters ---------- cfg: dict the opened global config dictionary, passed by ESMValTool. metadata: dict the metadata dictionary. """ #### # Load the data for each layer as a separate cube model_cubes = {} layers = {} for filename in sorted(metadata): cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata[filename]['short_name']) cubes = diagtools.make_cube_layer_dict(cube) model_cubes[filename] = cubes for layer in cubes: layers[layer] = True # Load image format extention image_extention = diagtools.get_image_format(cfg) # Load threshold/thresholds. thresholds = diagtools.load_thresholds(cfg, metadata) # Make a plot for each layer and each threshold for layer, threshold in itertools.product(layers, thresholds): title = '' z_units = '' plot_details = {} cmap = plt.cm.get_cmap('jet') land_drawn = False # Plot each file in the group for index, filename in enumerate(sorted(metadata)): if len(metadata) > 1: color = cmap(index / (len(metadata) - 1.)) else: color = 'blue' linewidth = 1. linestyle = '-' # Determine line style for Observations if metadata[filename]['project'] in diagtools.get_obs_projects(): color = 'black' linewidth = 1.7 linestyle = '-' # Determine line style for MultiModel statistics: if 'MultiModel' in metadata[filename]['dataset']: color = 'black' linestyle = ':' linewidth = 1.4 cube = model_cubes[filename][layer] qplt.contour(cube, [ threshold, ], colors=[ color, ], linewidths=linewidth, linestyles=linestyle, rasterized=True) plot_details[filename] = { 'c': color, 'ls': linestyle, 'lw': linewidth, 'label': metadata[filename]['dataset'] } if not land_drawn: try: plt.gca().coastlines() except AttributeError: logger.warning('Not able to add coastlines') plt.gca().add_feature(cartopy.feature.LAND, zorder=10, facecolor=[0.8, 0.8, 0.8]) land_drawn = True title = metadata[filename]['long_name'] if layer != '': z_units = model_cubes[filename][layer].coords('depth')[0].units units = str(model_cubes[filename][layer].units) # Add title, threshold, legend to plots title = ' '.join([title, str(threshold), units]) if layer: title = ' '.join([title, '(', str(layer), str(z_units), ')']) plt.title(title) plt.legend(loc='best') # Saving files: if cfg['write_plots']: path = diagtools.get_image_path( cfg, metadata[filename], prefix='MultipleModels_', suffix='_'.join([ '_contour_map_', str(threshold), str(layer) + image_extention ]), metadata_id_list=[ 'field', 'short_name', 'preprocessor', 'diagnostic', 'start_year', 'end_year' ], ) # Resize and add legend outside thew axes. plt.gcf().set_size_inches(9., 6.) diagtools.add_legend_outside_right(plot_details, plt.gca(), column_width=0.15) logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()
def make_map_contour( cfg, metadata, filename, ): """ Make a simple contour map plot for an individual model. Parameters ---------- cfg: dict the opened global config dictionary, passed by ESMValTool. metadata: dict the metadata dictionary filename: str the preprocessed model file. """ # Load cube and set up units cube = iris.load_cube(filename) cube = diagtools.bgc_units(cube, metadata['short_name']) # Is this data is a multi-model dataset? multi_model = metadata['dataset'].find('MultiModel') > -1 # Make a dict of cubes for each layer. cubes = diagtools.make_cube_layer_dict(cube) # Load image format extention and threshold.thresholds. image_extention = diagtools.get_image_format(cfg) # Load threshold/thresholds. plot_details = {} colours = [] thresholds = diagtools.load_thresholds(cfg, metadata) for itr, thres in enumerate(thresholds): if len(thresholds) > 1: colour = plt.cm.jet(float(itr) / float(len(thresholds) - 1.)) else: colour = plt.cm.jet(0) label = str(thres) + ' ' + str(cube.units) colours.append(colour) plot_details[thres] = {'c': colour, 'lw': 1, 'ls': '-', 'label': label} linewidths = [1 for thres in thresholds] linestyles = ['-' for thres in thresholds] # Making plots for each layer for layer_index, (layer, cube_layer) in enumerate(cubes.items()): layer = str(layer) qplt.contour(cube_layer, thresholds, colors=colours, linewidths=linewidths, linestyles=linestyles, rasterized=True) try: plt.gca().coastlines() except AttributeError: logger.warning('Not able to add coastlines') try: plt.gca().add_feature(cartopy.feature.LAND, zorder=10, facecolor=[0.8, 0.8, 0.8]) except AttributeError: logger.warning('Not able to add coastlines') # Add legend diagtools.add_legend_outside_right(plot_details, plt.gca(), column_width=0.02, loc='below') # Add title to plot title = ' '.join([metadata['dataset'], metadata['long_name']]) depth_units = str(cube_layer.coords('depth')[0].units) if layer: title = '{} ({} {})'.format(title, layer, depth_units) plt.title(title) # Determine image filename: if multi_model: path = os.path.join(diagtools.folder(cfg['plot_dir']), os.path.basename(filename)) path = path.replace('.nc', '_contour_map_' + str(layer_index)) path = path + image_extention else: path = diagtools.get_image_path( cfg, metadata, suffix='_contour_map_' + str(layer_index) + image_extention, ) # Saving files: if cfg['write_plots']: logger.info('Saving plots to %s', path) plt.savefig(path) plt.close()