def __init__(self,
              index_name,
              nc,
              times_SST,
              calendar_SST,
              t_units_SST,
              N,
              season='JJA'):
     """ """
     index_ts = nc.variables[index_name][:]
     index_annual_mean, years = calculate_annual_mean(index_ts,
                                                      times_SST,
                                                      calendar_SST,
                                                      t_units_SST,
                                                      season=season)
     index_running_mean = running_mean(index_annual_mean, N)
     self.index_running_mean = index_running_mean
     self.years = years
        # select only years 1900 onwards for ERA20C for common period with THF
        if model_name == 'ERA20C':
            SST_am = SST_am[years_SST >= 1900]
            THF_am = THF_am[years_THF >= 1900]
            years_SST = years_SST[years_SST >= 1900]

        for j, region in enumerate(regions_all):

            THF_region = region.get_regional_index(THF_am, lats_var, lons_var)
            SST_region = region.get_regional_index(SST_am, lats, lons)

            SST_region = region.get_tendency(SST_region, years_SST)

            if apply_running_mean is not None:
                THF_region = running_mean(THF_region, apply_running_mean)
                SST_region = running_mean(SST_region, apply_running_mean)

            # detrend
            THF_region = detrend(THF_region)
            SST_region = detrend(SST_region)

            if plot_type == 'scatter':
                slope, intercept, r_value, p_value, std_err = linregress(
                    SST_region, THF_region)
                if model_name != 'ERA20C': plt.scatter(j, r_value)
                else:
                    lo, hi = confidence_intervals(THF_region, SST_region)
                    plt.errorbar(j + 0.1,
                                 r_value,
                                 yerr=hi - r_value,

    except:
        # otherwise, read in SST, THF and zonal wind files to calculate regression
        if i>=0:

            # read in SST index data
            SST_index_file_name = loading_dir + '/SST_indices_'+model_name+'_'+ML.ensemble_id[model_name]+'.nc'
            nc_SST = Dataset(SST_index_file_name,'r')
            times_SST = nc_SST.variables['times'][:]
            calendar_SST = nc_SST.variables['times'].calendar
            t_units_SST = nc_SST.variables['times'].units
            NINO34, years = prep_SST_index('NINO34',nc_SST,times_SST,calendar_SST,t_units_SST,season)
            IOBM2, years = prep_SST_index('IOBM2',nc_SST,times_SST,calendar_SST,t_units_SST,season)
            if apply_running_mean is not None: 
                NINO34 = running_mean(NINO34,apply_running_mean)
                IOBM2 = running_mean(IOBM2,apply_running_mean)

            # detrend SST
            NINO34 = detrend(NINO34)
            IOBM2 = detrend(IOBM2)

            # read in THF
            if model_name != 'ERA20C':
                data_path0 = '/network/aopp/hera/mad/patterson/CMIP6/data/piControl/'
                full_path = data_path0 + 'hfls/'+ ML.model_institute[model_name] + '/' + model_name + '/hfls/'
                list_of_files = [full_path+'hfls_Amon_'+model_name+'_piControl_'+ML.ensemble_id[model_name]+'_'+season+'.nc']
                hfls,lats_var,lons_var,levs_var,times_var,calendar_var,t_units_var = read_in_variable(list_of_files[:],'hfls')
                full_path = data_path0 + 'hfss/' + ML.model_institute[model_name] + '/' + model_name + '/hfss/'
                list_of_files = [full_path+'hfss_Amon_'+model_name+'_piControl_'+ML.ensemble_id[model_name]+'_'+season+'.nc']
                hfss,lats_THF,lons_THF,levs_THF,times_THF,calendar_THF,t_units_THF = read_in_variable(list_of_files[:],'hfss')
Пример #4
0
            full_path = data_path0 + 'hfss/' + ML.model_institute[
                model_name] + '/' + model_name + '/hfss/'
            list_of_files = [
                full_path + 'hfss_Amon_' + model_name + '_piControl_' +
                ML.ensemble_id[model_name] + '_' + season + '.nc'
            ]
            hfss, lats_THF, lons_THF, levs_THF, times_THF, calendar_THF, t_units_THF = read_in_variable(
                list_of_files[:], 'hfss')
        THF_am = hfls + hfss
        #THF_am, years_THF = calculate_annual_mean(THF,times_THF,calendar_THF,t_units_THF,season=season)

        if season == 'DJF':
            THF_am = THF_am[::-1][1:][::-1]

        if apply_running_mean is not None:
            SST_am = running_mean(SST_am, apply_running_mean)
            THF_am = running_mean(THF_am, apply_running_mean)

        # calculate correlation map
        corr_map, bottom_lat_bounds, left_lon_bounds = regress_gridpoint(
            SST_am, THF_am, lats_SST, lons_SST, lats_THF, lons_THF)

        # plotting
        ax = plt.subplot(gs[i],
                         projection=ccrs.Robinson(central_longitude=180.))
        plt.title(model_name, fontsize=20)
        cs = plt.pcolormesh(left_lon_bounds,
                            bottom_lat_bounds,
                            corr_map,
                            cmap='RdBu_r',
                            vmin=-0.9,
Пример #5
0
        nc = Dataset(regression_file_name, 'r')
        pcs = nc.variables['pcs'][:]
        variance_fraction = nc.variables['variance_fraction'][:]
        print('Read in %s' % (regression_file_name))

        # read in SST data
        SST_index_file_name = loading_dir + '/SST_indices_' + model_name + '_' + ML.ensemble_id[
            model_name] + '.nc'
        nc_SST = Dataset(SST_index_file_name, 'r')
        times_SST = nc_SST.variables['times'][:]
        calendar_SST = nc_SST.variables['times'].calendar
        t_units_SST = nc_SST.variables['times'].units
        PDO, years = prep_SST_index('NINO34', nc_SST, times_SST, calendar_SST,
                                    t_units_SST, season)
        if apply_running_mean is not None:
            PDO = running_mean(PDO, apply_running_mean)

        # make sure that all indices have the same sign and add EOF maps to array
        if model_name in ['CNRM-ESM2-1', 'CNRM-CM6-1', 'INM-CM5-0']:
            pc_number = 1  # these models have the first 2 EOFs the other way round
        else:
            pc_number = 0
        U = nc.variables['regress_U'][pc_number, :, :]
        U_pc, sign_changed = change_index_sign(pcs[:, pc_number],
                                               U,
                                               lats_ua,
                                               lons_ua,
                                               bounds=[25, 35, 100, 160],
                                               text='U')
        if sign_changed == True: U = -U
        SST = nc_SST.variables['reg_coeff_NINO34'][:]
        # calculate annual means of fields
        psl_am, years = calculate_annual_mean(psl_data,
                                              times_psl,
                                              calendar_psl,
                                              t_units_psl,
                                              season=season)
        pr_am, years = calculate_annual_mean(pr_data,
                                             times_pr,
                                             calendar_pr,
                                             t_units_pr,
                                             season=season)

        # perform low pass time filtering on fields
        N = 10
        halfN = int(N / 2)
        psl_rm = running_mean(psl_am, N)
        pr_rm = running_mean(pr_am, N)

        # prepare SST indices
        PDO_object = prep_index_regress_save('PDO',
                                             nc_SST,
                                             times_SST,
                                             calendar_SST,
                                             t_units_SST,
                                             N,
                                             season=season)
        IOD_object = prep_index_regress_save('IOD',
                                             nc_SST,
                                             times_SST,
                                             calendar_SST,
                                             t_units_SST,
            # read in SST data
            SST_index_file_name = loading_dir + '/SST_indices_' + model_name + '_' + ensemble_id[
                model_name] + '.nc'
            nc_SST = Dataset(SST_index_file_name, 'r')
            times_SST = nc_SST.variables['times'][:]
            calendar_SST = nc_SST.variables['times'].calendar
            t_units_SST = nc_SST.variables['times'].units
            IOBM2, years = prep_SST_index('IOBM2', nc_SST, times_SST,
                                          calendar_SST, t_units_SST, season)
            NINO34, years = prep_SST_index('NINO34', nc_SST, times_SST,
                                           calendar_SST, t_units_SST, season)

            # apply running mean
            if apply_running_mean is not None:
                IOBM2 = running_mean(IOBM2, apply_running_mean)
                NINO34 = running_mean(NINO34, apply_running_mean)

            # regress out other index
            IOBM2_no_NINO34 = regress_out_index(IOBM2, NINO34)
            NINO34_no_IOBM2 = regress_out_index(NINO34, IOBM2)

            # read in circulation indices
            data_path0 = '/network/aopp/hera/mad/patterson/CMIP6/data/piControl/ua/'
            data_path1 = '/' + var_name + '/'
            full_path = data_path0 + model_institute[
                model_name] + '/' + model_name + data_path1
            list_of_files = [
                full_path + var_name + '_Amon_' + model_name + '_piControl_' +
                ensemble_id[model_name] + '_' + season + '.nc'
            ]
        variable2_data = variable2_data[time_mask2]

        # calculate annual means
        variable1_JJA, years = calculate_annual_mean(variable1_data,
                                                     times1,
                                                     calendar1,
                                                     t_units1,
                                                     season='JJA')
        variable2_JJA, years = calculate_annual_mean(variable2_data,
                                                     times2,
                                                     calendar2,
                                                     t_units2,
                                                     season='JJA')

        # perform low pass time filtering
        variable1_rm = running_mean(variable1_JJA, N)
        variable2_rm = running_mean(variable2_JJA, N)

        # only use variable in region over East Asia for MCA
        lon_mask_EAsia = (lons1 >= lon_min) & (lons1 <= lon_max)
        lat_mask_EAsia = (lats1 >= lat_min) & (lats1 <= lat_max)
        variable1_rm_EAsia = variable1_rm[:, lat_mask_EAsia, :][:, :,
                                                                lon_mask_EAsia]

        # only take variable 2 in tropics
        lon_mask_tropics = (lons2 >= lon_min_tropics) & (lons2 <=
                                                         lon_max_tropics)
        lat_mask_tropics = (lats2 >= lat_min_tropics) & (lats2 <=
                                                         lat_max_tropics)
        variable2_rm_tropics = variable2_rm[:,
                                            lat_mask_tropics, :][:, :,
Пример #9
0
               clevs_mean,
               title='ERAI EOF2 %.f%%' % (100 * var_frac[1]))
ax = plt.subplot(gs[1, 2], projection=ccrs.PlateCarree(central_longitude=180.))
cs = plot_mode(ax,
               -reg_pc3,
               np.mean(psl_am_ERAI, axis=0),
               lats_ERAI,
               lons_ERAI,
               clevs,
               clevs_mean,
               title='ERAI EOF3 %.f%%' % (100 * var_frac[2]))

# do the same with a running mean applied
print('Calculating running means')
N = 10
psl_am_HadGEM_rm = running_mean(psl_am_HadGEM, N)
psl_am_ERAI_rm = running_mean(psl_am_ERAI, N)
clevs = 0.2 * clevs

ax = plt.subplot(gs[2, :])
make_plots.colorbar(ax, cs, orientation='horizontal')

var_frac, reg_pc1, pval_pc1, reg_pc2, pval_pc2, reg_pc3, pval_pc3 = calculate_EAsia_rm_eofs(
    psl_am_HadGEM_rm, lats_HadGEM, lons_HadGEM)
ax = plt.subplot(gs[3, 0], projection=ccrs.PlateCarree(central_longitude=180.))
cs = plot_mode(ax,
               reg_pc1,
               np.mean(psl_am_HadGEM, axis=0),
               lats_HadGEM,
               lons_HadGEM,
               clevs,