def readDataPeriods(varnames): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Calculate relative change relativem = ((np.nanmean(varfuturem,axis=0) - np.nanmean(varpastm,axis=0)) \ /np.abs(np.nanmean(varpastm,axis=0))) * 100. ### Calculate significance for each month stat = np.empty((varpastm.shape[1], len(lat), len(lon))) pvalue = np.empty((varpastm.shape[1], len(lat), len(lon))) for i in range(varpastm.shape[1]): stat[i], pvalue[i] = UT.calc_indttest(varfuturem[:, i, :, :], varpastm[:, i, :, :]) return relativem, pvalue, lat, lon
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'SIT_Fu', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'SIT_Cu', 'surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :] varpast = varpast[:100, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :] varpast = varpast[100:200, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :] varpast = varpast[200:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) return varfuturem, varpastm, lat, lon, lev
def readDataPeriods(varnames): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'SIT_Fu', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'SIT_Cu', 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Calculate ensemble mean future = np.nanmean(varfuturem, axis=0) climo = np.nanmean(varpastm, axis=0) ### Calculate anomalies anomall = varfuturem - varpastm anomm = future - climo ### Calculate standard deviation anomstd = np.nanstd(anomall, axis=0) ### Calculate signal to noise (mean/std) sig = np.abs(anomm) / anomstd return sig, lat, lon
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'profile') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'profile') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :, :] varpast = varpast[:, :, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :, :] varpast = varpast[:100, :, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :, :] varpast = varpast[100:200, :, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :, :] varpast = varpast[200:, :, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :, :], varfuture[:, :4, :, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :, :], varpast[:, :4, :, :, :], axis=1) ### Calculate zonal means varfuturemz = np.nanmean(varfuturem, axis=4) varpastmz = np.nanmean(varpastm, axis=4) ### Calculate anomalies anompi = varfuturemz - varpastmz ### Calculate ensemble mean anompim = np.nanmean(anompi, axis=0) zdiffruns = anompim ### Calculate climatologies zclimo = np.nanmean(varpastmz, axis=0) ### Calculate significance for each month stat_past = np.empty((varpastmz.shape[1], len(lev), len(lat))) pvalue_past = np.empty((varpastmz.shape[1], len(lev), len(lat))) for i in range(varpastmz.shape[1]): stat_past[i], pvalue_past[i] = UT.calc_indttest( varfuturemz[:, i, :, :], varpastmz[:, i, :, :]) pruns = pvalue_past return zdiffruns, zclimo, pruns, lat, lon, lev
def readDataPeriods(varnames): ### Call function for 4d variable data if varnames == 'SIT': dataf = Dataset( '/seley/ypeings/simu/PAMIP-1.10-300yr/monthly/SIT_PAMIP-1.10.nc') lat = dataf.variables['TLAT'][:] lon = dataf.variables['TLON'][:] lev = 'surface' varfuture = dataf.variables['hi'][:] dataf.close() datah = Dataset( '/seley/ypeings/simu/PAMIP-1.9-300yr/monthly/SIT_PAMIP-1.9.nc') varpast = datah.variables['hi'][:] datah.close() ### Select ensemble mean period varfuture = varfuture[:, :, :] varpast = varpast[:, :, :] ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varfuture[np.where(varfuture <= 0)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan varpast[np.where(varpast <= 0)] = np.nan ### Starts in July varfuturem = varfuture[5:11, :, :] varpastm = varpast[5:11, :, :] else: lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'surface') ### Select ensemble mean period varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) return varfuturem, varpastm, lat, lon, lev
def readDataPeriods(varnames,sliceq): ### Call function for 4d variable data lat,lon,lev,varfuture = MO.readExperiAll(varnames,'Future','surface') lat,lon,lev,varpast = MO.readExperiAll(varnames,'Past','surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:,:,:,:] varpast = varpast[:,:,:,:] elif sliceq == 'A': varfuture = varfuture[:100,:,:,:] varpast = varpast[:100,:,:,:] elif sliceq == 'B': varfuture = varfuture[100:200,:,:,:] varpast = varpast[100:200,:,:,:] elif sliceq == 'C': varfuture = varfuture[200:,:,:,:] varpast = varpast[200:,:,:,:] ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:,-2:,:,:],varfuture[:,:4,:,:], axis=1) varpastm = np.append(varpast[:,-2:,:,:],varpast[:,:4,:,:],axis=1) ### Calculate anomalies anom = varfuturem - varpastm ### Calculate ensemble mean anomm = np.nanmean(anom,axis=0) pastm = np.nanmean(varpastm,axis=0) ### Calculate zonal mean anommz = np.nanmean(anomm,axis=2) climoz = np.nanmean(pastm,axis=2) ### Calculate significance for each month stat = np.empty((varpastm.shape[1],len(lat))) pvalue = np.empty((varpastm.shape[1],len(lat))) for i in range(varpastm.shape[1]): stat[i],pvalue[i] = UT.calc_indttest( np.nanmean(varfuturem[:,i,:],axis=2), np.nanmean(varpastm[:,i,:],axis=2)) return anommz,climoz,lat,lon,pvalue
def readDataPeriods(varnames, sliceq, simu): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, simu, 'surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :] varpast = varpast[:100, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :] varpast = varpast[100:200, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :] varpast = varpast[200:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan runs = [varfuture, varpast] ### Separate per monthly periods period = 'DJF' if period == 'DJF': varmo = np.empty((len(runs), varpast.shape[0] - 1, varpast.shape[2], varpast.shape[3])) for i in range(len(runs)): varmo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 17) varfuturem = varmo[0] varpastm = varmo[1] elif period == 'NDJFMA': varfuturem = np.nanmean(np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1), axis=1) varpastm = np.nanmean(np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1), axis=1) else: ValueError('Wrong period selected! (DJF,JFM,JFMA,ND)') return varfuturem, varpastm, lat, lon
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'SIT_Fu', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'SIT_Cu', 'surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :] varpast = varpast[:100, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :] varpast = varpast[100:200, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :] varpast = varpast[200:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Calculate anomalies anompi = varfuturem - varpastm ### Calculate ensemble mean anompim = np.nanmean(anompi, axis=0) zdiffruns = anompim ### Calculate climatologies zclimo = np.nanmean(varpastm, axis=0) ### Calculate significance for each month (pick method) pruns = UT.calc_FDR_ttest(varfuturem[:, :, :], varpastm[:, :, :], 0.05) #FDR # pruns = UT.calc_indttest(varfuturem[:,:,:],varpastm[:,:,:])[1] #ttest return zdiffruns, zclimo, pruns, lat, lon, lev
def readSICData(experiment): ### Call function for 4d variable data lat,lon,lev,sicq = MO.readExperiAll('SIC',experiment,'surface') ### Calculate ensemble mean sicm = np.nanmean(sicq[:,:,:,:],axis=0) ### Remove missing data sicm[np.where(sicm <= -1e10)] = np.nan ### Mask data directorymask = '/seley/zlabe/simu/masks/' filenamemask = 'domain.camocn.1.9x2.5_gx1v6_090403.nc' datam = Dataset(directorymask + filenamemask) mask = datam.variables['frac'][:] datam.close() ### Set missing data sic = sicm * mask sic[sic<0] = 0 sic[sic>100] = 100 ### Slice for Arctic data (Northern Hemisphere) latq = np.where(lat >= 0)[0] lat = lat[latq] sic = sic[:,latq,:] return sic,lat,lon
def readDataPeriods(varnames, experiment): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, experiment, 'surface') ### Select ensemble mean period varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) return varfuturem, varpastm, lat, lon, lev
def readHeatFluxData(experiment, variable): ### Call function for 4d variable data lat, lon, lev, flxq = MO.readExperiAll('RNET', experiment, 'surface') ### Calculate ensemble mean if variable == 'RNET': flxm = np.nanmean(flxq[:, :, :, :], axis=0) * -1 # upwards is positive else: flxm = np.nanmean(flxq[:, :, :, :], axis=0) ### Remove missing data flxm[np.where(flxm <= -1e10)] = np.nan ### Slice for Arctic data (Southern Hemisphere) latq = np.where(lat <= -40)[0] lat = lat[latq] flx = flxm[:, latq, :] return flx, lat, lon
def readSICData(experiment): ### Call function for 4d variable data lat, lon, lev, sicq = MO.readExperiAll('SIC', experiment, 'surface') ### Calculate ensemble mean sicm = np.nanmean(sicq[:, :, :, :], axis=0) ### Remove missing data sicm[np.where(sicm <= -1e10)] = np.nan ### Slice for Arctic data (Southern Hemisphere) latq = np.where(lat <= -40)[0] lat = lat[latq] sic = sicm[:, latq, :] sic[np.where(sic <= 10)] = 0. sic[np.where(sic > 10)] = 1. return sic, lat, lon
### Alott time series (300 ensemble members) year1 = 1701 year2 = 2000 years = np.arange(year1, year2 + 1, 1) ############################################################################### ############################################################################### ############################################################################### ### Call arguments varnames = ['U', 'GEOP', 'TEMP'] ###################### for v in range(len(varnames)): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll('%s' % varnames[v], 'Future', 'profile') lat, lon, lev, varpast = MO.readExperiAll('%s' % varnames[v], 'Past', 'profile') lat, lon, lev, varcurrent = MO.readExperiAll('%s' % varnames[v], 'Current', 'profile') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan varcurrent[np.where(varcurrent <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :, :],
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Past', 'surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :] varpast = varpast[:100, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :] varpast = varpast[100:200, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :] varpast = varpast[200:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Calculate over region lonq1 = np.where((lon >= 0) & (lon <= 120))[0] lonq2 = np.where((lon > 120) & (lon <= 240))[0] lonq3 = np.where((lon > 240) & (lon <= 360))[0] varfuturem1 = varfuturem[:, :, :, lonq1] varfuturem2 = varfuturem[:, :, :, lonq2] varfuturem3 = varfuturem[:, :, :, lonq3] varpastm1 = varpastm[:, :, :, lonq1] varpastm2 = varpastm[:, :, :, lonq2] varpastm3 = varpastm[:, :, :, lonq3] ### Calculate anomalies anom1 = varfuturem1 - varpastm1 anom2 = varfuturem2 - varpastm2 anom3 = varfuturem3 - varpastm3 ### Calculate ensemble mean anomm1 = np.nanmean(anom1, axis=0) pastm1 = np.nanmean(varpastm1, axis=0) anomm2 = np.nanmean(anom2, axis=0) pastm2 = np.nanmean(varpastm2, axis=0) anomm3 = np.nanmean(anom3, axis=0) pastm3 = np.nanmean(varpastm3, axis=0) ### Calculate zonal mean anommz1 = np.nanmean(anomm1, axis=2) climoz1 = np.nanmean(pastm1, axis=2) anommz2 = np.nanmean(anomm2, axis=2) climoz2 = np.nanmean(pastm2, axis=2) anommz3 = np.nanmean(anomm3, axis=2) climoz3 = np.nanmean(pastm3, axis=2) ### Calculate significance for each month using FDR pvalue1 = np.empty((varpastm1.shape[1], len(lat))) for i in range(varpastm1.shape[1]): pvalue1[i] = UT.calc_FDR_ttest( np.nanmean(varfuturem1[:, i, :, :], axis=2), np.nanmean(varpastm1[:, i, :, :], axis=2), 0.05) pvalue2 = np.empty((varpastm2.shape[1], len(lat))) for i in range(varpastm2.shape[1]): pvalue2[i] = UT.calc_FDR_ttest( np.nanmean(varfuturem2[:, i, :, :], axis=2), np.nanmean(varpastm2[:, i, :, :], axis=2), 0.05) pvalue3 = np.empty((varpastm3.shape[1], len(lat))) for i in range(varpastm3.shape[1]): pvalue3[i] = UT.calc_FDR_ttest( np.nanmean(varfuturem3[:, i, :, :], axis=2), np.nanmean(varpastm3[:, i, :, :], axis=2), 0.05) return lat, lon, anommz1, anommz2, anommz3, climoz1, climoz2, climoz3, pvalue1, pvalue2, pvalue3
def readDataPeriods(varnames): ### Call function for 4d variable data if varnames == 'RNET': datatf = Dataset('/seley/zlabe/simu/PAMIP-1.10-300yr/monthly/RNET_1701-2000.nc') rnet_sitf = datatf[varnames][:-12] lat = datatf['latitude'][:] lon = datatf['longitude'][:] rnet_sitf = np.reshape(rnet_sitf,(300,12,96,144)) datatf.close() datath = Dataset('/seley/zlabe/simu/PAMIP-1.9-300yr/monthly/RNET_1701-2000.nc') rnet_sith = datath[varnames][:-12] rnet_sith = np.reshape(rnet_sith,(300,12,96,144)) datath.close() datacf = Dataset('/seley/zlabe/simu/PAMIP_Fu/monthly/RNET_1701-2000.nc') rnet_sicf = datacf[varnames][:] rnet_sicf = np.reshape(rnet_sicf,(300,12,96,144)) datacf.close() datach = Dataset('/seley/zlabe/simu/PAMIP_Cu/monthly/RNET_1701-2000.nc') rnet_sich = datach[varnames][:] rnet_sich = np.reshape(rnet_sich,(300,12,96,144)) datach.close() ### Rearrange months (N,D,J,F,M,A) rnetdiff = np.nanmean((rnet_sitf - rnet_sith) - (rnet_sicf - rnet_sich),axis=0) diff = np.append(rnetdiff[-2:,:,:],rnetdiff[:4,:,:],axis=0) ####################################################################### ####################################################################### ####################################################################### else: lat,lon,lev,varfuture = MO.readExperiAll(varnames,'SIT_Fu','surface') lat,lon,lev,varpast = MO.readExperiAll(varnames,'SIT_Cu','surface') ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:,-2:,:,:],varfuture[:,:4,:,:], axis=1) varpastm = np.append(varpast[:,-2:,:,:],varpast[:,:4,:,:],axis=1) ####################################################################### ####################################################################### ####################################################################### lat,lon,lev,varf_sic = MO.readExperiAll(varnames,'Future','surface') lat,lon,lev,varh_sic = MO.readExperiAll(varnames,'Current','surface') ### Remove missing data varf_sic[np.where(varf_sic <= -1e10)] = np.nan varh_sic[np.where(varh_sic <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varf_sicm = np.append(varf_sic[:,-2:,:,:],varf_sic[:,:4,:,:], axis=1) varh_sicm = np.append(varh_sic [:,-2:,:,:],varh_sic [:,:4,:,:],axis=1) diff = np.nanmean((varfuturem - varpastm),axis=0) - \ np.nanmean((varf_sicm - varh_sicm),axis=0) return diff,lat,lon
### Call arguments varnames = ['U10'] simuh = 'Past' # Enter simulation time (Current,Past) letters = [r'Mean', r'A', r'B', r'C'] ############################################################################### if simuh == 'Current': simuq = 'Cu' elif simuh == 'Past': simuq = 'Pi' else: print(ValueError('Wrong simulation selected!')) ############################################################################### ############################################################################### ############################################################################### ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames[0], 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames[0], simuh, 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture < -1e10)] = np.nan varpast[np.where(varpast < -1e10)] = np.nan ### Slice ensembles if needed varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] ### Calculate polar vortex strength using 60N latq = np.where((lat >= 59.5) & (lat <= 60.5))[0]
def polarVortexComp(simu,varname,vartype,stat,time): """ Calculate polar vortex statistics per year """ ### Import modules import numpy as np import read_MonthlyData as MO ### Call function for 4d variable data lat,lon,lev,var= MO.readExperiAll(varname,simu,vartype) ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Remove missing data var[np.where(var < -1e10)] = np.nan ### Calculate polar vortex strength using 60N if varname == 'U10': latq = np.where((lat >= 59.5) & (lat <= 60.5))[0] varu = var[:,:,latq,:].squeeze() ### Calculate time month mean [ensemble,month,longitude] if time == 'annual': varf = np.nanmean(varu[:,:,:],axis=2) elif time == 'JFM': varf = np.nanmean(varu[:,0:3,:],axis=2) elif time == 'JFMA': varf = np.nanmean(varu[:,0:4,:],axis=2) elif time == 'JF': varf = np.nanmean(varu[:,0:2,:],axis=2) elif time == 'J': varf = np.nanmean(varu[:,0:1,:],axis=2) elif time == 'FM': varf = np.nanmean(varu[:,1:3,:],axis=2) elif time == 'D': varf = np.nanmean(varu[:,-1:,:],axis=2) elif time == 'NDJFMA': varf= np.append(varu[:,-2:,:],varu[:,:4,:],axis=1) ### Calculate zonal mean [ensemble,longitude] if time == 'NDJFMA': pvf = np.nanmean(varf,axis=2) else: pvf = np.nanmean(varf,axis=1) ########################################################################### ########################################################################### ########################################################################### ### Calculate statistics if time == 'NDJFMA': stats = [] for i in range(pvf.shape[1]): if stat == '5-95': pvf5 = np.nanpercentile(pvf[:,i],5) pvf95 = np.nanpercentile(pvf[:,i],95) argyearsq = np.where((pvf[:,i] > pvf5) & (pvf[:,i] < pvf95))[0] stats.append(argyearsq) elif stat == '10-90': pvf10 = np.nanpercentile(pvf[:,i],10) pvf90 = np.nanpercentile(pvf[:,i],90) argyearsq = np.where((pvf[:,i] > pvf10) & (pvf[:,i] < pvf90))[0] stats.append(argyearsq) argyears = np.asarray(stats) else: if stat == '5-95': pvf5 = np.nanpercentile(pvf,5) pvf95 = np.nanpercentile(pvf,95) argyears = np.where((pvf > pvf5) & (pvf < pvf95))[0] elif stat == '10-90': pvf10 = np.nanpercentile(pvf,10) pvf90 = np.nanpercentile(pvf,90) argyears = np.where((pvf > pvf10) & (pvf < pvf90))[0] elif stat == '33-66': pvf33 = np.nanpercentile(pvf,33.333) pvf66 = np.nanpercentile(pvf,66.666) argyears = np.where((pvf > pvf33) & (pvf < pvf66))[0] elif stat == '>50': pvf50 = np.nanpercentile(pvf,50) argyears = np.where((pvf > pvf50))[0] elif stat == '<50': pvf50 = np.nanpercentile(pvf,50) argyears = np.where((pvf < pvf50))[0] elif stat == '>66': pvf66 = np.nanpercentile(pvf,66.666) argyears = np.where((pvf > pvf66))[0] elif stat == '<33': pvf33 = np.nanpercentile(pvf,33.333) argyears = np.where((pvf < pvf33))[0] elif stat == '1sigma': stdev = np.nanstd(pvf) stdl = np.nanmean(pvf) - stdev stdu = np.nanmean(pvf) + stdev argyears = np.where((pvf > stdl) & (pvf < stdu))[0] return argyears ############################################################################### ############################################################################### ############################################################################### ### Test functions (not needed!!!) #argyears = polarVortexComp('Future','U10','surface','<50','J')
def readData(simuh, simuf, varnames, period): for v in range(len(varnames)): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll('%s' % varnames[v], simuf, 'profile') lat, lon, lev, varpast = MO.readExperiAll('%s' % varnames[v], simuh, 'profile') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### List of experiments runs = [varfuture, varpast] ### Separate per monthly periods if period == 'DJF': varmo = np.empty( (len(runs), varpast.shape[0] - 1, varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'profile', 17) elif period == 'DJFM': varmo = np.empty((len(runs), varpast.shape[0], varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo1 = runs[i][:, :3, :, :, :] varmo2 = runs[i][:, -1, :, :, :] varmo2 = np.expand_dims(varmo2, axis=1) varmoall = np.append(varmo1, varmo2, axis=1) varmo[i] = np.nanmean(varmoall, axis=1) elif period == 'JFM': varmo = np.empty((len(runs), varpast.shape[0], varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:, :3, :, :, :], axis=1) elif period == 'JFMA': varmo = np.empty((len(runs), varpast.shape[0], varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:, :4, :, :, :], axis=1) elif period == 'ND': varmo = np.empty((len(runs), varpast.shape[0], varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:, -2:, :, :, :], axis=1) elif period == 'MA': varmo = np.empty((len(runs), varpast.shape[0], varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:, 2:4, :, :, :], axis=1) else: ValueError('Wrong period selected! (DJF,JFM,JFMA,ND)') ### Remove missing data varmo[np.where(varmo < -1e10)] = np.nan ### Take total ensemble mean (300) meanens = np.nanmean(varmo, axis=1) ### Calculate climos climo = np.nanmean(meanens[1, :, :, :], axis=2) ### Calculate anomaly anom = np.nanmean(meanens[0, :, :, :] - meanens[1, :, :, :], axis=2) ### Calculate significance testing at 95% confidence level meanx = np.nanmean(varmo[0, :, :, :, :], axis=3) meany = np.nanmean(varmo[1, :, :, :, :], axis=3) pvalue = UT.calc_FDR_ttest(meanx, meany, 0.05) #FDR pvalue[np.where(pvalue < 0.05)] = 1. pvalue[np.where(np.isnan(pvalue))] = 0. return anom, climo, pvalue, lev, lat
### Call arguments varnames = ['U', 'GEOP', 'TEMP', 'V', 'EGR'] period = 'MA' # Enter temporal period (DJF,JFM,JFMA,ND,MA) simuh = 'Past' # Enter simulation time (Current,Past) ###################### if simuh == 'Current': simuq = 'Cu' elif simuh == 'Past': simuq = 'Pi' else: print(ValueError('Wrong simulation selected!')) ###################### letters = [r'Mean', r'A', r'B', r'C'] for v in range(len(varnames)): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll('%s' % varnames[v], 'Future', 'profile') lat, lon, lev, varpast = MO.readExperiAll('%s' % varnames[v], '%s' % simuh, 'profile') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### List of experiments runs = [varfuture, varpast] ### Separate per monthly periods if period == 'DJF': varmo = np.empty((len(runs), varpast.shape[0] - 1, varpast.shape[2], varpast.shape[3], varpast.shape[4])) for i in range(len(runs)): varmo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'profile',
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'surface') ### Rearrange months (N,D,J,F,M,A) varfuture = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpast = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Select ensemble mean period if sliceq == 'Mean': varfutures = varfuture[:, :, :, :] varpasts = varpast[:, :, :, :] zclimo = np.nanmean(varpasts, axis=0) elif sliceq == 'A': varfutures = varfuture[:100, :, :, :] varpasts = varpast[:100, :, :, :] zclimo = np.nanmean(varpasts, axis=0) elif sliceq == 'B': varfutures = varfuture[100:200, :, :, :] varpasts = varpast[100:200, :, :, :] zclimo = np.nanmean(varpasts, axis=0) elif sliceq == 'C': varfutures = varfuture[200:, :, :, :] varpasts = varpast[200:, :, :, :] zclimo = np.nanmean(varpasts, axis=0) ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Calculate ensemble mean varfuturem = varfuture[:, :, :, :] varpastm = varpast[:, :, :, :] anommean = varfuturem - varpastm anommeanmean = np.nanmean(anommean, axis=0) ### Calculate sliced differences anomslice = varfutures - varpasts anomslicemean = np.nanmean(anomslice, axis=0) ### Calculate difference from total ensemble mean (300) diffs = anomslicemean - anommeanmean if sliceq == 'Mean': ### Calculate significance for each month (FDR method!) pvalue_past = np.empty((varpastm.shape[1], len(lat), len(lon))) for i in range(varpastm.shape[1]): pvalue_past[i] = UT.calc_FDR_ttest(varfuturem[:, i, :, :], varpastm[:, i, :, :], 0.05) else: ### Calculate significance for each month stat_past = np.empty((varpastm.shape[1], len(lat), len(lon))) pvalue_past = np.empty((varpastm.shape[1], len(lat), len(lon))) for i in range(varpastm.shape[1]): stat_past[i], pvalue_past[i] = UT.calc_indttest( anommean[:, i, :, :], anomslice[:, i, :, :]) pruns = pvalue_past return anommeanmean, diffs, zclimo, pruns, lat, lon, lev
def polarVortexStats(simuF, simuP, varname, vartype, stat, time): """ Calculate polar vortex statistics per year """ ### Import modules import numpy as np import read_MonthlyData as MO ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varname, simuF, vartype) lat, lon, lev, varpast = MO.readExperiAll(varname, simuP, vartype) ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture < -1e10)] = np.nan varpast[np.where(varpast < -1e10)] = np.nan ### Calculate polar vortex strength using 60N if varname == 'U10': latq = np.where((lat >= 59.5) & (lat <= 60.5))[0] latu = lat[latq].squeeze() varfutureu = varfuture[:, :, latq, :].squeeze() varpastu = varpast[:, :, latq, :].squeeze() ### Calculate time month mean [ensemble,month,longitude] if time == 'annual': varf = np.nanmean(varfutureu[:, :, :], axis=2) varp = np.nanmean(varpastu[:, :, :], axis=2) elif time == 'JFM': varf = np.nanmean(varfutureu[:, 0:3, :], axis=2) varp = np.nanmean(varpastu[:, 0:3, :], axis=2) elif time == 'JF': varf = np.nanmean(varfutureu[:, 0:2, :], axis=2) varp = np.nanmean(varpastu[:, 0:2, :], axis=2) elif time == 'J': varf = np.nanmean(varfutureu[:, 0:1, :], axis=2) varp = np.nanmean(varpastu[:, 0:1, :], axis=2) elif time == 'FM': varf = np.nanmean(varfutureu[:, 1:3, :], axis=2) varp = np.nanmean(varpastu[:, 1:3, :], axis=2) elif time == 'D': varf = np.nanmean(varfutureu[:, -1:, :], axis=2) varp = np.nanmean(varpastu[:, -1:, :], axis=2) elif time == 'NDJFMA': varf = np.append(varfutureu[:, -2:, :], varfutureu[:, :4, :], axis=1) varp = np.append(varpastu[:, -2:, :], varpastu[:, :4, :], axis=1) ### Calculate zonal mean [ensemble,longitude] if time == 'NDJFMA': pvf = np.nanmean(varf, axis=2) pvp = np.nanmean(varp, axis=2) else: pvf = np.nanmean(varf, axis=1) pvp = np.nanmean(varp, axis=1) ### Calculate anomalies anom = pvf - pvp ########################################################################### ########################################################################### ########################################################################### ### Calculate statistics if time == 'NDJFMA': stats = [] for i in range(anom.shape[1]): if stat == '5-95': anom5 = np.nanpercentile(anom[:, i], 5) anom95 = np.nanpercentile(anom[:, i], 95) argyearsq = np.where((anom[:, i] > anom5) & (anom[:, i] < anom95))[0] stats.append(argyearsq) elif stat == '10-90': anom10 = np.nanpercentile(anom[:, i], 10) anom90 = np.nanpercentile(anom[:, i], 90) argyearsq = np.where((anom[:, i] > anom10) & (anom[:, i] < anom90))[0] stats.append(argyearsq) argyears = np.asarray(stats) else: if stat == '5-95': anom5 = np.nanpercentile(anom, 5) anom95 = np.nanpercentile(anom, 95) argyears = np.where((anom > anom5) & (anom < anom95))[0] elif stat == '10-90': anom10 = np.nanpercentile(anom, 10) anom90 = np.nanpercentile(anom, 90) argyears = np.where((anom > anom10) & (anom < anom90))[0] elif stat == '33-66': anom33 = np.nanpercentile(anom, 33.333) anom66 = np.nanpercentile(anom, 66.666) argyears = np.where((anom > anom33) & (anom < anom66))[0] elif stat == '>50': anom50 = np.nanpercentile(anom, 50) argyears = np.where((anom > anom50))[0] elif stat == '<50': anom50 = np.nanpercentile(anom, 50) argyears = np.where((anom < anom50))[0] elif stat == '>66': anom66 = np.nanpercentile(anom, 66.66) argyears = np.where((anom > anom66))[0] elif stat == '<33': anom33 = np.nanpercentile(anom, 33.333) argyears = np.where((anom < anom33))[0] elif stat == '1sigma': stdev = np.nanstd(anom) stdl = np.nanmean(anom) - stdev stdu = np.nanmean(anom) + stdev argyears = np.where((anom > stdl) & (anom < stdu))[0] return argyears ############################################################################### ############################################################################### ############################################################################### ### Test functions (not needed!!!) #argyears = polarVortexStats('Future','Past','U10','surface','10/90','NDJFMA')
def readinData(varnames,simuh,period): ### Import modules import numpy as np import datetime import read_MonthlyData as MO import calc_Utilities as UT ### Define time now = datetime.datetime.now() currentmn = str(now.month) currentdy = str(now.day) currentyr = str(now.year) titletime = currentmn + '/' + currentdy + '/' + currentyr print('\n' '----Calculate Minimum Ensembles- %s----' % titletime) ############################################################################### ############################################################################### ############################################################################### ### Read in data for v in range(len(varnames)): ### Call function for 4d variable data lat,lon,lev,varfuture = MO.readExperiAll('%s' % varnames[v],'Future', 'profile') lat,lon,lev,varpast = MO.readExperiAll('%s' % varnames[v],'%s' % simuh, 'profile') ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### List of experiments runs = [varfuture,varpast] ### Separate per monthly periods if period == 'DJF': varmo = np.empty((len(runs),varpast.shape[0]-1,varpast.shape[2], varpast.shape[3],varpast.shape[4])) for i in range(len(runs)): varmo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'profile',17) elif period == 'JFM': varmo = np.empty((len(runs),varpast.shape[0],varpast.shape[2], varpast.shape[3],varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:,:3,:,:,:],axis=1) elif period == 'JFMA': varmo = np.empty((len(runs),varpast.shape[0],varpast.shape[2], varpast.shape[3],varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:,:4,:,:,:],axis=1) elif period == 'ND': varmo = np.empty((len(runs),varpast.shape[0],varpast.shape[2], varpast.shape[3],varpast.shape[4])) for i in range(len(runs)): varmo[i] = np.nanmean(runs[i][:,-2:,:,:,:],axis=1) else: ValueError('Wrong period selected! (DJF,JFM,JFMA,ND)') ### Remove missing data varmo[np.where(varmo < -1e10)] = np.nan ### Simulation control = varmo[1,:,:,:,:] future = varmo[0,:,:,:,:] ### Calculate anomaly anom = future - control return anom,future,control,lat,lon,lev
def readDataPeriods(varnames,simulations,period): ### Call function for 4d variable data lat,lon,lev,varfuture = MO.readExperiAll(varnames,simulations[0],'surface') lat,lon,lev,varpast = MO.readExperiAll(varnames,simulations[1],'surface') ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Remove missing data [ensembles,months,lat,lon] varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Calculate over DJF if period == 'OND': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,-3:,:,:],axis=1) varpastm = np.nanmean(varpast[:,-3:,:,:],axis=1) elif period == 'D': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,-1:,:,:],axis=1) varpastm = np.nanmean(varpast[:,-1:,:,:],axis=1) elif period == 'DJF': print('Calculating over %s months!' % period) runs = [varfuture,varpast] var_mo = np.empty((2,varpast.shape[0]-1,varpast.shape[2],varpast.shape[3])) for i in range(len(runs)): var_mo[i,:,:,:] = UT.calcDecJanFeb(runs[i],runs[i],lat,lon,'surface',1) varfuturem = var_mo[0] varpastm = var_mo[1] elif period == 'JFM': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,0:3,:,:],axis=1) varpastm = np.nanmean(varpast[:,0:3,:,:],axis=1) elif period == 'JF': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,0:2,:,:],axis=1) varpastm = np.nanmean(varpast[:,0:2,:,:],axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,1:4,:,:],axis=1) varpastm = np.nanmean(varpast[:,1:4,:,:],axis=1) elif period == 'FM': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,1:3,:,:],axis=1) varpastm = np.nanmean(varpast[:,1:3,:,:],axis=1) elif period == 'J': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,0:1,:,:],axis=1) varpastm = np.nanmean(varpast[:,0:1,:,:],axis=1) elif period == 'F': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,1:2,:,:],axis=1) varpastm = np.nanmean(varpast[:,1:2,:,:],axis=1) elif period == 'M': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:,2:3,:,:],axis=1) varpastm = np.nanmean(varpast[:,2:3,:,:],axis=1) else: print(ValueError('Selected wrong month period!')) ### Calculate anomalies anompi = varfuturem - varpastm ### Calculate ensemble mean anompim = np.nanmean(anompi,axis=0) zdiffruns = anompim ### Calculate climatologies zclimo = np.nanmean(varpastm,axis=0) ### Calculate significance for each month (pick method) pruns = UT.calc_FDR_ttest(varfuturem[:,:,:],varpastm[:,:,:],0.05) #FDR # pruns = UT.calc_indttest(varfuturem[:,:,:],varpastm[:,:,:])[1] #ttest return zdiffruns,zclimo,pruns,lat,lon,lev
def readDataPeriods(typesimu, varnames, simulations, period): ### Call function for 4d variable data if typesimu == 'arc_sea_ice': lat, lon, lev, varfuture = MO.readExperiAll(varnames, simulations[0], 'zonmean') lat, lon, lev, varpast = MO.readExperiAll(varnames, simulations[1], 'zonmean') elif typesimu == 'sst': lat, lon, lev, varfuture = MOS.readExperiAll(varnames, simulations[0], 'zonmean') lat, lon, lev, varpast = MOS.readExperiAll(varnames, simulations[1], 'zonmean') elif typesimu == 'ant_sea_ice': lat, lon, lev, varfuture = MOA.readExperiAll(varnames, simulations[0], 'zonmean') lat, lon, lev, varpast = MOA.readExperiAll(varnames, simulations[1], 'zonmean') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data [ensembles,months,lat,lon] varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Calculate over DJF if period == 'JJA': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 5:8, :, :], axis=1) varpastm = np.nanmean(varpast[:, 5:8:, :, :], axis=1) elif period == 'JAS': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 6:9, :, :], axis=1) varpastm = np.nanmean(varpast[:, 6:9:, :, :], axis=1) elif period == 'July': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 6:7, :, :], axis=1) varpastm = np.nanmean(varpast[:, 6:7:, :, :], axis=1) elif period == 'August': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 7:8, :, :], axis=1) varpastm = np.nanmean(varpast[:, 7:8:, :, :], axis=1) elif period == 'JA': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 6:8, :, :], axis=1) varpastm = np.nanmean(varpast[:, 6:8:, :, :], axis=1) elif period == 'S': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 8:9, :, :], axis=1) varpastm = np.nanmean(varpast[:, 8:9:, :, :], axis=1) elif period == 'AMJ': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 3:6, :, :], axis=1) varpastm = np.nanmean(varpast[:, 3:6:, :, :], axis=1) elif period == 'OND': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, -3:, :, :], axis=1) varpastm = np.nanmean(varpast[:, -3:, :, :], axis=1) elif period == 'JFM': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 0:3, :, :], axis=1) varpastm = np.nanmean(varpast[:, 0:3, :, :], axis=1) elif period == 'JF': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 0:2, :, :], axis=1) varpastm = np.nanmean(varpast[:, 0:2, :, :], axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 1:4, :, :], axis=1) varpastm = np.nanmean(varpast[:, 1:4, :, :], axis=1) elif period == 'FM': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 1:3, :, :], axis=1) varpastm = np.nanmean(varpast[:, 1:3, :, :], axis=1) elif period == 'J': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 0:1, :, :], axis=1) varpastm = np.nanmean(varpast[:, 0:1, :, :], axis=1) elif period == 'F': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 1:2, :, :], axis=1) varpastm = np.nanmean(varpast[:, 1:2, :, :], axis=1) elif period == 'M': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, 2:3, :, :], axis=1) varpastm = np.nanmean(varpast[:, 2:3, :, :], axis=1) elif period == 'Annual': print('Calculating over %s months!' % period) varfuturem = np.nanmean(varfuture[:, :, :, :], axis=1) varpastm = np.nanmean(varpast[:, :, :, :], axis=1) else: print(ValueError('Selected wrong month period!')) ### Calculate anomalies and ensemble means varfutureq = varfuturem.copy() varpastq = varpastm.copy() anommean = np.nanmean(varfutureq, axis=0) - np.nanmean(varpastq, axis=0) ### Calculate climatologies climo = np.nanmean(varpastq, axis=0) ### Calculate significance for each month (pick method) pruns = UT.calc_FDR_ttest(varfuturem[:, :, :], varpastm[:, :, :], 0.05) #FDR return anommean, climo, pruns, lat, lev
def readDataPeriods(varnames, sliceq): ### Call function for 4d variable data lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'SIT_Fu', 'surface') lat, lon, lev, varpast = MO.readExperiAll(varnames, 'SIT_Cu', 'surface') ### Select ensemble mean period if sliceq == 'Mean': varfuture = varfuture[:, :, :, :] varpast = varpast[:, :, :, :] elif sliceq == 'A': varfuture = varfuture[:100, :, :, :] varpast = varpast[:100, :, :, :] elif sliceq == 'B': varfuture = varfuture[100:200, :, :, :] varpast = varpast[100:200, :, :, :] elif sliceq == 'C': varfuture = varfuture[200:, :, :, :] varpast = varpast[200:, :, :, :] ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Remove missing data varfuture[np.where(varfuture <= -1e10)] = np.nan varpast[np.where(varpast <= -1e10)] = np.nan ### Rearrange months (N,D,J,F,M,A) varfuturem = np.append(varfuture[:, -2:, :, :], varfuture[:, :4, :, :], axis=1) varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1) ### Calculate anomalies anompi = varfuturem - varpastm ### Calculate ensemble mean anompim = np.nanmean(anompi, axis=0) zdiffruns = anompim ### Calculate climatologies zclimo = np.nanmean(varpastm, axis=0) ### Calculate significance for each month stat_past = np.empty((varpastm.shape[1], len(lat), len(lon))) pvalue_past = np.empty((varpastm.shape[1], len(lat), len(lon))) for i in range(varpastm.shape[1]): stat_past[i], pvalue_past[i] = calc_indttestfdr( varfuturem[:, i, :, :], varpastm[:, i, :, :]) ### Ravel into month x all p values prunsr = np.reshape(pvalue_past, (pvalue_past.shape[0],pvalue_past.shape[1] \ * pvalue_past.shape[2])) ### Calculate false discovery rate prunsq = np.empty((prunsr.shape)) prunsq.fill(np.nan) prunsqq = np.empty((prunsr.shape[1])) prunsqq.fill(np.nan) for i in range(prunsr.shape[0]): ### Check for nans before correction!! mask = np.isfinite(prunsr[i, :]) prunsrr = prunsr[i, :] score, prunsqq[mask] = fdr.fdrcorrection(prunsrr[mask], alpha=0.05, method='indep') prunsq[i, :] = prunsqq ### Reshape into month x lat x lon pruns = np.reshape(prunsq, (pvalue_past.shape)) ### Mask variables by their adjusted p-values pruns[np.where(pruns >= 0.05)] = np.nan pruns[np.where(pruns < 0.05)] = 1. pruns[np.where(np.isnan(pruns))] = 0. return zdiffruns, zclimo, pruns, lat, lon, lev
def readPolarCapData(varnames, level, levq, sliceq, period): """ Read in all data for polar cap (>65N) """ if varnames == 'U10': # data needed to calculate polar vortex definition lat, lon, lev, varf = MO.readExperiAll(varnames, 'Future', 'surface') lat, lon, lev, varcu = MO.readExperiAll(varnames, 'Current', 'surface') lat, lon, lev, varpi = MO.readExperiAll(varnames, 'Past', 'surface') else: # averaged over the polar cap lat, lon, lev, varf = MO.readExperiAveVar(varnames, 'Future', 'polar', level) lat, lon, lev, varcu = MO.readExperiAveVar(varnames, 'Current', 'polar', level) lat, lon, lev, varpi = MO.readExperiAveVar(varnames, 'Past', 'polar', level) if sliceq == True: # data from the polar cap print('\nSlicing grid at level=%s!' % levq) levqq = np.where(lev == levq)[0] varf = varf[:, :, levqq].squeeze() varcu = varcu[:, :, levqq].squeeze() varpi = varpi[:, :, levqq].squeeze() elif varnames == 'U10': latq = np.where((lat >= 59.5) & (lat <= 60.5))[0] varf = np.nanmean(varf[:, :, latq, :].squeeze(), axis=2) varcu = np.nanmean(varcu[:, :, latq, :].squeeze(), axis=2) varpi = np.nanmean(varpi[:, :, latq, :].squeeze(), axis=2) else: print('\nSurface variable!') ### Calculate time mean [returns 1D array] print('-------Period of time: %s!-------\n' % period) if period == 'NDJFM': varwf = np.nanmean(np.append(varf[:, -2:], varf[:, :3], axis=1), axis=1) varwcu = np.nanmean(np.append(varcu[:, -2:], varcu[:, :3], axis=1), axis=1) varwpi = np.nanmean(np.append(varpi[:, -2:], varpi[:, :3], axis=1), axis=1) elif period == 'DJF': varwf = np.nanmean(np.append(varf[:, -1:], varf[:, :2], axis=1), axis=1) varwcu = np.nanmean(np.append(varcu[:, -1:], varcu[:, :2], axis=1), axis=1) varwpi = np.nanmean(np.append(varpi[:, -1:], varpi[:, :2], axis=1), axis=1) elif period == 'JFM': varwf = np.nanmean(varf[:, 0:3], axis=1) varwcu = np.nanmean(varcu[:, 0:3], axis=1) varwpi = np.nanmean(varpi[:, 0:3], axis=1) elif period == 'JF': varwf = np.nanmean(varf[:, 0:2], axis=1) varwcu = np.nanmean(varcu[:, 0:2], axis=1) varwpi = np.nanmean(varpi[:, 0:2], axis=1) elif period == 'OND': varwf = np.nanmean(varf[:, -3:], axis=1) varwcu = np.nanmean(varcu[:, -3:], axis=1) varwpi = np.nanmean(varpi[:, -3:], axis=1) elif period == 'ND': varwf = np.nanmean(varf[:, -2:], axis=1) varwcu = np.nanmean(varcu[:, -2:], axis=1) varwpi = np.nanmean(varpi[:, -2:], axis=1) elif period == 'MAM': varwf = np.nanmean(varf[:, 2:5], axis=1) varwcu = np.nanmean(varcu[:, 2:5], axis=1) varwpi = np.nanmean(varpi[:, 2:5], axis=1) elif period == 'Annual': varwf = np.nanmean(varf[:, :], axis=1) varwcu = np.nanmean(varcu[:, :], axis=1) varwpi = np.nanmean(varpi[:, :], axis=1) elif period == 'Dec': varwf = varf[:, -1] varwcu = varcu[:, -1] varwpi = varpi[:, -1] elif period == 'Jan': varwf = varf[:, 0] varwcu = varcu[:, 0] varwpi = varpi[:, 0] elif period == 'Feb': varwf = varf[:, 1] varwcu = varcu[:, 1] varwpi = varpi[:, 1] elif period == 'Mar': varwf = varf[:, 2] varwcu = varcu[:, 2] varwpi = varpi[:, 2] ### Check for missing data! this occurs between 100,200,300 ensembles varwf[np.where(varwf < -1e20)] = np.nan varwcu[np.where(varwcu < -1e20)] = np.nan varwpi[np.where(varwpi < -1e20)] = np.nan ### Calculate anomalies [1D arrays] anomcu = varwf - varwcu anompi = varwf - varwpi return lat, lon, anomcu, anompi