def backgroundAnalysis(): output = open('/home/kingrice/ARCONS-pipeline/examples/crabN/CrabStack_phaseWvl.pkl', 'rb') results = pickle.load(output) vim = results['vim'] #pulls out the dictionary containing all of the relevant information for virtual image object #this is the info included in the dictionary: ob = RADecImage() ob.phaseEdges = vim['phase'] ob.wvlEdges = vim['wvl'] ob.gridDec = vim['Dec'] ob.gridRA = vim['RA'] ob.image = vim['Im'] ob.effIntTimes = vim['effIntT'] ob.totExpTime = vim['totExpT'] ob.expTimeWeights = vim['timeWeights'] ob.vExpTimesStack = vim['vTimeStacks'] ob.imageIsLoaded = vim['loaded'] output.close() ob.display(DDArr = True) #sums across the wavlength and phase dimension to get a 2D image for the display. mpl.show() ''' Here is the fir4st step in the analysis. We want to obtain a sky subtracted spectrum for lets say 5 different scenarios where the same aperture is used but six different anuli are used in addition to the original annulus. This should be no problem. ''' spectrumOG, skySubtractionOG, innerApOG, skyMaskOG, wvlBinEdgesOG, apAreaOG, anAreaOG = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000770, degrees=True) #OG spectrumT1, skySubtractionT1, innerApT1, skyMaskT1, wvlBinEdgesT1, apAreaT1, anAreaT1 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6301176, radDec=22.0143848, radius3=.000770) #T1 spectrumT2, skySubtractionT2, innerApT2, skyMaskT2, wvlBinEdgesT2, apAreaT2, anAreaT2 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6317452, radDec=22.0112381, radius3=.000770) #T2 spectrumT3, skySubtractionT3, innerApT3, skyMaskT3, wvlBinEdgesT3, apAreaT3, anAreaT3 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6338792, radDec=22.0119614, radius3=.000770) #T3 spectrumT4, skySubtractionT4, innerApT4, skyMaskT4, wvlBinEdgesT4, apAreaT4, anAreaT4 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6350004, radDec=22.0135529, radius3=.000770) #T4 spectrumT5, skySubtractionT5, innerApT5, skyMaskT5, wvlBinEdgesT5, apAreaT5, anAreaT5 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6341686, radDec=22.0179293, radius3=.000770) #T5 spectrumT6, skySubtractionT6, innerApT6, skyMaskT6, wvlBinEdgesT6, apAreaT6, anAreaT6 = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000530, degrees=True, offSet=True, radRA=83.6350004, radDec=22.0161571, radius3=.000770) #T6 print 'apArea = ', apAreaOG, ' (arcseconds^2)' print 'anArea = ', anAreaOG, ' (arcseconds^2)' print '---determining wavelengthBin centers---' nWvlBins = len(wvlBinEdgesOG) - 1 wvls = np.empty((nWvlBins), dtype = float) for n in xrange(nWvlBins): binsize = wvlBinEdgesOG[n+1] - wvlBinEdgesOG[n] wvls[n] = (wvlBinEdgesOG[n] + (binsize/2.0)) print '---gathering conversion factors---' c=2.998E18 #Angs/s h=6.626E-27 #erg*s diam = 510.55 #5 meter telescope in centimeters. area = np.pi * ((diam/2.0)**2 -(183/2.0)**2) #secondary obstruction diameter 1.83m print '---dereddening spectra---' #this is where the dereddening happens Alam = (-7.51*np.log10(wvls/10000) + 1.15)*0.52 #find the extinction magnitude for each wavelength bin in terms of magnitude spectrumOG = spectrumOG*10**(Alam/2.5) spectrumT1 = spectrumT1*10**(Alam/2.5) spectrumT2 = spectrumT2*10**(Alam/2.5) spectrumT3 = spectrumT3*10**(Alam/2.5) spectrumT4 = spectrumT4*10**(Alam/2.5) spectrumT5 = spectrumT5*10**(Alam/2.5) spectrumT6 = spectrumT6*10**(Alam/2.5) skySubtractionOG = skySubtractionOG*10**(Alam/2.5) skySubtractionT1 = skySubtractionT1*10**(Alam/2.5) skySubtractionT2 = skySubtractionT2*10**(Alam/2.5) skySubtractionT3 = skySubtractionT3*10**(Alam/2.5) skySubtractionT4 = skySubtractionT4*10**(Alam/2.5) skySubtractionT5 = skySubtractionT5*10**(Alam/2.5) skySubtractionT6 = skySubtractionT6*10**(Alam/2.5) print '---converting flux units to erg/s/cm^2/A---' spectrumOG = spectrumOG*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT1 = spectrumT1*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT2 = spectrumT2*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT3 = spectrumT3*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT4 = spectrumT4*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT5 = spectrumT5*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumT6 = spectrumT6*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionOG = skySubtractionOG*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT1 = skySubtractionT1*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT2 = skySubtractionT2*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT3 = skySubtractionT3*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT4 = skySubtractionT4*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT5 = skySubtractionT5*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionT6 = skySubtractionT6*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) print '---plotting photometry points for comparison---' #photPoints = np.array([17.23,16.66,16.17,15.65]) photPoints = np.array([17.22,16.64,16.14,15.61]) photPointsErr = np.array([.02, .02, .01, .01]) photPointsFlux = np.array([4260.,3640.,3080.,2550.]) #these are in janskys centerWvl = np.array([4400.,5500.,6400.,7900.]) #these are in Angstrom AlamPP = (-7.51*np.log10(centerWvl/10000.) + 1.15)*0.51 photPointsFlux = photPointsFlux*(10**(AlamPP/2.5)) #dereddened photPointsErr = photPointsErr*(10**(AlamPP/2.5)) # 1Jy = 10^-23 erg/sec/cm^2/Hz photPointsFlux = photPointsFlux*(10**-23) #now in units of erg/sec/cm^2/Hz photPointsErr = photPointsErr*(10**-23) photPointsFlux = photPointsFlux*(c/(centerWvl**2)) #now in units of erg/s/cm^2/A photPointsErr = photPointsErr*(c/(centerWvl**2)) ppfFinal = photPointsFlux*(10**(-photPoints/2.5)) #now same units as plot ppEFinal = photPointsErr*(10**(-photPoints/2.5)) image = (ob.image*ob.expTimeWeights) image = np.sum(image, axis = 3) image = np.sum(image, axis = 2) image[np.where(skyMaskOG==0)] = 0 image[np.where(skyMaskT1==0)] = 0 image[np.where(skyMaskT2==0)] = 0 image[np.where(skyMaskT3==0)] = 0 image[np.where(skyMaskT4==0)] = 0 image[np.where(skyMaskT5==0)] = 0 image[np.where(skyMaskT6==0)] = 0 #image[np.where(innerApOG==0)] = 0 #image[np.where(innerApOG==0)] = 0 #image[np.where(innerApOG==0)] = 0 ob.display(image = image) #sums across the wavlength and phase dimension to get a 2D image for the display. mpl.show() mpl.figure(1) mpl.step(wvls, spectrumOG*(10**14), color = 'r', where = 'mid') mpl.step(wvls, spectrumT1*(10**14), color = 'b', where = 'mid') mpl.step(wvls, spectrumT2*(10**14), color = 'g', where = 'mid') mpl.step(wvls, spectrumT3*(10**14), color = 'y', where = 'mid') mpl.step(wvls, spectrumT4*(10**14), color = 'c', where = 'mid') mpl.step(wvls, spectrumT5*(10**14), color = 'k', where = 'mid') mpl.step(wvls, spectrumT6*(10**14), color = 'm', where = 'mid') mpl.plot(centerWvl, ppfFinal*(10**14), 'bo') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.figure(2) mpl.step(wvls, skySubtractionOG*(10**16), color = 'r', where = 'mid') mpl.step(wvls, skySubtractionT1*(10**16), color = 'b', where = 'mid') mpl.step(wvls, skySubtractionT2*(10**16), color = 'g', where = 'mid') mpl.step(wvls, skySubtractionT3*(10**16), color = 'y', where = 'mid') mpl.step(wvls, skySubtractionT4*(10**16), color = 'c', where = 'mid') mpl.step(wvls, skySubtractionT5*(10**16), color = 'k', where = 'mid') mpl.step(wvls, skySubtractionT6*(10**16), color = 'm', where = 'mid') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.show() ############################################################################################################### ''' This next step is to demonstrate the functionality of the getApertureSpectrum when phase is included ''' spectrumAlt, phaseSpectrumAlt, skySubtractionAlt, innerAppAlt, skyMaskAlt, wvlBinEdgesAlt, phaseBinEdgesAlt, apAreaAlt, anAreaAlt = ob.getApertureSpectrum(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, radius2 = .000770, degrees=True, phase = True) skySubtractionAlt = np.sum(skySubtractionAlt, axis = 1) phaseProFileAlt = np.sum(phaseSpectrumAlt, axis = 0) print '---determining wavelengthBin centers---' nWvlBins = len(wvlBinEdgesAlt) - 1 wvls = np.empty((nWvlBins), dtype = float) for n in xrange(nWvlBins): binsize = wvlBinEdgesAlt[n+1] - wvlBinEdgesAlt[n] wvls[n] = (wvlBinEdgesAlt[n] + (binsize/2.0)) print '---determining phase bin centers---' nphaseBins = len(phaseBinEdgesAlt) - 1 phases = np.empty((nphaseBins), dtype = float) for n in xrange(nphaseBins): pbinsize = phaseBinEdgesAlt[n+1]-phaseBinEdgesAlt[n] phases[n] = (phaseBinEdgesAlt[n] + (pbinsize/2.0)) print '---gathering conversion factors---' c=2.998E18 #Angs/s h=6.626E-27 #erg*s diam = 510.55 #5 meter telescope in centimeters. area = np.pi * ((diam/2.0)**2 -(183/2.0)**2) #secondary obstruction diameter 1.83m print '---dereddening spectra---' #this is where the dereddening happens Alam = (-7.51*np.log10(wvls/10000) + 1.15)*0.52 #find the extinction magnitude for each wavelength bin in terms of magnitude spectrumAlt = spectrumAlt*10**(Alam/2.5) skySubtractionAlt = skySubtractionAlt*10**(Alam/2.5) print '---converting flux units to erg/s/cm^2/A---' spectrumAlt = spectrumAlt*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) skySubtractionAlt = skySubtractionAlt*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) mpl.figure(3) mpl.step(wvls, spectrumAlt*(10**14), color = 'r', where = 'mid') mpl.plot(centerWvl, ppfFinal*(10**14), 'bo') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.figure(4) mpl.step(wvls, skySubtractionAlt*(10**16), color = 'r', where = 'mid') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.figure(5) mpl.step(phases, phaseProFileAlt, color = 'k', where = 'mid') mpl.show() ############################################################################################################################# ''' the previous step was to get an idea of how the sky background changes from place to place in the sky. Now we want to compare the off pulse flux to the various sky annuli. In adittion we should now like to plot the off pulse region ''' phaseWvlCount, wvlBinEdges, phaseBinEdges, innerAp, apArea = ob.getAperturePhase(cenRA=83.6330495, cenDec=22.0144933, nPixRA=250, nPixDec=250, radius1=.000530, degrees=True, spectrum = True) print np.shape(phaseWvlCount) phaseProfile = np.sum(phaseWvlCount, axis = 1) phaseProfile = np.sum(phaseProfile, axis = 0) print np.shape(phaseProfile) print '---determining phase bin centers---' nphaseBins = len(phaseBinEdges) - 1 phases = np.empty((nphaseBins), dtype = float) for n in xrange(nphaseBins): pbinsize = phaseBinEdges[n+1]-phaseBinEdges[n] phases[n] = (phaseBinEdges[n] + (pbinsize/2.0)) print np.shape(phases) print '---grouping spectrum by phases---' #spectrumAll = ob.getPhaseSpectrum(countArray=phaseWvlCount, lowLim=0., highLim=1.) #spectrumAll = np.sum(phaseWvlCount, axis = 2) #spectrumAll = np.sum(spectrumAll, axis = 0) #for i in range(len(spectrumAll)): # spectrumAll[i]/=(wvlBinEdges[i+1]-wvlBinEdges[i]) spectrumP = ob.getPhaseSpectrum(countArray=phaseWvlCount, lowLim=.6, highLim=.74) spectrumIP = ob.getPhaseSpectrum(countArray=phaseWvlCount, lowLim=.02, highLim=.16) spectrumNeb1 = ob.getPhaseSpectrum(countArray=phaseWvlCount, lowLim=.4, highLim=.54, background = True, med = True) spectrumNeb2 = ob.getPhaseSpectrum(countArray=phaseWvlCount, lowLim=.4, highLim=.54, background = True) print '---gathering conversion factors---' spectrumAll = np.sum(phaseWvlCount, axis = 2) for i in range(len(spectrumAll)): for j in range(len(spectrumAll[i])): spectrumAll[i][j]/=(wvlBinEdges[j+1]-wvlBinEdges[j]) for i in range(len(spectrumNeb1)): spectrumNeb1[i]/=(wvlBinEdges[i+1]-wvlBinEdges[i]) for i in range(len(spectrumP)): for j in range(len(spectrumP[i])): spectrumP[i][j]/=(wvlBinEdges[j+1]-wvlBinEdges[j]) for i in range(len(spectrumIP)): for j in range(len(spectrumIP[i])): spectrumIP[i][j]/=(wvlBinEdges[j+1]-wvlBinEdges[j]) for i in range(len(spectrumNeb2)): for j in range(len(spectrumNeb2[i])): spectrumNeb2[i][j]/=(wvlBinEdges[j+1]-wvlBinEdges[j]) c=3.00E18 #Angs/s h=6.626E-27 #erg*s diam = 510.55 #5 meter telescope in centimeters. area = np.pi * ((diam/2.0)**2 -(183/2.0)**2) #secondary obstruction diameter 1.83m print '---dereddening spectra---' #this is where the dereddening happens Alam = (-7.51*np.log10(wvls/10000) + 1.15)*0.51 #find the extinction magnitude for each wavelength bin in terms of magnitude spectrumAll = spectrumAll*10**(Alam/2.5) spectrumP = spectrumP*10**(Alam/2.5) #this is specifically for the pulse spectrum spectrumIP = spectrumIP*10**(Alam/2.5) #interpulse spectrum spectrumNeb1 = spectrumNeb1*10**(Alam/2.5) #deadtime betweeen IP and P spectrumNeb2 = spectrumNeb2*10**(Alam/2.5) #deadtime betweeen P and IP print '---converting flux units to erg/s/cm^2/A---' spectrumAll = spectrumAll*(h*c/wvls)*(1./area)*(1./float(ob.totExpTime)) spectrumP = spectrumP*(h*c/wvls)*(1./area)*(50./7.)*(1./float(ob.totExpTime)) spectrumIP = spectrumIP*(h*c/wvls)*(1./area)*(50./7.)*(1./float(ob.totExpTime)) spectrumNeb1 = spectrumNeb1*(h*c/wvls)*(1./area)*(50./7.)*(1./float(ob.totExpTime)) spectrumNeb2 = spectrumNeb2*(h*c/wvls)*(1./area)*(50./7.)*(1./float(ob.totExpTime)) for i in range(len(spectrumAll)): spectrumAll[i] = spectrumAll[i] - spectrumNeb1 #spectrumAllCorr = spectrumAll - spectrumNeb1 #spectrumPCorr = spectrumP - spectrumNeb1 #spectrumIPCorr = spectrumIP - spectrumNeb2 for i in range(len(spectrumP)): spectrumP[i] = spectrumP[i] - spectrumNeb2[i] for i in range(len(spectrumIP)): spectrumIP[i] = spectrumIP[i] -spectrumNeb2[i] spectrumAll = np.sum(spectrumAll, axis = 0) spectrumIP = np.sum(spectrumIP, axis = 0) spectrumP = np.sum(spectrumP, axis = 0) mpl.figure(6) mpl.step(phases, phaseProfile, color = 'k', where = 'mid') mpl.figure(7) mpl.step(wvls, spectrumAll*(10**14), color = 'r', where = 'mid') mpl.step(wvls, spectrumP*(10**14), color = 'b', where = 'mid') mpl.step(wvls, spectrumIP*(10**14), color = 'g', where = 'mid') mpl.plot(centerWvl, ppfFinal*(10**14), 'bo') mpl.errorbar(centerWvl, ppfFinal*(10**14), yerr = ppEFinal*(10**14), fmt = 'k.') mpl.xlim(4000,10000) mpl.ylim(0,2.5) mpl.figure(8) mpl.step(wvls, spectrumNeb1*(10**16), color = 'r', where = 'mid') #mpl.step(wvls, spectrumNeb2*(10**16), color = 'b', where = 'mid') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.figure(9) mpl.step(wvls, spectrumNeb2[0]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[1]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[2]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[3]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[50]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[100]*(10**16), color = 'b', where = 'mid') mpl.step(wvls, spectrumNeb2[-1]*(10**16), color = 'b', where = 'mid') mpl.xlim(4000,10000) mpl.ylim(0,1) mpl.show() ''' Now we apply our Fits ''' spectrumNeb2 = np.sum(spectrumNeb2, axis = 0) print '---determining initial gusses for fit parameters---' x0 = np.array([5.9*10**-15,.2]) #initial guesses for fit paramaters for main pulse x1 = np.array([1.9*10**-15,.2]) #initial guesses for fit paramaters for interPulse x2 = np.array([3.4*10**-15,-.4]) #initial guesses for fit paramaters for nebula #this makes the fit for the various spectra print '---determining fits---' #poptP, pcovP = optimization.curve_fit(func, wvls[15:28], spectrumP[15:28], x0) # main pulse #poptIP, pcovIP = optimization.curve_fit(func, wvls[15:28], spectrumIP[15:28], x1) #interpulse #poptNeb1, pcovNeb1 = optimization.curve_fit(func, wvls[15:28], (spectrumNeb1[15:28]/apArea), x2) # main pulse poptNeb2, pcovNeb2 = optimization.curve_fit(func, wvls[15:28], (spectrumNeb2[15:28]/apArea), x2) #interpulse #poptNebMed, pcovNebMed = optimization.curve_fit(func, wvls, (nebMedian[15:28]/apArea), x2) #interpulse poptP, pcovP = optimization.curve_fit(func, wvls[15:28], spectrumP[15:28], x0) # main pulse poptIP, pcovIP = optimization.curve_fit(func, wvls[15:28], spectrumIP[15:28], x1) #interpulse print 'fit prameters: ' #print poptP #print poptIP #print 'Nebula1/apArea - ', poptNeb1 print 'Nebula2/apArea - ', poptNeb2 #print 'Median Nebula/apArea', poptNebMed print 'Main Pulse - ', poptP print 'Interpulse - ', poptIP #fitP = poptP[0]*(wvls[15:28]/6000)**-(poptP[1]+2) # main pulse #fitIP = poptIP[0]*(wvls[15:28]/6000)**-(poptIP[1]+2) #interpulse #fitNeb1 = poptNeb1[0]*(wvls[15:28]/6000)**-(poptNeb1[1]+2) # nebula fitNeb2 = poptNeb2[0]*(wvls[15:28]/6000)**-(poptNeb2[1]+2) #nebula #fitNebMed = poptNebMed[0]*(wvls/6000)**-(poptNebMed[1]+2) #nebula fitP = poptP[0]*(wvls[15:28]/6000)**-(poptP[1]+2) # main pulse fitIP = poptIP[0]*(wvls[15:28]/6000)**-(poptIP[1]+2) #interpulse print 'wvls[15:28]', wvls[15:28] print 'wvls[12:28]', wvls[12:28] mpl.figure(10) mpl.step(wvls, np.log10(spectrumP), color = 'b', where = 'mid') mpl.step(wvls, np.log10(spectrumIP), color = 'g', where = 'mid') mpl.plot(wvls[15:28], np.log10(fitP), color = 'k') mpl.plot(wvls[15:28], np.log10(fitIP), color = 'k') mpl.xlim(4000,10000) mpl.figure(11) mpl.step(wvls, np.log10(spectrumNeb2/apArea), color = 'b', where = 'mid') mpl.plot(wvls[15:28], np.log10(fitNeb2), color = 'k') mpl.xlim(4000,10000) mpl.show()