def readVariables(varnames,runnames,period,directory):
for v in range(len(varnames)):
### Call function for surface temperature data from reach run
lat,lon,time,lev,varhit = MO.readExperi(directory,'%s' % varnames[v],
'%s' % runnames,'surface')
### Create 2d array of latitude and longitude
lon2,lat2 = np.meshgrid(lon,lat)
### Concatonate runs
runs = [varhit]
### Separate per periods
if period == 'ON':
tas_mo = np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = np.nanmean(runs[i][:,9:11,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,varhit.shape[0]-1,varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'FM':
tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = np.nanmean(runs[i][:,1:3,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((varhit.shape[0]-1,varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:],tas_mo[:] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'M':
tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = runs[i][:,2,:,:]
elif period == 'D':
tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = runs[i][:,-1,:,:]
elif period == 'N':
tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = runs[i][:,-2,:,:]
elif period == 'ND':
tas_mo= np.empty((varhit.shape[0],varhit.shape[2],varhit.shape[3]))
for i in range(len(runs)):
tas_mo[:] = np.nanmean(runs[i][:,-2:,:,:],axis=1)
else:
ValueError('Wrong period selected! (ON,DJ,FM)')
return lat,lon,tas_mo
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for 50 mb height data
lat, lon, time, lev, Z50h = MO.readExperi(directorydata, 'Z50', 'HIT',
'surface')
lat, lon, time, lev, Z50f = MO.readExperi(directorydata, 'Z50', 'FIT',
'surface')
### Separate per periods (ON,DJ,FM)
Z50h_on = np.nanmean(Z50h[:, 9:11, :, :], axis=1)
Z50f_on = np.nanmean(Z50f[:, 9:11, :, :], axis=1)
Z50h_dj, Z50f_dj = UT.calcDecJan(Z50h, Z50f, lat, lon, 'surface', 1)
Z50h_fm = np.nanmean(Z50h[:, 1:3, :, :], axis=1)
Z50f_fm = np.nanmean(Z50f[:, 1:3, :, :], axis=1)
### Calculate period differenceds
diff_on = np.nanmean((Z50f_on - Z50h_on), axis=0)
diff_dj = np.nanmean((Z50f_dj - Z50h_dj), axis=0)
diff_fm = np.nanmean((Z50f_fm - Z50h_fm), axis=0)
### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(Z50h_on, Z50f_on)
stat_dj, pvalue_dj = UT.calc_indttest(Z50h_dj, Z50f_dj)
stat_fm, pvalue_fm = UT.calc_indttest(Z50h_fm, Z50f_fm)
###########################################################################
def readVariables(varnames, period, location):
### Call function for surface temperature data from reach run
lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames, 'HIT',
'surface')
lat, lon, time, lev, tasfict = MO.readExperiAll('%s' % varnames, 'FICT',
'surface')
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Read in QBO phases
filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
pos_hit = np.append(
np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') +
101)
non_hit = np.append(
np.genfromtxt(filenamehitno, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitno2, unpack=True, usecols=[0], dtype='int') +
101)
neg_hit = np.append(
np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') +
101)
filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
1]
filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
0]
filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
1]
filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
2]
pos_fict = np.append(
np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictp2, unpack=True, usecols=[0], dtype='int') +
101)
non_fict = np.append(
np.genfromtxt(filenamefictno, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictno2, unpack=True, usecols=[0], dtype='int') +
101)
neg_fict = np.append(
np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictn2, unpack=True, usecols=[0], dtype='int') +
101)
### Concatonate runs
runs = [tashit, tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, 9:11, :, :], axis=1)
elif period == 'DJ':
tas_mo = np.empty(
(3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i], tas_mo[i] = UT.calcDecJan(runs[i], runs[i], lat, lon,
'surface', 1)
elif period == 'FM':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, 1:3, :, :], axis=1)
elif period == 'DJF':
tas_mo = np.empty(
(3, tashit.shape[0] - 1, tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i], tas_mo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon,
'surface', 1)
elif period == 'M':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, 2, :, :]
elif period == 'D':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, -1, :, :]
elif period == 'N':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, -2, :, :]
elif period == 'ND':
tas_mo = np.empty(
(3, tashit.shape[0], tashit.shape[2], tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :], axis=1)
else:
ValueError('Wrong period selected! (ON,DJ,FM)')
### Composite by QBO phase
tas_mohitpos = tas_mo[0][pos_hit, :, :]
tas_mofictpos = tas_mo[1][pos_fict, :, :]
tas_mohitnon = tas_mo[0][non_hit, :, :]
tas_mofictnon = tas_mo[1][non_fict, :, :]
tas_mohitneg = tas_mo[0][neg_hit, :, :]
tas_mofictneg = tas_mo[1][neg_fict, :, :]
### Compute comparisons for months - select region
if varnames == 'SLP':
lonq = np.where((lon >= 80) & (lon <= 120))[0]
ficthitpos = tas_mofictpos[:, :, lonq]
ficthitnon = tas_mofictnon[:, :, lonq]
ficthitneg = tas_mofictneg[:, :, lonq]
latq = np.where((lat >= 40) & (lat <= 65))[0]
ficthitpos = ficthitpos[:, latq]
ficthitnon = ficthitnon[:, latq]
ficthitneg = ficthitneg[:, latq]
lat2sq = lat2[latq, :]
lat2s = lat2sq[:, lonq]
ficthitpos = UT.calc_weightedAve(ficthitpos, lat2s)
ficthitnon = UT.calc_weightedAve(ficthitnon, lat2s)
ficthitneg = UT.calc_weightedAve(ficthitneg, lat2s)
diffruns = [
ficthitpos.squeeze(),
ficthitnon.squeeze(),
ficthitneg.squeeze()
]
return diffruns, lat, lon, lev
def calcVarResp(varnames,period,qbophase):
### Call function for surface temperature data from reach run
lat,lon,time,lev,tashit = MO.readExperiAll('%s' % varnames,'HIT',
'surface')
lat,lon,time,lev,tasfict = MO.readExperiAll('%s' % varnames,'FICT',
'surface')
### Create 2d array of latitude and longitude
lon2,lat2 = np.meshgrid(lon,lat)
### Read in QBO phases
filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
pos_hit = np.append(np.genfromtxt(filenamehitp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitp2,unpack=True,usecols=[0],dtype='int')+101)
non_hit = np.append(np.genfromtxt(filenamehitno,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitno2,unpack=True,usecols=[0],dtype='int')+101)
neg_hit = np.append(np.genfromtxt(filenamehitn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitn2,unpack=True,usecols=[0],dtype='int')+101)
filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[1]
filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[1]
filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
pos_fict = np.append(np.genfromtxt(filenamefictp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictp2,unpack=True,usecols=[0],dtype='int')+101)
non_fict = np.append(np.genfromtxt(filenamefictno,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictno2,unpack=True,usecols=[0],dtype='int')+101)
neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101)
### Concatonate runs
runs = [tashit,tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'FM':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'M':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,2,:,:]
elif period == 'D':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-1,:,:]
elif period == 'N':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-2,:,:]
elif period == 'ND':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,-2:,:,:],axis=1)
else:
ValueError('Wrong period selected! (ON,DJ,FM)')
### Composite by QBO phase
tas_mohitpos = tas_mo[0][pos_hit,:,:]
tas_mofictpos = tas_mo[1][pos_fict,:,:]
tas_mohitneg = tas_mo[0][neg_hit,:,:]
tas_mofictneg = tas_mo[1][neg_fict,:,:]
### Compute climatology
climohitpos = np.nanmean(tas_mohitpos,axis=0)
climohitneg = np.nanmean(tas_mohitneg,axis=0)
climo = [climohitpos,climohitneg]
### Compute comparisons for months - taken ensemble average
ficthitpos = np.nanmean(tas_mofictpos - tas_mohitpos,axis=0)
ficthitneg = np.nanmean(tas_mofictneg - tas_mohitneg,axis=0)
diffruns = [ficthitpos,ficthitneg]
### Calculate significance for ND
stat_FICTHITpos,pvalue_FICTHITpos = UT.calc_indttest(tas_mo[1][pos_fict,:,:],
tas_mo[0][pos_hit,:,:])
stat_FICTHITnon,pvalue_FICTHITnon = UT.calc_indttest(tas_mo[1][non_fict,:,:],
tas_mo[0][non_hit,:,:])
stat_FICTHITneg,pvalue_FICTHITneg = UT.calc_indttest(tas_mo[1][neg_fict,:,:],
tas_mo[0][neg_hit,:,:])
pruns = [pvalue_FICTHITpos,pvalue_FICTHITneg]
return diffruns,pruns,climo,lat,lon
def readWAFy(varnames, qbophase):
lat, lon, time, lev, tashit = MO.readExperiAll('%s' % varnames[0], 'HIT',
'profile')
lat, lon, time, lev, tasfict = MO.readExperiAll('%s' % varnames[0], 'FICT',
'profile')
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Read in QBO phases
filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitno2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[1]
filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
pos_hit = np.append(
np.genfromtxt(filenamehitp, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitp2, unpack=True, usecols=[0], dtype='int') +
101)
non_hit = np.append(
np.genfromtxt(filenamehitno, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitno2, unpack=True, usecols=[0], dtype='int') +
101)
neg_hit = np.append(
np.genfromtxt(filenamehitn, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamehitn2, unpack=True, usecols=[0], dtype='int') +
101)
filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictno = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
1]
filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
0]
filenamefictno2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
1]
filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[
2]
pos_fict = np.append(
np.genfromtxt(filenamefictp, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictp2, unpack=True, usecols=[0], dtype='int') +
101)
non_fict = np.append(
np.genfromtxt(filenamefictno, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictno2, unpack=True, usecols=[0], dtype='int') +
101)
neg_fict = np.append(
np.genfromtxt(filenamefictn, unpack=True, usecols=[0], dtype='int'),
np.genfromtxt(filenamefictn2, unpack=True, usecols=[0], dtype='int') +
101)
### Concatonate runs
runs = [tashit, tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, 9:11, :, :, :], axis=1)
elif period == 'DJ':
tas_mo = np.empty((3, tashit.shape[0] - 1, tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i], tas_mo[i] = UT.calcDecJan(runs[i], runs[i], lat, lon,
'profile', 1)
elif period == 'FM':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, 1:3, :, :, :], axis=1)
elif period == 'DJF':
tas_mo = np.empty((3, tashit.shape[0] - 1, tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i], tas_mo[i] = UT.calcDecJanFeb(runs[i], runs[i], lat, lon,
'profile', 1)
elif period == 'M':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, 2, :, :, :]
elif period == 'D':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, -1, :, :, :]
elif period == 'N':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:, -2, :, :, :]
elif period == 'ND':
tas_mo = np.empty((3, tashit.shape[0], tashit.shape[2],
tashit.shape[3], tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:, -2:, :, :, :], axis=1)
else:
ValueError('Wrong period selected! (ON,DJ,FM)')
### Composite by QBO phase
tas_mohitposq = tas_mo[0][pos_hit, :, :]
tas_mofictposq = tas_mo[1][pos_fict, :, :]
tas_mohitnonq = tas_mo[0][non_hit, :, :]
tas_mofictnonq = tas_mo[1][non_fict, :, :]
tas_mohitnegq = tas_mo[0][neg_hit, :, :]
tas_mofictnegq = tas_mo[1][neg_fict, :, :]
### Take zonal average
tas_mohitpos = np.nanmean(tas_mohitposq, axis=3)
tas_mofictpos = np.nanmean(tas_mofictposq, axis=3)
tas_mohitnon = np.nanmean(tas_mohitnonq, axis=3)
tas_mofictnon = np.nanmean(tas_mofictnonq, axis=3)
tas_mohitneg = np.nanmean(tas_mohitnegq, axis=3)
tas_mofictneg = np.nanmean(tas_mofictnegq, axis=3)
ficthitpos = np.nanmean(tas_mofictpos - tas_mohitpos, axis=0) / np.nanstd(
tas_mofictpos, axis=0)
ficthitnon = np.nanmean(tas_mofictnon - tas_mohitnon, axis=0) / np.nanstd(
tas_mofictnon, axis=0)
ficthitneg = np.nanmean(tas_mofictneg - tas_mohitneg, axis=0) / np.nanstd(
tas_mofictneg, axis=0)
diffruns_mo = [ficthitneg, ficthitpos, ficthitneg - ficthitpos]
### Calculate significance
stat_FICTHITpos, pvalue_FICTHITpos = UT.calc_indttest(
tas_mohitpos, tas_mofictpos)
stat_FICTHITnon, pvalue_FICTHITnon = UT.calc_indttest(
tas_mohitnon, tas_mofictnon)
stat_FICTHITneg, pvalue_FICTHITneg = UT.calc_indttest(
tas_mohitneg, tas_mofictneg)
pruns_mo = [pvalue_FICTHITneg, pvalue_FICTHITpos, pvalue_FICTHITneg]
return diffruns_mo, pruns_mo, lat, lon, lev
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for SLP data
lat, lon, time, lev, slph = MO.readExperi(directorydata, 'SLP', 'HIT',
'surface')
lat, lon, time, lev, slpf = MO.readExperi(directorydata, 'SLP', 'FIT',
'surface')
### Separate per periods (ON,DJ,FM)
slph_on = np.nanmean(slph[:, 9:11, :, :], axis=1)
slpf_on = np.nanmean(slpf[:, 9:11, :, :], axis=1)
slph_dj, slpf_dj = UT.calcDecJan(slph, slpf, lat, lon, 'surface', 1)
slph_fm = np.nanmean(slph[:, 1:3, :, :], axis=1)
slpf_fm = np.nanmean(slpf[:, 1:3, :, :], axis=1)
### Calculate period differenceds
diff_on = np.nanmean((slpf_on - slph_on), axis=0)
diff_dj = np.nanmean((slpf_dj - slph_dj), axis=0)
diff_fm = np.nanmean((slpf_fm - slph_fm), axis=0)
diff_onq = slpf_on - np.nanmean(slph_on, axis=0)
diff_djq = slpf_dj - np.nanmean(slph_dj, axis=0)
diff_fmq = slpf_fm - np.nanmean(slph_fm, axis=0)
stat_on, pvalue_on = UT.calc_indttest(slph_on, slpf_on)
stat_dj, pvalue_dj = UT.calc_indttest(slph_dj, slpf_dj)
stat_fm, pvalue_fm = UT.calc_indttest(slph_fm, slpf_fm)
print('\n' '----Plotting temperature - %s----' % titletime)
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1,year2+1,1)
### Call function for zonal wind data
lat,lon,time,lev,uh = MO.readExperi(directorydata,'U','HIT','profile')
lat,lon,time,lev,uf = MO.readExperi(directorydata,'U','FIT','profile')
#### Separate per periods (ON,DJ,FM)
uh_on = np.nanmean(uh[:,9:11,:,:,:],axis=1)
uf_on = np.nanmean(uf[:,9:11,:,:,:],axis=1)
uh_dj,uf_dj = UT.calcDecJan(uh,uf,lat,lon,'profile',lev.shape[0])
uh_fm = np.nanmean(uh[:,1:3,:,:,:],axis=1)
uf_fm = np.nanmean(uf[:,1:3,:,:,:],axis=1)
#### Calculate period differenceds
diff_on = np.nanmean((uf_on-uh_on),axis=0)
diff_dj = np.nanmean((uf_dj-uh_dj),axis=0)
diff_fm = np.nanmean((uf_fm-uh_fm),axis=0)
### Calculate zonal mean
zdiff_on = np.nanmean((diff_on),axis=2)
zdiff_dj = np.nanmean((diff_dj),axis=2)
zdiff_fm = np.nanmean((diff_fm),axis=2)
## Calculate climo
def readVar(varnames,runnames,qbophase,period):
for v in range(len(varnames)):
### Call function for surface temperature data from reach run
lat,lon,time,lev,tashit = MO.readExperiAll('%s' % varnames[v],'HIT',
'surface')
lat,lon,time,lev,tasfit = MO.readExperiAll('%s' % varnames[v],'FIT',
'surface')
lat,lon,time,lev,tasfict = MO.readExperiAll('%s' % varnames[v],'FIT',
'surface')
### Create 2d array of latitude and longitude
lon2,lat2 = np.meshgrid(lon,lat)
### Read in QBO phases
filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
pos_hit = np.append(np.genfromtxt(filenamehitp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitp2,unpack=True,usecols=[0],dtype='int')+101)
neg_hit = np.append(np.genfromtxt(filenamehitn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitn2,unpack=True,usecols=[0],dtype='int')+101)
filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
pos_fict = np.append(np.genfromtxt(filenamefictp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictp2,unpack=True,usecols=[0],dtype='int')+101)
neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101)
### Concatonate runs
runs = [tashit,tasfit,tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'FM':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'M':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,2,:,:]
elif period == 'D':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-1,:,:]
elif period == 'N':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-2,:,:]
elif period == 'ND':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,-2:,:,:],axis=1)
else:
print(ValueError('Wrong period selected!'))
### Composite by QBO phase
vhitpos = tas_mo[0][pos_hit,:,:]
vfictpos = tas_mo[2][pos_fict,:,:]
vhitneg = tas_mo[0][neg_hit,:,:]
vfictneg = tas_mo[2][neg_fict,:,:]
### Compute comparisons for months - taken ensemble average
ficthitpos = np.nanmean(vfictpos - vhitpos,axis=0)
ficthitneg = np.nanmean(vfictneg - vhitneg,axis=0)
return vhitpos,vfictpos,vhitneg,vfictneg,ficthitpos,ficthitneg,lat,lon
def calcVarResp(varnames,period,qbophase):
### Call function for surface temperature data from reach run
lat,lon,time,lev,tashit = MO.readExperiAll('%s' % varnames,'HIT',
'surface')
lat,lon,time,lev,tasfict = MO.readExperiAll('%s' % varnames,'FICT',
'surface')
lat,lon,time,lev,tasfit = MO.readExperiAll('%s' % varnames,'FIT',
'surface')
### Create 2d array of latitude and longitude
lon2,lat2 = np.meshgrid(lon,lat)
### Read in QBO phases
filenamehitp = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitn = directorydata + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
filenamehitp2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[0]
filenamehitn2 = directorydata2 + 'HIT/monthly/QBO_%s_HIT.txt' % qbophase[2]
pos_hit = np.append(np.genfromtxt(filenamehitp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitp2,unpack=True,usecols=[0],dtype='int')+101)
neg_hit = np.append(np.genfromtxt(filenamehitn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamehitn2,unpack=True,usecols=[0],dtype='int')+101)
filenamefictp = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictn = directorydata + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
filenamefictp2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[0]
filenamefictn2 = directorydata2 + 'FICT/monthly/QBO_%s_FICT.txt' % qbophase[2]
pos_fict = np.append(np.genfromtxt(filenamefictp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictp2,unpack=True,usecols=[0],dtype='int')+101)
neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101)
filenamefitp = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[0]
filenamefitn = directorydata + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[2]
filenamefitp2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[0]
filenamefitn2 = directorydata2 + 'FIT/monthly/QBO_%s_FIT.txt' % qbophase[2]
pos_fit = np.append(np.genfromtxt(filenamefitp,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefitp2,unpack=True,usecols=[0],dtype='int')+101)
neg_fit = np.append(np.genfromtxt(filenamefitn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefitn2,unpack=True,usecols=[0],dtype='int')+101)
### Concatonate runs
runs = [tashit,tasfict,tasfit]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'FM':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'M':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,2,:,:]
elif period == 'D':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-1,:,:]
elif period == 'N':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,-2,:,:]
elif period == 'ND':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,-2:,:,:],axis=1)
else:
ValueError('Wrong period selected! (ON,DJ,FM)')
### Composite by QBO phase
tas_mohitpos = tas_mo[0][pos_hit,:,:]
tas_mofictpos = tas_mo[1][pos_fict,:,:]
tas_mofitpos = tas_mo[2][pos_fit,:,:]
tas_mohitneg = tas_mo[0][neg_hit,:,:]
tas_mofictneg = tas_mo[1][neg_fict,:,:]
tas_mofitneg = tas_mo[2][neg_fit,:,:]
### Slice U10 at 65N
latq = np.where((lat >= 64.5) & (lat <= 65.5))[0]
lat = lat[latq].squeeze()
tas_mohitpos = tas_mohitpos[:,latq,:].squeeze()
tas_mohitneg = tas_mohitneg[:,latq,:].squeeze()
tas_mofictpos = tas_mofictpos[:,latq,:].squeeze()
tas_mofictneg = tas_mofictneg[:,latq,:].squeeze()
tas_mofitpos = tas_mofitpos[:,latq,:].squeeze()
tas_mofitneg = tas_mofitneg[:,latq,:].squeeze()
### Take zonal mean
hitpos = np.nanmean(tas_mohitpos,axis=1)
hitneg = np.nanmean(tas_mohitneg,axis=1)
fictpos = np.nanmean(tas_mofictpos,axis=1)
fictneg = np.nanmean(tas_mofictneg,axis=1)
fitpos = np.nanmean(tas_mofitpos,axis=1)
fitneg = np.nanmean(tas_mofitneg,axis=1)
runs = [hitpos,hitneg,fictpos,fictneg,fitpos,fitneg]
return runs,lat,lon
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for vertical thickness data
lat, lon, time, lev, thickh = MO.readExperi(directorydata, 'THICK', 'HIT',
'surface')
lat, lon, time, lev, thickf = MO.readExperi(directorydata, 'THICK', 'FIT',
'surface')
### Separate per periods (ON,DJ,FM)
thickh_on = np.nanmean(thickh[:, 9:11, :, :], axis=1)
thickf_on = np.nanmean(thickf[:, 9:11, :, :], axis=1)
thickh_dj, thickf_dj = UT.calcDecJan(thickh, thickf, lat, lon, 'surface', 1)
thickh_fm = np.nanmean(thickh[:, 1:3, :, :], axis=1)
thickf_fm = np.nanmean(thickf[:, 1:3, :, :], axis=1)
#### Calculate period differenceds
diff_on = np.nanmean((thickf_on - thickh_on), axis=0)
diff_dj = np.nanmean((thickf_dj - thickh_dj), axis=0)
diff_fm = np.nanmean((thickf_fm - thickh_fm), axis=0)
#### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(thickh_on, thickf_on)
stat_dj, pvalue_dj = UT.calc_indttest(thickh_dj, thickf_dj)
stat_fm, pvalue_fm = UT.calc_indttest(thickh_fm, thickf_fm)
###########################################################################
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for U10 wind (m/s)
lat, lon, time, lev, U10h = MO.readExperi(directorydata, 'U10', 'HIT',
'surface')
lat, lon, time, lev, U10f = MO.readExperi(directorydata, 'U10', 'FIT',
'surface')
### Separate per periods (ON,DJ,FM)
U10h_on = np.nanmean(U10h[:, 9:11, :, :], axis=1)
U10f_on = np.nanmean(U10f[:, 9:11, :, :], axis=1)
U10h_dj, U10f_dj = UT.calcDecJan(U10h, U10f, lat, lon, 'surface', 1)
U10h_fm = np.nanmean(U10h[:, 1:3, :, :], axis=1)
U10f_fm = np.nanmean(U10f[:, 1:3, :, :], axis=1)
### Calculate period differenceds
diff_on = np.nanmean((U10f_on - U10h_on), axis=0)
diff_dj = np.nanmean((U10f_dj - U10h_dj), axis=0)
diff_fm = np.nanmean((U10f_fm - U10h_fm), axis=0)
### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(U10h_on, U10f_on)
stat_dj, pvalue_dj = UT.calc_indttest(U10h_dj, U10f_dj)
stat_fm, pvalue_fm = UT.calc_indttest(U10h_fm, U10f_fm)
###########################################################################
### Create 2d array of latitude and longitude
lon2, lat2 = np.meshgrid(lon, lat)
### Concatonate runs
runnames = [r'HIT', r'FIT', r'FIC', r'CIT']
experiments = [r'\textbf{FIT--HIT}', r'\textbf{FIC--CIT}']
runs = [varhit, varfit, varfic, varcit]
### Separate per 2 month periods
varmo_on = np.empty((4, varhit.shape[0], varhit.shape[2], varhit.shape[3]))
varmo_dj = np.empty(
(4, varhit.shape[0] - 1, varhit.shape[2], varhit.shape[3]))
varmo_fm = np.empty((4, varhit.shape[0], varhit.shape[2], varhit.shape[3]))
for i in range(len(runs)):
varmo_on[i] = np.nanmean(runs[i][:, 9:11, :, :], axis=1)
varmo_dj[i], varmo_dj[i] = UT.calcDecJan(runs[i], runs[i], lat, lon,
'surface', 1)
varmo_fm[i] = np.nanmean(runs[i][:, 1:3, :, :], axis=1)
### Calculate differences [FIT-HIT and FICT - FIT]
diff_fithit_on = np.nanmean(varmo_on[1] - varmo_on[0], axis=0)
diff_ficcit_on = np.nanmean(varmo_on[2] - varmo_on[3], axis=0)
diff_fithit_dj = np.nanmean(varmo_dj[1] - varmo_dj[0], axis=0)
diff_ficcit_dj = np.nanmean(varmo_dj[2] - varmo_dj[3], axis=0)
diff_fithit_fm = np.nanmean(varmo_fm[1] - varmo_fm[0], axis=0)
diff_ficcit_fm = np.nanmean(varmo_fm[2] - varmo_fm[3], axis=0)
### Calculate significance
stat_FITHITon, pvalue_FITHITon = UT.calc_indttest(varmo_on[1], varmo_on[0])
stat_FICCITon, pvalue_FICCITon = UT.calc_indttest(varmo_on[2], varmo_on[3])
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for geopotential height
lat, lon, time, lev, zh = MO.readExperi(directorydata, 'GEOP', 'HIT',
'profile')
lat, lon, time, lev, zf = MO.readExperi(directorydata, 'GEOP', 'FIT',
'profile')
#### Separate per periods (ON,DJ,FM)
zh_on = np.nanmean(zh[:, 9:11, :, :, :], axis=1)
zf_on = np.nanmean(zf[:, 9:11, :, :, :], axis=1)
zh_dj, zf_dj = UT.calcDecJan(zh, zf, lat, lon, 'profile', lev.shape[0])
zh_fm = np.nanmean(zh[:, 1:3, :, :, :], axis=1)
zf_fm = np.nanmean(zf[:, 1:3, :, :, :], axis=1)
#### Calculate period differenceds
diff_on = np.nanmean((zf_on - zh_on), axis=0)
diff_dj = np.nanmean((zf_dj - zh_dj), axis=0)
diff_fm = np.nanmean((zf_fm - zh_fm), axis=0)
### Calculate zonal mean
zdiff_on = np.nanmean((diff_on), axis=2)
zdiff_dj = np.nanmean((diff_dj), axis=2)
zdiff_fm = np.nanmean((diff_fm), axis=2)
## Calculate climo
print('\n' '----Plotting Z50 - %s----' % titletime)
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for precipitation data
lat, lon, time, lev, prh = MO.readExperi(directorydata, 'P', 'HIT', 'surface')
lat, lon, time, lev, prf = MO.readExperi(directorydata, 'P', 'FIT', 'surface')
### Separate per periods (ON,DJ,FM)
prh_on = np.nanmean(prh[:, 9:11, :, :], axis=1)
prf_on = np.nanmean(prf[:, 9:11, :, :], axis=1)
prh_dj, prf_dj = UT.calcDecJan(prh, prf, lat, lon, 'surface', 1)
prh_fm = np.nanmean(prh[:, 1:3, :, :], axis=1)
prf_fm = np.nanmean(prf[:, 1:3, :, :], axis=1)
### Calculate period differenceds
diff_on = np.nanmean((prf_on - prh_on), axis=0)
diff_dj = np.nanmean((prf_dj - prh_dj), axis=0)
diff_fm = np.nanmean((prf_fm - prh_fm), axis=0)
diff_onq = prf_on - np.nanmean(prh_on, axis=0)
diff_djq = prf_dj - np.nanmean(prh_dj, axis=0)
diff_fmq = prf_fm - np.nanmean(prh_fm, axis=0)
### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(prh_on, prf_on)
stat_dj, pvalue_dj = UT.calc_indttest(prh_dj, prf_dj)
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for energy flux terms
lat, lon, time, lev, fsh = MO.readExperi(directorydata, 'RNET', 'HIT',
'surface')
lat, lon, time, lev, fsf = MO.readExperi(directorydata, 'RNET', 'FIT',
'surface')
### Separate per periods (ON,DJ,FM)
fsh_on = np.nanmean(fsh[:, 9:11, :, :], axis=1)
fsf_on = np.nanmean(fsf[:, 9:11, :, :], axis=1)
fsh_dj, fsf_dj = UT.calcDecJan(fsh, fsf, lat, lon, 'surface', 1)
fsh_fm = np.nanmean(fsh[:, 1:3, :, :], axis=1)
fsf_fm = np.nanmean(fsf[:, 1:3, :, :], axis=1)
### Calculate period differenceds
diff_on = np.nanmean((fsf_on - fsh_on), axis=0)
diff_dj = np.nanmean((fsf_dj - fsh_dj), axis=0)
diff_fm = np.nanmean((fsf_fm - fsh_fm), axis=0)
### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(fsh_on, fsf_on)
stat_dj, pvalue_dj = UT.calc_indttest(fsh_dj, fsf_dj)
stat_fm, pvalue_fm = UT.calc_indttest(fsh_fm, fsf_fm)
###########################################################################
non_fict = np.append(np.genfromtxt(filenamefictno,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictno2,unpack=True,usecols=[0],dtype='int')+101)
neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101)
### Concatonate runs
runs = [tashit,tasfit,tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3],tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3],tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'profile',1)
elif period == 'FM':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3],tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3],tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'profile',1)
elif period == 'M':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3],tashit.shape[4]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,2,:,:,:]
elif period == 'D':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3],tashit.shape[4]))
np.genfromtxt(filenamefictno2,unpack=True,usecols=[0],dtype='int')+101)
neg_fict = np.append(np.genfromtxt(filenamefictn,unpack=True,usecols=[0],dtype='int'),
np.genfromtxt(filenamefictn2,unpack=True,usecols=[0],dtype='int')+101)
### Concatonate runs
runs = [tashit,tasfit,tasfict]
### Separate per periods (ON,DJ,FM)
if period == 'ON':
tas_mo = np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,9:11,:,:],axis=1)
elif period == 'DJ':
tas_mo = np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJan(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'FM':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = np.nanmean(runs[i][:,1:3,:,:],axis=1)
elif period == 'DJF':
tas_mo= np.empty((3,tashit.shape[0]-1,tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i],tas_mo[i] = UT.calcDecJanFeb(runs[i],runs[i],lat,
lon,'surface',1)
elif period == 'M':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
for i in range(len(runs)):
tas_mo[i] = runs[i][:,2,:,:]
elif period == 'D':
tas_mo= np.empty((3,tashit.shape[0],tashit.shape[2],tashit.shape[3]))
### Alott time series
year1 = 1900
year2 = 2000
years = np.arange(year1, year2 + 1, 1)
### Call function for vertical temperature data
lat, lon, time, lev, th = MO.readExperi(directorydata, 'TEMP', 'HIT',
'profile')
lat, lon, time, lev, tf = MO.readExperi(directorydata, 'TEMP', 'FIT',
'profile')
### Separate per periods (ON,DJ,FM)
th_on = np.nanmean(th[:, 9:11, :, :, :], axis=1)
tf_on = np.nanmean(tf[:, 9:11, :, :, :], axis=1)
th_dj, tf_dj = UT.calcDecJan(th, tf, lat, lon, 'profile', lev.shape[0])
th_fm = np.nanmean(th[:, 1:3, :, :, :], axis=1)
tf_fm = np.nanmean(tf[:, 1:3, :, :, :], axis=1)
#### Calculate period differenceds
diff_on = np.nanmean((tf_on - th_on), axis=0)
diff_dj = np.nanmean((tf_dj - th_dj), axis=0)
diff_fm = np.nanmean((tf_fm - th_fm), axis=0)
#### Calculate significance
stat_on, pvalue_on = UT.calc_indttest(np.nanmean(th_on, axis=3),
np.nanmean(tf_on, axis=3))
stat_dj, pvalue_dj = UT.calc_indttest(np.nanmean(th_dj, axis=3),
np.nanmean(tf_dj, axis=3))
stat_fm, pvalue_fm = UT.calc_indttest(np.nanmean(th_fm, axis=3),
