def return_aspect(year, ftype): datapathT=datapath+ftype+'/' xptsT, yptsT, heightT, nearmax_heightT, max_heightT, sizeRT = ro.get_indy_mean_max_height(mib, mplot, year, datapathT) c00T, c01T, c10T, c11T, sect_numRT= ro.get_indy_covar(year, datapathT) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest') mask = where((region_maskR<11)&(max_heightT<10)) xptsT=xptsT[mask] yptsT=yptsT[mask] heightT=heightT[mask] max_heightT=max_heightT[mask] sect_numRT=sect_numRT[mask] c00T=c00T[mask] c01T=c01T[mask] c10T=c10T[mask] c11T=c11T[mask] #CHECK BODMAS l1T=(c00T+c11T-np.sqrt((c00T+c11T)**2.0-4*(c00T*c11T-c01T**2.0)))/2.0 l2T=(c00T+c11T+np.sqrt((c00T+c11T)**2.0-4*(c00T*c11T-c01T**2.0)))/2.0 #theta=0.5*180.0/np.pi*np.arctan2(2*c01T,c00T-c11T) #b=np.sqrt((dx**2)*sizeRT*np.sqrt(l2T/l1T)) aspectT = sqrt(l2T/l1T) return xptsT, yptsT, aspectT
def return_aspect(year, ftype):
datapathT = datapath + ftype + '/'
xptsT, yptsT, heightT, nearmax_heightT, max_heightT, sizeRT = ro.get_indy_mean_max_height(
mib, mplot, year, datapathT)
c00T, c01T, c10T, c11T, sect_numRT = ro.get_indy_covar(year, datapathT)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsT, yptsT),
method='nearest')
mask = where((region_maskR < 11) & (max_heightT < 10))
xptsT = xptsT[mask]
yptsT = yptsT[mask]
heightT = heightT[mask]
max_heightT = max_heightT[mask]
sect_numRT = sect_numRT[mask]
c00T = c00T[mask]
c01T = c01T[mask]
c10T = c10T[mask]
c11T = c11T[mask]
#CHECK BODMAS
l1T = (c00T + c11T - np.sqrt((c00T + c11T)**2.0 - 4 *
(c00T * c11T - c01T**2.0))) / 2.0
l2T = (c00T + c11T + np.sqrt((c00T + c11T)**2.0 - 4 *
(c00T * c11T - c01T**2.0))) / 2.0
#theta=0.5*180.0/np.pi*np.arctan2(2*c01T,c00T-c11T)
#b=np.sqrt((dx**2)*sizeRT*np.sqrt(l2T/l1T))
aspectT = sqrt(l2T / l1T)
return xptsT, yptsT, aspectT
def get_ridge_data_sections(region): max_height=[] xpts=[] ypts=[] if (region==0): region_lonlat = [-150, 10, 81, 90] region_str='CA' if (region==1): region_lonlat = [-170, -120, 69, 79] region_str='BC' for year in xrange(start_year, end_year+1): print year xptsT, yptsT, lonT, latT, max_heightT, sizeT, sectionT = ro.get_indy_mean_max_height(mib, mplot, year, datapath, lonlat_section=1) #xptsT, yptsT, lonT, latT, heightT, nearmax_heightT, max_heightT = ro.get_indy_mean_max_height(mib, mplot, year, ridge_stats_path, lonlat=1) region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest') mask = where((lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8) &(max_heightT<10.)) #mask = mask[0].tolist() lonT=lonT[mask] latT=latT[mask] xptsT=xptsT[mask] yptsT=yptsT[mask] max_heightT=max_heightT[mask] xpts.append(xptsT) ypts.append(yptsT) max_height.append(max_heightT) return xpts, ypts,max_height
def get_ridge_data_sections(region): ice_volumeALL=[] xpts=[] ypts=[] if (region==0): region_lonlat = [-150, 10, 81, 90] region_str='CA' if (region==1): region_lonlat = [-170, -120, 69, 79] region_str='BC' for year in xrange(start_year, end_year+1): print year xptsT, yptsT, lonT, latT, sail_area_fracT, heightT, ice_volumeT= ro.get_bulk_ridge_stats(mib, mplot, year, datapath, areavollonlat=1) region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest') mask = where((lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)) #mask = mask[0].tolist() lonT=lonT[mask] latT=latT[mask] xptsT=xptsT[mask] yptsT=yptsT[mask] ice_volumeT=ice_volumeT[mask] print year, size(mask) xpts.append(xptsT) ypts.append(yptsT) ice_volumeALL.append(ice_volumeT) return xpts, ypts, ice_volumeALL
def get_hist_allyears(region, mask_type, var_str): hist=[] bins=[] if (region==0): region_lonlat = [-150, 10, 81, 90] region_str='CA' if (region==1): region_lonlat = [-170, -120, 69, 79] region_str='BC' if (region==2): region_lonlat = [-190, 30, 60, 90] region_str='ARC' varALL=[] for year in xrange(start_year, end_year+1): print year xptsT = load(datapath+'mean_xptsB'+str(year)+str(num_kms)+'km_'+type_str+'.txt') yptsT = load(datapath+'mean_yptsB'+str(year)+str(num_kms)+'km_'+type_str+'.txt') varT = load(datapath+'mean_'+var_str+str(year)+str(num_kms)+'km_'+type_str+'.txt') xptsT=xptsT[where(~isnan(varT))] yptsT=yptsT[where(~isnan(varT))] varT=varT[where(~isnan(varT))] lonT, latT = mplot(xptsT, yptsT, inverse=True) #xptsT, yptsT, lonT, latT, max_heightT, sizeT, sectionT = ro.get_indy_mean_max_height(mib, mplot, year, ridge_stats_path, lonlat_section=1) #GET MY ICE IN BC (0.5) AND CA (1) ice_type, xptsA, yptsA = ro.get_mean_ice_type(mplot,rawdatapath, year, res=1) ice_typeR = griddata((xptsA.flatten(), yptsA.flatten()),ice_type.flatten(), (xptsT, yptsT), method='nearest') region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest') if (mask_type==0): mask = where((ice_typeR<1.1) & (ice_typeR>0.4)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)) if (mask_type==1): mask = where((ice_typeR<0.6) & (ice_typeR>0.4)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)) if (mask_type==2): mask = where((ice_typeR<1.1) & (ice_typeR>0.9)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)) varT=varT[mask] varALL.extend(varT) histT, binsT = np.histogram(varALL, bins=bin_vals) meanH = mean(varALL) medianH = median(varALL) stdH = std(varALL) modeH = binsT[argmax(histT)] + bin_width/2. #hist.append(histT) #bins.append(binsT) return binsT, histT, meanH, medianH, modeH, stdH
def calc_mean_height_dist(year):
mean_xptsB = []
mean_yptsB = []
mean_heightsR = []
sect_dists = []
#READ IN YEAR DATA BULK/INDY/COVARS
xptsBT, yptsBT, swath_areaBT, num_labelsBT, sail_areaBT, sail_heightBT, sect_numBT, numptsBT = ro.get_bulk_ridge_stats(
mib, mplot, year, datapath, section=1)
xptsRT, yptsRT, lonRT, latRT, max_heightRT, sizeRT, sect_numRT = ro.get_indy_mean_max_height(
mib, mplot, year, datapath, lonlat_section=1)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsRT, yptsRT),
method='nearest')
if region < 2:
mask = where((region_maskR < 11) & (max_heightRT < 10)
& (max_heightRT > 0.2) & (lonRT > region_lonlat[0])
& (lonRT < region_lonlat[1]) & (latRT > region_lonlat[2])
& (latRT < region_lonlat[3]))
else:
mask = where((region_maskR < 11) & (max_heightRT < 10)
& (max_heightRT > 0.2))
xptsRT = xptsRT[mask]
yptsRT = yptsRT[mask]
max_heightRT = max_heightRT[mask]
sizeRT = sizeRT[mask]
sect_numRT = sect_numRT[mask]
for i in xrange(
np.amin(sect_numBT),
np.amax(sect_numBT) - 10,
num_kms): #sect_numBT[0], sect_numBT[-1]-num_kms, num_kms):
sect1 = i
sect2 = sect1 + num_kms
#BULK
sect_idxsB = where((sect_numBT >= sect1) & (sect_numBT < sect2))[0]
if (size(sect_idxsB) >= num_gd_sections):
sect_dist = sqrt(
(xptsBT[sect_idxsB[-1]] - xptsBT[sect_idxsB[0]])**2 +
(yptsBT[sect_idxsB[-1]] - yptsBT[sect_idxsB[0]])**2)
sect_dists.append(sect_dist)
if (sect_dist < num_kms * 1200):
mean_xptsB.append(mean(xptsBT[sect_idxsB]))
mean_yptsB.append(mean(yptsBT[sect_idxsB]))
#sails_areaB = sum(sail_areaBT[sect_idxsB])
ice_areaB = sum(swath_areaBT[sect_idxsB])
#INDY
sect_idxsI = where((sect_numRT >= sect1)
& (sect_numRT < sect2))[0]
#DECIDE WHAT TO DO ABOUT NUMBER OF RIDGES NEEDED
if (size(sect_idxsI) >= 2):
mean_heightR = mean(max_heightRT[sect_idxsI])
mean_heightsR.append(mean_heightR)
else:
mean_heightsR.append(np.nan)
return array(mean_xptsB), array(mean_yptsB), array(mean_heightsR)
def get_hist_allyears(region, type): hist=[] bins=[] if (region==0): region_lonlat = [-150, 10, 81, 90] region_str='CA' if (region==1): region_lonlat = [-170, -120, 69, 79] region_str='BC' max_heightALL=[] for year in xrange(start_year, end_year+1): print year xptsT, yptsT, lonT, latT, max_heightT, sizeT, sectionT = ro.get_indy_mean_max_height(mib, mplot, year, datapath, lonlat_section=1) region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest') #ice_type, xptsA, yptsA = ro.get_ice_type_year(mplot, year-2009, res=1) ice_type, xptsA, yptsA = ro.get_mean_ice_type(mplot, rawdatapath, year, res=1) ice_typeR = griddata((xptsA.flatten(), yptsA.flatten()),ice_type.flatten(), (xptsT, yptsT), method='nearest') if (type==0): mask = where((ice_typeR<1.1) & (ice_typeR>0.4)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)&(max_heightT<10)) if (type==1): mask = where((ice_typeR<0.6) & (ice_typeR>0.4)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)&(max_heightT<10)) if (type==2): mask = where((ice_typeR<1.1) & (ice_typeR>0.9)&(lonT>region_lonlat[0]) & (lonT<region_lonlat[1]) & (latT>region_lonlat[2]) & (latT<region_lonlat[3])& (region_maskR==8)&(max_heightT<10)) max_heightT=max_heightT[mask] max_heightALL.extend(max_heightT) histT, binsT = np.histogram(max_heightALL, bins=bin_vals) meanH = mean(max_heightALL) medianH = median(max_heightALL) stdH = std(max_heightALL) modeH = binsT[argmax(histT)] + bin_width/2. #hist.append(histT) #bins.append(binsT) return binsT, histT, meanH, medianH, modeH, stdH
def get_sail_thickness_ave(year, addsnow):
mean_heightALL = []
thicknessALL = []
xpts_matchALL = []
ypts_matchALL = []
print year
#mean_xpts, mean_ypts, mean_height = running_mean(xptsT, yptsT, max_heightT, window)
mean_xpts, mean_ypts, mean_height, gd_sections, gd_distance, gd_ridges, sections = calc_mean_height_dist(
year)
mean_height.dump(savepath + '/Sailheightave_10km_' + str(year) +
region_str + 'nomatch.txt')
mean_xpts.dump(savepath + '/xpts_10km_' + str(year) + region_str +
'nomatch.txt')
mean_ypts.dump(savepath + '/ypts_10km_' + str(year) + region_str +
'nomatch.txt')
xptsIB, yptsIB, latsIB, lonsIB, thicknessIB, snowIB = ro.read_icebridgeALL(
mplot, rawdatapath, year, mask_hi=1, mask_nonarctic=1)
mean_xptsIB, mean_yptsIB, mean_thicknessIB = running_mean(
xptsIB, yptsIB, thicknessIB, window)
mean_thicknessIBR = griddata((mean_xptsIB, mean_yptsIB),
mean_thicknessIB, (mean_xpts, mean_ypts),
method='nearest',
rescale=True)
print 'size IB ave:', size(mean_thicknessIB)
print 'size IB ave:', size(mean_thicknessIBR)
mean_thicknessIBR = kdtree_clean1D(mean_xpts, mean_ypts, mean_xptsIB,
mean_yptsIB, mean_thicknessIBR,
kdtree_radius)
#REMOVE LOW gridded thickness VALS
mean_thicknessIBR[where(mean_thicknessIBR < 0)] = np.nan
mean_xpts[where(mean_thicknessIBR < 0)] = np.nan
mean_ypts[where(mean_thicknessIBR < 0)] = np.nan
#FIND WHERE BOTH HAVE DATA
match_data = where(~(np.isnan(mean_thicknessIBR + mean_height)))
xpts_match = mean_xpts[match_data]
ypts_match = mean_ypts[match_data]
mean_thicknessIBR_match = mean_thicknessIBR[match_data]
mean_height_match = mean_height[match_data]
xpts_match.dump(savepath + '/xpts_10km_' + str(year) + region_str + '.txt')
ypts_match.dump(savepath + '/ypts_10km_' + str(year) + region_str + '.txt')
mean_height_match.dump(savepath + '/Sailheightave_10km_' + str(year) +
region_str + '.txt')
mean_thicknessIBR_match.dump(savepath + '/IBthickness_10km_' + str(year) +
region_str + '.txt')
return mean_thicknessIB, mean_thicknessIBR, mean_thicknessIBR_match, mean_height, mean_height_match, gd_sections, gd_distance, gd_ridges, sections
def get_ridge_data_sections(region):
ice_volumeALL = []
xpts = []
ypts = []
if (region == 0):
region_lonlat = [-150, 10, 81, 90]
region_str = 'CA'
if (region == 1):
region_lonlat = [-170, -120, 69, 79]
region_str = 'BC'
for year in xrange(start_year, end_year + 1):
print year
xptsT, yptsT, lonT, latT, sail_area_fracT, heightT, ice_volumeT = ro.get_bulk_ridge_stats(
mib, mplot, year, datapath, areavollonlat=1)
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsT, yptsT),
method='nearest')
mask = where((lonT > region_lonlat[0]) & (lonT < region_lonlat[1])
& (latT > region_lonlat[2]) & (latT < region_lonlat[3])
& (region_maskR == 8))
#mask = mask[0].tolist()
lonT = lonT[mask]
latT = latT[mask]
xptsT = xptsT[mask]
yptsT = yptsT[mask]
ice_volumeT = ice_volumeT[mask]
print year, size(mask)
xpts.append(xptsT)
ypts.append(yptsT)
ice_volumeALL.append(ice_volumeT)
return xpts, ypts, ice_volumeALL
def calc_mean_height_dist(year): mean_xptsB=[] mean_yptsB=[] mean_heightsR=[] sect_dists=[] #READ IN YEAR DATA BULK/INDY/COVARS xptsBT, yptsBT, swath_areaBT, num_labelsBT, sail_areaBT, sail_heightBT, sect_numBT, numptsBT = ro.get_bulk_ridge_stats(mib, mplot, year, datapath, section=1) xptsRT, yptsRT, lonRT, latRT, max_heightRT, sizeRT, sect_numRT = ro.get_indy_mean_max_height(mib, mplot, year, datapath, lonlat_section=1) region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsRT, yptsRT), method='nearest') if region<2: mask = where((region_maskR<11)&(max_heightRT<10)&(max_heightRT>0.2)&(lonRT>region_lonlat[0]) & (lonRT<region_lonlat[1]) & (latRT>region_lonlat[2]) & (latRT<region_lonlat[3])) else: mask = where((region_maskR<11)&(max_heightRT<10)&(max_heightRT>0.2)) xptsRT=xptsRT[mask] yptsRT=yptsRT[mask] max_heightRT=max_heightRT[mask] sizeRT=sizeRT[mask] sect_numRT=sect_numRT[mask] for i in xrange(np.amin(sect_numBT), np.amax(sect_numBT)-10, num_kms): #sect_numBT[0], sect_numBT[-1]-num_kms, num_kms): sect1 = i sect2 = sect1+num_kms #BULK sect_idxsB = where((sect_numBT>=sect1) & (sect_numBT<sect2))[0] if (size(sect_idxsB)>=num_gd_sections): sect_dist = sqrt((xptsBT[sect_idxsB[-1]]-xptsBT[sect_idxsB[0]])**2 + (yptsBT[sect_idxsB[-1]]-yptsBT[sect_idxsB[0]])**2) sect_dists.append(sect_dist) if (sect_dist<num_kms*1200): mean_xptsB.append(mean(xptsBT[sect_idxsB])) mean_yptsB.append(mean(yptsBT[sect_idxsB])) #sails_areaB = sum(sail_areaBT[sect_idxsB]) ice_areaB = sum(swath_areaBT[sect_idxsB]) #INDY sect_idxsI = where((sect_numRT>=sect1) & (sect_numRT<sect2))[0] #DECIDE WHAT TO DO ABOUT NUMBER OF RIDGES NEEDED if (size(sect_idxsI)>=2): mean_heightR = mean(max_heightRT[sect_idxsI]) mean_heightsR.append(mean_heightR) else: mean_heightsR.append(np.nan) return array(mean_xptsB), array(mean_yptsB), array(mean_heightsR)
def calc_mean_height_dist1d(year):
mean_xpts = []
mean_ypts = []
mean_heights = []
mean_dists = []
sect_dists = []
xptsT, yptsT, max_heightT, atrk_distT, distsT, sectionT = ro.get_stats_1D(
mib, mplot, datapath1D, year)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsT, yptsT),
method='nearest')
mask = where((region_maskR == 8) & (max_heightT < 10))
xptsT = xptsT[mask]
yptsT = yptsT[mask]
max_heightT = max_heightT[mask]
distsT = distsT[mask]
sectionT = sectionT[mask]
atrk_distT = atrk_distT[mask]
num_kms = 10
num_gd_sections = 0.3 * num_kms
for i in xrange(sectionT[0], sectionT[-1] - num_kms, num_kms):
sect1 = i
sect2 = sect1 + num_kms
#get app
sect_idxs = where((sectionT >= sect1) & (sectionT < sect2))[0]
sectionsS = sectionT[sect_idxs]
#are there a
if ((size(sect_idxs) >= 2)
and (size(unique(sectionsS)) >= num_gd_sections)):
sect_dist = sqrt((xptsT[sect_idxs[-1]] - xptsT[sect_idxs[0]])**2 +
(xptsT[sect_idxs[-1]] - xptsT[sect_idxs[0]])**2)
#if number of unique seciotn sin big section is more than number needed
# and if the actual distance from start to end of this big section is less than 110%
# and if there are more than 2 points..
if ((sect_dist < num_kms * 1100)):
mean_heights.append(nanmean(max_heightT[sect_idxs]))
mean_dists.append(nanmean(distsT[sect_idxs]))
mean_xpts.append(nanmean(xptsT[sect_idxs]))
mean_ypts.append(nanmean(yptsT[sect_idxs]))
return array(mean_xpts), array(mean_ypts), array(mean_heights), array(
mean_dists)
section_num=0 print 'Num points req', num_points_req ftype = str(int(along_track_res/1000))+'km_xyres'+str(xy_res)+'m_'+str(int(min_ridge_height*100))+'cm' outpath = datapath+ftype+'/' for year in xrange(start_year, end_year+1): ATM_year = ATM_path+str(year)+'/' atm_files_year = glob(ATM_year+'/*/') #for days in xrange(): for days in xrange(size(atm_files_year)): atm_path_date = atm_files_year[days] print 'ATM day:', atm_path_date atm_files_in_day = ro.get_atm_files(atm_path_date, year) #load POS file posAV = loadtxt(posAV_path+str(year)+'_GR_NASA/sbet_'+str(atm_path_date[-9:-1])+'.out.txt', skiprows=1) #GET POSITION OF PLANE AND 1km MARKERS FROM POSAV xp, yp, dist, km_idxs, km_utc_times = ro.get_pos_sections(posAV, m, along_track_res) for atm_file in xrange(size(atm_files_in_day)): atm_statsALL=np.array([]).reshape(0,3) ridge_statsALL=np.array([]).reshape(0,9) covarALL=np.array([]).reshape(0,5) bulk_statsALL=np.array([]).reshape(0,18) print 'ATM file:', atm_files_in_day[atm_file], str(atm_file)+'/'+str(size(atm_files_in_day)) lonT, latT, elevationT, utc_timeT= ro.get_atmqih5(atm_files_in_day[atm_file], year, 1) #IF SIZE OF DATA IS LESS THAN SOME THRESHOLD THEN DONT BOTHER ANALYZING if (size(utc_timeT)<100): break
thresh=20 plot_max=1 fadd = '' ftype1='1km_xyres2m_'+str(20)+'cm'+fadd ftype2='1km_xyres2m_'+str(80)+'cm'+fadd datapath = './Data_output/' figpath = './Figures/' rawdatapath='../../../DATA/' xpts=[] ypts=[] height=[] aspect=[] region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot) year=2012 xptsT1, yptsT1, aspectT1 = return_aspect(year, ftype1) xptsT2, yptsT2, aspectT2 = return_aspect(year, ftype2) ridge_var=aspect minval = 1 maxval = 4 label_str = 'Aspect ratio' out_var = 'aspect_ratio' ice_typeT, xpts_type, ypts_type = ro.get_mean_ice_type(mplot, rawdatapath, year, res=1) ice_type=np.zeros((shape(ice_typeT)))
lats.append(lats_t[x])
lons.append(lons_t[x])
return lons, lats
#mpl.rc('text', usetex=True)
m=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-110, llcrnrlat=73,urcrnrlon=10, urcrnrlat=72)
rawdatapath='../../../DATA/'
figpath='./Figures/'
xpts_all=[]
ypts_all=[]
lonsT, latsT = ro.calc_icebridge_flights('2015FALL',rawdatapath, 'GR')
xptsT, yptsT=m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
Bscatdataoutpath='../../BitBucket/backscatter/Data_output/'
year1=2015
year2=2015
day1=280
day2=300
day1str='%03d' %day1
day2str='%03d' %day2
lons=load(Bscatdataoutpath+'lonsA')
lats=load(Bscatdataoutpath+'latsA')
xpts, ypts = m(lons, lats)
image_mean=load(Bscatdataoutpath+'A'+str(year1)+str(year2)+'-'+day1str+'-'+day2str)
llcrnrlat=58,
urcrnrlon=10,
urcrnrlat=72)
rawdatapath = '../../../DATA/'
figpath = './Figures/'
startYear = 2009
endYear = 2016
numYears = endYear - startYear + 1
xpts_all = []
ypts_all = []
for year in xrange(startYear, endYear + 1, 1):
print year
lonsT, latsT = ro.calc_icebridge_flights(year, rawdatapath, 'GR')
xptsT, yptsT = m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
Bscatdataoutpath = '../../BitBucket/backscatter/Data_output/'
year1 = 2009
year2 = 2015
day1 = 80
day2 = 110
day1str = '%03d' % day1
day2str = '%03d' % day2
lons = load(Bscatdataoutpath + 'lonsA')
lats = load(Bscatdataoutpath + 'latsA')
xpts, ypts = m(lons, lats)
rcParams['axes.labelsize'] = 8
rcParams['xtick.labelsize'] = 8
rcParams['ytick.labelsize'] = 8
rcParams['legend.fontsize'] = 8
rcParams['font.size'] = 9
rcParams['axes.linewidth'] = .5
rcParams['lines.linewidth'] = .5
rcParams['patch.linewidth'] = .5
#rcParams['patch.linewidth'] = .5
rc('font', **{'family': 'sans-serif', 'sans-serif': ['Arial']})
#rc('font',**{'family':'sans-serif','sans-serif':['Arial']})
#my_cmap=ro.perceptual_colormap("Linear_L", '../../../DATA/OTHER/CMAPS/', reverse=1)
my_cmap = ro.get_new_cmaps(cmap_str='viridis')
mplot = Basemap(projection='stere',
lat_0=74,
lon_0=-90,
llcrnrlon=-150,
llcrnrlat=58,
urcrnrlon=10,
urcrnrlat=72)
mib = pyproj.Proj("+init=EPSG:3413")
lonlatBC = [-170., -120., 69., 79.]
lonlatCA = [-150., 10., 81., 90.]
xptsBC, yptsBC = ro.get_box_xy(mplot, lonlatBC)
xptsCA, yptsCA = ro.get_box_xy(mplot, lonlatCA)
def plot_6plot_thresh(dms_plot=0):
minvalD = 0
maxvalD = 255
sizex = np.amax(xT) - np.amin(xT)
sizey = np.amax(yT) - np.amin(yT)
ratio = sizey / sizex
minvalL = 0
if (found_ridges == 1):
elevation2d_ridge_comp = ma.compressed(elevation2d_ridge_maL)
maxvalL = np.round(np.percentile(elevation2d_ridge_comp, 99),
decimals=1)
else:
maxvalL = min_ridge_height
lowerp = 5
upperp = 99.5
minval = np.round(np.percentile(elevation_ma, lowerp), decimals=1)
maxval = np.round(np.percentile(elevation_ma, upperp), decimals=1)
res = 2
#dms_plot=0
textwidth = 5.5
fig = figure(figsize=(textwidth, textwidth * 1.25 * ratio))
ax1 = subplot(321)
ax1.annotate('(a) Raw DMS',
xy=(0.03, 0.9),
textcoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
if (dms_plot == 1):
im1 = pcolormesh(xT[::res, ::res],
yT[::res, ::res],
dms[::res, ::res],
vmin=minvalD,
vmax=maxvalD,
cmap=cm.gist_gray,
rasterized=True)
ax2 = subplot(322)
ax2.annotate('(b) Raw DMS + ATM',
xy=(0.03, 0.9),
textcoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
if (dms_plot == 1):
im2 = pcolormesh(xT[::res, ::res],
yT[::res, ::res],
dms[::res, ::res],
vmin=minvalD,
vmax=maxvalD,
cmap=cm.gist_gray,
rasterized=True)
im21 = scatter(xatm,
yatm,
c=elevation_ma,
vmin=minval,
vmax=maxval,
s=1,
lw=0,
cmap=cm.RdYlBu_r,
rasterized=True)
ax3 = subplot(323)
xe = [i for i in xrange(100)]
ye = [np.percentile(elevation_ma, i) for i in xrange(100)]
im3 = plot(xe, ye, 'k')
mid_percent = (pint * min_index) + (pwidth / 2)
low_percent = (pint * min_index)
up_percent = (pint * min_index) + pwidth
#axhline(y=level_elev, xmin=0, xmax=mid_percent, color='b')
axhline(y=level_elev, linestyle='--', color='b')
axhline(thresh, color='r')
ax3.annotate('Elevation threshold',
xy=(10, thresh),
xycoords='data',
color='r',
horizontalalignment='left',
verticalalignment='bottom')
ax3.annotate('Level ice (' + str(low_percent) + '-' + str(up_percent) +
'%)',
xy=(10, level_elev),
xycoords='data',
color='b',
horizontalalignment='left',
verticalalignment='top')
xlim([0, 100])
ax3.annotate('(c) Elevation distribution',
xy=(0.03, 0.9),
xycoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
ax3.annotate(str(min_ridge_height) + ' m',
xy=(mid_percent - 15,
level_elevl + (thresh - level_elevu) * 0.5),
color='k',
horizontalalignment='left',
verticalalignment='bottom')
#ax4.annotate('(d)' , xy=(0.03, 0.93), textcoords='axes fraction', color='k', horizontalalignment='middle', verticalalignment='middle')
ax3.set_ylim(np.amin(ye), np.amax(ye))
norm = ro.MidpointNormalize(midpoint=0)
ax4 = subplot(324)
ax4.annotate('(d) Gridded (' + str(xy_res) + ' m) ATM',
xy=(0.03, 0.9),
textcoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
im4 = pcolormesh(xx2d,
yy2d,
elevation2d - level_elev,
norm=norm,
vmin=minvalEL,
vmax=maxvalEL,
cmap=cm.RdBu_r)
#
im4.set_clim(minvalEL, maxvalEL)
im41 = contour(xx2d,
yy2d,
level_ice,
levels=[np.amin(level_ice),
np.amax(level_ice)],
colors='k',
linewidths=0.5)
#cs.set_clim(50, 210)
ax5 = subplot(325)
ax5.annotate('(e) High topography (>0.2 m)',
xy=(0.03, 0.9),
textcoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
#im3 = pcolormesh(xx2d, yy2d, level_ice, vmin = minvalL, vmax = maxvalL, cmap = cm.RdYlBu_r)
if (found_ridges == 1):
im31 = pcolormesh(xx2d,
yy2d,
elevation2d_ridge_maL,
vmin=minvalL,
vmax=maxvalL,
cmap=cm.RdYlBu_r)
im51 = contour(xx2d,
yy2d,
label_im,
np.arange(0, num_ridges + 1),
colors='k',
linewidths=1)
ax6 = subplot(326)
ax6.annotate(r'(f) Unique features',
xy=(0.03, 0.9),
textcoords='axes fraction',
color='k',
horizontalalignment='middle',
verticalalignment='middle')
if (found_big_ridge == 1):
minvalLAB = 0
maxvalLAB = np.amax(label_im)
label_im_ma = ma.masked_where(label_im < 0.5, label_im)
im6 = pcolormesh(xx2d,
yy2d,
label_im_ma,
vmin=minvalLAB,
vmax=maxvalLAB,
cmap=my_cmap)
im61 = plot(ridge_stats[:, 0],
ridge_stats[:, 1],
marker='o',
markersize=2,
linestyle='None',
color='k')
#for i in xrange(ridge_stats.shape[0]):
# im62 = plot([ridge_stats[i, 0]-2*ridge_stats[i, 2], ridge_stats[i, 0]+2*ridge_stats[i, 2]], [ridge_stats[i, 1]-2*ridge_stats[i, 3], ridge_stats[i, 1]+2*ridge_stats[i, 3]], marker='None', linestyle = '-', color='k')
ax3.set_xlabel('Percentile (%)', labelpad=1)
ax3.set_ylabel('Relative elevation (m)', labelpad=1)
axesname = ['ax1', 'ax2', 'ax3', 'ax4', 'ax5', 'ax6']
for plotnum in [0, 1, 3, 4, 5]:
vars()[axesname[plotnum]].set_xlim(np.amin(xT), np.amax(xT))
vars()[axesname[plotnum]].set_ylim(np.amin(yT), np.amax(yT))
for plotnum in [0, 4, 5]:
vars()[axesname[plotnum]].set_xlabel('y (m)', labelpad=1)
for plotnum in [0, 3, 4]:
vars()[axesname[plotnum]].set_ylabel('x (m)', labelpad=1)
for plotnum in xrange(6):
vars()[axesname[plotnum]].yaxis.grid(True)
vars()[axesname[plotnum]].xaxis.grid(True)
letters = ['(a)', '(b)', '(c)', '(d)', '(e)', '(f)']
#for plotnum in xrange(6):
fig.text(
0.15, 0.98, 'DMS Date: ' + date + ' DMS Time: ' + dms_time + ' ' +
latDMS_str + 'N, ' + lonDMS_str + 'E')
cax = fig.add_axes([0.58, 0.71, 0.02, 0.08])
cbar = colorbar(im21,
cax=cax,
orientation='vertical',
extend='both',
use_gridspec=True)
cbar.set_label('Elevation to \n WGS84 (m)', labelpad=28, rotation=0)
xticks1 = np.linspace(minval, maxval, 3)
cbar.set_ticks(xticks1)
cax1 = fig.add_axes([0.58, 0.4, 0.02, 0.08])
cbar1 = colorbar(im4,
cax=cax1,
orientation='vertical',
extend='max',
use_gridspec=True)
cbar1.set_label('Elevation to \n level ice (m)', labelpad=28, rotation=0)
xticksL = np.linspace(minvalEL, maxvalEL, 4)
cbar1.set_ticks(xticksL)
cax2 = fig.add_axes([0.1, 0.08, 0.02, 0.08])
cbar2 = colorbar(im31,
cax=cax2,
orientation='vertical',
extend='max',
use_gridspec=True)
cbar2.set_label('Elevation to \n level ice (m)', labelpad=30, rotation=0)
xticks2 = np.linspace(minvalL, maxvalL, 3)
cbar2.set_ticks(xticks2)
if (found_big_ridge == 1):
cax3 = fig.add_axes([0.58, 0.08, 0.02, 0.08])
cbar3 = colorbar(im6,
cax=cax3,
orientation='vertical',
extend='neither',
use_gridspec=True)
cbar3.set_label('Feature\nidentifier', labelpad=20, rotation=0)
xticks2 = np.linspace(minvalLAB, maxvalLAB, 2)
cbar3.set_ticks(xticks2)
cbar3.solids.set_rasterized(True)
cbar.solids.set_rasterized(True)
cbar1.solids.set_rasterized(True)
cbar2.solids.set_rasterized(True)
im4.cmap.set_under('w')
#plt.tight_layout()
print 'Saving figure...'
subplots_adjust(bottom=0.07, left=0.09, top=0.96, right=0.98, hspace=0.22)
savefig(figpath + 'figure3.png', dpi=300)
import os
#-------------- GET IB Projection ------------------
mplot = Basemap(projection='stere',
lat_0=74,
lon_0=-90,
llcrnrlon=-150,
llcrnrlat=58,
urcrnrlon=10,
urcrnrlat=72)
rawdatapath = '../../../DATA/'
figpath = './Figures/'
my_cmap = ro.perceptual_colormap("Linear_L",
rawdatapath + 'OTHER/CMAPS/',
reverse=1)
coast_file = Dataset(rawdatapath + '/OTHER/distance-to-coast_2m.nc', 'r')
lat_c = coast_file.variables['lat'][:]
lon_c = coast_file.variables['lon'][:]
z_c = coast_file.variables['z'][:]
#REMOVE SOME OF THE COAST DISTANCE DATA THAT ISN'T NEEDED
lat_c = lat_c[4250:-1]
lon_c = lon_c[::20]
z_c = z_c[4250:-1, ::20]
xpts_c, ypts_c = mplot(*np.meshgrid(lon_c, lat_c))
lonlatBC = [-170., -120., 69., 79.]
#mpl.rc('text', usetex=True)
#m=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
m=Basemap(projection='stere', lat_0=-74, lon_0=-100,llcrnrlon=-50, llcrnrlat=-50,urcrnrlon=-200, urcrnrlat=-65)
rawdatapath='../../../DATA/'
figpath='./Figures/'
startYear=2009
endYear=2014
numYears=endYear-startYear+1
xpts_all=[]
ypts_all=[]
for year in xrange(startYear, endYear+1, 1):
print year
lonsT, latsT = ro.calc_icebridge_flights(year,rawdatapath, 'AN')
xptsT, yptsT=m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
etopo=Dataset(rawdatapath+'/OTHER/etopo5.nc', 'r')
topo = etopo.variables['topo'][::2, ::2]
topo_lon = etopo.variables['topo_lon'][::2]
topo_lat = etopo.variables['topo_lat'][::2]
xptsTopo, yptsTopo= m(*np.meshgrid(topo_lon, topo_lat))
lats_k, lons_k, snow_k, ice_k = ro.calc_kurtz('fall', rawdatapath)
xptsK, yptsK=m(lons_k, lats_k)
axvline(x=level_elevl, linestyle='--', color='r')
axvline(x=level_elevu, linestyle='--', color='r')
ax.set_ylabel('Prob Density', labelpad=1)
ax.set_xlabel('Relative elevation (m)', labelpad=1)
tight_layout()
savefig(figpath+'atm_dmsdist_'+str(xy_res)+'mxy_'+date+'_'+dms_time+int_method+str(int(min_ridge_height*100))+'_cm2.png', dpi=300)
datapath='./Data_output/'
rawdatapath = '../../../DATA/ICEBRIDGE/'
ATM_path = rawdatapath+'/ATM/ARCTIC/'
dms_path = rawdatapath+'/DMS/'
posAV_path =rawdatapath+'/POSAV/'
figpath='./Figures/'
my_cmap=ro.perceptual_colormap("cube1", '../../../DATA/OTHER/CMAPS/', reverse=1)
norm = ro.MidpointNormalize(midpoint=0)
xy_res=2
pwidth=20
pint=5
min_ridge_size=100
dms_image = 1
min_ridge_height = .2
minvalEL=-1
maxvalEL=1
sh=0
def get_hist_allyears(region, type):
hist = []
bins = []
if (region == 0):
region_lonlat = [-150, 10, 81, 90]
region_str = 'CA'
if (region == 1):
region_lonlat = [-170, -120, 69, 79]
region_str = 'BC'
varALL = []
for year in xrange(start_year, end_year + 1):
print year
xptsT, yptsT, lonT, latT, sail_area_fracT, ridge_heightT, ice_volumeT = ro.get_bulk_ridge_stats(
mib, mplot, year, datapath, areavollonlat=1)
if (bulk_type == 0):
varT = np.copy(sail_area_fracT)
elif (bulk_type == 1):
varT = np.copy(ice_volumeT)
elif (bulk_type == 2):
varT = np.copy(ridge_heightT)
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsT, yptsT),
method='nearest')
ice_type, xptsA, yptsA = ro.get_mean_ice_type(mplot,
rawdatapath,
year,
res=1)
ice_typeR = griddata((xptsA.flatten(), yptsA.flatten()),
ice_type.flatten(), (xptsT, yptsT),
method='nearest')
if (type == 0):
mask = where((ice_typeR < 1.1) & (ice_typeR > 0.4)
& (lonT > region_lonlat[0])
& (lonT < region_lonlat[1])
& (latT > region_lonlat[2])
& (latT < region_lonlat[3]) & (region_maskR == 8))
if (type == 1):
mask = where((ice_typeR < 0.6) & (ice_typeR > 0.4)
& (lonT > region_lonlat[0])
& (lonT < region_lonlat[1])
& (latT > region_lonlat[2])
& (latT < region_lonlat[3]) & (region_maskR == 8))
if (type == 2):
mask = where((ice_typeR < 1.1) & (ice_typeR > 0.9)
& (lonT > region_lonlat[0])
& (lonT < region_lonlat[1])
& (latT > region_lonlat[2])
& (latT < region_lonlat[3]) & (region_maskR == 8))
varT = varT[mask]
varALL.extend(varT)
histT, binsT = np.histogram(varALL, bins=bin_vals)
meanH = mean(varALL)
medianH = median(varALL)
stdH = std(varALL)
modeH = binsT[argmax(histT)] + bin_width / 2.
#hist.append(histT)
#bins.append(binsT)
return binsT, histT, meanH, medianH, modeH, stdH
from glob import glob
rcParams['axes.labelsize'] =10
rcParams['xtick.labelsize']=10
rcParams['ytick.labelsize']=10
rcParams['legend.fontsize']=10
rcParams['font.size']=10
rc('font',**{'family':'sans-serif','sans-serif':['Arial']})
#mpl.rc('text', usetex=True)
m=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
rawdatapath='../../../DATA/'
figpath='./Figures/'
xptsW, yptsW, xvel, yvel, wind_speed = ro.get_era_winds(m, rawdatapath, 2009, 2014, 0, 3, 75)
xpts_all=[]
ypts_all=[]
for year in xrange(2009, 2014+1, 1):
print year
lonsT, latsT = ro.calc_icebridge_flights(year,rawdatapath, 'GR')
xptsT, yptsT=m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
#xpts_all, ypts_all = ro.calc_icebridge_flights_years(m,2009,2014, 'GR')
#xpts_type, ypts_type, ice_type_mean, ice_type, latsT = get_mean_icetype(m, 1)
urcrnrlon=10,
urcrnrlat=72)
#-------------- IB Projection------------------
mib = pyproj.Proj("+init=EPSG:3413")
thresh = 20
plot_max = 1
fadd = ''
ftype = '1km_xyres2m_' + str(thresh) + 'cm' + fadd
print 'file path', ftype
print 'plot type:', plot_max
figpath = './Figures/'
datapath = './Data_output/' + ftype + '/'
rawdatapath = '../../../DATA/'
my_cmap = ro.perceptual_colormap("Linear_L",
rawdatapath + '/OTHER/CMAPS/',
reverse=1)
xpts = []
ypts = []
levpercent = []
for year in xrange(2009, 2015):
#BIG IS IN TERMS OF AREA - WHERE WE REMOVE RIDGES LESS THAN 100m2
xptsT, yptsT, levpercentT = ro.get_bulk_ridge_stats(mib,
mplot,
year,
datapath,
getlevpercent=1)
xpts.append(xptsT)
ypts.append(yptsT)
levpercent.append(levpercentT)
elif (stats_found==0):
#a = ma.masked_all((0))
#masked_val = mean(a)
return [mean_x, mean_y, -999, 0,-999, -999, -999, -999, mean_alt, mean_pitch, mean_roll, mean_vel, num_pts_section, stats_found]
#-------------- ATM AND DMS PATHS------------------
datapath='./Data_output/'
rawdatapath = '../../../DATA/'
IBrawdatapath = rawdatapath+'/ICEBRIDGE/'
ATM_path = IBrawdatapath+'/ATM/ARCTIC/'
dms_path = IBrawdatapath+'/DMS/'
posAV_path =IBrawdatapath+'/POSAV/SEA_ICE/GR/'
figpath='./Figures/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
m=pyproj.Proj("+init=EPSG:3413")
calc_atm_stats=1
min_ridge_height = 0.2
pint=5
pwidth = 20
along_track_res=1000
pts_threshold=18000*(along_track_res/1000)
xy_res=2
num_points_req = 100/(xy_res**2)
rcParams['font.size']=9
rc('font',**{'family':'sans-serif','sans-serif':['Arial']})
mplot = Basemap(projection='npstere',boundinglat=66,lon_0=0, resolution='l' )
mplot2=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
thresh=20
fadd=''
ftype='1km_xyres2m_'+str(thresh)+'cm'+fadd
datapath = './Data_output/'+ftype+'/'
avefilepath=datapath+'/CORRELATIONS/INDY/'
figpath = './Figures/'
rawdatapath='../../../DATA/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
year=2015
mean_height_years = load(avefilepath+'/Sailheightave_10km_'+str(year)+'.txt')
mean_thicknessIBR_years = load(avefilepath+'/IBthickness_10km_'+str(year)+'.txt')
#mean_snowIBR_years.append(load(savepath+'/IBsnow_10km_'+str(year)+'.txt'))
xpts_matchT = load(avefilepath+'/xpts_10km_'+str(year)+'.txt')
ypts_matchT = load(avefilepath+'/ypts_10km_'+str(year)+'.txt')
lonT, latT=mplot(xpts_matchT, ypts_matchT, inverse=True)
xpts_match, ypts_match = mplot2(lonT, latT)
ice_typeT, xpts_type, ypts_type = ro.get_mean_ice_type(mplot2, rawdatapath, year, res=1)
from mpl_toolkits.axes_grid.inset_locator import mark_inset
from mpl_toolkits.axes_grid.anchored_artists import AnchoredSizeBar
from netCDF4 import Dataset
from matplotlib import rc
from glob import glob
from scipy.interpolate import griddata
import os
#-------------- GET IB Projection ------------------
mplot=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
rawdatapath='../../../DATA/'
figpath = './Figures/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'OTHER/CMAPS/', reverse=1)
coast_file = Dataset(rawdatapath+'/OTHER/distance-to-coast_2m.nc','r')
lat_c = coast_file.variables['lat'][:]
lon_c = coast_file.variables['lon'][:]
z_c = coast_file.variables['z'][:]
#REMOVE SOME OF THE COAST DISTANCE DATA THAT ISN'T NEEDED
lat_c=lat_c[4250:-1]
lon_c=lon_c[::20]
z_c=z_c[4250:-1, ::20]
xpts_c, ypts_c = mplot(*np.meshgrid(lon_c, lat_c))
lonlatBC = [-170., -120., 69., 79.]
def correlate_sails_IB(addsnow):
mean_heightALL = []
thicknessALL = []
thickness_uncIBALL = []
xpts_matchALL = []
ypts_matchALL = []
trend_years = []
intercept_years = []
r_years = []
prob_years = []
stderr_years = []
p_coef_years = []
thickness_years = []
height_years = []
for year in xrange(start_year, end_year + 1):
print year
#mean_xpts, mean_ypts, mean_height = running_mean(xptsT, yptsT, max_heightT, window)
mean_xpts, mean_ypts, mean_height = calc_mean_height_dist(year)
xptsIB, yptsIB, latsIB, lonsIB, thicknessIB, thickness_uncIB, snowIB = read_icebridge_uncALL(
mplot, rawdatapath, year, mask_hi=1, mask_nonarctic=1)
mean_xptsIB, mean_yptsIB, mean_thicknessIB = running_mean(
xptsIB, yptsIB, thicknessIB, window)
mean_xptsIB, mean_yptsIB, mean_thickness_uncIB = running_mean(
xptsIB, yptsIB, thickness_uncIB, window)
mean_thicknessIBR = griddata((mean_xptsIB, mean_yptsIB),
mean_thicknessIB, (mean_xpts, mean_ypts),
method='nearest',
rescale=True)
mean_thicknessIBR = griddata((mean_xptsIB, mean_yptsIB),
mean_thicknessIB, (mean_xpts, mean_ypts),
method='nearest',
rescale=True)
mean_thicknessIBR = kdtree_clean1D(mean_xpts, mean_ypts, mean_xptsIB,
mean_yptsIB, mean_thicknessIBR,
kdtree_radius)
#REMOVE LOW gridded thickness VALS
mean_thicknessIBR[where(mean_thicknessIBR < 0)] = np.nan
mean_xpts[where(mean_thicknessIBR < 0)] = np.nan
mean_ypts[where(mean_thicknessIBR < 0)] = np.nan
#FIND WHERE BOTH HAVE DATA
match_data = where(~(np.isnan(mean_thicknessIBR + mean_height)))
xpts_match = mean_xpts[match_data]
ypts_match = mean_ypts[match_data]
mean_thicknessIBR_match = mean_thicknessIBR[match_data]
mean_height_match = mean_height[match_data]
xpts_match.dump(savepath + '/xpts_10km_' + str(year) + region_str +
'.txt')
ypts_match.dump(savepath + '/ypts_10km_' + str(year) + region_str +
'.txt')
mean_height_match.dump(savepath + '/Sailheightave_10km_' + str(year) +
region_str + '.txt')
mean_thicknessIBR_match.dump(savepath + '/IBthickness_10km_' +
str(year) + region_str + '.txt')
if (addsnow == 1):
mean_xptsIBSNOW, mean_yptsIBSNOW, mean_snowIB = ro.running_mean(
xptsIB, yptsIB, snowIB, window)
mean_snowIBR = griddata((mean_xptsIB, mean_yptsIB),
mean_snowIB, (mean_xpts, mean_ypts),
method='nearest',
rescale=True)
mean_snowIBR = kdtree_clean1D(mean_xpts, mean_ypts, mean_xptsIB,
mean_yptsIB, mean_snowIBR,
kdtree_radius)
#mean_snowIBR[where(np.isnan(mean_thicknessIBR))] = np.nan
mean_snowIBR_match = mean_snowIBR[match_data]
mean_height_match = mean_height_match + mean_snowIBR_match
mean_snowIBR_match.dump(savepath + '/IBsnow_10km_' + str(year) +
region_str + '.txt')
p = optimization.curve_fit(func, mean_thicknessIBR_match,
mean_height_match, [1.])
trendT, interceptT, rT, probT, stderrT = stats.linregress(
p[0][0] * sqrt(mean_thicknessIBR_match), mean_height_match)
p_coef_years.append(p[0][0])
trend_years.append(trendT)
intercept_years.append(interceptT)
r_years.append(rT)
prob_years.append(probT)
stderr_years.append(stderrT)
thickness_years.append(mean_thicknessIBR_match)
height_years.append(mean_height_match)
xpts_matchALL.extend(xpts_match)
ypts_matchALL.extend(ypts_match)
mean_heightALL.extend(mean_height_match)
thicknessALL.extend(mean_thicknessIBR_match)
thickness_uncIBALL.extend(mean_thickness_uncIB)
thicknesses = [np.mean(thickness_years[x]) for x in xrange(num_years)]
heights = [np.mean(height_years[x]) for x in xrange(num_years)]
pALL = optimization.curve_fit(func, thicknessALL, mean_heightALL, [1.])
trend2, intercept2, r2, prob2, stderr2 = stats.linregress(
pALL[0][0] * sqrt(thicknessALL), mean_heightALL)
return mean_heightALL, thicknessALL, thickness_years, height_years, r_years, r2, pALL[
0][0], p_coef_years[0:6], thickness_uncIBALL
thresh = 20
plot_max = 1
fadd = ''
ftype1 = '1km_xyres2m_' + str(20) + 'cm' + fadd
ftype2 = '1km_xyres2m_' + str(80) + 'cm' + fadd
datapath = './Data_output/'
figpath = './Figures/'
rawdatapath = '../../../DATA/'
xpts = []
ypts = []
height = []
aspect = []
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
year = 2012
xptsT1, yptsT1, aspectT1 = return_aspect(year, ftype1)
xptsT2, yptsT2, aspectT2 = return_aspect(year, ftype2)
ridge_var = aspect
minval = 1
maxval = 4
label_str = 'Aspect ratio'
out_var = 'aspect_ratio'
ice_typeT, xpts_type, ypts_type = ro.get_mean_ice_type(mplot,
rawdatapath,
year,
def calc_mean_height_dist2d(year):
mean_xptsB = []
mean_yptsB = []
mean_heightsR = []
mean_dists = []
sect_dists = []
ice_areaBs = []
lengthR2s = []
#READ IN YEAR DATA BULK/INDY/COVARS
xptsBT, yptsBT, swath_areaBT, num_labelsBT, sail_areaBT, sail_heightBT, sect_numBT, numptsBT = ro.get_bulk_ridge_stats(
mib, mplot, year, datapath2D, section=1)
xptsRT, yptsRT, lonRT, latRT, max_heightRT, sizeRT, sect_numRT = ro.get_indy_mean_max_height(
mib, mplot, year, datapath2D, lonlat_section=1)
c00T, c01T, c10T, c11T, sect_numRT2 = ro.get_indy_covar(year, datapath2D)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),
region_mask.flatten(), (xptsRT, yptsRT),
method='nearest')
mask = where((region_maskR == 8) & (max_heightRT < 10) & (sizeRT > 10))
print size(xptsBT)
print size(xptsRT)
print size(mask)
xptsRT = xptsRT[mask]
yptsRT = yptsRT[mask]
max_heightRT = max_heightRT[mask]
sizeRT = sizeRT[mask]
sect_numRT = sect_numRT[mask]
c00T = c00T[mask]
c01T = c01T[mask]
c10T = c10T[mask]
c11T = c11T[mask]
#CHECK BODMAS
l1T = (c00T + c11T - np.sqrt((c00T + c11T)**2.0 - 4 *
(c00T * c11T - c01T**2.0))) / 2.0
l2T = (c00T + c11T + np.sqrt((c00T + c11T)**2.0 - 4 *
(c00T * c11T - c01T**2.0))) / 2.0
theta = 0.5 * 180.0 / np.pi * np.arctan2(2 * c01T, c00T - c11T)
l1T[where(l1T == 0)] = 1
print 'L', l1T[where(l1T == 0)]
#if (l1T==0):
# print l1T, l2T
b = (2. / sqrt(np.pi)) * np.sqrt((dx**2) * sizeRT * np.sqrt(l2T / l1T))
#set inf b values to one (normally where the feature is very small and only 1 pixel in one direction)
print 'b', size(b[where(np.isnan(b))]), size(b)
print 'l2T', l2T[where(np.isnan(b))]
print 'l1T', l1T[where(np.isnan(b))]
print 'sizeRT', sizeRT[where(np.isnan(b))]
for i in xrange(sect_numBT[0], sect_numBT[-1] - num_kms, num_kms):
sect1 = i
sect2 = sect1 + num_kms
#BULK
sect_idxsB = where((sect_numBT >= sect1) & (sect_numBT < sect2))[0]
if (size(sect_idxsB) >= num_gd_sections):
sect_dist = sqrt(
(xptsBT[sect_idxsB[-1]] - xptsBT[sect_idxsB[0]])**2 +
(yptsBT[sect_idxsB[-1]] - yptsBT[sect_idxsB[0]])**2)
sect_dists.append(sect_dist)
if (sect_dist < num_kms * 1100):
#sails_areaB = sum(sail_areaBT[sect_idxsB])
ice_areaB = sum(swath_areaBT[sect_idxsB])
sect_idxsI = where((sect_numRT >= sect1)
& (sect_numRT < sect2))[0]
#DECIDE WHAT TO DO ABOUT NUMBER OF RIDGES NEEDED
if (size(sect_idxsI) >= 2):
#print sect_idxsI
sails_areaR = sum(sizeRT[sect_idxsI]) * (dx**2)
lengthR2 = sum(b[sect_idxsI])
#theta_b = sum(b[sect_idxsI]*theta[sect_idxsI])
#mean_theta = theta_b/lengthR2
mean_heightR = mean(max_heightRT[sect_idxsI])
#height_sizeWR = sum(max_heightRT[sect_idxsI]*sizeRT[sect_idxsI]**(dx**2))
#mean_heightWR = height_sizeWR/sails_areaR
mean_dist = (np.pi * 0.5 * ice_areaB) / lengthR2
if (mean_dist > 1000):
mean_dist = 1000.
#min_spacings = ro.shot_spacing(xptsRT[sect_idxsI], yptsRT[sect_idxsI], out_min_only=1)
#mean_dist3=mean(min_spacings)
#MAYBE MASK IF NAN - PROBS NO RIDGES TO CALCULATE DIST
#mean_distance1T(i)=3.1415*0.5*ice_areaB/length_ridges1
mean_heightsR.append(mean_heightR)
#mean_heightsWR.append(mean_heightWR)
ice_areaBs.append(b[sect_idxsI])
lengthR2s.append(lengthR2)
mean_dists.append(mean_dist)
mean_xptsB.append(mean(xptsBT[sect_idxsB]))
mean_yptsB.append(mean(yptsBT[sect_idxsB]))
#mean_dists3.append(mean(min_spacings))
#else:
# mean_heightsR.append(np.nan)
#mean_heightsWR.append(np.nan)
# mean_dists2.append(np.nan)
#mean_dists3.append(np.nan)
return array(mean_xptsB), array(mean_yptsB), array(mean_heightsR), array(
mean_dists), array(ice_areaBs), b
mplot=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
#-------------- IB Projection------------------
mib=pyproj.Proj("+init=EPSG:3413")
thresh=20
plot_max=1
fadd = ''
ftype='1km_xyres2m_'+str(thresh)+'cm'+fadd
print 'file path', ftype
print 'plot type:', plot_max
figpath = './Figures/'
datapath='./Data_output/'+ftype+'/'
rawdatapath='../../../DATA/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
xpts=[]
ypts=[]
levpercent=[]
for year in xrange(2009, 2015):
#BIG IS IN TERMS OF AREA - WHERE WE REMOVE RIDGES LESS THAN 100m2
xptsT, yptsT, levpercentT = ro.get_bulk_ridge_stats(mib, mplot, year, datapath, getlevpercent=1)
xpts.append(xptsT)
ypts.append(yptsT)
levpercent.append(levpercentT)
label_str='Level ice elevation percenitle (%)'
out_str='lev_percent'
minval=20
maxval=50
tight_layout()
savefig(figpath + 'atm_dmsdist_' + str(xy_res) + 'mxy_' + date + '_' +
dms_time + int_method + str(int(min_ridge_height * 100)) +
'_cm2.png',
dpi=300)
datapath = './Data_output/'
rawdatapath = '../../../DATA/ICEBRIDGE/'
ATM_path = rawdatapath + '/ATM/ARCTIC/'
dms_path = rawdatapath + '/DMS/'
posAV_path = rawdatapath + '/POSAV/'
figpath = './Figures/'
my_cmap = ro.perceptual_colormap("cube1",
'../../../DATA/OTHER/CMAPS/',
reverse=1)
norm = ro.MidpointNormalize(midpoint=0)
xy_res = 2
pwidth = 20
pint = 5
min_ridge_size = 100
dms_image = 1
min_ridge_height = .2
minvalEL = -1
maxvalEL = 1
sh = 0
thresh=20
plot_max=1
fadd = ''
ftype='1km_xyres2m_'+str(thresh)+'cm'+fadd
print 'file path', ftype
print 'plot type:', plot_max
#plot_area=0
#ftype='1km_xyres2m_40cm'
figpath = './Figures/'
datapath='./Data_output/'+ftype+'/'
rawdatapath='../../../DATA/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
#--------------------------------------------------
#-------------- GET DMS Projection ------------------
mib=pyproj.Proj("+init=EPSG:3413")
xpts=[]
ypts=[]
height=[]
max_height=[]
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
for year in xrange(2009, 2015):
matplotlib.use("AGG")
# basemap import
from mpl_toolkits.basemap import Basemap, shiftgrid
# Numpy import
import numpy as np
import mpl_toolkits.basemap.pyproj as pyproj
from pylab import *
import IB_functions as ro
import numpy.ma as ma
from scipy.interpolate import griddata
import os
from glob import glob
#mpl.cm.register_cmap(name='cubehelix1', data=mpl._cm.cubehelix(gamma=1.0, s=1.5, r=-1.0, h=1.5))
#my_cmap=apy.perceptual_colormap("Linear_L", reverse=1)
viridis = ro.get_new_cmaps(cmap_str='viridis')
def get_pos_AV(datapath, year, pole_str='GR'):
posAVpath = datapath + '/ICEBRIDGE/POSAV/SEA_ICE/' + pole_str + '/' + str(
year) + '_' + pole_str + '_NASA/'
#files = glob()
files = glob(posAVpath + '/*.txt')
print year, size(files)
time = []
lats = []
lons = []
alt = []
vel = []
pitch = []
roll = []
def correlate_sails_IB(addsnow): mean_heightALL=[] thicknessALL=[] thickness_uncIBALL=[] xpts_matchALL=[] ypts_matchALL=[] trend_years=[] intercept_years=[] r_years=[] prob_years=[] stderr_years=[] p_coef_years=[] thickness_years=[] height_years=[] for year in xrange(start_year, end_year+1): print year #mean_xpts, mean_ypts, mean_height = running_mean(xptsT, yptsT, max_heightT, window) mean_xpts, mean_ypts, mean_height = calc_mean_height_dist(year) xptsIB, yptsIB, latsIB,lonsIB,thicknessIB, thickness_uncIB,snowIB= read_icebridge_uncALL(mplot, rawdatapath, year, mask_hi=1, mask_nonarctic=1) mean_xptsIB, mean_yptsIB, mean_thicknessIB = running_mean(xptsIB, yptsIB, thicknessIB, window) mean_xptsIB, mean_yptsIB, mean_thickness_uncIB = running_mean(xptsIB, yptsIB, thickness_uncIB, window) mean_thicknessIBR = griddata((mean_xptsIB, mean_yptsIB),mean_thicknessIB, (mean_xpts, mean_ypts), method='nearest', rescale=True) mean_thicknessIBR = griddata((mean_xptsIB, mean_yptsIB),mean_thicknessIB, (mean_xpts, mean_ypts), method='nearest', rescale=True) mean_thicknessIBR = kdtree_clean1D(mean_xpts, mean_ypts, mean_xptsIB, mean_yptsIB, mean_thicknessIBR, kdtree_radius) #REMOVE LOW gridded thickness VALS mean_thicknessIBR[where(mean_thicknessIBR<0)] = np.nan mean_xpts[where(mean_thicknessIBR<0)] = np.nan mean_ypts[where(mean_thicknessIBR<0)] = np.nan #FIND WHERE BOTH HAVE DATA match_data = where(~(np.isnan(mean_thicknessIBR+mean_height))) xpts_match = mean_xpts[match_data] ypts_match = mean_ypts[match_data] mean_thicknessIBR_match=mean_thicknessIBR[match_data] mean_height_match=mean_height[match_data] xpts_match.dump(savepath+'/xpts_10km_'+str(year)+region_str+'.txt') ypts_match.dump(savepath+'/ypts_10km_'+str(year)+region_str+'.txt') mean_height_match.dump(savepath+'/Sailheightave_10km_'+str(year)+region_str+'.txt') mean_thicknessIBR_match.dump(savepath+'/IBthickness_10km_'+str(year)+region_str+'.txt') if (addsnow==1): mean_xptsIBSNOW, mean_yptsIBSNOW, mean_snowIB = ro.running_mean(xptsIB, yptsIB, snowIB, window) mean_snowIBR = griddata((mean_xptsIB, mean_yptsIB),mean_snowIB, (mean_xpts, mean_ypts), method='nearest', rescale=True) mean_snowIBR = kdtree_clean1D(mean_xpts, mean_ypts, mean_xptsIB, mean_yptsIB, mean_snowIBR, kdtree_radius) #mean_snowIBR[where(np.isnan(mean_thicknessIBR))] = np.nan mean_snowIBR_match=mean_snowIBR[match_data] mean_height_match = mean_height_match+mean_snowIBR_match mean_snowIBR_match.dump(savepath+'/IBsnow_10km_'+str(year)+region_str+'.txt') p= optimization.curve_fit(func, mean_thicknessIBR_match, mean_height_match, [1.]) trendT, interceptT, rT, probT, stderrT = stats.linregress(p[0][0]*sqrt(mean_thicknessIBR_match), mean_height_match) p_coef_years.append(p[0][0]) trend_years.append(trendT) intercept_years.append(interceptT) r_years.append(rT) prob_years.append(probT) stderr_years.append(stderrT) thickness_years.append(mean_thicknessIBR_match) height_years.append(mean_height_match) xpts_matchALL.extend(xpts_match) ypts_matchALL.extend(ypts_match) mean_heightALL.extend(mean_height_match) thicknessALL.extend(mean_thicknessIBR_match) thickness_uncIBALL.extend(mean_thickness_uncIB) thicknesses = [np.mean(thickness_years[x]) for x in xrange(num_years)] heights = [np.mean(height_years[x]) for x in xrange(num_years)] pALL= optimization.curve_fit(func, thicknessALL, mean_heightALL, [1.]) trend2, intercept2, r2, prob2, stderr2 = stats.linregress(pALL[0][0]*sqrt(thicknessALL), mean_heightALL) return mean_heightALL, thicknessALL, thickness_years, height_years, r_years, r2, pALL[0][0], p_coef_years[0:6], thickness_uncIBALL
#mpl.rc('text', usetex=True)
m=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
rawdatapath='../../../DATA/'
figpath='./Figures/'
startYear=2009
endYear=2016
numYears=endYear-startYear+1
xpts_all=[]
ypts_all=[]
for year in xrange(startYear, endYear+1, 1):
print year
lonsT, latsT = ro.calc_icebridge_flights(year,rawdatapath, 'GR')
xptsT, yptsT=m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
ice_type=[]
for year in xrange(startYear, 2014+1):
ice_typeT, xpts_type, ypts_type = ro.get_mean_ice_type(m, rawdatapath, year, res=1, extrapolate=0)
ice_type.append(ice_typeT)
ice_type_meanT=np.mean(ice_type, axis=0)
ice_type_mean=np.copy(ice_type_meanT)
ice_type_mean[where(ice_type_meanT>0.9)]=0.75
ice_type_mean[where((ice_type_meanT<0.9) & (ice_type_meanT>0.6))]=0.5
ice_type_mean[where((ice_type_meanT<0.6) & (ice_type_meanT>0.4))]=0.25
#mask open water
ice_type_mean=ma.masked_where(ice_type_mean<0.25, ice_type_mean)
print 'Num points req', num_points_req
ftype = str(int(
along_track_res / 1000)) + 'km_xyres' + str(xy_res) + 'm_' + str(
int(min_ridge_height * 100)) + 'cm'
outpath = datapath + ftype + '/'
for year in xrange(start_year, end_year + 1):
print year
ATM_year = ATM_path + str(year) + '/'
atm_files_year = glob(ATM_year + '/*/')
#for days in xrange():
for days in xrange(size(atm_files_year)):
atm_path_date = atm_files_year[days]
print 'ATM day:', atm_path_date
atm_files_in_day = ro.get_atm_files(atm_path_date, year)
#load POS file
posAV = loadtxt(posAV_path + str(year) + '_GR_NASA/sbet_' +
str(atm_path_date[-9:-1]) + '.out.txt',
skiprows=1)
#GET POSITION OF PLANE AND 1km MARKERS FROM POSAV
xp, yp, dist, km_idxs, km_utc_times = ro.get_pos_sections(
posAV, m, along_track_res)
for atm_file in xrange(size(atm_files_in_day)):
ridge_statsALL = np.array([]).reshape(7, 0)
print 'ATM file:', atm_files_in_day[atm_file], str(
atm_file) + '/' + str(size(atm_files_in_day))
lonT, latT, elevationT, utc_timeT, aziT = ro.get_atmqih5(
atm_files_in_day[atm_file], year, res=1, utc_time=1, azi_out=1)
#IF SIZE OF DATA IS LESS THAN SOME THRESHOLD THEN DONT BOTHER ANALYZING
# basemap import
from mpl_toolkits.basemap import Basemap, shiftgrid
# Numpy import
import numpy as np
import mpl_toolkits.basemap.pyproj as pyproj
from pylab import *
import IB_functions as ro
import numpy.ma as ma
from scipy.interpolate import griddata
import os
from glob import glob
# mpl.cm.register_cmap(name='cubehelix1', data=mpl._cm.cubehelix(gamma=1.0, s=1.5, r=-1.0, h=1.5))
# my_cmap=apy.perceptual_colormap("Linear_L", reverse=1)
viridis = ro.get_new_cmaps(cmap_str="viridis")
def get_pos_AV(datapath, year, pole_str="GR"):
posAVpath = datapath + "/ICEBRIDGE/POSAV/SEA_ICE/" + pole_str + "/" + str(year) + "_" + pole_str + "_NASA/"
# files = glob()
files = glob(posAVpath + "/*.txt")
print year, size(files)
time = []
lats = []
lons = []
alt = []
vel = []
pitch = []
roll = []
flines = []
outpath = datapath1D + 'ATMO/'
rawdatapath = '../../../../DATA/'
if not os.path.exists(outpath):
os.makedirs(outpath)
#--------------------------------------------------
num_kms = 10
num_gd_sections = 0.3 * num_kms
dx = 2
start_year = 2009
end_year = 2015
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
for year in xrange(start_year, end_year + 1, 1):
print year
mean_xptsB, mean_yptsB, mean_heightsR, mean_dists = calc_mean_height_dist1d(
year)
Cd = 1000 * ((0.185 + 0.147 * mean_heightsR) / np.pi) * (
mean_heightsR / mean_dists) * (
(log(mean_heightsR / 0.00001) - 1)**2 + 1) / (log(10 / 0.00001))**2
Intensity = mean_heightsR / mean_dists
mean_xptsB.dump(outpath + 'mean_xptsB' + str(year) + str(num_kms) +
'km_1D.txt')
mean_yptsB.dump(outpath + 'mean_yptsB' + str(year) + str(num_kms) +
'km_1D.txt')
mean_heightsR.dump(outpath + 'mean_heights' + str(year) + str(num_kms) +
print 'Num points req', num_points_req
ftype = str(int(
along_track_res / 1000)) + 'km_xyres' + str(xy_res) + 'm_' + str(
int(min_ridge_height * 100)) + 'cm'
outpath = datapath + ftype + '/'
for year in xrange(start_year, end_year + 1):
ATM_year = ATM_path + str(year) + '/'
atm_files_year = glob(ATM_year + '/*/')
#for days in xrange():
for days in xrange(size(atm_files_year)):
atm_path_date = atm_files_year[days]
print 'ATM day:', atm_path_date
atm_files_in_day = ro.get_atm_files(atm_path_date, year)
#load POS file
posAV = loadtxt(posAV_path + str(year) + '_GR_NASA/sbet_' +
str(atm_path_date[-9:-1]) + '.out.txt',
skiprows=1)
#GET POSITION OF PLANE AND 1km MARKERS FROM POSAV
xp, yp, dist, km_idxs, km_utc_times = ro.get_pos_sections(
posAV, m, along_track_res)
for atm_file in xrange(size(atm_files_in_day)):
atm_statsALL = np.array([]).reshape(0, 3)
ridge_statsALL = np.array([]).reshape(0, 9)
covarALL = np.array([]).reshape(0, 5)
bulk_statsALL = np.array([]).reshape(0, 18)
print 'ATM file:', atm_files_in_day[atm_file], str(
atm_file) + '/' + str(size(atm_files_in_day))
mean_pitch, mean_roll, mean_vel, num_pts_section, stats_found
]
#-------------- ATM AND DMS PATHS------------------
datapath = './Data_output/'
rawdatapath = '../../../DATA/'
IBrawdatapath = rawdatapath + '/ICEBRIDGE/'
ATM_path = IBrawdatapath + '/ATM/ARCTIC/'
dms_path = IBrawdatapath + '/DMS/'
posAV_path = IBrawdatapath + '/POSAV/SEA_ICE/GR/'
figpath = './Figures/'
my_cmap = ro.perceptual_colormap("Linear_L",
rawdatapath + '/OTHER/CMAPS/',
reverse=1)
m = pyproj.Proj("+init=EPSG:3413")
calc_atm_stats = 1
min_ridge_height = 0.2
pint = 5
pwidth = 20
along_track_res = 1000
pts_threshold = 18000 * (along_track_res / 1000)
xy_res = 2
num_points_req = 100 / (xy_res**2)
year = 2011
#-------------- IB Projection ------------------
mib = pyproj.Proj("+init=EPSG:3413")
thresh = 20
fadd = ''
ftype = '1km_xyres2m_' + str(thresh) + 'cm' + fadd
figpath = './Figures/'
datapath = './Data_output/' + ftype + '/'
rawdatapath = '../../../DATA/'
savepath = datapath + '/CORRELATIONS/INDY/'
if not os.path.exists(savepath):
os.makedirs(savepath)
my_cmap = ro.perceptual_colormap("Linear_L",
rawdatapath + '/OTHER/CMAPS/',
reverse=1)
num_kms = 10
num_gd_sections = 0.3 * num_kms
window = num_kms * 1000
kdtree_radius = 5000
#--------------------------------------------------
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
region = 2
if (region == 0):
region_lonlat = [-150, 10, 81, 90]
region_str = 'CA'
if (region == 1):
import matplotlib
matplotlib.use("AGG")
# basemap import
from mpl_toolkits.basemap import Basemap, shiftgrid
# Numpy import
import numpy as np
import mpl_toolkits.basemap.pyproj as pyproj
from pylab import *
import IB_functions as ro
import numpy.ma as ma
from scipy.interpolate import griddata
import os
from glob import glob
#mpl.cm.register_cmap(name='cubehelix1', data=mpl._cm.cubehelix(gamma=1.0, s=1.5, r=-1.0, h=1.5))
#my_cmap=apy.perceptual_colormap("Linear_L", reverse=1)
viridis=ro.get_new_cmaps(cmap_str='viridis')
def get_pos_AV(datapath, year, pole_str='GR'):
posAVpath = datapath+'/ICEBRIDGE/POSAV/SEA_ICE/'+pole_str+'/'+str(year)+'_'+pole_str+'_NASA/'
#files = glob()
files = glob(posAVpath+'/*.txt')
print year, size(files)
time=[]
lats=[]
lons=[]
alt=[]
vel=[]
pitch=[]
roll=[]
flines=[]
llcrnrlon=-150,
llcrnrlat=58,
urcrnrlon=10,
urcrnrlat=72)
thresh = 20
fadd = ''
ftype = '1km_xyres2m_' + str(thresh) + 'cm' + fadd
datapath = './Data_output/' + ftype + '/'
avefilepath = datapath + '/CORRELATIONS/INDY/'
figpath = './Figures/'
rawdatapath = '../../../DATA/'
my_cmap = ro.perceptual_colormap("Linear_L",
rawdatapath + '/OTHER/CMAPS/',
reverse=1)
year = 2015
mean_height_years = load(avefilepath + '/Sailheightave_10km_' + str(year) +
'.txt')
mean_thicknessIBR_years = load(avefilepath + '/IBthickness_10km_' + str(year) +
'.txt')
#mean_snowIBR_years.append(load(savepath+'/IBsnow_10km_'+str(year)+'.txt'))
xpts_matchT = load(avefilepath + '/xpts_10km_' + str(year) + '.txt')
ypts_matchT = load(avefilepath + '/ypts_10km_' + str(year) + '.txt')
lonT, latT = mplot(xpts_matchT, ypts_matchT, inverse=True)
xpts_match, ypts_match = mplot2(lonT, latT)
ice_typeT, xpts_type, ypts_type = ro.get_mean_ice_type(mplot2,
mib=pyproj.Proj("+init=EPSG:3413")
thresh=20
plot_area=1
fadd = ''
ftype='1km_xyres2m_'+str(thresh)+'cm'+fadd
print 'file path', ftype
print 'plot type:', plot_area
figpath = './Figures/'
datapath='./Data_output/'+ftype+'/'
rawdatapath='../../../DATA/'
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
#-------------------------------------------------
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
xpts=[]
ypts=[]
areafrac=[]
volume=[]
for year in xrange(2009, 2015):
#BIG IS IN TERMS OF AREA - WHERE WE REMOVE RIDGES LESS THAN 100m2
xptsT, yptsT, areafracT, volumeT = ro.get_bulk_ridge_stats(mib, mplot, year, datapath, areavol=1)
region_maskR = griddata((xptsM.flatten(), yptsM.flatten()),region_mask.flatten(), (xptsT, yptsT), method='nearest')
mask = where(region_maskR<11)
xptsT=xptsT[mask]
#mpl.rc('text', usetex=True)
m=Basemap(projection='stere', lat_0=74, lon_0=-90,llcrnrlon=-150, llcrnrlat=58,urcrnrlon=10, urcrnrlat=72)
rawdatapath='../../../DATA/'
figpath='./Figures/'
startYear=2009
endYear=2016
numYears=endYear-startYear+1
xpts_all=[]
ypts_all=[]
for year in xrange(startYear, endYear+1, 1):
print year
lonsT, latsT = ro.calc_icebridge_flights(year,rawdatapath, 'GR')
xptsT, yptsT=m(lonsT, latsT)
xpts_all.append(xptsT)
ypts_all.append(yptsT)
Bscatdataoutpath='../../BitBucket/backscatter/Data_output/'
year1=2009
year2=2015
day1=80
day2=110
day1str='%03d' %day1
day2str='%03d' %day2
lons=load(Bscatdataoutpath+'lonsA')
lats=load(Bscatdataoutpath+'latsA')
mplot = Basemap(projection='npstere',boundinglat=66,lon_0=0, resolution='l' )
#-------------- IB Projection ------------------
mib=pyproj.Proj("+init=EPSG:3413")
thresh=20
fadd=''
ftype='1km_xyres2m_'+str(thresh)+'cm'+fadd
figpath = './Figures/'
datapath = './Data_output/'+ftype+'/'
rawdatapath='../../../DATA/'
savepath=datapath+'/CORRELATIONS/INDY/'
if not os.path.exists(savepath):
os.makedirs(savepath)
my_cmap=ro.perceptual_colormap("Linear_L", rawdatapath+'/OTHER/CMAPS/', reverse=1)
num_kms=10
num_gd_sections=0.3*num_kms
window=num_kms*1000
kdtree_radius=5000
#--------------------------------------------------
region_mask, xptsM, yptsM = ro.get_region_mask(rawdatapath, mplot)
region =2
if (region==0):
region_lonlat = [-150, 10, 81, 90]
region_str='CA'
if (region==1):
