Updates of ocean diagnostics and recipes for GMD-2019-291 (ESMValTool Part II paper)

esmvaltool/diag_scripts/ocean/diagnostic_model_vs_obs.py

@@ -228,6 +228,14 @@ def make_model_vs_obs_plots(
                 cmap='bwr',
                 title=' '.join([model, 'over', obs]),
                 log=True)
+        else:
+            add_map_subplot(
+                224,
+                cube224,
+                logspace4,
+                cmap='bwr',
+                title=' '.join([model, 'over', obs]),
+                log=True)
 
         # Add overall title
         fig.suptitle(long_name + ' [' + units + ']', fontsize=14)
@@ -362,9 +370,8 @@ def make_scatter(
     obs_filename: str
         the preprocessed observations file.
     """
-
     filenames = {'model': model_filename, 'obs': obs_filename}
-    logger.debug('make_model_vs_obs_plots: \t%s', filenames)
+
     # ####
     # Load the data for each layer as a separate cube
     layers = {}
@@ -377,9 +384,6 @@ def make_scatter(
         for layer in cubes[model_type]:
             layers[layer] = True
 
-    logger.debug('layers: %s', layers)
-    logger.debug('cubes: %s', ', '.join(cubes))
-
     # ####
     # load names:
     model = metadata[filenames['model']]['dataset']
@@ -392,28 +396,37 @@ def make_scatter(
 
     # Make a plot for each layer
     for layer in layers:
-
         fig = plt.figure()
         fig.set_size_inches(7, 6)
 
         # Create the cubes
         model_data = np.ma.array(cubes['model'][layer].data)
         obs_data = np.ma.array(cubes['obs'][layer].data)
+        units = str(cubes['model'][layer].units)
 
         mask = model_data.mask + obs_data.mask
         model_data = np.ma.masked_where(mask, model_data).compressed()
         obs_data = np.ma.masked_where(mask, obs_data).compressed()
 
-        colours = 'gist_yarg'
         zrange = diagtools.get_array_range([model_data, obs_data])
         plotrange = [zrange[0], zrange[1], zrange[0], zrange[1]]
 
         x_scale = 'log'
+        mask_neg = False
+        if np.min(zrange) < 0.:
+            if mask_neg:
+                mask = np.ma.masked_where(model_data <= 0., model_data).mask
+                mask += np.ma.masked_where(obs_data <= 0., obs_data).mask
+
+                model_data = np.ma.masked_where(mask, model_data).compressed()
+                obs_data = np.ma.masked_where(mask, obs_data).compressed()
+                zrange = diagtools.get_array_range([model_data, obs_data])
+                plotrange = [zrange[0], zrange[1], zrange[0], zrange[1]]
+            else:
+                x_scale = 'linear'
+
         if np.min(zrange) * np.max(zrange) < -1:
             x_scale = 'linear'
-        if np.min(zrange) < 0.:
-            logger.info('Skip scatter for %s. Min is < 0', long_name)
-            return
 
         pyplot.hexbin(
             model_data,
@@ -423,7 +436,7 @@ def make_scatter(
             bins='log',
             # extent=np.log10(plotrange),
             gridsize=50,
-            cmap=pyplot.get_cmap(colours),
+            cmap=pyplot.get_cmap('gist_yarg'),
             mincnt=0)
         cbar = pyplot.colorbar()
         cbar.set_label('log10(N)')
@@ -439,7 +452,7 @@ def make_scatter(
             add_diagonal=True,
             extent=plotrange)
 
-        pyplot.title(long_name)
+        pyplot.title(long_name+ ', '+units)
         pyplot.xlabel(model)
         pyplot.ylabel(obs)
 

esmvaltool/diag_scripts/ocean/diagnostic_seaice.py

@@ -289,7 +289,7 @@ def make_polar_map(
         ax1 = plt.subplot(111, projection=cartopy.crs.SouthPolarStereo())
         ax1.set_extent([-180, 180, -90, -50], cartopy.crs.PlateCarree())
 
-    linrange = np.linspace(0., 100., 21.)
+    linrange = np.linspace(0., 100., 21)
     qplt.contourf(cube, linrange, cmap=cmap, linewidth=0, rasterized=True)
     plt.tight_layout()
 

esmvaltool/diag_scripts/ocean/diagnostic_timeseries.py

@@ -50,14 +50,15 @@
 
 import logging
 import os
-
+import datetime
 import iris
 import matplotlib.pyplot as plt
 import numpy as np
 
 from esmvaltool.diag_scripts.ocean import diagnostic_tools as diagtools
 from esmvaltool.diag_scripts.shared import run_diagnostic
 
+
 # This part sends debug statements to stdout
 logger = logging.getLogger(os.path.basename(__file__))
 
@@ -137,42 +138,94 @@ def moving_average(cube, window):
 
     times = cube.coord('time').units.num2date(cube.coord('time').points)
 
-    datetime = diagtools.guess_calendar_datetime(cube)
+    guessed_dt = diagtools.guess_calendar_datetime(cube)
 
     output = []
 
     times = np.array([
-        datetime(time_itr.year, time_itr.month, time_itr.day, time_itr.hour,
-                 time_itr.minute) for time_itr in times
+        guessed_dt(time_itr.year, time_itr.month, time_itr.day, time_itr.hour,
+                   time_itr.minute) for time_itr in times
     ])
 
     for time_itr in times:
         if win_units in ['years', 'yrs', 'year', 'yr']:
-            tmin = datetime(time_itr.year - window_len, time_itr.month,
-                            time_itr.day, time_itr.hour, time_itr.minute)
-            tmax = datetime(time_itr.year + window_len, time_itr.month,
-                            time_itr.day, time_itr.hour, time_itr.minute)
+            tmin = guessed_dt(time_itr.year - window_len, time_itr.month,
+                              time_itr.day, time_itr.hour, time_itr.minute)
+            tmax = guessed_dt(time_itr.year + window_len, time_itr.month,
+                              time_itr.day, time_itr.hour, time_itr.minute)
 
         if win_units in ['months', 'month', 'mn']:
-            tmin = datetime(time_itr.year, time_itr.month - window_len,
-                            time_itr.day, time_itr.hour, time_itr.minute)
-            tmax = datetime(time_itr.year, time_itr.month + window_len,
-                            time_itr.day, time_itr.hour, time_itr.minute)
+            tmin = guessed_dt(time_itr.year, time_itr.month - window_len,
+                              time_itr.day, time_itr.hour, time_itr.minute)
+            tmax = guessed_dt(time_itr.year, time_itr.month + window_len,
+                              time_itr.day, time_itr.hour, time_itr.minute)
 
         if win_units in ['days', 'day', 'dy']:
-            tmin = datetime(time_itr.year, time_itr.month,
-                            time_itr.day - window_len, time_itr.hour,
-                            time_itr.minute)
-            tmax = datetime(time_itr.year, time_itr.month,
-                            time_itr.day + window_len, time_itr.hour,
-                            time_itr.minute)
+            tmin = guessed_dt(time_itr.year, time_itr.month,
+                              time_itr.day - window_len, time_itr.hour,
+                              time_itr.minute)
+            tmax = guessed_dt(time_itr.year, time_itr.month,
+                              time_itr.day + window_len, time_itr.hour,
+                              time_itr.minute)
 
         arr = np.ma.masked_where((times < tmin) + (times > tmax), cube.data)
         output.append(arr.mean())
     cube.data = np.array(output)
     return cube
 
 
+def calculate_anomaly(cube, anomaly):
+    """
+    Calculate the anomaly using a specified time range.
+
+    The anomaly window is a list which includes a starting year and and end
+    year to indicate the start and end of the time period in which to calculate
+    the anomaly.
+
+    Parameters
+    ----------
+    cube: iris.cube.Cube
+        Input cube
+    anomaly: list
+        A start year and end year to calculate an anomaly.
+
+    Returns
+    ----------
+    iris.cube.Cube:
+        A cube with the anomaly calculated.
+    """
+    #start_year = int(np.array(anomaly).min())
+    #end_year = int(np.array(anomaly).max())
+    #start_month = 1
+    #end_month = 12
+    #start_day = 1
+    #end_day = 31
+
+    start = [int(np.array(anomaly).min()), 1, 1]
+    end = [int(np.array(anomaly).max()), 12, 31]
+
+    time_units = cube.coord('time').units
+    if time_units.calendar == '360_day':
+        start[2] = 30
+        end[2] = 30
+
+    start_date = datetime.datetime(
+        int(start[0]), int(start[1]), int(start[2]))
+    end_date = datetime.datetime(int(end[0]), int(end[1]), int(end[2]))
+
+    t_1 = time_units.date2num(start_date)
+    t_2 = time_units.date2num(end_date)
+    constraint = iris.Constraint(
+        time=lambda t: t_1 < time_units.date2num(t.point) < t_2)
+
+    new_cube = cube.extract(constraint)
+    if new_cube is None:
+        return None
+    mean = new_cube.data.mean()
+    cube.data = cube.data - mean
+    return cube
+
+
 def make_time_series_plots(
         cfg,
         metadata,
@@ -211,28 +264,32 @@ def make_time_series_plots(
     # Making plots for each layer
     for layer_index, (layer, cube_layer) in enumerate(cubes.items()):
         layer = str(layer)
+        title = ' '.join([metadata['dataset'], metadata['long_name']])
+
         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'])
+        if 'anomaly' in cfg:
+            title = ' '.join([title, 'anomaly'])
+            cube_layer = calculate_anomaly(cube_layer, cfg['anomaly'])
+            if cube_layer is None:
+                return
 
         # 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))
+
+        ylabel = str(cube_layer.units)
+        if 'ylabel' in cfg:
+            ylabel = cfg['ylabel']
 
         # Determine image filename:
         if multi_model:
+            timeplot(cube_layer, label=metadata['dataset'], ls=':')
             path = diagtools.get_image_path(
                 cfg,
                 metadata,
@@ -244,17 +301,21 @@ def make_time_series_plots(
                     'start_year', 'end_year'
                 ],
             )
-
         else:
+            timeplot(cube_layer, label=metadata['dataset'])
+
             path = diagtools.get_image_path(
                 cfg,
                 metadata,
                 suffix='timeseries_' + str(layer_index) + image_extention,
             )
 
+        plt.title(title)
+        plt.legend(loc='best')
+        plt.ylabel(ylabel)
+
         # Saving files:
         if cfg['write_plots']:
-
             logger.info('Saving plots to %s', path)
             plt.savefig(path)
 
@@ -320,17 +381,25 @@ def multi_model_time_series(
             else:
                 cube = model_cubes[filename][layer]
 
-            if 'MultiModel' in metadata[filename]['dataset']:
+            if 'anomaly' in cfg:
+                cube = calculate_anomaly(cube, cfg['anomaly'])
+                if cube is None:
+                    logger.info(' '.join(['Not enough time for anomaly',
+                                          'calculation',
+                                          metadata[filename]['dataset']]))
+                    continue
+
+            if metadata[filename]['dataset'].lower().find('multimodel') > -1:
                 timeplot(
                     cube,
-                    c=color,
+                    c='black',
                     # label=metadata[filename]['dataset'],
-                    ls=':',
+                    ls='--',
                     lw=2.,
                 )
                 plot_details[filename] = {
-                    'c': color,
-                    'ls': ':',
+                    'c': 'black',
+                    'ls': '--',
                     'lw': 2.,
                     'label': metadata[filename]['dataset']
                 }
@@ -350,24 +419,38 @@ def multi_model_time_series(
                 }
 
             title = metadata[filename]['long_name']
+            ylabel = str(model_cubes[filename][layer].units)
             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 'anomaly' in cfg:
+            title = ' '.join([title, 'anomaly'])
+
         if layer:
             title = ' '.join([title, '(', str(layer), str(z_units), ')'])
+
+        # check to see if the title is mentionned in the recipe.
+        # If so, it overwrites the dafult title.
+        if 'title' in cfg:
+            title = cfg['title']
+
+        if 'ylabel' in cfg:
+            ylabel = cfg['ylabel']
+
         plt.title(title)
         plt.legend(loc='best')
-        plt.ylabel(str(model_cubes[filename][layer].units))
+        plt.ylabel(ylabel)
 
         # Saving files:
         if cfg['write_plots']:
             path = diagtools.get_image_path(
                 cfg,
                 metadata[filename],
-                prefix='MultipleModels_',
+                prefix='MultipleModels',
                 suffix='_'.join(['timeseries',
                                  str(layer) + image_extention]),
                 metadata_id_list=[
@@ -377,9 +460,14 @@ def multi_model_time_series(
             )
 
         # 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)
+        if len(plot_details) < 25:
+            plt.gcf().set_size_inches(9., 6.)
+            diagtools.add_legend_outside_right(
+                plot_details, plt.gca(), column_width=0.15)
+        if len(plot_details) > 25:
+            plt.gcf().set_size_inches(11., 6.)
+            diagtools.add_legend_outside_right(
+                plot_details, plt.gca(), column_width=0.18)
 
         logger.info('Saving plots to %s', path)
         plt.savefig(path)