# In[11]: plt.figure() plt.plot(star['tau']) # In[11]: plt.figure() plt.plot(star['utc'],star['tau']) # In[13]: star['ref'] = Sp.smooth(star['ref'],20) # In[14]: plt.figure() plt.plot(star['utc'],star['ref'],'x-') # ## Load the important MODIS files # In[12]: myd06_file = fp+'MODIS\\MYD06_L2.A2013050.1725.006.2014260074007.hdf'
iwat = np.argmin(abs(ssfr.tmhrs-twat)) # In[36]: alb = ssfr.nspectra1/ssfr.zspectra1 alb[alb<=0.0] = 0.0 alb[alb>=1.0] = 1.0 alb[np.isnan(alb)] = 0.0 # In[37]: plt.figure() plt.plot(wvl,alb[iwat,:],'b.') plt.plot(wvl,Sp.smooth(alb[iwat,:],6),'r') plt.xlim([350,1700]) plt.ylim([0,1]) plt.ylabel('Albedo') plt.xlabel('Wavelength [nm]') plt.title('Surface albedo, above water UTC: %.4f' % ssfr.tmhrs[iwat]) plt.savefig(fp+'dc8/'+daystr+'_surface_albedo_ice.png',dpi=600,transparent=True) # In[38]: plt.figure() plt.plot(wvl,alb[iice,:],'b.') plt.plot(wvl,Sp.smooth(alb[iice,:],6),'r') plt.xlim([350,1700])
cba.set_label('UTC [h]') plt.ylim(0,1) plt.xlim(340,1750) plt.title('SASZe normalized spectra, Ascension Island, 2016-08-14') plt.xlabel('Wavelength [nm]') plt.ylabel('Normalized Radiance') plt.tight_layout() #plt.plot(lut.wvl,lut.norm[0,:,0,8,20],'k-',lw=3, # label='Modeled, $\\tau$={:2.1f}, r$_{{eff}}$={:2.0f}$\\mu$m'.format(lut.tau[20],lut.ref[8])) plt.plot(lut.wvl,lut.norm[0,:,0,4,16],'-',color='k',lw=3,alpha=0.8, label='Modeled, $\\tau$={:2.1f}, r$_{{eff}}$={:2.0f}$\\mu$m'.format(lut.tau[16],lut.ref[4])) plt.plot(lut.wvl,lut.norm[0,:,0,4,1],'-',color='lightgrey',lw=3,alpha=0.8, label='Modeled, $\\tau$={:2.1f}, r$_{{eff}}$={:2.0f}$\\mu$m'.format(lut.tau[1],lut.ref[4])) plt.legend(handletextpad=0.08,labelspacing=0.05,frameon=True) plt.savefig(fp+'data/SASZe_sample_spectra_with_model.png',dpi=600,transparent=True) # In[184]: fig = sp.plt_zenrad(sr) plt.ylim(0,0.5) #plt.figure() # In[253]: sp.plt_norm_zenrad(sr)
def run_retrieval(meas, model, subp=range(15)): """ Name: run_retrieval Purpose: A function that uses the Sp class to run through each utc point in meas, and finds the closest model values, uses only the subset of parameters defined by subp, which defaults to first 15 parameters Calling Sequence: (ta,re,ph,ki) = run_retrieval(meas,model,subp=range(15)) Input: meas : Sp object (from Sp_parameters) of measurement spectra model: Sp object (from Sp_paramters) of modeled spectra, also considered the look-up-table (lut) object subp: (optional) array of parameters to use for retrieval Output: ta: array of cloud optical thickness re: array of cloud particle effective radius ph: array of cloud thermodynamic phase (ph=0 for liquid, ph=1 for ice) ki: array of minimal ki^2 values Keywords: none Dependencies: Sp_parameters numpy gc: for clearing the garbage run_kisq_retrieval (this file) pdb: for debugging when there is an error Required files: none Example: ... Modification History: Written (v1.0): Samuel LeBlanc, 2014-11-08, NASA Ames """ import Sp_parameters as Sp import numpy as np import run_kisq_retrieval as rk rk.assure_input(meas) rk.assure_input(model) # normalize the parameters pcoef = model.norm_par() meas.norm_par(pcoef=pcoef) # build the measurement error meas.build_std( ) #in future must reference a set of measurements to establishe the uncertainty, right now only white noise at 0.5% meas.stdparn = meas.stdpar / pcoef[ 'coef'] #for creating the normalized version of the stdpar # build the reshaped model for ice and liquid model.reshape_lut(phase='liq') model.reshape_lut(phase='ice') # build the normalized measurement parameters based on liquid or ice values meas.norm_par(pcoef=model.ice.pcoef, vartitle='parn_ice') meas.norm_par(pcoef=model.liq.pcoef, vartitle='parn_liq') # build the weights from the stdparn of measurements wg = np.sqrt(meas.stdpar) / pcoef['coef'] #start loop over measurement Sp.startprogress('Retrieval progress over times') ph = np.zeros_like(meas.utc) * np.nan ki = np.zeros_like(meas.utc) * np.nan ta = np.zeros_like(meas.utc) * np.nan re = np.zeros_like(meas.utc) * np.nan #ki_2ph = np.zeros_like(meas.utc) #kisq with 2 phase for tt in meas.good: try: if np.all(np.isnan(meas.parn[tt, subp])): continue except: import pdb pdb.set_trace() #first get the phase in first method #import pdb; pdb.set_trace() ph[tt] = rk.phase(meas.parn[tt, :].ravel(), model, meas.stdparn) if ph[tt] == 2: # undecided, must do the kisq ki_2ph = np.nansum( wg[subp] * (meas.parn[tt, subp] - model.parn[:, :, :, subp])**2, axis=3) ki_minin = np.unravel_index(np.nanargmin(ki_2ph), ki_2ph.shape) ph[tt] = ki_minin[0] if ph[tt] == 0: #liquid goodpi = [ i for i in subp if (meas.parn_liq[tt, i] + meas.stdparn[i] >= 0) and ( meas.parn_liq[tt, i] - meas.stdparn[i] <= 1) ] if len(goodpi) < 4: continue ki_arr = np.nansum( wg[goodpi] * (meas.parn_liq[tt, goodpi] - model.liq.parn[:, :, goodpi])**2, axis=2) ki[tt] = np.nanmin(ki_arr) #print ki[tt] ki_minin = np.unravel_index(np.nanargmin(ki_arr), ki_arr.shape) (ta[tt], re[tt]) = (model.liq.tau[ki_minin[1]], model.liq.ref[ki_minin[0]]) elif ph[tt] == 1: #ice goodpi = [ i for i in subp if (meas.parn_ice[tt, i] + meas.stdparn[i] >= 0) and ( meas.parn_ice[tt, i] - meas.stdparn[i] <= 1) ] # print goodpi if len(goodpi) < 4: continue ki_arr = np.nansum( wg[goodpi] * (meas.parn_ice[tt, goodpi] - model.ice.parn[:, :, goodpi])**2, axis=2) ki[tt] = np.nanmin(ki_arr) ki_minin = np.unravel_index(np.nanargmin(ki_arr), ki_arr.shape) (ta[tt], re[tt]) = (model.ice.tau[ki_minin[1]], model.ice.ref[ki_minin[0]]) #print ki[tt] else: print('Problem with phase!') return Sp.progress(float(tt) / len(meas.utc) * 100.0) Sp.endprogress() #save the file return (ta, re, ph, ki)
# <codecell> map(lambda x:x*x,[-1,1,24]) # <codecell> reload(Sp) if 'meas' in locals(): del meas import gc; gc.collect() # <codecell> # first convert measurements to Sp class, with inherent parameters defined meas = Sp.Sp(m) meas.params() # <markdowncell> # Plot the parameters for the specified time # <codecell> fig2,ax2 = plt.subplots(5,3,sharex=True,figsize=(15,8)) ax2 = ax2.ravel() for i in range(meas.npar-1): ax2[i].plot(meas.utc,Sp.smooth(meas.par[:,i],3)) ax2[i].set_title('Parameter '+str(i)) ax2[i].grid() ax2[i].set_xlim([17,19])
try: ccn[i] = recarray_to_dict(ccn[i]) except: pass ccn[i]['alt'] = nearest_neighbor(hsk[i]['Start_UTC'],hsk[i]['GPS_Altitude'],ccn[i]['UTC_mid'],dist=1.0/3600.0) # ## Check out AMS data # In[185]: plt.figure() cs = ['r','g','b','k','c','y'] for i,d in enumerate(days): #plt.plot(ams[i]['UTC_mid'],ams[i]['Org_STP'],'x',color=cs[i],label=d,alpha=0.3) plt.plot(ams[i]['UTC_mid'],Sp.smooth(ams[i]['Org_STP'],16),'-',color=cs[i],alpha=0.6,label=d) plt.legend(frameon=False) plt.xlabel('UTC') plt.ylabel('Org_STP') # In[210]: plt.figure() plt.plot(ams[2]['UTC_mid'],Sp.smooth(ams[2]['Org_STP'],14)) plt.plot(ams[2]['UTC_mid'],Sp.smooth(ams[2]['SO4_STP'],14),'-g') plt.plot(ams[2]['UTC_mid'],Sp.smooth(ams[2]['Chl_STP'],14),'-c') plt.plot(star[2]['Start_UTC'],star[2]['COD']/200.0,'xk') plt.plot(star[2]['Start_UTC'],star[2]['REF']/100.0,'+r') plt.xlim(15,15.8)
def plot_vert_hist(fig,ax1,y,pos,ylim,color='grey',label=None,legend=False,onlyhist=True,loc=2,bins=30,alpha=0.5): """ Purpose: function to plot a 'bean' like vertical histogram Input: fig: figure object for reference and plotting ax1: axis object to plot on y: values to be plotted in histogram fashion pos: position along axis to create the bean plot ylim: range of plotted axis [min,max] color: (default to grey) color of the plotted histogram label: (default to none) if included, the label for the color squares of this histogram legend: (default to False) If True adds a legend on the location onlyhist: (default to True) only plots the histogram bean, not the mean and median lines loc: (default to 2) location of the legend bins: (default to 30) number of bins to plot alpha: (defautl to 0.5) value of transparency (0 to 1) Output: only the histogram plot on top of an existing plot Dependencies: - numpy - Sp_parameters - plotting_utils : this file Required files: None Modification History: Written: Samuel LeBlanc, NASA Ames Modified: Samuel LeBlanc, NASA Ames in Santa Cruz, 2015-12-09 - added comments - added the bins keyword to be used Modified: Samuel LeBlanc, NASA Ames in Santa Cruz, 2015-12-12 - added alpha keyword """ import Sp_parameters as Sp import numpy as np from plotting_utils import data2figpoints (ymask,iy) = Sp.nanmasked(y) ax = fig.add_axes(data2figpoints(pos,0.4,fig=fig,ax1=ax1),frameon=False,ylim=ylim) ax.tick_params(axis='both', which='both', labelleft='off', labelright='off',bottom='off',top='off', labelbottom='off',labeltop='off',right='off',left='off') ax.hist(ymask,orientation='horizontal',normed=True,color=color,edgecolor='None',bins=bins,alpha=alpha,label=label,range=ylim) if onlyhist: label_mean = None label_median = None else: label_mean = 'Mean' label_median = 'Median' ax.axhline(np.mean(ymask),color='red',linewidth=2,label=label_mean) ax.axhline(np.median(ymask),color='k',linewidth=2,linestyle='--',label=label_median) if legend: ax.legend(frameon=False,loc=loc) ax = fig.add_axes(data2figpoints(pos+0.01,-0.4,fig=fig,ax1=ax1),frameon=False,ylim=ylim) ax.tick_params(axis='both', which='both', labelleft='off', labelright='off',bottom='off',top='off', labelbottom='off',labeltop='off',right='off',left='off') ax.hist(ymask,orientation='horizontal',normed=True,color=color,edgecolor='None',bins=bins,alpha=alpha,range=ylim) ax.axhline(np.mean(ymask),color='red',linewidth=2) ax.axhline(np.median(ymask),color='k',linewidth=2,linestyle='--')
print 'sp (wp, wvl, z, re, ta)' # create custom key for sorting via wavelength iwvls = np.argsort(s.zenlambda) s.wv = np.sort(s.zenlambda) # <codecell> if 'Sp' in locals(): reload(Sp) if 'lut' in locals(): del lut import gc; gc.collect() # <codecell> lut = Sp.Sp(s,irrad=True) lut.params() lut.param_hires() # <codecell> lut.sp_hires() # <codecell> print lut.tau.shape print lut.ref.shape print lut.sp.ndim print lut.par.size print lut.par.shape print lut.ref
def run_retrieval(meas,model,subp=range(15)): """ Name: run_retrieval Purpose: A function that uses the Sp class to run through each utc point in meas, and finds the closest model values, uses only the subset of parameters defined by subp, which defaults to first 15 parameters Calling Sequence: (ta,re,ph,ki) = run_retrieval(meas,model,subp=range(15)) Input: meas : Sp object (from Sp_parameters) of measurement spectra model: Sp object (from Sp_paramters) of modeled spectra, also considered the look-up-table (lut) object subp: (optional) array of parameters to use for retrieval Output: ta: array of cloud optical thickness re: array of cloud particle effective radius ph: array of cloud thermodynamic phase (ph=0 for liquid, ph=1 for ice) ki: array of minimal ki^2 values Keywords: none Dependencies: Sp_parameters numpy gc: for clearing the garbage run_kisq_retrieval (this file) pdb: for debugging when there is an error Required files: none Example: ... Modification History: Written (v1.0): Samuel LeBlanc, 2014-11-08, NASA Ames """ import Sp_parameters as Sp import numpy as np import run_kisq_retrieval as rk rk.assure_input(meas) rk.assure_input(model) # normalize the parameters pcoef = model.norm_par() meas.norm_par(pcoef=pcoef) # build the measurement error meas.build_std() #in future must reference a set of measurements to establishe the uncertainty, right now only white noise at 0.5% meas.stdparn = meas.stdpar/pcoef['coef'] #for creating the normalized version of the stdpar # build the reshaped model for ice and liquid model.reshape_lut(phase='liq') model.reshape_lut(phase='ice') # build the normalized measurement parameters based on liquid or ice values meas.norm_par(pcoef=model.ice.pcoef,vartitle='parn_ice') meas.norm_par(pcoef=model.liq.pcoef,vartitle='parn_liq') # build the weights from the stdparn of measurements wg = np.sqrt(meas.stdpar)/pcoef['coef'] #start loop over measurement Sp.startprogress('Retrieval progress over times') ph = np.zeros_like(meas.utc)*np.nan ki = np.zeros_like(meas.utc)*np.nan ta = np.zeros_like(meas.utc)*np.nan re = np.zeros_like(meas.utc)*np.nan #ki_2ph = np.zeros_like(meas.utc) #kisq with 2 phase for tt in meas.good: try: if np.all(np.isnan(meas.parn[tt,subp])): continue except: import pdb; pdb.set_trace() #first get the phase in first method #import pdb; pdb.set_trace() ph[tt] = rk.phase(meas.parn[tt,:].ravel(),model,meas.stdparn) if ph[tt] == 2: # undecided, must do the kisq ki_2ph = np.nansum(wg[subp]*(meas.parn[tt,subp]-model.parn[:,:,:,subp])**2,axis=3) ki_minin = np.unravel_index(np.nanargmin(ki_2ph),ki_2ph.shape) ph[tt] = ki_minin[0] if ph[tt] == 0: #liquid goodpi = [i for i in subp if (meas.parn_liq[tt,i]+meas.stdparn[i]>=0) and (meas.parn_liq[tt,i]-meas.stdparn[i]<=1)] if len(goodpi) < 4: continue ki_arr = np.nansum(wg[goodpi]*(meas.parn_liq[tt,goodpi]-model.liq.parn[:,:,goodpi])**2,axis=2) ki[tt] = np.nanmin(ki_arr) #print ki[tt] ki_minin = np.unravel_index(np.nanargmin(ki_arr),ki_arr.shape) (ta[tt],re[tt]) = (model.liq.tau[ki_minin[1]],model.liq.ref[ki_minin[0]]) elif ph[tt] == 1: #ice goodpi = [i for i in subp if (meas.parn_ice[tt,i]+meas.stdparn[i]>=0) and (meas.parn_ice[tt,i]-meas.stdparn[i]<=1)] # print goodpi if len(goodpi) < 4: continue ki_arr = np.nansum(wg[goodpi]*(meas.parn_ice[tt,goodpi]-model.ice.parn[:,:,goodpi])**2,axis=2) ki[tt] = np.nanmin(ki_arr) ki_minin = np.unravel_index(np.nanargmin(ki_arr),ki_arr.shape) (ta[tt],re[tt]) = (model.ice.tau[ki_minin[1]],model.ice.ref[ki_minin[0]]) #print ki[tt] else: print('Problem with phase!') return Sp.progress(float(tt)/len(meas.utc)*100.0) Sp.endprogress() #save the file return (ta,re,ph,ki)
# In[73]: meas = Sp.Sp(m) meas.params() # # Now plot the measurements and luts # ## Plot all measurements # In[85]: pz = Sp.plt_zenrad(meas,good_only=True) # In[86]: pn = Sp.plt_norm_zenrad(meas,good_only=True) # In[87]: pc = Sp.curtain_zenrad(meas) # In[90]:
# In[ ]: print 'Running the parameter calculations on measured spectra' meas = Sp.Sp(mea,verbose=False) meas.params() # ### plot out the different spectra # In[ ]: if not noplot: print('Making plots...') fig1 = Sp.plt_zenrad(meas) fig1.savefig(fp_zencld_plot+'{datestr}_zenrad.png'.format(datestr=datestr), dpi=600,transparent=True) print('zenrad...'), fig1n = Sp.plt_norm_zenrad(meas) fig1n.savefig(fp_zencld_plot+'{datestr}_norm_zenrad.png'.format(datestr=datestr), dpi=600,transparent=True) print('norm zenrad...'), fig2 = Sp.curtain_zenrad(meas,utc=True) fig2.savefig(fp_zencld_plot+'{datestr}_curtain_utc_zenrad.png'.format(datestr=datestr), dpi=600,transparent=True) print('utc curtain zenrad...'), fig2n = Sp.curtain_norm_zenrad(meas,utc=True)
def run_2wvl_retrieval(meas,model,wvls=[500.0,1600.0],sza_norm=True): """ Name: run_2wvl_retrieval Purpose: Retrieves cloud optical properties from reflectance 2 wavelength method (Nakajima & King, 1990) A function that uses the Sp class to run through each utc point in meas, and finds the closest model values. If sza is present then the reflectance is calculated with sza_factor (1/cos(sza)) Calling Sequence: (ta,re,ki) = run_2wvl_retrieval(meas,model,wvls=[500.0,1600.0],sza_norm=True) Input: meas : object with keys of utc (time in fractional hours), Rvis (reflectance in vis), Rnir (reflectance in nir) model: Sp object with irradiance values set Output: ta: 2d array of cloud optical thickness, for [:,0] = liquid, for [:,1] = ice re: 2d array of cloud particle effective radius, for [:,0] = liquid, for [:,1] = ice ki: 2d array of minimal ki^2 values, for [:,0] = liquid, for [:,1] = ice Keywords: wvls: (optional) array of two values with the vis wavlength in first, and nir wavelength in second [nm] sza_norm: (optional) if set to True (default) then searches for sza in meas and model. If there, normalizes meas and model reflectances by 1/cos(sza) Dependencies: Sp_parameters numpy warnings gc: for clearing the garbage run_2wvl_retrieval (this file) pdb: for debugging when there is an error math Required files: none Example: ... Modification History: Written (v1.0): Samuel LeBlanc, 2014-12-08, NASA Ames """ import Sp_parameters as Sp import numpy as np import run_2wvl_retrieval as rw import warnings import math if not model.irrad: warnings.warn('model lut does not have irradiances set! please rerun with irradiances') return if sza_norm & hasattr(meas,'sza'): meas.sza_factor = 1.0/np.cos(np.radians(meas.sza)) else: meas.sza_factor = 1.0 meas.Rvis = meas.Rvis*meas.sza_factor meas.Rnir = meas.Rnir*meas.sza_factor model.lut_2wvl = rw.build_lut_2wvl(model,wvls,sza_norm) #start loop over measurement Sp.startprogress('Retrieval progress over times') ki = np.ndarray((len(meas.utc),2))*np.nan ta = np.ndarray((len(meas.utc),2))*np.nan re = np.ndarray((len(meas.utc),2))*np.nan #make good filter meas.good = np.where((np.isfinite(meas.Rvis)) & (meas.Rvis > 0) & (np.isfinite(meas.Rnir)) & (meas.Rnir > 0))[0] for tt in meas.good: for ph in [0,1]: ki_ref_tau = ((meas.Rvis[tt]-model.lut_2wvl[ph,0,:,:])/meas.Rvis[tt])**2+((meas.Rnir[tt]-model.lut_2wvl[ph,1,:,:])/meas.Rnir[tt])**2 try: ki_minin = np.unravel_index(np.nanargmin(ki_ref_tau),ki_ref_tau.shape) except: import pdb; pdb.set_trace() ki[tt,ph] = np.nanmin(ki_ref_tau) (ta[tt,ph],re[tt,ph]) = (model.tau[ki_minin[1]],model.ref[ki_minin[0]]) # if (ph == 1) & (meas.utc[tt] > 18.4): # import pdb; pdb.set_trace() Sp.progress(float(tt)/len(meas.utc)*100.0) Sp.endprogress() return (ta,re,ki)