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