Ejemplo n.º 1
0
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
Ejemplo n.º 2
0
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
Ejemplo n.º 3
0
def PolarCap(simu,vari,level,latpolar,period):
    """
    Script calculates average over the polar cap (set latitude)
    """
    ### Import modules
    import numpy as np
    import calc_Utilities as UT
    import read_CTLNQ as CONT
    import read_ExpMonthly as NUDG
    import read_ShortCoupled as COUP
    import read_SIT as THICK
    import read_SIC as CONC
    import read_SIT_E3SM as E3SIT
    import read_SIC_E3SM as E3SIC
    import read_OldIceExperi as OLD
    import read_LongCoupled as LC
    
    if any([vari=='T700',vari=='T500']):
        varia = 'TEMP'
        level = 'profile'
    elif vari == 'U700':
        varia = 'U'
        level = 'profile'
    else:
        varia = vari
    
    ############################################################################### 
    ############################################################################### 
    ############################################################################### 
    if simu == 'AA-2030':
        lat,lon,lev,future = NUDG.readExperi(varia,'AA','2030',level,'none')
        lat,lon,lev,historical = CONT.readControl(varia,level,'none')
    elif simu == 'AA-2060':
        lat,lon,lev,future = NUDG.readExperi(varia,'AA','2060',level,'none')
        lat,lon,lev,historical = CONT.readControl(varia,level,'none')
    elif simu == 'AA-2090':
        lat,lon,lev,future = NUDG.readExperi(varia,'AA','2090',level,'none')
        lat,lon,lev,historical = CONT.readControl(varia,level,'none')
    ############################################################################### 
    elif simu == 'coupled_Pd':
        lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level)
        lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pd',level)      
    ############################################################################### 
    elif simu == 'coupled_Pi':
        lat,lon,lev,future = COUP.readCOUPs(varia,'C_Fu',level)
        lat,lon,lev,historical = COUP.readCOUPs(varia,'C_Pi',level)      
    ###############################################################################        
    elif simu == 'SIT':
        lat,lon,lev,future = THICK.readSIT(varia,'SIT_Fu',level)
        lat,lon,lev,historical = THICK.readSIT(varia,'SIT_Pd',level)
    ############################################################################### 
    elif simu == 'SIC_Pd':
        lat,lon,lev,future = CONC.readSIC(varia,'Fu',level)
        lat,lon,lev,historical = CONC.readSIC(varia,'Pd',level)
    ############################################################################### 
    elif simu == 'SIC_Pi':
        lat,lon,lev,future = CONC.readSIC(varia,'Fu',level)
        lat,lon,lev,historical = CONC.readSIC(varia,'Pi',level)
    ############################################################################### 
    elif simu == 'E3SIT':
        lat,lon,lev,future = E3SIT.readE3SM_SIT(varia,'ESIT_Fu',level)
        lat,lon,lev,historical = E3SIT.readE3SM_SIT(varia,'ESIT_Pd_B',level)
    ############################################################################### 
    elif simu == 'E3SIC_Pd':
        lat,lon,lev,future = E3SIC.readE3SM_SIC(varia,'ESIC_Fu',level)
        lat,lon,lev,historical = E3SIC.readE3SM_SIC(varia,'ESIC_Pd',level)
    elif simu == 'E3SIC_Pi':
        lat,lon,lev,future = E3SIC.readE3SM_SIC(varia,'ESIC_Fu',level)
        lat,lon,lev,historical = E3SIC.readE3SM_SIC(varia,'ESIC_Pi',level)
    ############################################################################### 
    elif simu == 'OLD':
        lat,lon,lev,future = OLD.readOldIceExperi(varia,'FICT',level)
        lat,lon,lev,historical = OLD.readOldIceExperi(varia,'HIT',level)
    ############################################################################### 
    elif simu == 'LONG':
        lat,lon,lev,future = LC.readLong(varia,'Long_Fu',level)
        lat,lon,lev,historical = LC.readLong(varia,'Long_Pd',level)
    ############################################################################### 
    ############################################################################### 
    ############################################################################### 
    ### Check for missing data [ensembles,months,lat,lon]
    future[np.where(future <= -1e10)] = np.nan
    historical[np.where(historical <= -1e10)] = np.nan
    
    ### Check for 4D field
    if vari == 'T700':
        levq = np.where(lev == 700)[0]
        future = future[:,:,levq,:,:].squeeze()
        historical = historical[:,:,levq,:,:].squeeze()
    elif vari == 'T500':
        levq = np.where(lev == 500)[0]
        future = future[:,:,levq,:,:].squeeze()
        historical = historical[:,:,levq,:,:].squeeze()
    elif vari == 'U700':
        levq = np.where(lev == 700)[0]
        future = future[:,:,levq,:,:].squeeze()
        historical = historical[:,:,levq,:,:].squeeze()
    
    ############################################################################### 
    ############################################################################### 
    ############################################################################### 
    ### Calculate over period
    if period == 'OND':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,-3:,:,:],axis=1)
        historicalm = np.nanmean(historical[:,-3:,:,:],axis=1)
    elif period == 'D':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,-1:,:,:],axis=1)
        historicalm = np.nanmean(historical[:,-1:,:,:],axis=1)
    elif period == 'DJF':
        print('Calculating over %s months!' % period)
        runs = [future,historical]
        var_mo = np.empty((2,historical.shape[0]-1,historical.shape[2],historical.shape[3]))
        for i in range(len(runs)):
            var_mo[i,:,:,:] = UT.calcDecJanFeb(runs[i],runs[i],lat,lon,'surface',1) 
        futurem = var_mo[0]
        historicalm = var_mo[1]
    elif period == 'JFM':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,0:3,:,:],axis=1)
        historicalm = np.nanmean(historical[:,0:3,:,:],axis=1)
    elif period == 'JF':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,0:2,:,:],axis=1)
        historicalm = np.nanmean(historical[:,0:2,:,:],axis=1)
    elif period == 'FMA':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,1:4,:,:],axis=1)
        historicalm = np.nanmean(historical[:,1:4,:,:],axis=1)
    elif period == 'FM':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,1:3,:,:],axis=1)
        historicalm = np.nanmean(historical[:,1:3,:,:],axis=1)
    elif period == 'J':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,0:1,:,:],axis=1)
        historicalm = np.nanmean(historical[:,0:1,:,:],axis=1)
    elif period == 'F':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,1:2,:,:],axis=1)
        historicalm = np.nanmean(historical[:,1:2,:,:],axis=1)
    elif period == 'M':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,2:3,:,:],axis=1)
        historicalm = np.nanmean(historical[:,2:3,:,:],axis=1)
    elif period == 'MA':
        print('Calculating over %s months!' % period)
        futurem = np.nanmean(future[:,2:4,:,:],axis=1)
        historicalm = np.nanmean(historical[:,2:4,:,:],axis=1)
    elif period == 'NONE':
        futurem = future
        historicalm = historical
    else:
        print(ValueError('Selected wrong month period!'))

    ############################################################################### 
    ############################################################################### 
    ############################################################################### 
    ### Calculate anomalies
    anom = futurem - historicalm
    
    ### Meshgrid for lat,lon
    lon2,lat2 = np.meshgrid(lon,lat)
    
    ### Calculate SHI
    if period == 'NONE':
        latq = np.where((lat >= latpolar))[0]
        anomp = anom[:,:,latq,:]
        lat2p = lat2[latq,:]
        polarave = UT.calc_weightedAve(anomp,lat2p)
    else:
        latq = np.where((lat >= latpolar))[0]
        anomp = anom[:,latq,:]
        lat2p = lat2[latq,:]
        polarave = UT.calc_weightedAve(anomp,lat2p)
    
    print('\n========Calculated Polar Cap Average========\n')
    return polarave

### Test functions (do not use!)
#ave = PolarCap('AA-2030','TEMP','profile',65,'DJF')

#import matplotlib.pyplot as plt
#import numpy as np
#plt.figure(figsize=(11,4))
#plt.title('Monthly SIC Anomalies')
#plt.plot(ave.ravel())
#plt.savefig('/home/zlabe/Desktop/' + 'monthly_SIC_anom.png',dpi=300)
Ejemplo n.º 4
0
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
Ejemplo n.º 5
0
def SHI(simu, period):
    """
    Script calculates the Siberian High Index
    """
    ### Import modules
    import numpy as np
    import calc_Utilities as UT
    import read_CTLNQ as CONT
    import read_ExpMonthly as NUDG
    import read_ShortCoupled as COUP
    import read_SIT as THICK
    import read_SIC as CONC
    import read_SIT_E3SM as E3SIT
    import read_SIC_E3SM as E3SIC
    import read_OldIceExperi as OLD
    import read_LongCoupled as LC

    ### Select variable
    varia = 'SLP'
    level = 'surface'

    ###############################################################################
    ###############################################################################
    ###############################################################################
    if simu == 'AA-2030':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2030', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    elif simu == 'AA-2060':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2060', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    elif simu == 'AA-2090':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2090', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    ###############################################################################
    elif simu == 'coupled_Pd':
        lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level)
        lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pd', level)
    ###############################################################################
    elif simu == 'coupled_Pi':
        lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level)
        lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pi', level)
    ###############################################################################
    elif simu == 'SIT':
        lat, lon, lev, future = THICK.readSIT(varia, 'SIT_Fu', level)
        lat, lon, lev, historical = THICK.readSIT(varia, 'SIT_Pd', level)
    ###############################################################################
    elif simu == 'SIC_Pd':
        lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level)
        lat, lon, lev, historical = CONC.readSIC(varia, 'Pd', level)
    ###############################################################################
    elif simu == 'SIC_Pi':
        lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level)
        lat, lon, lev, historical = CONC.readSIC(varia, 'Pi', level)
    ###############################################################################
    elif simu == 'E3SIT':
        lat, lon, lev, future = E3SIT.readE3SM_SIT(varia, 'ESIT_Fu', level)
        lat, lon, lev, historical = E3SIT.readE3SM_SIT(varia, 'ESIT_Pd_B',
                                                       level)
    ###############################################################################
    elif simu == 'E3SIC_Pd':
        lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level)
        lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pd', level)
    elif simu == 'E3SIC_Pi':
        lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level)
        lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pi', level)
    ###############################################################################
    elif simu == 'OLD':
        lat, lon, lev, future = OLD.readOldIceExperi(varia, 'FICT', level)
        lat, lon, lev, historical = OLD.readOldIceExperi(varia, 'HIT', level)
    ###############################################################################
    elif simu == 'LONG':
        lat, lon, lev, future = LC.readLong(varia, 'Long_Fu', level)
        lat, lon, lev, historical = LC.readLong(varia, 'Long_Pd', level)
    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### Check for missing data [ensembles,months,lat,lon]
    future[np.where(future <= -1e10)] = np.nan
    historical[np.where(historical <= -1e10)] = np.nan

    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### 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

    ### Meshgrid for lat,lon
    lon2, lat2 = np.meshgrid(lon, lat)

    ### Calculate SHI
    lonq = np.where((lon >= 80) & (lon <= 120))[0]
    latq = np.where((lat >= 40) & (lat <= 65))[0]
    anomlon = anom[:, :, lonq]
    anoms = anomlon[:, latq, :]
    lat2sq = lat2[latq, :]
    lat2s = lat2sq[:, lonq]
    shi = UT.calc_weightedAve(anoms, lat2s)

    print('\n========Calculated Siberian High Index========\n')
    return shi


### Test functions (do not use!)
#shi = SHI('AA-2090','DJF')
Ejemplo n.º 6
0
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 PolarCapVert(simu, varia, level, latpolar, period, levelVert):
    ###############################################################################
    ###############################################################################
    ###############################################################################
    if simu == 'AA-2030':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2030', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    elif simu == 'AA-2060':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2060', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    elif simu == 'AA-2090':
        lat, lon, lev, future = NUDG.readExperi(varia, 'AA', '2090', level,
                                                'none')
        lat, lon, lev, historical = CONT.readControl(varia, level, 'none')
    ###############################################################################
    elif simu == 'coupled_Pd':
        lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level)
        lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pd', level)
    ###############################################################################
    elif simu == 'coupled_Pi':
        lat, lon, lev, future = COUP.readCOUPs(varia, 'C_Fu', level)
        lat, lon, lev, historical = COUP.readCOUPs(varia, 'C_Pi', level)
    ###############################################################################
    elif simu == 'SIT':
        lat, lon, lev, future = THICK.readSIT(varia, 'SIT_Fu', level)
        lat, lon, lev, historical = THICK.readSIT(varia, 'SIT_Pd', level)
    ###############################################################################
    elif simu == 'SIC_Pd':
        lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level)
        lat, lon, lev, historical = CONC.readSIC(varia, 'Pd', level)
    ###############################################################################
    elif simu == 'SIC_Pi':
        lat, lon, lev, future = CONC.readSIC(varia, 'Fu', level)
        lat, lon, lev, historical = CONC.readSIC(varia, 'Pi', level)
    ###############################################################################
    elif simu == 'E3SIT':
        lat, lon, lev, future = E3SIT.readE3SM_SIT(varia, 'ESIT_Fu', level)
        lat, lon, lev, historical = E3SIT.readE3SM_SIT(varia, 'ESIT_Pd_B',
                                                       level)
    ###############################################################################
    elif simu == 'E3SIC_Pd':
        lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level)
        lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pd', level)
    elif simu == 'E3SIC_Pi':
        lat, lon, lev, future = E3SIC.readE3SM_SIC(varia, 'ESIC_Fu', level)
        lat, lon, lev, historical = E3SIC.readE3SM_SIC(varia, 'ESIC_Pi', level)
    ###############################################################################
    elif simu == 'OLD':
        lat, lon, lev, future = OLD.readOldIceExperi(varia, 'FICT', level)
        lat, lon, lev, historical = OLD.readOldIceExperi(varia, 'HIT', level)
    ###############################################################################
    elif simu == 'LONG':
        lat, lon, lev, future = LC.readLong(varia, 'Long_Fu', level)
        lat, lon, lev, historical = LC.readLong(varia, 'Long_Pd', level)
    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### Check for missing data [ensembles,months,lat,lon]
    future[np.where(future <= -1e10)] = np.nan
    historical[np.where(historical <= -1e10)] = np.nan

    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### 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 == 'NONE':
        futurem = future
        historicalm = historical
    else:
        print(ValueError('Selected wrong month period!'))

    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### Calculate anomalies
    anom = futurem - historicalm

    ### Meshgrid for lat,lon
    lon2, lat2 = np.meshgrid(lon, lat)

    ### Calculate SHI
    latq = np.where((lat >= latpolar))[0]
    anomp = anom[:, :, latq, :]
    lat2p = lat2[latq, :]
    polarave = UT.calc_weightedAve(anomp, lat2p)

    ### Calculate ensemble mean
    polaraveMean = np.nanmean(polarave, axis=0)

    ###############################################################################
    ###############################################################################
    ###############################################################################
    ### Calculate vertical levels and save file
    levqq = np.where((lev >= levelVert))[0]
    levvv = lev[levqq]
    polaraveMeanvvv = polaraveMean[levqq]

    ### Save file
    np.savetxt(directorydata + '%s_1000-%s_%s.txt' % (simu, levelVert, varia),
               polaraveMeanvvv,
               delimiter=',',
               fmt='%.3f')
    np.savetxt(directorydata + 'Levels_1000-%s_%s.txt' % (levelVert, varia),
               levvv,
               delimiter=',',
               fmt='%.1f')

    print('\n========Calculated Polar Cap Average========\n')
    return polaraveMeanvvv, levvv


###############################################################################
###############################################################################
###############################################################################
### Test functions (do not use!)

#aveAA30,lev = PolarCapVert('AA-2030','TEMP','profile',65,'DJF',500)
#aveAA60,lev = PolarCapVert('AA-2060','TEMP','profile',65,'DJF',500)
#aveAA90,lev = PolarCapVert('AA-2090','TEMP','profile',65,'DJF',500)
################################################################################
#ave_coupPd,lev = PolarCapVert('coupled_Pd','TEMP','profile',65,'DJF',500)
#ave_coupPi,lev = PolarCapVert('coupled_Pi','TEMP','profile',65,'DJF',500)
################################################################################
#ave_SIT,lev = PolarCapVert('SIT','TEMP','profile',65,'DJF',500)
#ave_SICPd,lev = PolarCapVert('SIC_Pd','TEMP','profile',65,'DJF',500)
#ave_SICPi,lev = PolarCapVert('SIC_Pi','TEMP','profile',65,'DJF',500)
###############################################################################
#ave_NET,lev = PolarCapVert('OLD','TEMP','profile',65,'DJF',500)
###############################################################################
#ave_ESICPd,lev = PolarCapVert('E3SIC_Pd','TEMP','profile',65,'DJF',500)
#ave_ESICPi,lev = PolarCapVert('E3SIC_Pi','TEMP','profile',65,'DJF',500)