def readVar(varnames,monthperiod): ### Call function to read in ERA-Interim lat,lon,time,lev,era = MOR.readDataR(varnames,'surface',False,True) ### Call functions to read in WACCM data models = np.empty((len(runnamesm),ensembles,era.shape[0],era.shape[1], era.shape[2],era.shape[3])) for i in range(len(runnamesm)): lat,lon,time,lev,models[i] = MOM.readDataM(varnames,runnamesm[i], 'surface',False,True) ### Retrieve time period of interest if monthperiod == 'DJF': modq = np.empty((len(runnamesm),ensembles,era.shape[0]-1,era.shape[2], era.shape[3])) for i in range(len(runnamesm)): for j in range(ensembles): modq[i,j,:,:,:] = UT.calcDecJanFeb(models[i,j,:,:,:], lat,lon,'surface',1) eraq = UT.calcDecJanFeb(era,lat,lon,'surface',1) elif monthperiod == 'Annual': modq = np.nanmean(models[:,:,:,:,:,:],axis=3) eraq = np.nanmean(era[:,:,:,:],axis=1) ### Take ensemble mean modmean = np.nanmean(modq,axis=1) ### Slice over Arctic polar cap latslicemin = 40 latslicemax = 65 lonslicemin = 50 lonslicemax = 130 latq = np.where((lat >= latslicemin) & (lat <= latslicemax))[0] lat = lat[latq] lonq = np.where((lon >= lonslicemin) & (lon <= lonslicemax))[0] lon = lon[lonq] eraq = eraq[:,latq,:] eraq = eraq[:,:,lonq] modmean = modmean[:,:,latq,:] modmean = modmean[:,:,:,lonq] ### Meshgrid for lat/lon lon2,lat2 = np.meshgrid(lon,lat) eramean = UT.calc_weightedAve(eraq,lat2) mmean = UT.calc_weightedAve(modmean,lat2) ### Create climo over time series eraiave = np.nanmean(eramean) modelave = np.nanmean(mmean,axis=1) ### Calculate anomalies eraanom = eramean - eraiave modelanom = (mmean.transpose() - modelave).transpose() return eraanom, modelanom
def readVar(varnames, runnamesm, period): ### Call function to read in ERA-Interim (detrended) lat, lon, time, lev, era = MOR.readDataR(varnames, 'surface', True, True) ### Call functions to read in WACCM data (detrended) models = np.empty((len(runnamesm), ensembles, era.shape[0], era.shape[1], era.shape[2], era.shape[3])) for i in range(len(runnamesm)): lat, lon, time, lev, models[i] = MOM.readDataM(varnames, runnamesm[i], 'surface', True, True) ### Retrieve time period of interest if period == 'ON': modq = np.nanmean(models[:, :, :, 9:11, :, :], axis=3) eraq = np.nanmean(era[:, 9:11, :, :], axis=1) elif period == 'OND': modq = np.nanmean(models[:, :, :, -3:, :, :], axis=3) eraq = np.nanmean(era[:, -3:, :, :], axis=1) elif period == 'ND': modq = np.nanmean(models[:, :, :, -2:, :, :], axis=3) eraq = np.nanmean(era[:, -2:, :, :], axis=1) elif period == 'N': modq = models[:, :, :, -2, :, :].squeeze() eraq = era[:, -2, :, :].squeeze() elif period == 'D': modq = models[:, :, :, -1:, :, :].squeeze() eraq = era[:, -1:, :, :].squeeze() elif period == 'JJA': modq = np.nanmean(models[:, :, :, 5:8, :, :], axis=3) eraq = np.nanmean(era[:, 5:8, :, :], axis=1) elif period == 'Annual': modq = np.nanmean(models[:, :, :, :, :, :], axis=3) eraq = np.nanmean(era[:, :, :, :], axis=1) elif period == 'DJF': modq = np.empty((len(runnamesm), ensembles, era.shape[0] - 1, era.shape[2], era.shape[3])) for i in range(len(runnamesm)): for j in range(ensembles): modq[i, j, :, :, :] = UT.calcDecJanFeb(models[i, j, :, :, :, :], lat, lon, 'surface', 1) eraq = UT.calcDecJanFeb(era, lat, lon, 'surface', 1) ### Slice U10 at 65N latq = np.where((lat >= 64.5) & (lat <= 65.5))[0] lat = lat[latq].squeeze() eraq = eraq[:, latq, :].squeeze() modq = modq[:, :, :, latq, :].squeeze() ### Take zonal mean eraq = np.nanmean(eraq, axis=1) modq = np.nanmean(modq, axis=3) return modq, eraq, lat, lon
def calcVarResp(varnames): ### Call function for variable data from each run lat, lon, time, lev, varhit = MO.readExperi(directorydata, '%s' % varnames, 'HIT', 'surface') lat, lon, time, lev, varfit = MO.readExperi(directorydata, '%s' % varnames, 'FIT', 'surface') lat, lon, time, lev, varcit = MO.readExperi(directorydata, '%s' % varnames, 'CIT', 'surface') lat, lon, time, lev, varfic = MO.readExperi(directorydata, '%s' % varnames, 'FIC', 'surface') ### Concatonate runs runs = [varhit, varfit, varcit, varfic] ### Separate per periods (ON,DJ,FM) var_djf = np.empty( (4, varhit.shape[0] - 1, varhit.shape[2], varhit.shape[3])) for i in range(len(runs)): var_djf[i], var_djf[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 1) ### Compute comparisons for FM - taken ensemble average diff_FITHIT = np.nanmean(var_djf[1] - var_djf[0], axis=0) diff_FICCIT = np.nanmean(var_djf[3] - var_djf[2], axis=0) diffruns_djf = [diff_FITHIT, diff_FICCIT] ### Calculate significance for FM stat_FITHIT, pvalue_FITHIT = UT.calc_indttest(var_djf[1], var_djf[0]) stat_FICCIT, pvalue_FICCIT = UT.calc_indttest(var_djf[3], var_djf[2]) pruns_djf = [pvalue_FITHIT, pvalue_FICCIT] return diffruns_djf, pruns_djf, lat, lon
def readVar(varnames): ### Call function to read in ERA-Interim (detrended) lat, lon, time, lev, era = MOR.readDataR(varnames, 'surface', True, True) ### Call functions to read in WACCM data (detrended) models = np.empty((len(runnamesm), ensembles, era.shape[0], era.shape[1], era.shape[2], era.shape[3])) for i in range(len(runnamesm)): lat, lon, time, lev, models[i] = MOM.readDataM(varnames, runnamesm[i], 'surface', True, True) ### Retrieve time period of interest modq = np.empty((len(runnamesm), ensembles, era.shape[0] - 1, era.shape[2], era.shape[3])) for i in range(len(runnamesm)): for j in range(ensembles): modq[i, j, :, :, :] = UT.calcDecJanFeb(models[i, j, :, :, :], lat, lon, 'surface', 1) eraq = UT.calcDecJanFeb(era, lat, lon, 'surface', 1) return modq, eraq, lat, lon
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 readVariables(varnames,runnames,period,directory): for v in range(len(varnames)): ### Call function for surface temperature data from reach run lat,lon,time,lev,varhit = MO.readExperi(directory,'%s' % varnames[v], '%s' % runnames,'surface') ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Concatonate runs runs = [varhit] ### Separate per periods if period == 'ON': tas_mo = np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = np.nanmean(runs[i][:,9:11,:,:],axis=1) elif period == 'DJ': tas_mo = np.empty((3,varhit.shape[0]-1,varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat, lon,'surface',1) elif period == 'FM': tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = np.nanmean(runs[i][:,1:3,:,:],axis=1) elif period == 'DJF': tas_mo= np.empty((varhit.shape[0]-1,varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:],tas_mo[:] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'surface',1) elif period == 'M': tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = runs[i][:,2,:,:] elif period == 'D': tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = runs[i][:,-1,:,:] elif period == 'N': tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = runs[i][:,-2,:,:] elif period == 'ND': tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3])) for i in range(len(runs)): tas_mo[:] = np.nanmean(runs[i][:,-2:,:,:],axis=1) else: ValueError('Wrong period selected! (ON,DJ,FM)') return lat,lon,tas_mo
def readTemp(varnames): """ Read in temperature data for selected variables and calculate differences between experiments """ for v in range(len(varnames)): ### Call function for T2M data from reach run lat, lon, time, lev, varhit = MO.readExperi(directorydata, '%s' % varnames[v], 'HIT', 'surface') lat, lon, time, lev, varfit = MO.readExperi(directorydata, '%s' % varnames[v], 'FIT', 'surface') lat, lon, time, lev, varcit = MO.readExperi(directorydata, '%s' % varnames[v], 'CIT', 'surface') lat, lon, time, lev, varfic = MO.readExperi(directorydata, '%s' % varnames[v], 'FIC', 'surface') lat, lon, time, lev, varfict = MO.readExperi(directorydata, '%s' % varnames[v], 'FICT', 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Concatonate runs runs = [varhit, varfit, varcit, varfic, varfict] ### Separate per periods (DJF) var_djf = np.empty( (5, varhit.shape[0] - 1, varhit.shape[2], varhit.shape[3])) for i in range(len(runs)): var_djf[i], var_djf[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 1) ### Compute comparisons for FM - taken ensemble average diff_FITHIT = np.nanmean(var_djf[1] - var_djf[0], axis=0) diff_FICCIT = np.nanmean(var_djf[3] - var_djf[2], axis=0) diff_FICTHIT = np.nanmean(var_djf[4] - var_djf[0], axis=0) diffruns_djf = [diff_FITHIT, diff_FICCIT, diff_FICTHIT] ### Calculate significance for FM stat_FITHIT, pvalue_FITHIT = UT.calc_indttest(var_djf[1], var_djf[0]) stat_FICCIT, pvalue_FICCIT = UT.calc_indttest(var_djf[3], var_djf[2]) stat_FICTHIT, pvalue_FICTHIT = UT.calc_indttest(var_djf[4], var_djf[0]) pruns_djf = [pvalue_FITHIT, pvalue_FICCIT, pvalue_FICTHIT] return diffruns_djf, pruns_djf, lat, lon
def readControl(period): directory = '/surtsey/zlabe/simu/CTLQ/monthly/' filename = directory + 'U30_1801-2000.nc' datac = Dataset(filename) tashitq = datac.variables['U30'][:] lat = datac.variables['latitude'][:] lon = datac.variables['longitude'][:] datac.close() ### Reshape array (200,12,96,144) tashit = np.reshape(tashitq,(tashitq.shape[0]//12,12,lat.shape[0],lon.shape[0])) ### Concatonate runs runs = [tashit] ### Separate per periods (ON,DJ,FM) if period == 'DJF': tas_mo,tas_mo = UT.calcDecJanFeb(runs[0],runs[0],lat, lon,'surface',1) elif period == 'D': tas_mo = runs[0][:,-1,:,:] ### Read in QBO winters filenamefctlqp = directorydata + 'CTLQ/monthly/QBO_%s_CTLQ.txt' % qbophase[0] filenamefctlqn = directorydata + 'CTLQ/monthly/QBO_%s_CTLQ.txt' % qbophase[2] pos_ctlq = np.genfromtxt(filenamefctlqp,unpack=True,usecols=[0],dtype='int') neg_ctlq = np.genfromtxt(filenamefctlqn,unpack=True,usecols=[0],dtype='int') ### Composite by QBO phase if period == 'DJF': upos = tas_mo[pos_ctlq[:-1],:,:] else: upos = tas_mo[pos_ctlq,:,:] uneg = tas_mo[neg_ctlq,:,:] ### Slice U10 at 65N latq = np.where((lat >= 64.5) & (lat <= 65.5))[0] lat = lat[latq].squeeze() upos = upos[:,latq,:].squeeze() uneg = uneg[:,latq,:].squeeze() ### Take zonal mean uupos = np.nanmean(upos,axis=1) uuneg = np.nanmean(uneg,axis=1) return uupos,uuneg
def read300yrf(period): """ Read in 300 year control """ directory300 = '/seley/ypeings/simu/PAMIP-1.6-QBO-300yr/monthly/' file300 = 'U10_1700-2000.nc' filename = directory300 + file300 data = Dataset(filename) lat = data.variables['latitude'][:] lon = data.variables['longitude'][:] u10q = data.variables['U10'][:] data.close() ### Reshape in year/month u10n = np.reshape(u10q, (u10q.shape[0] // 12, 12, lat.shape[0], lon.shape[0])) ### Calculate over particular months u10 = UT.calcDecJanFeb(u10n, lat, lon, 'surface', 1) ### Slice U10 at 65N latq = np.where((lat >= 64.5) & (lat <= 65.5))[0] lat = lat[latq].squeeze() u10 = u10[:, latq, :].squeeze() ### Take zonal mean u10z = np.nanmean(u10, axis=1) ### Remove missing data mask = np.where(u10z > -1e5)[0] ### Detrend u10zdt = sss.detrend(u10z[mask], type='linear') return lat, lon, u10zdt
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
def calcVarResp(varnames,period,qbophase): ### Call function for surface temperature data from reach run lat,lon,time,lev,tashit = MO.readExperiAll('%s' % varnames,'HIT', 'surface') lat,lon,time,lev,tasfict = MO.readExperiAll('%s' % varnames,'FICT', 'surface') ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Read in QBO phases filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] pos_hit = np.append(np.genfromtxt(filenamehitp,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamehitp2,unpack=True,usecols=[0],dtype='int')+101) non_hit = np.append(np.genfromtxt(filenamehitno,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamehitno2,unpack=True,usecols=[0],dtype='int')+101) neg_hit = np.append(np.genfromtxt(filenamehitn,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamehitn2,unpack=True,usecols=[0],dtype='int')+101) filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[1] filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[1] filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] pos_fict = np.append(np.genfromtxt(filenamefictp,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefictp2,unpack=True,usecols=[0],dtype='int')+101) non_fict = np.append(np.genfromtxt(filenamefictno,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefictno2,unpack=True,usecols=[0],dtype='int')+101) neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101) ### Concatonate runs runs = [tashit,tasfict] ### Separate per periods (ON,DJ,FM) if period == 'ON': tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1) elif period == 'DJ': tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat, lon,'surface',1) elif period == 'FM': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1) elif period == 'DJF': tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'surface',1) elif period == 'M': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,2,:,:] elif period == 'D': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,-1,:,:] elif period == 'N': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,-2,:,:] elif period == 'ND': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,-2:,:,:],axis=1) else: ValueError('Wrong period selected! (ON,DJ,FM)') ### Composite by QBO phase tas_mohitpos = tas_mo[0][pos_hit,:,:] tas_mofictpos = tas_mo[1][pos_fict,:,:] tas_mohitneg = tas_mo[0][neg_hit,:,:] tas_mofictneg = tas_mo[1][neg_fict,:,:] ### Compute climatology climohitpos = np.nanmean(tas_mohitpos,axis=0) climohitneg = np.nanmean(tas_mohitneg,axis=0) climo = [climohitpos,climohitneg] ### Compute comparisons for months - taken ensemble average ficthitpos = np.nanmean(tas_mofictpos - tas_mohitpos,axis=0) ficthitneg = np.nanmean(tas_mofictneg - tas_mohitneg,axis=0) diffruns = [ficthitpos,ficthitneg] ### Calculate significance for ND stat_FICTHITpos,pvalue_FICTHITpos = UT.calc_indttest(tas_mo[1][pos_fict,:,:], tas_mo[0][pos_hit,:,:]) stat_FICTHITnon,pvalue_FICTHITnon = UT.calc_indttest(tas_mo[1][non_fict,:,:], tas_mo[0][non_hit,:,:]) stat_FICTHITneg,pvalue_FICTHITneg = UT.calc_indttest(tas_mo[1][neg_fict,:,:], tas_mo[0][neg_hit,:,:]) pruns = [pvalue_FICTHITpos,pvalue_FICTHITneg] return diffruns,pruns,climo,lat,lon
elif period == 'ND': modanom = np.nanmean(modanomq[:,:,:,-2:,:,:],axis=3) elif period == 'D': modanom = modanomq[:,:,:,-1:,:,:].squeeze() elif period == 'F': modanom = modanomq[:,:,:,1,:,:].squeeze() elif period == 'FM': modanom = modanomq[:,:,:,1:3,:,:].squeeze() elif period == 'JFM': modanom = np.nanmean(modanomq[:,:,:,0:3,:,:],axis=3) elif period == 'DJF': modanom = np.empty((len(runnames),ensembles,modanomq.shape[2]-1, modanomq.shape[4],modanomq.shape[5])) for i in range(len(runnames)): for j in range(ensembles): modanom[i,j,:,:,:] = UT.calcDecJanFeb(modanomq[i,j,:,:,:], lat,lon,'surface',1) snowindex = snowindex[:,:-1] ### Calculate regression functions modcoeff,modint,modr2,modpval,moderr = regressData(snowindex, modanom[:,:,:-1,:,:], runnames) ### 1979-2015 ### Calculate ensemble mean modcoeffm = np.nanmean(modcoeff,axis=1) # [model,ens,lat,lon] ########################################################################### ########################################################################### ########################################################################### ### Plot snow cover regressions plt.rc('text',usetex=True)
def read_LENS(directory, vari, sliceperiod, slicebase, sliceshape, addclimo, slicenan, takeEnsMean): """ Function reads monthly data from LENS Parameters ---------- directory : string path for data vari : string variable for analysis sliceperiod : string how to average time component of data sliceyear : string how to slice number of years for data sliceshape : string shape of output array addclimo : binary True or false to add climatology slicenan : string or float Set missing values takeEnsMean : binary whether to take ensemble mean Returns ------- lat : 1d numpy array latitudes lon : 1d numpy array longitudes var : numpy array processed variable ENSmean : numpy array ensemble mean Usage ----- read_LENS(directory,vari,sliceperiod, slicebase,sliceshape,addclimo, slicenan,takeEnsMean) """ print('\n>>>>>>>>>> STARTING read_LENS function!') ### Import modules import numpy as np from netCDF4 import Dataset import warnings import calc_Utilities as UT warnings.simplefilter(action='ignore', category=FutureWarning) warnings.simplefilter(action='ignore', category=RuntimeWarning) ########################################################################### ### Parameters time = np.arange(1920, 2100 + 1, 1) mon = 12 ens1 = np.arange(1, 35 + 1, 1) ens2 = np.arange(101, 105 + 1, 1) allens = np.append(ens1, ens2) ens = list(map('{:03d}'.format, allens)) ########################################################################### ### Read in data membersvar = [] for i, ensmember in enumerate(ens): if vari == 'SLP': filename = directory + '%s/%s_%s_1920_2100.nc' % (vari, vari, ensmember) else: filename = directory + '%s/%s_%s_1920-2100.nc' % (vari, vari, ensmember) data = Dataset(filename, 'r') lat1 = data.variables['latitude'][:] lon1 = data.variables['longitude'][:] var = data.variables['%s' % vari][:, :, :] data.close() print('Completed: read ensemble --%s--' % ensmember) membersvar.append(var) del var membersvar = np.asarray(membersvar) ensvar = np.reshape( membersvar, (len(ens), time.shape[0], mon, lat1.shape[0], lon1.shape[0])) del membersvar print('Completed: read all members!\n') ########################################################################### ### Calculate anomalies or not if addclimo == True: ensvalue = ensvar print('Completed: calculated absolute variable!') elif addclimo == False: yearsq = np.where((time >= slicebase.min()) & (time <= slicebase.max()))[0] yearssel = time[yearsq] mean = np.nanmean(ensvar[:, yearsq, :, :, :]) ensvalue = ensvar - mean print('Completed: calculated anomalies from', slicebase.min(), 'to', slicebase.max()) ########################################################################### ### Slice over months (currently = [ens,yr,mn,lat,lon]) ### Shape of output array if sliceperiod == 'annual': ensvalue = np.nanmean(ensvalue, axis=2) if sliceshape == 1: ensshape = ensvalue.ravel() elif sliceshape == 4: ensshape = ensvalue print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: ANNUAL MEAN!') elif sliceperiod == 'DJF': ensshape = np.empty((ensvalue.shape[0], ensvalue.shape[1] - 1, lat1.shape[0], lon1.shape[0])) for i in range(ensvalue.shape[0]): ensshape[i, :, :, :] = UT.calcDecJanFeb(ensvalue[i, :, :, :, :], lat1, lon1, 'surface', 1) print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: DJF MEAN!') elif sliceperiod == 'MAM': enstime = np.nanmean(ensvalue[:, :, 2:5, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: MAM MEAN!') elif sliceperiod == 'JJA': enstime = np.nanmean(ensvalue[:, :, 5:8, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: JJA MEAN!') elif sliceperiod == 'SON': enstime = np.nanmean(ensvalue[:, :, 8:11, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: SON MEAN!') elif sliceperiod == 'JFM': enstime = np.nanmean(ensvalue[:, :, 0:3, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: JFM MEAN!') elif sliceperiod == 'AMJ': enstime = np.nanmean(ensvalue[:, :, 3:6, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: AMJ MEAN!') elif sliceperiod == 'JAS': enstime = np.nanmean(ensvalue[:, :, 6:9, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: JAS MEAN!') elif sliceperiod == 'OND': enstime = np.nanmean(ensvalue[:, :, 9:, :, :], axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape, [[ensshape.ndim]]) print('Completed: OND MEAN!') elif sliceperiod == 'none': if sliceshape == 1: ensshape = ensvalue.ravel() elif sliceshape == 3: ensshape = np.reshape(ensvalue, (ensvalue.shape[0] * ensvalue.shape[1], ensvalue.shape[2], ensvalue.shape[3])) elif sliceshape == 5: ensshape = ensvalue print('Shape of output =', ensshape.shape, [[ensshape.ndim]]) print('Completed: ALL MONTHS!') ########################################################################### ### Change missing values if slicenan == 'nan': ensshape[np.where(np.isnan(ensshape))] = np.nan print('Completed: missing values are =', slicenan) else: ensshape[np.where(np.isnan(ensshape))] = slicenan ########################################################################### ### Take ensemble mean if takeEnsMean == True: ENSmean = np.nanmean(ensshape, axis=0) print('Ensemble mean AVAILABLE!') elif takeEnsMean == False: ENSmean = np.nan print('Ensemble mean NOT available!') else: ValueError('WRONG OPTION!') ########################################################################### ### Change units if vari == 'SLP': ensshape = ensshape / 100 # Pa to hPa ENSmean = ENSmean / 100 # Pa to hPa print('Completed: Changed units (Pa to hPa)!') elif vari == 'T2M': ensshape = ensshape - 273.15 # K to C ENSmean = ENSmean - 273.15 # K to C print('Completed: Changed units (K to C)!') print('>>>>>>>>>> ENDING read_LENS function!') return lat1, lon1, ensshape, ENSmean # ### Test functions - do not use! # import numpy as np # import matplotlib.pyplot as plt # import calc_Utilities as UT # directory = '/Users/zlabe/Data/LENS/monthly/' # vari = 'T2M' # sliceperiod = 'annual' # slicebase = np.arange(1951,1980+1,1) # sliceshape = 4 # slicenan = 'nan' # addclimo = True # takeEnsMean = False # lat,lon,var,ENSmean = read_LENS(directory,vari,sliceperiod, # slicebase,sliceshape,addclimo, # slicenan,takeEnsMean)
def readData(simu, period, varia, level): ############################################################################### ############################################################################### ############################################################################### if simu == 'AA-2030': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2030', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') elif simu == 'AA-2060': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2060', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') elif simu == 'AA-2090': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2090', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') ############################################################################### elif simu == 'coupled': lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level) lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pd', level) ############################################################################### elif simu == 'SIT': lat, lon, lev, future = THICK.readSIT(varia, 'SIT_Fu', level) lat, lon, lev, historical = THICK.readSIT(varia, 'SIT_Pd', level) ############################################################################### elif simu == 'SIC_Pd': lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level) lat, lon, lev, historical = CONC.readSIC(varia, 'Pd', level) ############################################################################### elif simu == 'SIC_Pi': lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level) lat, lon, lev, historical = CONC.readSIC(varia, 'Pi', level) ############################################################################### elif simu == 'E3SIT': lat, lon, lev, future = E3SIT.readE3SM_SIT(varia, 'ESIT_Fu', level) lat, lon, lev, historical = E3SIT.readE3SM_SIT(varia, 'ESIT_Pd', level) ############################################################################### elif simu == 'E3SIC_Pd': lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level) lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pd', level) elif simu == 'E3SIC_Pi': lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level) lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pi', level) ############################################################################### elif simu == 'OLD': lat, lon, lev, future = OLD.readOldIceExperi(varia, 'FICT', level) lat, lon, lev, historical = OLD.readOldIceExperi(varia, 'HIT', level) ############################################################################### ############################################################################### ############################################################################### ### Calculate number of ensembles nens = np.shape(historical)[0] ### Check for missing data [ensembles,months,lat,lon] future[np.where(future <= -1e10)] = np.nan historical[np.where(historical <= -1e10)] = np.nan ############################################################################### ############################################################################### ############################################################################### ### Calculate over period if period == 'OND': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, -3:], axis=1) historicalm = np.nanmean(historical[:, -3:], axis=1) elif period == 'D': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, -1:], axis=1) historicalm = np.nanmean(historical[:, -1:], axis=1) elif period == 'DJF': print('Calculating over %s months!' % period) runs = [future, historical] var_mo = np.empty((2, historical.shape[0] - 1, historical.shape[2], historical.shape[3], historical.shape[4])) for i in range(len(runs)): var_mo[i, :, :, :, :] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, level, 17) futurem = var_mo[0] historicalm = var_mo[1] elif period == 'JFM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:3], axis=1) historicalm = np.nanmean(historical[:, 0:3], axis=1) elif period == 'JF': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:2], axis=1) historicalm = np.nanmean(historical[:, 0:2], axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:4], axis=1) historicalm = np.nanmean(historical[:, 1:4], axis=1) elif period == 'FM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:3], axis=1) historicalm = np.nanmean(historical[:, 1:3], axis=1) elif period == 'J': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:1], axis=1) historicalm = np.nanmean(historical[:, 0:1], axis=1) elif period == 'F': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:2], axis=1) historicalm = np.nanmean(historical[:, 1:2], axis=1) elif period == 'M': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 2:3], axis=1) historicalm = np.nanmean(historical[:, 2:3], axis=1) elif period == 'MA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 2:4], axis=1) historicalm = np.nanmean(historical[:, 2:4], axis=1) else: print(ValueError('Selected wrong month period!')) ########################################################################### ########################################################################### ########################################################################### ### Calculate zonal means futuremz = np.nanmean(futurem, axis=3) historicalmz = np.nanmean(historicalm, axis=3) ### Calculate anomalies [ens,level,lat] anom = futuremz - historicalmz ### Calculate ensemble mean anommean = np.nanmean(anom, axis=0) ### Calculate significance pruns = UT.calc_FDR_ttest(futuremz, historicalmz, 0.05) #FDR ### Select climo climo = np.nanmean(historicalmz, axis=0) return lat, lon, lev, anommean, nens, pruns, climo
def PolarCap(simu,vari,level,latpolar,period): """ Script calculates average over the polar cap (set latitude) """ ### Import modules import numpy as np import calc_Utilities as UT import read_CTLNQ as CONT import read_ExpMonthly as NUDG import read_ShortCoupled as COUP import read_SIT as THICK import read_SIC as CONC import read_SIT_E3SM as E3SIT import read_SIC_E3SM as E3SIC import read_OldIceExperi as OLD import read_LongCoupled as LC if any([vari=='T700',vari=='T500']): varia = 'TEMP' level = 'profile' elif vari == 'U700': varia = 'U' level = 'profile' else: varia = vari ############################################################################### ############################################################################### ############################################################################### if simu == 'AA-2030': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2030',level,'none') lat,lon,lev,historical = CONT.readControl(varia,level,'none') elif simu == 'AA-2060': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2060',level,'none') lat,lon,lev,historical = CONT.readControl(varia,level,'none') elif simu == 'AA-2090': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2090',level,'none') lat,lon,lev,historical = CONT.readControl(varia,level,'none') ############################################################################### elif simu == 'coupled_Pd': lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level) lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pd',level) ############################################################################### elif simu == 'coupled_Pi': lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level) lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pi',level) ############################################################################### elif simu == 'SIT': lat,lon,lev,future = THICK.readSIT(varia,'SIT_Fu',level) lat,lon,lev,historical = THICK.readSIT(varia,'SIT_Pd',level) ############################################################################### elif simu == 'SIC_Pd': lat,lon,lev,future = CONC.readSIC(varia,'Fu',level) lat,lon,lev,historical = CONC.readSIC(varia,'Pd',level) ############################################################################### elif simu == 'SIC_Pi': lat,lon,lev,future = CONC.readSIC(varia,'Fu',level) lat,lon,lev,historical = CONC.readSIC(varia,'Pi',level) ############################################################################### elif simu == 'E3SIT': lat,lon,lev,future = E3SIT.readE3SM_SIT(varia,'ESIT_Fu',level) lat,lon,lev,historical = E3SIT.readE3SM_SIT(varia,'ESIT_Pd_B',level) ############################################################################### elif simu == 'E3SIC_Pd': lat,lon,lev,future = E3SIC.readE3SM_SIC(varia,'ESIC_Fu',level) lat,lon,lev,historical = E3SIC.readE3SM_SIC(varia,'ESIC_Pd',level) elif simu == 'E3SIC_Pi': lat,lon,lev,future = E3SIC.readE3SM_SIC(varia,'ESIC_Fu',level) lat,lon,lev,historical = E3SIC.readE3SM_SIC(varia,'ESIC_Pi',level) ############################################################################### elif simu == 'OLD': lat,lon,lev,future = OLD.readOldIceExperi(varia,'FICT',level) lat,lon,lev,historical = OLD.readOldIceExperi(varia,'HIT',level) ############################################################################### elif simu == 'LONG': lat,lon,lev,future = LC.readLong(varia,'Long_Fu',level) lat,lon,lev,historical = LC.readLong(varia,'Long_Pd',level) ############################################################################### ############################################################################### ############################################################################### ### Check for missing data [ensembles,months,lat,lon] future[np.where(future <= -1e10)] = np.nan historical[np.where(historical <= -1e10)] = np.nan ### Check for 4D field if vari == 'T700': levq = np.where(lev == 700)[0] future = future[:,:,levq,:,:].squeeze() historical = historical[:,:,levq,:,:].squeeze() elif vari == 'T500': levq = np.where(lev == 500)[0] future = future[:,:,levq,:,:].squeeze() historical = historical[:,:,levq,:,:].squeeze() elif vari == 'U700': levq = np.where(lev == 700)[0] future = future[:,:,levq,:,:].squeeze() historical = historical[:,:,levq,:,:].squeeze() ############################################################################### ############################################################################### ############################################################################### ### Calculate over period if period == 'OND': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,-3:,:,:],axis=1) historicalm = np.nanmean(historical[:,-3:,:,:],axis=1) elif period == 'D': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,-1:,:,:],axis=1) historicalm = np.nanmean(historical[:,-1:,:,:],axis=1) elif period == 'DJF': print('Calculating over %s months!' % period) runs = [future,historical] var_mo = np.empty((2,historical.shape[0]-1,historical.shape[2],historical.shape[3])) for i in range(len(runs)): var_mo[i,:,:,:] = UT.calcDecJanFeb(runs[i],runs[i],lat,lon,'surface',1) futurem = var_mo[0] historicalm = var_mo[1] elif period == 'JFM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:3,:,:],axis=1) historicalm = np.nanmean(historical[:,0:3,:,:],axis=1) elif period == 'JF': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:2,:,:],axis=1) historicalm = np.nanmean(historical[:,0:2,:,:],axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:4,:,:],axis=1) historicalm = np.nanmean(historical[:,1:4,:,:],axis=1) elif period == 'FM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:3,:,:],axis=1) historicalm = np.nanmean(historical[:,1:3,:,:],axis=1) elif period == 'J': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:1,:,:],axis=1) historicalm = np.nanmean(historical[:,0:1,:,:],axis=1) elif period == 'F': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:2,:,:],axis=1) historicalm = np.nanmean(historical[:,1:2,:,:],axis=1) elif period == 'M': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,2:3,:,:],axis=1) historicalm = np.nanmean(historical[:,2:3,:,:],axis=1) elif period == 'MA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,2:4,:,:],axis=1) historicalm = np.nanmean(historical[:,2:4,:,:],axis=1) elif period == 'NONE': futurem = future historicalm = historical else: print(ValueError('Selected wrong month period!')) ############################################################################### ############################################################################### ############################################################################### ### Calculate anomalies anom = futurem - historicalm ### Meshgrid for lat,lon lon2,lat2 = np.meshgrid(lon,lat) ### Calculate SHI if period == 'NONE': latq = np.where((lat >= latpolar))[0] anomp = anom[:,:,latq,:] lat2p = lat2[latq,:] polarave = UT.calc_weightedAve(anomp,lat2p) else: latq = np.where((lat >= latpolar))[0] anomp = anom[:,latq,:] lat2p = lat2[latq,:] polarave = UT.calc_weightedAve(anomp,lat2p) print('\n========Calculated Polar Cap Average========\n') return polarave ### Test functions (do not use!) #ave = PolarCap('AA-2030','TEMP','profile',65,'DJF') #import matplotlib.pyplot as plt #import numpy as np #plt.figure(figsize=(11,4)) #plt.title('Monthly SIC Anomalies') #plt.plot(ave.ravel()) #plt.savefig('/home/zlabe/Desktop/' + 'monthly_SIC_anom.png',dpi=300)
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1) elif period == 'DJ': tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat, lon,'surface',1) elif period == 'FM': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1) elif period == 'DJF': tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'surface',1) elif period == 'M': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,2,:,:] elif period == 'D': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,-1,:,:] elif period == 'F': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,1,:,:] elif period == 'N': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)):
def read_20CRv3_monthly(variq,directory,sliceperiod,sliceyear,sliceshape,addclimo,slicenan): """ Function reads monthly data from 20CRv3 Parameters ---------- variq : string variable to retrieve directory : string path for data sliceperiod : string how to average time component of data sliceyear : string how to slice number of years for data sliceshape : string shape of output array addclimo : binary True or false to add climatology slicenan : string or float Set missing values Returns ------- lat : 1d numpy array latitudes lon : 1d numpy array longitudes var : 3d numpy array or 4d numpy array [time,lat,lon] or [year,month,lat,lon] Usage ----- lat,lon,var = read_20CRv3_monthly(variq,directory,sliceperiod,sliceyear, sliceshape,addclimo,slicenan) """ print('\n>>>>>>>>>> STARTING read_20CRv3_monthly function!') ### Import modules import numpy as np from netCDF4 import Dataset import warnings import calc_Utilities as UT warnings.simplefilter(action='ignore', category=FutureWarning) warnings.simplefilter(action='ignore', category=RuntimeWarning) ########################################################################### ### Parameters time = np.arange(1836,2015+1,1) monthslice = sliceyear.shape[0]*12 mon = 12 ########################################################################### ### Read in data filename = 'monthly/%s_1836-2015.nc' % variq data = Dataset(directory + filename,'r') lat1 = data.variables['latitude'][:] lon1 = data.variables['longitude'][:] var = data.variables['%s' % variq][-monthslice:,:,:] data.close() print('Years of output =',sliceyear.min(),'to',sliceyear.max()) ########################################################################### ### Reshape data into [year,month,lat,lon] datamon = np.reshape(var,(var.shape[0]//mon,mon, lat1.shape[0],lon1.shape[0])) ########################################################################### ### Return absolute temperature (1951-1980 baseline) if addclimo == True: varmon = datamon print('Completed: calculated absolute variable!') else: yearbasemin = 1981 yearbasemax = 2010 yearq = np.where((time >= yearbasemin) & (time<=yearbasemax))[0] varmon = datamon - np.nanmean(datamon[yearq,:,:,:],axis=0) print('Completed: calculated anomalies!') ########################################################################### ### Slice over months (currently = [yr,mn,lat,lon]) ### Shape of output array if sliceperiod == 'annual': vartime = np.nanmean(varmon,axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: ANNUAL MEAN!') elif sliceperiod == 'DJF': varshape = UT.calcDecJanFeb(varmon,lat1,lon1,'surface',1) print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: DJF MEAN!') elif sliceperiod == 'MAM': vartime = np.nanmean(varmon[:,2:5,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: MAM MEAN!') elif sliceperiod == 'JJA': vartime = np.nanmean(varmon[:,5:8,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: JJA MEAN!') elif sliceperiod == 'SON': vartime = np.nanmean(varmon[:,8:11,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: SON MEAN!') elif sliceperiod == 'JFM': vartime = np.nanmean(varmon[:,0:3,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: JFM MEAN!') elif sliceperiod == 'AMJ': vartime = np.nanmean(varmon[:,3:6,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: AMJ MEAN!') elif sliceperiod == 'JAS': vartime = np.nanmean(varmon[:,6:9,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: JAS MEAN!') elif sliceperiod == 'OND': vartime = np.nanmean(varmon[:,9:,:,:],axis=1) if sliceshape == 1: varshape = vartime.ravel() elif sliceshape == 3: varshape = vartime print('Shape of output = ', varshape.shape,[[varshape.ndim]]) print('Completed: OND MEAN!') elif sliceperiod == 'none': vartime = varmon if sliceshape == 1: varshape = varshape.ravel() elif sliceshape == 3: varshape = np.reshape(vartime,(vartime.shape[0]*vartime.shape[1], vartime.shape[2],vartime.shape[3])) elif sliceshape == 4: varshape = varmon print('Shape of output =', varshape.shape, [[varshape.ndim]]) print('Completed: ALL MONTHS!') ########################################################################### ### Change missing values if slicenan == 'nan': varshape[np.where(np.isnan(varshape))] = np.nan print('Completed: missing values are =',slicenan) else: varshape[np.where(np.isnan(varshape))] = slicenan ########################################################################### ### Change units if variq == 'SLP': varshape = varshape/100 # Pa to hPa print('Completed: Changed units (Pa to hPa)!') elif variq == 'T2M': varshape = varshape - 273.15 # K to C print('Completed: Changed units (K to C)!') print('>>>>>>>>>> ENDING read_20CRv3_monthly function!') return lat1,lon1,varshape ### Test functions - do not use! # import numpy as np # import matplotlib.pyplot as plt # import calc_Utilities as UT # variq = 'SLP' # directory = '/Users/zlabe/Data/20CRv3/' # sliceperiod = 'annual' # sliceyear = np.arange(1836,2015+1,1) # sliceshape = 3 # slicenan = 'nan' # addclimo = True # lat,lon,var = read_20CRv3_monthly(variq,directory,sliceperiod, # sliceyear,sliceshape,addclimo, # slicenan) # lon2,lat2 = np.meshgrid(lon,lat)
### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Concatonate runs runnames = [r'HIT',r'FIT',r'CIT',r'FIC',r'FICT'] experiments = [r'\textbf{FIT--HIT}',r'\textbf{FIT--CIT}', r'\textbf{HIT--CIT}',r'\textbf{FIC--CIT}', r'\textbf{FICT--FIT}',r'\textbf{FICT--HIT}'] runs = [varhit,varfit,varcit,varfic,varfict] ### Separate per periods (DJF) var_djf = np.empty((5,varhit.shape[0]-1,varhit.shape[2],varhit.shape[3], varhit.shape[4])) for i in range(len(runs)): var_djf[i],var_djf[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'profile',17) ### Compute comparisons for FM - taken ensemble average diff_FITHIT = np.nanmean(var_djf[1] - var_djf[0],axis=0) diff_FITCIT = np.nanmean(var_djf[1] - var_djf[2],axis=0) diff_HITCIT = np.nanmean(var_djf[0] - var_djf[2],axis=0) diff_FICCIT = np.nanmean(var_djf[3] - var_djf[2],axis=0) diff_FICTFIT = np.nanmean(var_djf[4] - var_djf[1],axis=0) diff_FICTHIT = np.nanmean(var_djf[4] - var_djf[0],axis=0) diffruns_djf = np.asarray([diff_FITHIT,diff_FITCIT,diff_HITCIT,diff_FICCIT, diff_FICTFIT,diff_FICTHIT]) ### Calculate zonal mean zdiff_FITHIT = np.nanmean(diff_FITHIT,axis=2) zdiff_FITCIT = np.nanmean(diff_FITCIT,axis=2) zdiff_HITCIT = np.nanmean(diff_HITCIT,axis=2)
def calcVarResp(varnames,period,qbophase): ### Call function for surface temperature data from reach run lat,lon,time,lev,tashit = MO.readExperiAll('%s' % varnames,'HIT', 'surface') lat,lon,time,lev,tasfict = MO.readExperiAll('%s' % varnames,'FICT', 'surface') lat,lon,time,lev,tasfit = MO.readExperiAll('%s' % varnames,'FIT', 'surface') ### Create 2d array of latitude and longitude lon2,lat2 = np.meshgrid(lon,lat) ### Read in QBO phases filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] pos_hit = np.append(np.genfromtxt(filenamehitp,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamehitp2,unpack=True,usecols=[0],dtype='int')+101) neg_hit = np.append(np.genfromtxt(filenamehitn,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamehitn2,unpack=True,usecols=[0],dtype='int')+101) filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] pos_fict = np.append(np.genfromtxt(filenamefictp,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefictp2,unpack=True,usecols=[0],dtype='int')+101) neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101) filenamefitp = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[0] filenamefitn = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[2] filenamefitp2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[0] filenamefitn2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[2] pos_fit = np.append(np.genfromtxt(filenamefitp,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefitp2,unpack=True,usecols=[0],dtype='int')+101) neg_fit = np.append(np.genfromtxt(filenamefitn,unpack=True,usecols=[0],dtype='int'), np.genfromtxt(filenamefitn2,unpack=True,usecols=[0],dtype='int')+101) ### Concatonate runs runs = [tashit,tasfict,tasfit] ### Separate per periods (ON,DJ,FM) if period == 'ON': tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1) elif period == 'DJ': tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat, lon,'surface',1) elif period == 'FM': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1) elif period == 'DJF': tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'surface',1) elif period == 'M': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,2,:,:] elif period == 'D': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,-1,:,:] elif period == 'N': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:,-2,:,:] elif period == 'ND': tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:,-2:,:,:],axis=1) else: ValueError('Wrong period selected! (ON,DJ,FM)') ### Composite by QBO phase tas_mohitpos = tas_mo[0][pos_hit,:,:] tas_mofictpos = tas_mo[1][pos_fict,:,:] tas_mofitpos = tas_mo[2][pos_fit,:,:] tas_mohitneg = tas_mo[0][neg_hit,:,:] tas_mofictneg = tas_mo[1][neg_fict,:,:] tas_mofitneg = tas_mo[2][neg_fit,:,:] ### Slice U10 at 65N latq = np.where((lat >= 64.5) & (lat <= 65.5))[0] lat = lat[latq].squeeze() tas_mohitpos = tas_mohitpos[:,latq,:].squeeze() tas_mohitneg = tas_mohitneg[:,latq,:].squeeze() tas_mofictpos = tas_mofictpos[:,latq,:].squeeze() tas_mofictneg = tas_mofictneg[:,latq,:].squeeze() tas_mofitpos = tas_mofitpos[:,latq,:].squeeze() tas_mofitneg = tas_mofitneg[:,latq,:].squeeze() ### Take zonal mean hitpos = np.nanmean(tas_mohitpos,axis=1) hitneg = np.nanmean(tas_mohitneg,axis=1) fictpos = np.nanmean(tas_mofictpos,axis=1) fictneg = np.nanmean(tas_mofictneg,axis=1) fitpos = np.nanmean(tas_mofitpos,axis=1) fitneg = np.nanmean(tas_mofitneg,axis=1) runs = [hitpos,hitneg,fictpos,fictneg,fitpos,fitneg] return runs,lat,lon
def procData(varnames, period, qbophase): """ Function reads in zonal wind data for listed experiments. It then post-processes the data for calculating the zero-wind line Parameters ---------- varnames : list of strings list of variables to download period : list of strings month(s) to calculate qbophase : list of strings list of qbo phases Returns ------- avez : list of arrays arrays for post-processed data for each experiment lat : 1d array latitude Usage ----- avez,lat = procData(varnames,period,qbophase) """ print('\n>>> Using procData function!') ### Read in data for v in range(len(varnames)): ### Call function for surface temperature data from reach run lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames[v], 'HIT', 'profile') lat, lon, time, lev, tasfit = MO.readExperiAll('%s' % varnames[v], 'FIT', 'profile') lat, lon, time, lev, tasfict = MO.readExperiAll( '%s' % varnames[v], 'FICT', 'profile') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Read in QBO phases filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[ 0] filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[ 2] filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[ 0] filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[ 2] pos_hit = np.append( np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') + 101) neg_hit = np.append( np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') + 101) filenamefitp = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[ 0] filenamefitn = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[ 2] filenamefitp2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[ 0] filenamefitn2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[ 2] pos_fit = np.append( np.genfromtxt(filenamefitp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefitp2, unpack=True, usecols=[0], dtype='int') + 101) neg_fit = np.append( np.genfromtxt(filenamefitn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefitn2, unpack=True, usecols=[0], dtype='int') + 101) filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 0] filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 2] filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 0] filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 2] pos_fict = np.append( np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt( filenamefictp2, unpack=True, usecols=[0], dtype='int') + 101) neg_fict = np.append( np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt( filenamefictn2, unpack=True, usecols=[0], dtype='int') + 101) ### Concatonate runs runs = [tashit, tasfit, tasfict] ### Separate per periods (ON,DJ,FM) if period == 'DJF': tas_mo = np.empty((3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i], tas_mo[i] = UT.calcDecJanFeb( runs[i], runs[i], lat, lon, 'profile', 17) elif period == 'ND': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :], axis=1) else: ValueError('Wrong period selected! (DJF)') ### Concatonate runs with selected level levq = np.where(lev == 30)[0] # selected at 10 hPa tas_mo = [ tas_mo[0][:, levq, :, :], tas_mo[1][:, levq, :, :], tas_mo[2][:, levq, :, :] ] ### Composite by QBO phase tas_mofitpos = tas_mo[1][pos_fit, :, :].squeeze() tas_mohitpos = tas_mo[0][pos_hit, :, :].squeeze() tas_mofictpos = tas_mo[2][pos_fict, :, :].squeeze() tas_mofitneg = tas_mo[1][neg_fit, :, :].squeeze() tas_mohitneg = tas_mo[0][neg_hit, :, :].squeeze() tas_mofictneg = tas_mo[2][neg_fict, :, :].squeeze() ### Compute meridional average tas_mofitposz = np.nanmean(tas_mofitpos, axis=2) tas_mohitposz = np.nanmean(tas_mohitpos, axis=2) tas_mofictposz = np.nanmean(tas_mofictpos, axis=2) tas_mofitnegz = np.nanmean(tas_mofitneg, axis=2) tas_mohitnegz = np.nanmean(tas_mohitneg, axis=2) tas_mofictnegz = np.nanmean(tas_mofictneg, axis=2) avez = [ tas_mofitposz, tas_mohitposz, tas_mofictposz, tas_mofitnegz, tas_mohitnegz, tas_mofictnegz ] print('\n*Completed: Finished procData function!') return avez, lat
def read_SMILE(directory,simulation,vari,sliceperiod,slicebase,sliceshape,addclimo,slicenan,takeEnsMean): """ Function reads monthly data from the MMLEA Parameters ---------- directory : string path for data simulation : string name of the model vari : string variable for analysis sliceperiod : string how to average time component of data sliceyear : string how to slice number of years for data sliceshape : string shape of output array addclimo : binary True or false to add climatology slicenan : string or float Set missing values takeEnsMean : binary whether to take ensemble mean Returns ------- lat : 1d numpy array latitudes lon : 1d numpy array longitudes var : numpy array processed variable ENSmean : numpy array ensemble mean Usage ----- read_SMILE(directory,simulation,vari,sliceperiod, slicebase,sliceshape,addclimo, slicenan,takeEnsMean) """ print('\n>>>>>>>>>> STARTING read_SMILE function!') ### Import modules import numpy as np from netCDF4 import Dataset import warnings import calc_Utilities as UT warnings.simplefilter(action='ignore', category=FutureWarning) warnings.simplefilter(action='ignore', category=RuntimeWarning) ########################################################################### ### Parameters if simulation=='CCCma_canesm2': time = np.arange(1950,2100+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,50+1,1) ens = allens elif simulation == 'CSIRO_MK3.6': time = np.arange(1850,2100+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,30+1,1) ens = allens elif simulation == 'GFDL_CM3': time = np.arange(1920,2100+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,20+1,1) ens = allens elif simulation == 'GFDL_ESM2M': time = np.arange(1950,2100+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,30+1,1) ens = allens elif simulation == 'KNMI_ecearth': time = np.arange(1860,2100+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,16+1,1) ens = allens elif simulation == 'MPI': time = np.arange(1850,2099+1,1) timeslice = '%s-%s' % (time.min(),time.max()) mon = 12 allens = np.arange(1,100+1,1) ens = allens else: ValueError('WRONG SINGLE LENS SELECTED!') ########################################################################### ### Read in data membersvar = [] for i,ensmember in enumerate(ens): filename = directory + '%s/monthly/%s_%s_%s.nc' % (simulation,vari,ensmember,timeslice) data = Dataset(filename,'r') lat1 = data.variables['latitude'][:] lon1 = data.variables['longitude'][:] var = data.variables['%s' % vari][:,:,:] data.close() print('Completed: read ensemble --%s for %s for %s--' % (simulation,ensmember,vari)) membersvar.append(var) del var membersvar = np.asarray(membersvar) ensvar = np.reshape(membersvar,(len(ens),time.shape[0],mon, lat1.shape[0],lon1.shape[0])) del membersvar print('Completed: read all members!\n') ########################################################################### ### Check for missing data ensvar[np.where(ensvar <= -999)] = np.nan ########################################################################### ### Calculate anomalies or not if addclimo == True: ensvalue = ensvar print('Completed: calculated absolute variable!') elif addclimo == False: yearsq = np.where((time >= slicebase.min()) & (time <= slicebase.max()))[0] yearssel = time[yearsq] mean = np.nanmean(ensvar[:,yearsq,:,:,:]) ensvalue = ensvar - mean print('Completed: calculated anomalies from', slicebase.min(),'to',slicebase.max()) ########################################################################### ### Slice over months (currently = [ens,yr,mn,lat,lon]) ### Shape of output array if sliceperiod == 'annual': ensvalue = np.nanmean(ensvalue,axis=2) if sliceshape == 1: ensshape = ensvalue.ravel() elif sliceshape == 4: ensshape = ensvalue print('Shape of output = ', ensshape.shape,[[ensshape.ndim]]) print('Completed: ANNUAL MEAN!') elif sliceperiod == 'DJF': ensshape = np.empty((ensvalue.shape[0],ensvalue.shape[1]-1, lat1.shape[0],lon1.shape[0])) for i in range(ensvalue.shape[0]): ensshape[i,:,:,:] = UT.calcDecJanFeb(ensvalue[i,:,:,:,:], lat1,lon1,'surface',1) print('Shape of output = ', ensshape.shape,[[ensshape.ndim]]) print('Completed: DJF MEAN!') elif sliceperiod == 'JJA': enstime = np.nanmean(ensvalue[:,:,5:8,:,:],axis=2) if sliceshape == 1: ensshape = enstime.ravel() elif sliceshape == 4: ensshape = enstime print('Shape of output = ', ensshape.shape,[[ensshape.ndim]]) print('Completed: JJA MEAN!') elif sliceperiod == 'none': if sliceshape == 1: ensshape = ensvalue.ravel() elif sliceshape == 3: ensshape= np.reshape(ensvalue,(ensvalue.shape[0]*ensvalue.shape[1], ensvalue.shape[2],ensvalue.shape[3])) elif sliceshape == 5: ensshape = ensvalue print('Shape of output =', ensshape.shape, [[ensshape.ndim]]) print('Completed: ALL MONTHS!') ########################################################################### ### Change missing values if slicenan == 'nan': ensshape[np.where(np.isnan(ensshape))] = np.nan print('Completed: missing values are =',slicenan) elif slicenan == False: ensshape = ensshape else: ensshape[np.where(np.isnan(ensshape))] = slicenan ########################################################################### ### Take ensemble mean if takeEnsMean == True: ENSmean = np.nanmean(ensshape,axis=0) print('Ensemble mean AVAILABLE!') elif takeEnsMean == False: ENSmean = np.nan print('Ensemble mean NOT available!') else: ValueError('WRONG OPTION!') ########################################################################### ### Change units if vari == 'SLP': ensshape = ensshape/100 # Pa to hPa ENSmean = ENSmean/100 # Pa to hPa print('Completed: Changed units (Pa to hPa)!') elif vari == 'T2M': ensshape = ensshape - 273.15 # K to C ENSmean = ENSmean - 273.15 # K to C print('Completed: Changed units (K to C)!') print('>>>>>>>>>> ENDING read_SMILE function!') return lat1,lon1,ensshape,ENSmean # ### Test functions - do not use! # import numpy as np # import matplotlib.pyplot as plt # import calc_Utilities as UT # directory = '/Users/zlabe/Data/SMILE/' # simulation = 'MPI' # vari = 'T2M' # sliceperiod = 'DJF' # slicebase = np.arange(1951,1980+1,1) # sliceshape = 4 # slicenan = 'nan' # addclimo = True # takeEnsMean = False # lat,lon,var,ENSmean = read_SMILE(directory,simulation,vari,sliceperiod, # slicebase,sliceshape,addclimo, # slicenan,takeEnsMean)
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 readVariables(varnames, period, location): ### Call function for surface temperature data from reach run lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames, 'HIT', 'surface') lat, lon, time, lev, tasfict = MO.readExperiAll('%s' % varnames, 'FICT', 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Read in QBO phases filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] pos_hit = np.append( np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') + 101) non_hit = np.append( np.genfromtxt(filenamehitno, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitno2, unpack=True, usecols=[0], dtype='int') + 101) neg_hit = np.append( np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') + 101) filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 1] filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 0] filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 1] filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 2] pos_fict = np.append( np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictp2, unpack=True, usecols=[0], dtype='int') + 101) non_fict = np.append( np.genfromtxt(filenamefictno, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictno2, unpack=True, usecols=[0], dtype='int') + 101) neg_fict = np.append( np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictn2, unpack=True, usecols=[0], dtype='int') + 101) ### Concatonate runs runs = [tashit, tasfict] ### Separate per periods (ON,DJ,FM) if period == 'ON': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, 9:11, :, :], axis=1) elif period == 'DJ': tas_mo = np.empty( (3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i], tas_mo[i] = UT.calcDecJan(runs[i], runs[i], lat, lon, 'surface', 1) elif period == 'FM': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, 1:3, :, :], axis=1) elif period == 'DJF': tas_mo = np.empty( (3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i], tas_mo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 1) elif period == 'M': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:, 2, :, :] elif period == 'D': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:, -1, :, :] elif period == 'N': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = runs[i][:, -2, :, :] elif period == 'ND': tas_mo = np.empty( (3, tashit.shape[0], tashit.shape[2], tashit.shape[3])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :], axis=1) else: ValueError('Wrong period selected! (ON,DJ,FM)') ### Composite by QBO phase tas_mohitpos = tas_mo[0][pos_hit, :, :] tas_mofictpos = tas_mo[1][pos_fict, :, :] tas_mohitnon = tas_mo[0][non_hit, :, :] tas_mofictnon = tas_mo[1][non_fict, :, :] tas_mohitneg = tas_mo[0][neg_hit, :, :] tas_mofictneg = tas_mo[1][neg_fict, :, :] ### Compute comparisons for months - select region if varnames == 'SLP': lonq = np.where((lon >= 80) & (lon <= 120))[0] ficthitpos = tas_mofictpos[:, :, lonq] ficthitnon = tas_mofictnon[:, :, lonq] ficthitneg = tas_mofictneg[:, :, lonq] latq = np.where((lat >= 40) & (lat <= 65))[0] ficthitpos = ficthitpos[:, latq] ficthitnon = ficthitnon[:, latq] ficthitneg = ficthitneg[:, latq] lat2sq = lat2[latq, :] lat2s = lat2sq[:, lonq] ficthitpos = UT.calc_weightedAve(ficthitpos, lat2s) ficthitnon = UT.calc_weightedAve(ficthitnon, lat2s) ficthitneg = UT.calc_weightedAve(ficthitneg, lat2s) diffruns = [ ficthitpos.squeeze(), ficthitnon.squeeze(), ficthitneg.squeeze() ] return diffruns, lat, lon, lev
def readData(simu, period, vari, level, cps): if any([vari == 'T700', vari == 'T500']): varia = 'TEMP' level = 'profile' elif vari == 'U700': varia = 'U' level = 'profile' elif any([vari == 'V925', vari == 'V700', vari == 'V1000']): varia = 'V' level = 'profile' else: varia = vari ############################################################################### ############################################################################### ############################################################################### if simu == 'AA-2030': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2030', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') elif simu == 'AA-2060': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2060', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') elif simu == 'AA-2090': lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2090', level, 'none') lat, lon, lev, historical = CONT.readControl(varia, level, 'none') ############################################################################### elif simu == 'coupled_Pd': lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level) lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pd', level) ############################################################################### elif simu == 'coupled_Pi': lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level) lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pi', level) ############################################################################### elif simu == 'SIT': lat, lon, lev, future = THICK.readSIT(varia, 'SIT_Fu', level) lat, lon, lev, historical = THICK.readSIT(varia, 'SIT_Pd', level) ############################################################################### elif simu == 'SIC_Pd': lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level) lat, lon, lev, historical = CONC.readSIC(varia, 'Pd', level) ############################################################################### elif simu == 'SIC_Pi': lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level) lat, lon, lev, historical = CONC.readSIC(varia, 'Pi', level) ############################################################################### elif simu == 'E3SIT': lat, lon, lev, future = E3SIT.readE3SM_SIT(varia, 'ESIT_Fu', level) lat, lon, lev, historical = E3SIT.readE3SM_SIT(varia, 'ESIT_Pd', level) ############################################################################### elif simu == 'E3SIC_Pd': lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level) lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pd', level) elif simu == 'E3SIC_Pi': lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level) lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pi', level) ############################################################################### elif simu == 'OLD': lat, lon, lev, future = OLD.readOldIceExperi(varia, 'FICT', level) lat, lon, lev, historical = OLD.readOldIceExperi(varia, 'HIT', level) ############################################################################### elif simu == 'LONG': lat, lon, lev, future = LC.readLong(varia, 'Long_Fu', level) lat, lon, lev, historical = LC.readLong(varia, 'Long_Pd', level) ############################################################################### ############################################################################### ############################################################################### ### Calculate number of ensembles nens = np.shape(historical)[0] ### Check for 4D field if vari == 'T700': levq = np.where(lev == 700)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() elif vari == 'T500': levq = np.where(lev == 500)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() elif vari == 'U700': levq = np.where(lev == 700)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() elif vari == 'V925': levq = np.where(lev == 925)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() elif vari == 'V700': levq = np.where(lev == 700)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() elif vari == 'V1000': levq = np.where(lev == 1000)[0] future = future[:, :, levq, :, :].squeeze() historical = historical[:, :, levq, :, :].squeeze() ### Check for missing data [ensembles,months,lat,lon] future[np.where(future <= -1e10)] = np.nan historical[np.where(historical <= -1e10)] = np.nan ############################################################################### ############################################################################### ############################################################################### ### Calculate over period if period == 'OND': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, -3:, :, :], axis=1) historicalm = np.nanmean(historical[:, -3:, :, :], axis=1) elif period == 'D': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, -1:, :, :], axis=1) historicalm = np.nanmean(historical[:, -1:, :, :], axis=1) elif period == 'DJF': print('Calculating over %s months!' % period) runs = [future, historical] var_mo = np.empty((2, historical.shape[0] - 1, historical.shape[2], historical.shape[3])) for i in range(len(runs)): var_mo[i, :, :, :] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 1) futurem = var_mo[0] historicalm = var_mo[1] elif period == 'JFM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:3, :, :], axis=1) historicalm = np.nanmean(historical[:, 0:3, :, :], axis=1) elif period == 'JF': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:2, :, :], axis=1) historicalm = np.nanmean(historical[:, 0:2, :, :], axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:4, :, :], axis=1) historicalm = np.nanmean(historical[:, 1:4, :, :], axis=1) elif period == 'FM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:3, :, :], axis=1) historicalm = np.nanmean(historical[:, 1:3, :, :], axis=1) elif period == 'J': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 0:1, :, :], axis=1) historicalm = np.nanmean(historical[:, 0:1, :, :], axis=1) elif period == 'F': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 1:2, :, :], axis=1) historicalm = np.nanmean(historical[:, 1:2, :, :], axis=1) elif period == 'M': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 2:3, :, :], axis=1) historicalm = np.nanmean(historical[:, 2:3, :, :], axis=1) elif period == 'MA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 2:4, :, :], axis=1) historicalm = np.nanmean(historical[:, 2:4, :, :], axis=1) elif period == 'JJA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:, 5:8, :, :], axis=1) historicalm = np.nanmean(historical[:, 5:8, :, :], axis=1) else: print(ValueError('Selected wrong month period!')) ############################################################################### ############################################################################### ############################################################################### ### Calculate anomalies anom = futurem - historicalm ### Calculate ensemble mean anommean = np.nanmean(anom, axis=0) ### Calculate significance pruns = UT.calc_FDR_ttest(futurem[:, :, :], historicalm[:, :, :], 0.05) #FDR ### Select climo climo = np.nanmean(historicalm, axis=0) return lat, lon, lev, anommean, nens, pruns, climo
'%s' % varnames[v], 'CIT', 'surface') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Concatonate runs runnames = [r'HIT', r'FIT', r'FIC', r'CIT'] experiments = [r'\textbf{FIT--HIT}', r'\textbf{FIC--CIT}'] runs = [varhit, varfit, varfic, varcit] ### Separate per 2 month periods varmo_djf = np.empty( (4, varhit.shape[0] - 1, varhit.shape[2], varhit.shape[3])) for i in range(len(runs)): varmo_djf[i], varmo_djf[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'surface', 1) ### Calculate differences [FIT-HIT and FICT - FIT] diff_fithit_djf = np.nanmean(varmo_djf[1] - varmo_djf[0], axis=0) diff_ficcit_djf = np.nanmean(varmo_djf[2] - varmo_djf[3], axis=0) ### Calculate significance stat_FITHITdjf, pvalue_FITHITdjf = UT.calc_indttest( varmo_djf[1], varmo_djf[0]) stat_FICCITdjf, pvalue_FICCITdjf = UT.calc_indttest( varmo_djf[2], varmo_djf[3]) ### Create mask of significant values pvalue_FITHITdjf[np.where(np.isnan(pvalue_FITHITdjf))] = 0.0 pvalue_FICCITdjf[np.where(np.isnan(pvalue_FICCITdjf))] = 0.0
def read_BEST(directory, sliceperiod, sliceyear, sliceshape, addclimo, slicenan): """ Function reads monthly data from BEST Parameters ---------- directory : string path for data sliceperiod : string how to average time component of data sliceyear : string how to slice number of years for data sliceshape : string shape of output array addclimo : binary True or false to add climatology slicenan : string or float Set missing values Returns ------- lat : 1d numpy array latitudes lon : 1d numpy array longitudes var : 3d numpy array or 4d numpy array [time,lat,lon] or [year,month,lat,lon] Usage ----- lat,lon,var = read_BEST(directory,sliceperiod,sliceyear, sliceshape,addclimo,slicenan) """ print('\n>>>>>>>>>> STARTING read_BEST function!') ### Import modules import numpy as np from netCDF4 import Dataset import warnings import calc_Utilities as UT warnings.simplefilter(action='ignore', category=FutureWarning) warnings.simplefilter(action='ignore', category=RuntimeWarning) ########################################################################### ### Parameters time = np.arange(1850, 2019 + 1, 1) monthslice = sliceyear.shape[0] * 12 mon = 12 ########################################################################### ### Read in data filename = 'T2M_BEST_1850-2019.nc' data = Dataset(directory + filename, 'r') lat1 = data.variables['latitude'][:] lon1 = data.variables['longitude'][:] anom = data.variables['T2M'][-monthslice:, :, :] data.close() print('Years of output =', sliceyear.min(), 'to', sliceyear.max()) ########################################################################### ### Reshape data into [year,month,lat,lon] datamon = np.reshape( anom, (anom.shape[0] // mon, mon, lat1.shape[0], lon1.shape[0])) ########################################################################### ### Return absolute temperature (1951-1980 baseline) if addclimo == True: filename = 'CLIM_BEST_1850-2019.nc' datac = Dataset(directory + filename, 'r') clim = datac['CLIM'][:, :, :] datac.close() ### Add [anomaly+climatology] tempmon = datamon + clim print('Completed: calculated absolute temperature!') else: tempmon = datamon print('Completed: calculated anomalies!') ########################################################################### ### Slice over months (currently = [yr,mn,lat,lon]) ### Shape of output array if sliceperiod == 'annual': temptime = np.nanmean(tempmon, axis=1) if sliceshape == 1: tempshape = temptime.ravel() elif sliceshape == 3: tempshape = temptime print('Shape of output = ', tempshape.shape, [[tempshape.ndim]]) print('Completed: ANNUAL MEAN!') print('Completed: ANNUAL MEAN!') elif sliceperiod == 'DJF': tempshape = UT.calcDecJanFeb(tempmon, lat1, lon1, 'surface', 1) print('Shape of output = ', tempshape.shape, [[tempshape.ndim]]) print('Completed: DJF MEAN!') elif sliceperiod == 'JJA': temptime = np.nanmean(tempmon[:, 5:8, :, :], axis=1) if sliceshape == 1: tempshape = temptime.ravel() elif sliceshape == 3: tempshape = temptime print('Shape of output = ', tempshape.shape, [[tempshape.ndim]]) print('Completed: JJA MEAN!') elif sliceperiod == 'none': temptime = tempmon if sliceshape == 1: tempshape = tempshape.ravel() elif sliceshape == 3: tempshape = np.reshape(temptime, (temptime.shape[0] * temptime.shape[1], temptime.shape[2], temptime.shape[3])) elif sliceshape == 4: tempshape = tempmon print('Shape of output =', tempshape.shape, [[tempshape.ndim]]) print('Completed: ALL MONTHS!') ########################################################################### ### Change missing values if slicenan == 'nan': tempshape[np.where(np.isnan(tempshape))] = np.nan print('Completed: missing values are =', slicenan) else: tempshape[np.where(np.isnan(tempshape))] = slicenan print('>>>>>>>>>> ENDING read_BEST function!') return lat1, lon1, tempshape ### Test functions - do not use! # import numpy as np # import matplotlib.pyplot as plt # directory = '/Users/zlabe/Data/BEST/' # sliceperiod = 'DJF' # sliceyear = np.arange(1956,2019+1,1) # sliceshape = 3 # slicenan = 'nan' # addclimo = True # lat,lon,var = read_BEST(directory,sliceperiod,sliceyear,sliceshape,addclimo,slicenan)
### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon1, lat) ### Concatonate runs runnames = [r'HIT', r'FIT', r'CIT', r'FIC', r'FICT'] experiments = [ r'\textbf{FIT--HIT}', r'\textbf{FIC--CIT}', r'\textbf{FICT--HIT}' ] runs = [varhit, varfit, varcit, varfic, varfict] ### Separate per periods (DJF) var_djf = np.empty( (5, varhit.shape[0] - 1, varhit.shape[2], varhit.shape[3])) for i in range(len(runs)): var_djf[i], var_djf[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon1, 'surface', 1) ### Compute comparisons for FM - taken ensemble average diff_FITHIT = np.nanmean(var_djf[1] - var_djf[0], axis=0) diff_FICCIT = np.nanmean(var_djf[3] - var_djf[2], axis=0) diff_FICTHIT = np.nanmean(var_djf[4] - var_djf[0], axis=0) diffruns_djf = [diff_FITHIT, diff_FICCIT, diff_FICTHIT] ### Calculate significance for FM stat_FITHIT, pvalue_FITHIT = UT.calc_indttest(var_djf[1], var_djf[0]) stat_FICCIT, pvalue_FICCIT = UT.calc_indttest(var_djf[3], var_djf[2]) stat_FICTHIT, pvalue_FICTHIT = UT.calc_indttest(var_djf[4], var_djf[0]) pruns_djf = [pvalue_FITHIT, pvalue_FICCIT, pvalue_FICTHIT] ### Read in wave number lat, lon, time, lev, wavef = MO.readExperi(directorydata,
def readData(simu,period,varia,level,latpolar,cps): ############################################################################### ############################################################################### ############################################################################### if simu == 'AA-2030': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2030',level,'none') lat,lon,lev,historical = CONT.readControl(varia,level,'none') elif simu == 'AA-2060': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2060',level,'none') lat,lon,lev,historical = CONT.readControl(varia,level,'none') elif simu == 'AA-2090': lat,lon,lev,future = NUDG.readExperi(varia,'AA','2090',level,cps) lat,lon,lev,historical = CONT.readControl(varia,level,cps) ############################################################################### elif simu == 'coupled': lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level) lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pd',level) ############################################################################### elif simu == 'SIT': lat,lon,lev,future = THICK.readSIT(varia,'SIT_Fu',level) lat,lon,lev,historical = THICK.readSIT(varia,'SIT_Pd',level) ############################################################################### elif simu == 'SIC': lat,lon,lev,future = CONC.readSIC(varia,'Fu',level) lat,lon,lev,historical = CONC.readSIC(varia,'Pd',level) ############################################################################### ############################################################################### ############################################################################### ### Calculate number of ensembles nens = np.shape(historical)[0] ### Check for missing data [ensembles,months,lat,lon] future[np.where(future <= -1e10)] = np.nan historical[np.where(historical <= -1e10)] = np.nan ############################################################################### ############################################################################### ############################################################################### ### Calculate over period if period == 'OND': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,-3:],axis=1) historicalm = np.nanmean(historical[:,-3:],axis=1) elif period == 'D': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,-1:],axis=1) historicalm = np.nanmean(historical[:,-1:],axis=1) elif period == 'DJF': print('Calculating over %s months!' % period) runs = [future,historical] var_mo = np.empty((2,historical.shape[0]-1,historical.shape[2],historical.shape[3],historical.shape[4])) for i in range(len(runs)): var_mo[i,:,:,:,:] = UT.calcDecJanFeb(runs[i],runs[i],lat,lon,level,17) futurem = var_mo[0] historicalm = var_mo[1] elif period == 'JFM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:3],axis=1) historicalm = np.nanmean(historical[:,0:3],axis=1) elif period == 'JF': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:2],axis=1) historicalm = np.nanmean(historical[:,0:2],axis=1) elif period == 'FMA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:4],axis=1) historicalm = np.nanmean(historical[:,1:4],axis=1) elif period == 'FM': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:3],axis=1) historicalm = np.nanmean(historical[:,1:3],axis=1) elif period == 'J': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,0:1],axis=1) historicalm = np.nanmean(historical[:,0:1],axis=1) elif period == 'F': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,1:2],axis=1) historicalm = np.nanmean(historical[:,1:2],axis=1) elif period == 'M': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,2:3],axis=1) historicalm = np.nanmean(historical[:,2:3],axis=1) elif period == 'MA': print('Calculating over %s months!' % period) futurem = np.nanmean(future[:,2:4],axis=1) historicalm = np.nanmean(historical[:,2:4],axis=1) elif period == 'annual': print('Calculating over %s months!' % period) futurem = np.nanmean(future,axis=1) historicalm = np.nanmean(historical,axis=1) elif period == 'NONE': print('Calculating over %s months!' % period) futurem = future historicalm = historical elif period == 'timemonth': print('Calculating over O,N,D,J,F,M months!') futurem = np.append(future[:,-3:,:,:,:],future[:,:3,:,:,:],axis=1) historicalm = np.append(historical[:,-3:,:,:,:],historical[:,:3,:,:,:],axis=1) else: print(ValueError('Selected wrong month period!')) ########################################################################### ########################################################################### ########################################################################### ### Calculate polar cap lon2,lat2 = np.meshgrid(lon,lat) ### Calculate SHI latq = np.where((lat >= latpolar))[0] lat2p = lat2[latq,:] futurep = futurem[:,:,:,latq,:] futuremz = UT.calc_weightedAve(futurep,lat2p) historicalp = historicalm[:,:,:,latq,:] historicalmz = UT.calc_weightedAve(historicalp,lat2p) ### Calculate anomalies [ens,level,lat] anom = futuremz - historicalmz ### Calculate ensemble mean anommean = np.nanmean(anom,axis=0) ### Calculate significance pruns = UT.calc_FDR_ttest(futuremz,historicalmz,0.05) #FDR ### Select climo climo = np.nanmean(historicalmz,axis=0) return lat,lon,lev,anommean,nens,pruns,climo
filenamefpolp = directorydata2 + 'FPOL/monthly/QBO_%s_FPOL.txt' % qbophase[0] filenamefpolno = directorydata2 + 'FPOL/monthly/QBO_%s_FPOL.txt' % qbophase[1] filenamefpoln = directorydata2 + 'FPOL/monthly/QBO_%s_FPOL.txt' % qbophase[2] pos_fpol = np.genfromtxt(filenamefpolp,unpack=True,usecols=[0],dtype='int') non_fpol = np.genfromtxt(filenamefpolno,unpack=True,usecols=[0],dtype='int') neg_fpol = np.genfromtxt(filenamefpoln,unpack=True,usecols=[0],dtype='int') ### Concatonate runs runs = [tascit,tasfsub,tasfpol] ### Separate per periods (ON,DJ,FM) if period == 'DJF': tas_mo= np.empty((3,tascit.shape[0]-1,tascit.shape[2],tascit.shape[3], tascit.shape[4])) for i in range(len(runs)): tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat, lon,'profile',17) else: ValueError('Wrong period selected! (DJF)') ### Composite by QBO phase tas_mofsubpos = tas_mo[1][pos_fsub,:,:,:] tas_mocitpos = tas_mo[0][pos_cit,:,:,:] tas_mofpolpos = tas_mo[2][pos_fpol,:,:,:] tas_mofsubnon = tas_mo[1][non_fsub,:,:,:] tas_mocitnon = tas_mo[0][non_cit,:,:,:] tas_mofpolnon = tas_mo[2][non_fpol,:,:,:] tas_mofsubneg = tas_mo[1][neg_fsub,:,:,:] tas_mocitneg = tas_mo[0][neg_cit,:,:,:] tas_mofpolneg = tas_mo[2][neg_fpol,:,:,:]
def readWAFy(varnames, qbophase): lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames[0], 'HIT', 'profile') lat, lon, time, lev, tasfict = MO.readExperiAll('%s' % varnames[0], 'FICT', 'profile') ### Create 2d array of latitude and longitude lon2, lat2 = np.meshgrid(lon, lat) ### Read in QBO phases filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0] filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1] filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2] pos_hit = np.append( np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') + 101) non_hit = np.append( np.genfromtxt(filenamehitno, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitno2, unpack=True, usecols=[0], dtype='int') + 101) neg_hit = np.append( np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') + 101) filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0] filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 1] filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2] filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 0] filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 1] filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[ 2] pos_fict = np.append( np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictp2, unpack=True, usecols=[0], dtype='int') + 101) non_fict = np.append( np.genfromtxt(filenamefictno, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictno2, unpack=True, usecols=[0], dtype='int') + 101) neg_fict = np.append( np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'), np.genfromtxt(filenamefictn2, unpack=True, usecols=[0], dtype='int') + 101) ### Concatonate runs runs = [tashit, tasfict] ### Separate per periods (ON,DJ,FM) if period == 'ON': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, 9:11, :, :, :], axis=1) elif period == 'DJ': tas_mo = np.empty((3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i], tas_mo[i] = UT.calcDecJan(runs[i], runs[i], lat, lon, 'profile', 1) elif period == 'FM': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, 1:3, :, :, :], axis=1) elif period == 'DJF': tas_mo = np.empty((3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i], tas_mo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon, 'profile', 1) elif period == 'M': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = runs[i][:, 2, :, :, :] elif period == 'D': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = runs[i][:, -1, :, :, :] elif period == 'N': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = runs[i][:, -2, :, :, :] elif period == 'ND': tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2], tashit.shape[3], tashit.shape[4])) for i in range(len(runs)): tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :, :], axis=1) else: ValueError('Wrong period selected! (ON,DJ,FM)') ### Composite by QBO phase tas_mohitposq = tas_mo[0][pos_hit, :, :] tas_mofictposq = tas_mo[1][pos_fict, :, :] tas_mohitnonq = tas_mo[0][non_hit, :, :] tas_mofictnonq = tas_mo[1][non_fict, :, :] tas_mohitnegq = tas_mo[0][neg_hit, :, :] tas_mofictnegq = tas_mo[1][neg_fict, :, :] ### Take zonal average tas_mohitpos = np.nanmean(tas_mohitposq, axis=3) tas_mofictpos = np.nanmean(tas_mofictposq, axis=3) tas_mohitnon = np.nanmean(tas_mohitnonq, axis=3) tas_mofictnon = np.nanmean(tas_mofictnonq, axis=3) tas_mohitneg = np.nanmean(tas_mohitnegq, axis=3) tas_mofictneg = np.nanmean(tas_mofictnegq, axis=3) ficthitpos = np.nanmean(tas_mofictpos - tas_mohitpos, axis=0) / np.nanstd( tas_mofictpos, axis=0) ficthitnon = np.nanmean(tas_mofictnon - tas_mohitnon, axis=0) / np.nanstd( tas_mofictnon, axis=0) ficthitneg = np.nanmean(tas_mofictneg - tas_mohitneg, axis=0) / np.nanstd( tas_mofictneg, axis=0) diffruns_mo = [ficthitneg, ficthitpos, ficthitneg - ficthitpos] ### Calculate significance stat_FICTHITpos, pvalue_FICTHITpos = UT.calc_indttest( tas_mohitpos, tas_mofictpos) stat_FICTHITnon, pvalue_FICTHITnon = UT.calc_indttest( tas_mohitnon, tas_mofictnon) stat_FICTHITneg, pvalue_FICTHITneg = UT.calc_indttest( tas_mohitneg, tas_mofictneg) pruns_mo = [pvalue_FICTHITneg, pvalue_FICTHITpos, pvalue_FICTHITneg] return diffruns_mo, pruns_mo, lat, lon, lev