def plot_pixel_phaseHeights(self,row=None,col=None):
self.row = row
self.col = col
self.laserCalFile = self.parent.wave_obs
dataDict=self.laserCalFile.getTimedPacketList(self.row,self.col,timeSpacingCut=self.parent.params['danicas_cut'])
peakHeights=np.asarray(dataDict['peakHeights'])*1.0
## less than 'min_amp' per second average count rate
if dataDict['effIntTime']==0.0 or len(peakHeights)<=(dataDict['effIntTime']*self.parent.params['min_count_rate']):
print 'Not enough data for phase histogram'
raise ValueError
baselines=np.asarray(dataDict['baselines'])*1.0
peakHeights-=baselines
biggest_photon = int(min(peakHeights))
n_inbin,phase_bins=np.histogram(peakHeights,bins=np.abs(biggest_photon),range=(biggest_photon,0))
phase_bins=(phase_bins+(phase_bins[1]-phase_bins[0])/2.0)[:-1]
self.n_inbin = n_inbin
self.phase_bins = phase_bins
try:
last_ind = np.where(n_inbin>self.parent.params['min_amp'])[0][-1]
except IndexError:
last_ind=len(n_inbin)-1
## Cut out all the zeros on the right
self.axes.plot(phase_bins,n_inbin, 'b.',label="data")
self.axes.set_xlim(phase_bins[(np.where(n_inbin >= 3))[0][0]],phase_bins[last_ind])
n_inbin = n_inbin[:last_ind]
phase_bins = phase_bins[:last_ind]
#Check if this pixel is in drift file
waveFN = FileName(obsFile=self.laserCalFile)
driftFile=tables.openFile(waveFN.calDriftInfo(),mode='r')
drift_row = driftFile.root.params_drift.driftparams.cols.pixelrow[:]
drift_col = driftFile.root.params_drift.driftparams.cols.pixelcol[:]
args=(np.where(np.multiply(drift_row==self.row, drift_col==self.col)))[0]
if len(args==1):
#pixel has a solution!
fit_params = driftFile.root.params_drift.driftparams.cols.gaussparams[args[0]]
#print fit_params
model = driftFile.root.params_drift.driftparams.attrs.model_type
model_list = {
'parabola': parabola,
'gaussian': gaussian,
'fourgaussian': fourgaussian,
'threegaussian_exp': threegaussian_exp,
'threegaussian_exppow': threegaussian_exppow,
'threegaussian_moyal': threegaussian_moyal,
'threegaussian_power': threegaussian_power,
'threegaussian_lorentzian': threegaussian_lorentzian}
modelArr=model_list[model](p=fit_params,x=phase_bins,return_models=True)
fullModel=np.zeros(len(n_inbin))
for model_part in modelArr:
fullModel = fullModel+model_part
self.axes.plot(phase_bins,model_part, 'k--')
self.axes.plot(phase_bins,fullModel, 'r-',label="model")
self.axes.legend()
self.axes.set_xlabel("phase")
self.axes.set_ylabel("counts")
self.axes.set_title('('+str(self.col)+', '+str(self.row)+') --> '+(self.laserCalFile.beamImage[self.row,self.col]).rsplit('/',1)[0])
#res_blue = (self.drift.r_blue[self.row,self.col,self.closest_time_ind])
#self.axes.text(0.15,0.95,"R ~ "+str(round(res_blue,3)),verticalalignment='center', horizontalalignment='center', transform=self.axes.transAxes)
#print res_blue
driftFile.close()
return True
def plot_pixel_soln(self,row,col,list_of_fits):
#self.fig, axarr = plt.subplots(2, sharex=True)
#self.axes=axarr[0]
#axes2=axarr[1]
self.fig.delaxes(self.axes)
gs = gridspec.GridSpec(2,1,height_ratios=[4,1])
self.fig.subplots_adjust(hspace=0.,wspace=0.)
self.axes=self.fig.add_subplot(gs[0])
QE_wavelengths = self.parent.QE_data[:,0]
QE_energies = [self.parent.params['h'] * self.parent.params['c'] / (x*10. * self.parent.params['ang2m']) for x in QE_wavelengths]
QE_x_offsets = np.asarray(list_of_fits)[:,1]
waveFN = FileName(obsFile=self.parent.wave_obs)
calFile=tables.openFile(waveFN.calSoln(),mode='r')
pixRow=calFile.root.wavecal.calsoln.cols.pixelrow[:]
pixCol=calFile.root.wavecal.calsoln.cols.pixelcol[:]
cal_ind = np.where((pixRow==row) * (pixCol==col))[0][0]
polyfit=calFile.root.wavecal.calsoln.cols.polyfit[cal_ind]
if np.all(polyfit==-1) and np.all(QE_x_offsets==0):
raise ValueError
calFile.close()
driftFile=tables.openFile(waveFN.calDriftInfo(),mode='r')
drift_row = driftFile.root.params_drift.driftparams.cols.pixelrow[:]
drift_col = driftFile.root.params_drift.driftparams.cols.pixelcol[:]
try:
drift_ind=(np.where(np.multiply(drift_row==row, drift_col==col)))[0][0]
fit_params = driftFile.root.params_drift.driftparams.cols.gaussparams[drift_ind]
cal_x_offsets = fit_params[[1,4,7]]
cal_x_offsets[1]+=cal_x_offsets[0]
cal_x_offsets[2]+=cal_x_offsets[1]
if fit_params[8]==0.:
cal_x_offsets[2]=0.
cal_wavelengths = [self.parent.params['bluelambda'],self.parent.params['redlambda'], self.parent.params['irlambda']] #Angstroms
cal_energies = [self.parent.params['h'] * self.parent.params['c'] / (x * self.parent.params['ang2m']) for x in cal_wavelengths] #eV
except IndexError:
cal_wavelengths = [self.parent.params['bluelambda'],self.parent.params['redlambda'], self.parent.params['irlambda']] #Angstroms
cal_energies = [self.parent.params['h'] * self.parent.params['c'] / (x * self.parent.params['ang2m']) for x in cal_wavelengths] #eV
cal_x_offsets = [0,0,0]
driftFile.close()
xArr = np.arange(-5000.,0.,0.1)
if not np.all(polyfit==-1):
modelArr=(parabola(p=polyfit,x=xArr,return_models=True))[0]
self.axes.plot(xArr,modelArr,'k-')
self.axes.plot(cal_x_offsets,cal_energies,'ko', label='Laser Cal')
self.axes.plot(QE_x_offsets,QE_energies,'gx',label='QE wavelength fits')
#Do linear fit of QE data to see if x-intercept is at 0
QE_x_offsets = np.asarray(QE_x_offsets)
QE_energies = np.asarray(QE_energies)
energies = (QE_energies[np.where(QE_x_offsets<0)])
sort_ind = np.argsort(energies)
energies = energies[sort_ind]
x_offsets = QE_x_offsets[np.where(QE_x_offsets<0)]
x_offsets = x_offsets[sort_ind]
if len(x_offsets)>1:
parameter_guess = [0.0,(energies[0]-energies[-1])*1.0/(x_offsets[0]-x_offsets[-1]), 0.]
parameter_lowerlimit=[None,None,0.]
parameter_upperlimit=[None,None,0.]
parameter_fit, redchi2gauss2, mpperr = fitData(x_offsets,energies,parameter_guess,parameter_lowerlimit,parameter_upperlimit,model='parabola')
print 'x_intercept: '+str(-1.*parameter_fit[0]/parameter_fit[1])
else:
print 'x_intercept: Not enough data'
#lin_fit=(parabola(p=parameter_fit,x=xArr,return_models=True))[0]
#self.axes.plot(xArr,lin_fit,'g--')
#Do parabola fit to QE data
if len(x_offsets)>1:
parameter_guess = [0.0,(energies[0]-energies[-1])*1.0/(x_offsets[0]-x_offsets[-1]), 0.]
parameter_lowerlimit=[None,None,None]
parameter_upperlimit=[None,None,None]
parameter_fit, redchi2gauss2, mpperr = fitData(x_offsets,energies,parameter_guess,parameter_lowerlimit,parameter_upperlimit,model='parabola')
print polyfit,' --> ',parameter_fit
parab_fit=(parabola(p=parameter_fit,x=xArr,return_models=True))[0]
self.axes.plot(xArr,parab_fit,'g--')
#Plot Residuals
if not np.all(polyfit==-1):
cal_QE=(parabola(p=polyfit,x=x_offsets,return_models=True))[0]
axes2=self.fig.add_subplot(gs[1],sharex=self.axes)
#axes2 = self.fig.add_axes((.1,.1,.8,.2))
axes2.plot(x_offsets,cal_QE-energies,'.')
axes2.axhline(0,color='black')
#Add labels etc
self.axes.set_ylabel('Energy (eV)')
self.axes.set_xlim(min(min(cal_x_offsets),min(QE_x_offsets))-200.,0.)
self.axes.set_ylim(0.,5.)
if not np.all(polyfit==-1):
axes2.set_xlabel('Phase (ADC/DAC units)')
axes2.set_ylabel('Calibration residuals (eV)')
axes2.set_ylim(-3.,3.)
#self.axes.set_xticklabels(self.axes.get_xticklabels(),visible=False)
plt.setp(self.axes.get_xticklabels(),visible=False)
