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
