def readDataPeriods(varnames, sliceq):
### Call function for 4d variable data
lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface')
lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'surface')
### Select ensemble mean period
if sliceq == 'Mean':
varfuture = varfuture[:, :, :, :]
varpast = varpast[:, :, :, :]
elif sliceq == 'A':
varfuture = varfuture[:100, :, :, :]
varpast = varpast[:100, :, :, :]
elif sliceq == 'B':
varfuture = varfuture[100:200, :, :, :]
varpast = varpast[100:200, :, :, :]
elif sliceq == 'C':
varfuture = varfuture[200:, :, :, :]
varpast = varpast[200:, :, :, :]
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Remove missing data
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Rearrange months (N,D,J,F,M,A)
varfuturem = np.append(varfuture[:, -2:, :, :],
varfuture[:, :4, :, :],
axis=1)
varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1)
### Calculate anomalies
anom = varfuturem - varpastm
### Calculate ensemble mean
anomm = np.nanmean(anom, axis=0)
pastm = np.nanmean(varpastm, axis=0)
### Calculate zonal mean
anommz = np.nanmean(anomm, axis=2)
climoz = np.nanmean(pastm, axis=2)
### Calculate significance for each month
pvalue = np.empty((varpastm.shape[1], len(lat)))
for i in range(varpastm.shape[1]):
pvalue[i] = UT.calc_FDR_ttest(np.nanmean(varfuturem[:, i, :], axis=2),
np.nanmean(varpastm[:, i, :], axis=2),
0.05)
return anommz, climoz, lat, lon, pvalue
def readDataPeriods(varnames, sliceq):
### Call function for 4d variable data
lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'SIT_Fu', 'surface')
lat, lon, lev, varpast = MO.readExperiAll(varnames, 'SIT_Cu', 'surface')
### Select ensemble mean period
if sliceq == 'Mean':
varfuture = varfuture[:, :, :, :]
varpast = varpast[:, :, :, :]
elif sliceq == 'A':
varfuture = varfuture[:100, :, :, :]
varpast = varpast[:100, :, :, :]
elif sliceq == 'B':
varfuture = varfuture[100:200, :, :, :]
varpast = varpast[100:200, :, :, :]
elif sliceq == 'C':
varfuture = varfuture[200:, :, :, :]
varpast = varpast[200:, :, :, :]
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Remove missing data
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Rearrange months (N,D,J,F,M,A)
varfuturem = np.append(varfuture[:, -2:, :, :],
varfuture[:, :4, :, :],
axis=1)
varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1)
### Calculate anomalies
anompi = varfuturem - varpastm
### Calculate ensemble mean
anompim = np.nanmean(anompi, axis=0)
zdiffruns = anompim
### Calculate climatologies
zclimo = np.nanmean(varpastm, axis=0)
### Calculate significance for each month (pick method)
pruns = UT.calc_FDR_ttest(varfuturem[:, :, :], varpastm[:, :, :],
0.05) #FDR
# pruns = UT.calc_indttest(varfuturem[:,:,:],varpastm[:,:,:])[1] #ttest
return zdiffruns, zclimo, pruns, lat, lon, lev
def 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 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 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 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
### Composite over selected period (x2)
if monthlychoice == 'DJF':
years = np.arange(meandata.shape[0]) + 1921
else:
years = np.arange(meandata.shape[0]) + 1920
length = years.shape[0]//2
historical = meandata[:length,:,:]
future = meandata[length:,:,:]
### Average over composites for plotting
historicalm = np.nanmean(historical,axis=0)
futurem = np.nanmean(future,axis=0)
### Calculate significance
pruns = UT.calc_FDR_ttest(future[:,:,:],historical[:,:,:],0.05) #FDR
###########################################################################
###########################################################################
###########################################################################
### Begin plots!!!
fig = plt.figure()
### Select graphing preliminaries
if rm_ensemble_mean == True:
if variq[i] == 'T2M':
label = r'\textbf{T2M [$\bf{^{\circ}}$C]}'
cmap = cm.cubehelix3_16_r.mpl_colormap
elif variq[i] == 'SLP':
label = r'\textbf{SLP [hPa]}'
cmap = cm.cubehelix3_16_r.mpl_colormap
varpolr = np.nanmean(varr, axis=3)
###############################################################################
###############################################################################
###############################################################################
### Calculate reanalysis epochs
oldthicke = np.nanmean(varpole[:epochq], axis=0) # 1979-1993
newthicke = np.nanmean(varpole[-epochq:], axis=0) # 2005-2019
diffe = newthicke - oldthicke
oldthickr = np.nanmean(varpolr[:epochq], axis=0) # 1979-1993
newthickr = np.nanmean(varpolr[-epochq:], axis=0) # 2005-2019
diffr = newthickr - oldthickr
### Significance testing
prunse = UT.calc_FDR_ttest(varpole[:epochq], varpole[-epochq:], 0.1)
prunsr = UT.calc_FDR_ttest(varpolr[:epochq], varpolr[-epochq:], 0.1)
############################################################################
############################################################################
############################################################################
##### Plot temperature profile
plt.rc('text', usetex=True)
plt.rc('font', **{'family': 'sans-serif', 'sans-serif': ['Avant Garde']})
fig = plt.figure()
ax1 = plt.subplot(121)
### Set limits for contours and colorbars
limit = np.arange(-120, 121, 10)
barlim = np.arange(-120, 121, 60)
def readDataPeriods(typesimu, varnames, simulations, period):
### Call function for 4d variable data
if typesimu == 'arc_sea_ice':
lat, lon, lev, varfuture = MO.readExperiAll(varnames, simulations[0],
'zonmean')
lat, lon, lev, varpast = MO.readExperiAll(varnames, simulations[1],
'zonmean')
elif typesimu == 'sst':
lat, lon, lev, varfuture = MOS.readExperiAll(varnames, simulations[0],
'zonmean')
lat, lon, lev, varpast = MOS.readExperiAll(varnames, simulations[1],
'zonmean')
elif typesimu == 'ant_sea_ice':
lat, lon, lev, varfuture = MOA.readExperiAll(varnames, simulations[0],
'zonmean')
lat, lon, lev, varpast = MOA.readExperiAll(varnames, simulations[1],
'zonmean')
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Remove missing data [ensembles,months,lat,lon]
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Calculate over DJF
if period == 'JJA':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 5:8, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 5:8:, :, :], axis=1)
elif period == 'JAS':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 6:9, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 6:9:, :, :], axis=1)
elif period == 'July':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 6:7, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 6:7:, :, :], axis=1)
elif period == 'August':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 7:8, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 7:8:, :, :], axis=1)
elif period == 'JA':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 6:8, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 6:8:, :, :], axis=1)
elif period == 'S':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 8:9, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 8:9:, :, :], axis=1)
elif period == 'AMJ':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 3:6, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 3:6:, :, :], axis=1)
elif period == 'OND':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, -3:, :, :], axis=1)
varpastm = np.nanmean(varpast[:, -3:, :, :], axis=1)
elif period == 'JFM':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 0:3, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 0:3, :, :], axis=1)
elif period == 'JF':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 0:2, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 0:2, :, :], axis=1)
elif period == 'FMA':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 1:4, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 1:4, :, :], axis=1)
elif period == 'FM':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 1:3, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 1:3, :, :], axis=1)
elif period == 'J':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 0:1, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 0:1, :, :], axis=1)
elif period == 'F':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 1:2, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 1:2, :, :], axis=1)
elif period == 'M':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, 2:3, :, :], axis=1)
varpastm = np.nanmean(varpast[:, 2:3, :, :], axis=1)
elif period == 'Annual':
print('Calculating over %s months!' % period)
varfuturem = np.nanmean(varfuture[:, :, :, :], axis=1)
varpastm = np.nanmean(varpast[:, :, :, :], axis=1)
else:
print(ValueError('Selected wrong month period!'))
### Calculate anomalies and ensemble means
varfutureq = varfuturem.copy()
varpastq = varpastm.copy()
anommean = np.nanmean(varfutureq, axis=0) - np.nanmean(varpastq, axis=0)
### Calculate climatologies
climo = np.nanmean(varpastq, axis=0)
### Calculate significance for each month (pick method)
pruns = UT.calc_FDR_ttest(varfuturem[:, :, :], varpastm[:, :, :],
0.05) #FDR
return anommean, climo, pruns, lat, lev
def 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
meanAz = np.nanmean(meanA[:, :, :], axis=2)
meanBz = np.nanmean(meanB[:, :, :], axis=2)
meanCz = np.nanmean(meanC[:, :, :], axis=2)
### Calculate significance testing at 95% confidence level
meanx = np.nanmean(varmo[0, :, :, :, :], axis=3)
meany = np.nanmean(varmo[1, :, :, :, :], axis=3)
Ax = np.nanmean(varmo[0, :100, :, :, :], axis=3)
Ay = np.nanmean(varmo[1, :100, :, :, :], axis=3)
Bx = np.nanmean(varmo[0, 100:200, :, :, :], axis=3)
By = np.nanmean(varmo[1, 100:200, :, :, :], axis=3)
Cx = np.nanmean(varmo[0, 200:, :, :, :], axis=3)
Cy = np.nanmean(varmo[1, 200:, :, :, :], axis=3)
if FDRmeth == True:
pvalue_mean = UT.calc_FDR_ttest(meanx, meany, 0.05) #FDR
pvalue_A = UT.calc_FDR_ttest(Ax, Ay, 0.05) #FDR
pvalue_B = UT.calc_FDR_ttest(Bx, By, 0.05) #FDR
pvalue_C = UT.calc_FDR_ttest(Cx, Cy, 0.05) #FDR
### Mask variables by their adjusted p-values
pvalue_mean[np.where(pvalue_mean < 0.05)] = 1.
pvalue_mean[np.where(np.isnan(pvalue_mean))] = 0.
### Mask variables by their adjusted p-values
pvalue_A[np.where(pvalue_A < 0.05)] = 1.
pvalue_A[np.where(np.isnan(pvalue_A))] = 0.
### Mask variables by their adjusted p-values
pvalue_B[np.where(pvalue_B < 0.05)] = 1.
pvalue_B[np.where(np.isnan(pvalue_B))] = 0.
def readDataPeriods(varnames, sliceq):
### Call function for 4d variable data
lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface')
lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Current', 'surface')
### Rearrange months (N,D,J,F,M,A)
varfuture = np.append(varfuture[:, -2:, :, :],
varfuture[:, :4, :, :],
axis=1)
varpast = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1)
### Remove missing data
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Select ensemble mean period
if sliceq == 'Mean':
varfutures = varfuture[:, :, :, :]
varpasts = varpast[:, :, :, :]
zclimo = np.nanmean(varpasts, axis=0)
elif sliceq == 'A':
varfutures = varfuture[:100, :, :, :]
varpasts = varpast[:100, :, :, :]
zclimo = np.nanmean(varpasts, axis=0)
elif sliceq == 'B':
varfutures = varfuture[100:200, :, :, :]
varpasts = varpast[100:200, :, :, :]
zclimo = np.nanmean(varpasts, axis=0)
elif sliceq == 'C':
varfutures = varfuture[200:, :, :, :]
varpasts = varpast[200:, :, :, :]
zclimo = np.nanmean(varpasts, axis=0)
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Calculate ensemble mean
varfuturem = varfuture[:, :, :, :]
varpastm = varpast[:, :, :, :]
anommean = varfuturem - varpastm
anommeanmean = np.nanmean(anommean, axis=0)
### Calculate sliced differences
anomslice = varfutures - varpasts
anomslicemean = np.nanmean(anomslice, axis=0)
### Calculate difference from total ensemble mean (300)
diffs = anomslicemean - anommeanmean
if sliceq == 'Mean':
### Calculate significance for each month (FDR method!)
pvalue_past = np.empty((varpastm.shape[1], len(lat), len(lon)))
for i in range(varpastm.shape[1]):
pvalue_past[i] = UT.calc_FDR_ttest(varfuturem[:, i, :, :],
varpastm[:, i, :, :], 0.05)
else:
### Calculate significance for each month
stat_past = np.empty((varpastm.shape[1], len(lat), len(lon)))
pvalue_past = np.empty((varpastm.shape[1], len(lat), len(lon)))
for i in range(varpastm.shape[1]):
stat_past[i], pvalue_past[i] = UT.calc_indttest(
anommean[:, i, :, :], anomslice[:, i, :, :])
pruns = pvalue_past
return anommeanmean, diffs, zclimo, pruns, lat, lon, lev
def readData(simu, period, vari, level, latpolar):
if 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', 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()
### 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 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 readData(simu,period,vari,level):
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
###############################################################################
###############################################################################
###############################################################################
lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level,simu)
lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pd',level,simu)
###############################################################################
###############################################################################
###############################################################################
### 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)
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
def readDataPeriods(varnames, sliceq):
### Call function for 4d variable data
lat, lon, lev, varfuture = MO.readExperiAll(varnames, 'Future', 'surface')
lat, lon, lev, varpast = MO.readExperiAll(varnames, 'Past', 'surface')
### Select ensemble mean period
if sliceq == 'Mean':
varfuture = varfuture[:, :, :, :]
varpast = varpast[:, :, :, :]
elif sliceq == 'A':
varfuture = varfuture[:100, :, :, :]
varpast = varpast[:100, :, :, :]
elif sliceq == 'B':
varfuture = varfuture[100:200, :, :, :]
varpast = varpast[100:200, :, :, :]
elif sliceq == 'C':
varfuture = varfuture[200:, :, :, :]
varpast = varpast[200:, :, :, :]
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Remove missing data
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Rearrange months (N,D,J,F,M,A)
varfuturem = np.append(varfuture[:, -2:, :, :],
varfuture[:, :4, :, :],
axis=1)
varpastm = np.append(varpast[:, -2:, :, :], varpast[:, :4, :, :], axis=1)
### Calculate over region
lonq1 = np.where((lon >= 0) & (lon <= 120))[0]
lonq2 = np.where((lon > 120) & (lon <= 240))[0]
lonq3 = np.where((lon > 240) & (lon <= 360))[0]
varfuturem1 = varfuturem[:, :, :, lonq1]
varfuturem2 = varfuturem[:, :, :, lonq2]
varfuturem3 = varfuturem[:, :, :, lonq3]
varpastm1 = varpastm[:, :, :, lonq1]
varpastm2 = varpastm[:, :, :, lonq2]
varpastm3 = varpastm[:, :, :, lonq3]
### Calculate anomalies
anom1 = varfuturem1 - varpastm1
anom2 = varfuturem2 - varpastm2
anom3 = varfuturem3 - varpastm3
### Calculate ensemble mean
anomm1 = np.nanmean(anom1, axis=0)
pastm1 = np.nanmean(varpastm1, axis=0)
anomm2 = np.nanmean(anom2, axis=0)
pastm2 = np.nanmean(varpastm2, axis=0)
anomm3 = np.nanmean(anom3, axis=0)
pastm3 = np.nanmean(varpastm3, axis=0)
### Calculate zonal mean
anommz1 = np.nanmean(anomm1, axis=2)
climoz1 = np.nanmean(pastm1, axis=2)
anommz2 = np.nanmean(anomm2, axis=2)
climoz2 = np.nanmean(pastm2, axis=2)
anommz3 = np.nanmean(anomm3, axis=2)
climoz3 = np.nanmean(pastm3, axis=2)
### Calculate significance for each month using FDR
pvalue1 = np.empty((varpastm1.shape[1], len(lat)))
for i in range(varpastm1.shape[1]):
pvalue1[i] = UT.calc_FDR_ttest(
np.nanmean(varfuturem1[:, i, :, :], axis=2),
np.nanmean(varpastm1[:, i, :, :], axis=2), 0.05)
pvalue2 = np.empty((varpastm2.shape[1], len(lat)))
for i in range(varpastm2.shape[1]):
pvalue2[i] = UT.calc_FDR_ttest(
np.nanmean(varfuturem2[:, i, :, :], axis=2),
np.nanmean(varpastm2[:, i, :, :], axis=2), 0.05)
pvalue3 = np.empty((varpastm3.shape[1], len(lat)))
for i in range(varpastm3.shape[1]):
pvalue3[i] = UT.calc_FDR_ttest(
np.nanmean(varfuturem3[:, i, :, :], axis=2),
np.nanmean(varpastm3[:, i, :, :], axis=2), 0.05)
return lat, lon, anommz1, anommz2, anommz3, climoz1, climoz2, climoz3, pvalue1, pvalue2, pvalue3
