def centroidObs(obsPath,centroidPath,centroidRa,centroidDec,haOffset,xGuess,yGuess,savePath,tstamp): obs = ObsFile(obsPath) # if not os.path.exists(hotPath): # hp.findHotPixels(obsFile=obs,outputFileName=hotPath) obs.loadAllCals() # obs.loadHotPixCalFile(hotPath,switchOnMask=True) # obs.loadBestWvlCalFile() # obs.loadFlatCalFile(flatPath) obs.setWvlCutoffs(3000,11000) obs.loadCentroidListFile(centroidPath) ctrdFile = obs.centroidListFile sliceTimes = ctrdFile.root.centroidlist.times.read() xPositions = ctrdFile.root.centroidlist.xPositions.read() yPositions = ctrdFile.root.centroidlist.yPositions.read() intTime = sliceTimes[1]-sliceTimes[0] for iTime,time in enumerate(sliceTimes): x = xPositions[iTime] y = yPositions[iTime] title='centroid_{}_{}s'.format(tstamp,time) imgDict = obs.getPixelCountImage(firstSec=time,integrationTime=intTime,weighted=True) imgPath=os.path.join(savePath,title+'.png') pop = PopUp(showMe=False) pop.plotArray(imgDict['image'],title=title) pop.axes.plot(x,y,color='g',marker='d') pop.fig.savefig(imgPath) print 'saved to',imgPath del obs
bad_solution_mask[y][x] = 1 unix = ob.getFromHeader('unixtime') startJD = unix/86400.+2440587.5 nSecInFile = ob.getFromHeader('exptime') #tic = time() deadMask = ob.getDeadPixels() #print 'Dead mask load time = ', time()-tic for sec in np.arange(0,nSecInFile,integrationTime): jd = startJD + sec/(24.*3600.) + integrationTime/2./(24.*3600.)#add seconds offset to julian date, move jd to center of bin print count,jd count+=1 times.append(jd) titles.append('%.6f'%jd) frameData = ob.getPixelCountImage(firstSec=sec,integrationTime=integrationTime,weighted=True,scaleByEffInt=True) frame = frameData['image'] showFrame = np.array(frame) showframes.append(showFrame) frame[deadMask == 0] = np.nan #frame[bad_solution_mask == 1] = np.nan frames.append(frame) cube = np.dstack(frames) times = np.array(times) np.savez(npzFileName,stack=cube,jd=times) print 'saved' utils.makeMovie(showframes,cbar=True,frameTitles=titles,outName=gifFileName)
def main(): #filenames = ['obs_20121212-033825.h5', fn = FileName(run='PAL2012',date='20121211',tstamp='20121212-055428').obs() ob = ObsFile(fn) frame = ob.getPixelCountImage(0,30,weighted=False) hotPixMask = hotPixels.findHotPixels(image=frame,firstSec=0,intTime=30,weighted=False)['badflag'] frame[hotPixMask == 1] = 0 def plotFrame(fig,axes): hMat=axes.matshow(frame,cmap=matplotlib.cm.gnuplot,origin='lower',vmax=np.mean(frame)+3*np.std(frame)) fig.colorbar(hMat) PopUp(plotFunc=plotFrame) #d = datetime.date(2012,10,15)#date of table value #d2 = datetime.date(2012,12,11)#date of observation #dt=(d2-d).total_seconds()#seconds between obs and table value ##crabtime ephemeris #nu=29.6957720714 #1/us #pdot=4.2013878e-13#us/s #period=(1.0/nu)+pdot*dt#us #goldstone ephemeris F0=29.7414493465249770#Hz deltaF0=0.0000000055983574 F1=-3.669005118205e-10#df0/dt Hz/s F2=-3.085573120457e-20#d^2f0/dt^2 Hz/s^2 pEpoch = 54781.604891 #Modified Julian Date corresponding to F0 pEpoch = pEpoch+2400000.5#convert mjd to jd pEpoch *= 24*3600 #in seconds #obsDate = ob.getFromHeader('jd') unixEpochJD = 2440587.5 unixSecsInDay = 86400. headerUnixtime = ob.getFromHeader('unixtime') obsDate = headerUnixtime/unixSecsInDay+unixEpochJD startTime = obsDate*24*3600#in seconds dt = startTime-pEpoch#seconds since pepoch #freq = F0+F1*dt+F2/2*dt**2 freq = F0+F1*dt period = 1.0/freq print 'period=',period,'s' #period=0.03367660643405371 #period=0.03367664238573182 #period=0.03367662440988317 iRow = 10 iCol = 14 integrationTime = 30 circCol,circRow = circ(iCol,iRow,radius=5) firstSec = 0 dt = startTime-pEpoch + firstSec freq = F0+F1*dt period = 1.0/freq print 'period=',period,'s' nPhaseBins = 200 #np.set_printoptions(threshold=np.nan) jdTimes = np.array([],dtype=np.float64) times = np.array([]) for i in range(len(circCol)): iRow = circRow[i] iCol = circCol[i] timestamps,peaks,baselines = ob.getTimedPacketList(iRow,iCol,firstSec,integrationTime) timestamps = np.array(timestamps,dtype=np.float64) jdTimestamps = obsDate+timestamps /(24.*3600.) jdTimes = np.append(jdTimes,jdTimestamps) times = np.append(times,timestamps) jdTimes -= 2400000.5 #convert to modified jd np.savetxt('crabOpticalSample-20121212-055428.txt',jdTimes) periodDays = period/(24.*3600.) phaseOffset = .2 phases = (jdTimes % periodDays)/periodDays+.2 phases = phases % 1.0 print len(phases) histPhases,phaseBinEdges = np.histogram(phases,bins=nPhaseBins) print jdTimes[0:10] print times[0:10] plt.plot(phaseBinEdges[0:-1],histPhases) plt.show()
class DisplayStack(QMainWindow): def __init__(self): # 0) Start up gui QWidget.__init__(self, parent=None) self.ui = Ui_DisplayStack_gui() self.ui.setupUi(self) # Initialize Variables self.initializeVariables() # Initialize run and target, load param file self.chooseRun() ''' # Browse wavecal button self.ui.wavelengthCalibrationSolutionButton.clicked.connect(self.chooseWavelengthFile) # Browse flatcal button self.ui.flatCalibrationSolutionButton.clicked.connect(self.chooseFlatFile) ''' # Use wavelength calibration checkbox self.ui.wavelengthCalibrationBox.clicked.connect(self.useWaveCal) # Use flat calibration checkbox self.ui.flatCalibrationBox.clicked.connect(self.useFlatCal) # Buttons for obs list creation self.ui.addButton.clicked.connect(self.addObservation) self.ui.removeButton.clicked.connect(self.removeObservation) self.ui.clearButton.clicked.connect(self.createObsList) # Start process button self.ui.stackButton.clicked.connect(self.stackProcess) # Load image stack button self.ui.loadStackButton.clicked.connect(self.chooseStack) # 1) Initialize Variables def initializeVariables(self): # Define path names self.displayStackPath = '/Scratch/DisplayStack/' self.defaultWavelengthPath = '/Scratch/waveCalSolnFiles/' self.defaultFlatPath = '/Scratch/flatCalSolnFiles/' # Arrays with run names and buttons self.runNames = ['LICK2012','PAL2012','PAL2013'] self.runButtons = [self.ui.lick2012Button, self.ui.pal2012Button, self.ui.pal2013Button] # Arrays with target names and buttons self.lick2012TargetNames = ['LICK2012_Object'] self.lick2012TargetButtons = [self.ui.lick2012ObjectButton] self.pal2012TargetNames = ['SDSS_J0651', 'SDSS_J0926'] self.pal2012TargetButtons = [self.ui.sdss0651Button,self.ui.sdss0926Button] self.pal2013TargetNames = ['PAL2013_Object'] self.pal2013TargetButtons = [self.ui.pal2013ObjectButton] self.targetNames = [self.lick2012TargetNames, self.pal2012TargetNames, self.pal2013TargetNames] self.targetButtons = [self.lick2012TargetButtons, self.pal2012TargetButtons, self.pal2013TargetButtons] # Activate run and target buttons for iRun in range(len(self.runButtons)): self.runButtons[iRun].clicked.connect(self.chooseRun) for iTarget in range(len(self.targetButtons[iRun])): self.targetButtons[iRun][iTarget].clicked.connect(self.chooseTarget) self.ui.sunsetList.itemClicked.connect(self.createObsList) def testFunction(self): print 'test' # 2) Choose Run def chooseRun(self): for iRun in range(len(self.runButtons)): for iTarget in range(len(self.targetButtons[iRun])): self.targetButtons[iRun][iTarget].setVisible(False) if self.runButtons[iRun].isChecked(): self.runNumber = iRun for iTarget in range(len(self.targetButtons[iRun])): self.targetButtons[iRun][iTarget].setVisible(True) self.run = self.runNames[self.runNumber] self.targetNumber = 0 self.targetButtons[self.runNumber][self.targetNumber].setChecked(True) self.target = self.targetNames[self.runNumber][self.targetNumber] self.loadParamFile() # 3) Choose Target def chooseTarget(self): for iTarget in range(len(self.targetButtons[self.runNumber])): if self.targetButtons[self.runNumber][iTarget].isChecked(): self.targetNumber = iTarget self.target = self.targetNames[self.runNumber][self.targetNumber] self.loadParamFile() # 4) Load Param File def loadParamFile(self): try: self.paramData = readDict() self.paramData.read_from_file(self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict') self.obsTimes = np.array(self.paramData['obsTimes']) self.utcDates = self.paramData['utcDates'] self.sunsetDates = self.paramData['sunsetDates'] self.calTimestamps = self.paramData['calTimestamps'] self.flatCalDates = self.paramData['flatCalDates'] print 'Loading parameter file at ' + self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict' self.createSunsetList() #self.createObsList() self.createWavelengthList() self.createFlatList() self.paramFileExists = True except IOError: print 'No existing parameter file at ' + self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict' self.ui.sunsetList.clear() self.ui.obsList.clear() self.ui.inputList.clear() self.ui.wavelengthList.clear() self.ui.flatList.clear() self.paramFileExists = False # 5) Choose Obs File # Create list of available sunset dates def createSunsetList(self): self.ui.sunsetList.clear() for iDate in range(len(self.sunsetDates)): self.ui.sunsetList.addItem(self.sunsetDates[iDate]) # Create Initial Obs file list def createObsList(self): self.ui.obsList.clear() self.ui.inputList.clear() self.currentSunsetDate = self.sunsetDates[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] self.currentUTCDate = self.utcDates[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] self.singleDayObservations = self.obsTimes[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] for iObs in range(len(self.singleDayObservations)): self.ui.obsList.addItem(self.singleDayObservations[iObs]) # Add observation to input list def addObservation(self): self.selectedObs = self.ui.obsList.currentItem() self.ui.obsList.takeItem(self.ui.obsList.row(self.selectedObs)) self.ui.inputList.addItem(self.selectedObs) self.ui.inputList.sortItems() # Remove observation from input list def removeObservation(self): self.removedObs = self.ui.inputList.currentItem() self.ui.inputList.takeItem(self.ui.inputList.row(self.removedObs)) self.ui.obsList.addItem(self.removedObs) self.ui.obsList.sortItems() # 6) Load settings def loadSettings(self): self.validSettings = True # Run and target information self.run = self.runNames[self.runNumber] self.target = self.targetNames[self.runNumber][self.targetNumber] # General settings self.integrationTime = int(self.ui.integrationTimeLine.text()) self.useTimeAdjustment = self.ui.timeAdjustmentBox.isChecked() self.useHotPixelMasking = self.ui.hotPixelBox.isChecked() # Wavelength calibration settings self.useWavelengthCalibration = self.ui.wavelengthCalibrationBox.isChecked() self.lowerWavelengthCutoff = float(self.ui.lowerWavelengthCutoffLine.text()) self.upperWavelengthCutoff = float(self.ui.upperWavelengthCutoffLine.text()) # Flat calibration settings self.useFlatCalibration = self.ui.flatCalibrationBox.isChecked() self.useDeadPixelMasking = self.ui.deadPixelBox.isChecked() self.fileCount = self.ui.inputList.count() self.weighted = self.useFlatCalibration self.useRawCounts = not (self.useWavelengthCalibration and self.useFlatCalibration) self.scaleByEffInt = self.useHotPixelMasking if self.ui.sunsetList.currentItem() != None: if self.fileCount == 0: print 'Please select files to process...' self.validSettings = False if self.useWavelengthCalibration: if self.ui.wavelengthList.currentItem() == None: print 'Please select wavelength calibration...' self.validSettings = False else: self.selectedWvlCal = self.ui.wavelengthList.currentItem().text() self.wvlCalFilename = str(FileName(run=self.run,date=self.currentSunsetDate,tstamp=self.selectedWvlCal).calSoln()) if self.useFlatCalibration: if self.ui.flatList.currentItem() == None: print 'Please select flat calibration...' self.validSettings = False else: self.flatCalNight = self.ui.flatList.currentItem().text() self.flatCalFilename = str(FileName(run=self.run,date=self.flatCalNight).flatSoln()) else: print 'Please select sunset night...' self.validSettings = False # 7) Load hot pixel mask def loadHotMask(self): self.hotPixelFilename = str(self.displayStackPath + self.run + '/' + self.target + '/HotPixelMasks/hotPixelMask_' + self.obsTS + '.h5') if not os.path.exists(self.hotPixelFilename): hp.findHotPixels(self.obsFn,self.hotPixelFilename) print "Hot pixel mask saved to %s"%(self.hotPixelFilename) self.ob.loadHotPixCalFile(self.hotPixelFilename,switchOnMask=True) # 8) Create wavelength cal file list def createWavelengthList(self): self.ui.wavelengthList.clear() for iCal in range(len(self.calTimestamps)): self.ui.wavelengthList.addItem(self.calTimestamps[iCal]) # Enable/disable wavecal options def useWaveCal(self): if self.ui.wavelengthCalibrationBox.isChecked(): self.ui.lowerWavelengthCutoffLine.setEnabled(True) self.ui.lowerWavelengthCutoffLabel.setEnabled(True) self.ui.upperWavelengthCutoffLine.setEnabled(True) self.ui.upperWavelengthCutoffLabel.setEnabled(True) self.ui.wavelengthList.setEnabled(True) self.ui.flatCalibrationBox.setEnabled(True) self.ui.flatCalibrationBox.setChecked(True) self.ui.deadPixelBox.setEnabled(True) self.ui.deadPixelBox.setChecked(True) self.ui.flatList.setEnabled(True) else: self.ui.lowerWavelengthCutoffLine.setEnabled(False) self.ui.lowerWavelengthCutoffLabel.setEnabled(False) self.ui.upperWavelengthCutoffLine.setEnabled(False) self.ui.upperWavelengthCutoffLabel.setEnabled(False) self.ui.wavelengthList.setEnabled(False) self.ui.flatCalibrationBox.setEnabled(False) self.ui.flatCalibrationBox.setChecked(False) self.ui.deadPixelBox.setChecked(False) self.ui.deadPixelBox.setEnabled(False) self.ui.flatList.setEnabled(False) # 9) Create flat cal file list def createFlatList(self): self.ui.flatList.clear() for iCal in range(len(self.flatCalDates)): self.ui.flatList.addItem(self.flatCalDates[iCal]) # Enable/disable flatcal options def useFlatCal(self): if self.ui.flatCalibrationBox.isChecked(): self.ui.deadPixelBox.setEnabled(True) self.ui.deadPixelBox.setChecked(True) self.ui.flatList.setEnabled(True) else: self.ui.deadPixelBox.setChecked(False) self.ui.deadPixelBox.setEnabled(False) self.ui.flatList.setEnabled(False) # 10) Load dead pixel mask def loadDeadMask(self): self.deadPixelFilename = str(self.displayStackPath + self.run + '/' + self.target + '/DeadPixelMasks/deadPixelMask_' + self.obsTS + '.npz') if not os.path.exists(self.deadPixelFilename): self.deadMask = self.ob.getDeadPixels() np.savez(self.deadPixelFilename,deadMask = self.deadMask) print "Dead pixel mask saved to %s"%(self.deadPixelFilename) else: self.deadFile = np.load(self.deadPixelFilename) self.deadMask = self.deadFile['deadMask'] # 12) Create output name def createOutputName(self): self.rawName = str(self.displayStackPath + self.run + '/' + self.target + '/ImageStacks/' + 'ImageStack_' + self.obsTS + '_' + str(self.integrationTime) + 's') if self.useWavelengthCalibration and self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_' + str(int(self.lowerWavelengthCutoff)) + '-' + str(int(self.upperWavelengthCutoff)) + '_hp.npz') elif self.useWavelengthCalibration and not self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_' + str(int(self.lowerWavelengthCutoff)) + '-' + str(int(self.upperWavelengthCutoff)) + '.npz') elif not self.waveLengthCalibration and self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_hp.npz') else: self.outputFilename = str(self.rawName + '.npz') # Start process for creating image stacks def stackProcess(self): # Check for valid params file if self.paramFileExists: # 6) Load settings choosen from gui self.loadSettings() if self.validSettings: # Loop through all files in input list for iFile in range(self.fileCount): # Create ObsFile instance self.obsTS = str(self.currentUTCDate) + '-' + self.ui.inputList.item(iFile).text() self.obsFn = str(FileName(run=self.run,date=self.currentSunsetDate,tstamp=self.obsTS).obs()) print 'Processing file ' + self.obsFn + '...' self.ob = ObsFile(self.obsFn) # Load time adjustment file if self.useTimeAdjustment: print 'Loading time adjustment file...' self.ob.loadTimeAdjustmentFile(FileName(run=self.run).timeAdjustments()) # 7) Load hot pixel mask if self.useHotPixelMasking: print 'Loading hot pixel mask...' self.loadHotMask() # 8) Load wave cal solution if self.useWavelengthCalibration: print 'Loading wavelength calibration...' self.ob.loadWvlCalFile(self.wvlCalFilename) # 9) Load flatcal solution if self.useFlatCalibration: print 'Loading flat calibration...' self.ob.loadFlatCalFile(self.flatCalFilename) # 10) Load dead pixel mask if self.useDeadPixelMasking: print 'Loading dead pixel mask...' self.loadDeadMask() # 11) Set wavelength cutoffs if self.useWavelengthCalibration: print 'Setting wavelength cutoffs...' self.ob.setWvlCutoffs(self.lowerWavelengthCutoff,self.upperWavelengthCutoff) # Timing self.unix = self.ob.getFromHeader('unixtime') self.startJD = self.unix/86400.+2440587.5 self.exptime = self.ob.getFromHeader('exptime') self.times = [] self.frames = [] # 11) Create Image Stack print 'Stacking images...' for iSec in np.arange(0,self.exptime,self.integrationTime): #add seconds offset to julian date, move jd to center of bin self.jd = self.startJD + iSec/(24.*3600.) + self.integrationTime/2./(24.*3600.) 'Creating frame for time ' + self.jd self.frameData = self.ob.getPixelCountImage(firstSec=iSec,integrationTime=self.integrationTime,weighted=self.weighted,getRawCount=self.useRawCounts,scaleByEffInt=self.scaleByEffInt) self.frame = self.frameData['image'] if self.useDeadPixelMasking: self.frame[self.deadMask == 0] = np.nan self.frames.append(self.frame) self.cube = np.dstack(self.frames) self.times = np.array(self.times) # 12) Create output file self.createOutputName() print 'Saving image stack to ' + self.outputFilename np.savez(self.outputFilename, stack=self.cube, jd=self.times) # Invalid params file else: print 'Invalid parameter file...' # Choose an image stack def chooseStack(self): self.defaultLoadStackDirectory = str(self.displayStackPath + self.run + '/' + self.target + '/ImageStacks') self.stackName = QFileDialog.getOpenFileName(parent=None, directory=self.defaultLoadStackDirectory, caption=str("Choose Image Stack"), filter=str("NPZ (*.npz)")) if self.stackName == '': print 'No file chosen' else: self.loadStack() # Load that image stack for viewing def loadStack(self):
obsFN = FileName(run=run,date=date,tstamp=tstamp) obsPath = obsFN.obs() flatPath = FileName(run=run,date=date).flatSoln() hotPath = obsFN.timeMask() centroidPath = obsFN.centroidList() obs = ObsFile(obsPath) if not os.path.exists(hotPath): hp.findHotPixels(obsPath,hotPath) obs.loadHotPixCalFile(hotPath,switchOnMask=False) obs.loadBestWvlCalFile() obs.loadFlatCalFile(flatPath) obs.setWvlCutoffs(3000,8000) centroidRa = '03:37:43.826' centroidDec = '14:15:14.828' haOffset = 150. imgDict = obs.getPixelCountImage(integrationTime=60,scaleByEffInt=True) plotArray(imgDict['image']) xGuess = 18 #col yGuess = 15 #row cc.centroidCalc(obs,centroidRa,centroidDec,guessTime=300,integrationTime=30,secondMaxCountsForDisplay=2000,HA_offset=haOffset,xyapprox=[xGuess,yGuess],outputFileName=centroidPath)
class DisplayStack(QMainWindow): def __init__(self): # Start up gui QWidget.__init__(self, parent=None) self.ui = Ui_DisplayStack_gui() self.ui.setupUi(self) # Initialize Variables self.initializeVariables() # Lists and buttons used for specifying run and target information. # Click item in runList to select a run. Run number corresponds to array index. Load up corresponding target list. self.ui.runList.itemClicked.connect(self.selectRun) # Click item in targetList to select a target. self.ui.targetList.itemClicked.connect(self.selectTarget) # Click button in self.ui.targetButton.clicked.connect(self.loadTarget) self.ui.sunsetList.itemClicked.connect(self.createObsList) # Use wavelength calibration checkbox self.ui.wavelengthCalibrationBox.clicked.connect(self.useWaveCal) # Use flat calibration checkbox self.ui.flatCalibrationBox.clicked.connect(self.useFlatCal) # Buttons for obs list creation self.ui.addButton.clicked.connect(self.addObservation) self.ui.removeButton.clicked.connect(self.removeObservation) self.ui.clearButton.clicked.connect(self.createObsList) # Start process button self.ui.stackButton.clicked.connect(self.stackProcess) # Load image stack button self.ui.loadStackButton.clicked.connect(self.chooseStack) # Initialize Variables def initializeVariables(self): # Define path names self.displayStackPath = '/Scratch/DisplayStack/' self.defaultWavelengthPath = '/Scratch/waveCalSolnFiles/PAL2012/master_cals/' self.defaultFlatPath = '/Scratch/flatCalSolnFiles/' # Load and display list of run names from /Scratch/DisplayStack/runList.dict self.loadRunData() # Load list of target names from /Scratch/DisplayStack/runName/runName.dict, for all runs self.loadTargetData() # Function to load list of run names. Runs on initialization. def loadRunData(self): # Load run data from /Scratch/DisplayStack/runList.dict self.runData = readDict() self.runData.read_from_file(self.displayStackPath + '/runList.dict') self.runNames = np.array(self.runData['runs']) # Populate runList table with run names. for iRun in range(len(self.runNames)): self.ui.runList.addItem(self.runNames[iRun]) # Function to load a table of target names. def loadTargetData(self): self.targetNames = [] # Cycle through runs and extract target name information from various dictionaries. for iRun in range(len(self.runNames)): self.targetData = readDict() self.targetData.read_from_file(self.displayStackPath + self.runNames[iRun] + '/' + self.runNames[iRun] + '.dict') self.iTargets = np.array(self.targetData['targets']) self.targetNames.append(self.iTargets) # Function to select a run and populate the target list for that particular run. def selectRun(self): # Clear list of target information for previously selected run. self.ui.targetList.clear() # Define a run number by the index of the selected run. self.runNumber = self.ui.runList.row(self.ui.runList.currentItem()) # Populate targetList table with target names for selected run. for iTarget in range(len(self.targetNames[self.runNumber])): self.ui.targetList.addItem(self.targetNames[self.runNumber][iTarget]) def selectTarget(self): self.targetNumber = self.ui.targetList.row(self.ui.targetList.currentItem()) def loadTarget(self): self.run = self.runNames[self.runNumber] self.target = self.targetNames[self.runNumber][self.targetNumber] try: self.paramName = self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict' self.paramData = readDict() self.paramData.read_from_file(self.paramName) self.obsTimes = np.array(self.paramData['obsTimes']) self.utcDates = self.paramData['utcDates'] self.sunsetDates = self.paramData['sunsetDates'] self.calTimestamps = self.paramData['calTimestamps'] self.flatCalDates = self.paramData['flatCalDates'] self.RA = self.paramData['RA'] self.Dec = self.paramData['Dec'] self.hourAngleOffset = self.paramData['HA_offset'] print 'Loading parameter file at ' + self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict' self.createSunsetList() #self.createObsList() self.createWavelengthList() self.createFlatList() self.paramFileExists = True except IOError: print 'No existing parameter file at ' + self.displayStackPath + self.run + '/' + self.target + '/' + self.target + '.dict' self.ui.sunsetList.clear() self.ui.obsList.clear() self.ui.inputList.clear() self.ui.wavelengthList.clear() self.ui.flatList.clear() self.paramFileExists = False # Choose Obs File # Create list of available sunset dates def createSunsetList(self): self.ui.sunsetList.clear() for iDate in range(len(self.sunsetDates)): self.ui.sunsetList.addItem(self.sunsetDates[iDate]) # Create Initial Obs file list def createObsList(self): self.ui.obsList.clear() self.ui.inputList.clear() self.currentSunsetDate = self.sunsetDates[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] self.currentUTCDate = self.utcDates[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] self.singleDayObservations = self.obsTimes[self.ui.sunsetList.row(self.ui.sunsetList.currentItem())] for iObs in range(len(self.singleDayObservations)): self.ui.obsList.addItem(self.singleDayObservations[iObs]) # Add observation to input list def addObservation(self): self.selectedObs = self.ui.obsList.currentItem() self.ui.obsList.takeItem(self.ui.obsList.row(self.selectedObs)) self.ui.inputList.addItem(self.selectedObs) self.ui.inputList.sortItems() # Remove observation from input list def removeObservation(self): self.removedObs = self.ui.inputList.currentItem() self.ui.inputList.takeItem(self.ui.inputList.row(self.removedObs)) self.ui.obsList.addItem(self.removedObs) self.ui.obsList.sortItems() # Load settings def loadSettings(self): self.validSettings = True # Run and target information self.run = self.runNames[self.runNumber] self.target = self.targetNames[self.runNumber][self.targetNumber] # General settings self.integrationTime = int(self.ui.integrationTimeLine.text()) self.useTimeAdjustment = self.ui.timeAdjustmentBox.isChecked() self.useHotPixelMasking = self.ui.hotPixelBox.isChecked() # Wavelength calibration settings self.useWavelengthCalibration = self.ui.wavelengthCalibrationBox.isChecked() self.useBestWavelengthCalibration = self.ui.bestWavelengthCalibrationBox.isChecked() self.lowerWavelengthCutoff = float(self.ui.lowerWavelengthCutoffLine.text()) self.upperWavelengthCutoff = float(self.ui.upperWavelengthCutoffLine.text()) # Flat calibration settings self.useFlatCalibration = self.ui.flatCalibrationBox.isChecked() self.useDeadPixelMasking = self.ui.deadPixelBox.isChecked() self.fileCount = self.ui.inputList.count() self.weighted = self.useFlatCalibration self.useRawCounts = not (self.useWavelengthCalibration and self.useFlatCalibration) self.scaleByEffInt = self.useHotPixelMasking if self.ui.sunsetList.currentItem() != None: if self.fileCount == 0: print 'Please select files to process...' self.validSettings = False if self.useWavelengthCalibration: if self.useBestWavelengthCalibration: print 'Using best wavelength calibration...' elif self.ui.wavelengthList.currentItem() == None: print 'Please select wavelength calibration...' self.validSettings = False else: self.selectedWvlCal = self.ui.wavelengthList.currentItem().text() print "Chose wvl cal: ", str(self.defaultWavelengthPath+self.selectedWvlCal) self.wvlCalFilename = str(self.defaultWavelengthPath+self.selectedWvlCal) #self.wvlCalFilename = str(FileName(run=self.run,date=self.currentSunsetDate,tstamp=self.selectedWvlCal).calSoln()) if self.useFlatCalibration: if self.ui.flatList.currentItem() == None: print 'Please select flat calibration...' self.validSettings = False else: self.flatCalNight = self.ui.flatList.currentItem().text() self.flatCalFilename = str(FileName(run=self.run,date=self.flatCalNight).flatSoln()) else: print 'Please select sunset night...' self.validSettings = False # Load hot pixel mask def loadHotMask(self): #self.hotPixelFilename = str(self.displayStackPath + self.run + '/' + self.target + '/HotPixelMasks/hotPixelMask_' + self.obsTS + '.h5') self.hotPixelFilename = str(FileName(obsFile = self.ob).timeMask()) if not os.path.exists(self.hotPixelFilename): hp.findHotPixels(obsFile=self.ob,outputFileName=self.hotPixelFilename) print "Hot pixel mask saved to %s"%(self.hotPixelFilename) self.ob.loadHotPixCalFile(self.hotPixelFilename,switchOnMask=True) # Create wavelength cal file list def createWavelengthList(self): self.ui.wavelengthList.clear() for iCal in range(len(self.calTimestamps)): self.ui.wavelengthList.addItem(self.calTimestamps[iCal]) # Enable/disable wavecal options def useWaveCal(self): if self.ui.wavelengthCalibrationBox.isChecked(): self.ui.lowerWavelengthCutoffLine.setEnabled(True) self.ui.lowerWavelengthCutoffLabel.setEnabled(True) self.ui.upperWavelengthCutoffLine.setEnabled(True) self.ui.upperWavelengthCutoffLabel.setEnabled(True) self.ui.wavelengthList.setEnabled(True) self.ui.flatCalibrationBox.setEnabled(True) self.ui.flatCalibrationBox.setChecked(True) self.ui.deadPixelBox.setEnabled(True) self.ui.deadPixelBox.setChecked(True) self.ui.flatList.setEnabled(True) self.ui.bestWavelengthCalibrationBox.setEnabled(True) self.ui.bestWavelengthCalibrationBox.setChecked(True) else: self.ui.lowerWavelengthCutoffLine.setEnabled(False) self.ui.lowerWavelengthCutoffLabel.setEnabled(False) self.ui.upperWavelengthCutoffLine.setEnabled(False) self.ui.upperWavelengthCutoffLabel.setEnabled(False) self.ui.wavelengthList.setEnabled(False) self.ui.flatCalibrationBox.setEnabled(False) self.ui.flatCalibrationBox.setChecked(False) self.ui.deadPixelBox.setChecked(False) self.ui.deadPixelBox.setEnabled(False) self.ui.flatList.setEnabled(False) self.ui.bestWavelengthCalibrationBox.setEnabled(False) self.ui.bestWavelengthCalibrationBox.setChecked(False) # Create flat cal file list def createFlatList(self): self.ui.flatList.clear() for iCal in range(len(self.flatCalDates)): self.ui.flatList.addItem(self.flatCalDates[iCal]) # Enable/disable flatcal options def useFlatCal(self): if self.ui.flatCalibrationBox.isChecked(): self.ui.deadPixelBox.setEnabled(True) self.ui.deadPixelBox.setChecked(True) self.ui.flatList.setEnabled(True) else: self.ui.deadPixelBox.setChecked(False) self.ui.deadPixelBox.setEnabled(False) self.ui.flatList.setEnabled(False) # Load dead pixel mask def loadDeadMask(self): self.deadPixelFilename = str(self.displayStackPath + self.run + '/' + self.target + '/DeadPixelMasks/deadPixelMask_' + self.obsTS + '.npz') if not os.path.exists(self.deadPixelFilename): self.deadMask = self.ob.getDeadPixels() np.savez(self.deadPixelFilename,deadMask = self.deadMask) print "Dead pixel mask saved to %s"%(self.deadPixelFilename) else: self.deadFile = np.load(self.deadPixelFilename) self.deadMask = self.deadFile['deadMask'] # Describe the structure of the header row class headerDescription(tables.IsDescription): targetName = tables.StringCol(100, dflt='') run = tables.StringCol(100, dflt='') obsFileName = tables.StringCol(100, dflt='') wvlCalFileName = tables.StringCol(100, dflt=np.nan) flatCalFileName = tables.StringCol(100, dflt='') deadPixFileName = tables.StringCol(100, dflt='') hotPixFileName = tables.StringCol(100, dflt='') nCol = tables.UInt32Col(dflt=-1) nRow = tables.UInt32Col(dflt=-1) lowWvlCutoff = tables.Float64Col(dflt=np.nan) highWvlCutoff = tables.Float64Col(dflt=np.nan) exptime = tables.Float64Col(dflt=np.nan) lst = tables.StringCol(100, dflt='') integrationTime = tables.Float64Col(dflt=np.nan) RA = tables.StringCol(100, dflt='') Dec = tables.StringCol(100, dflt='') HA_offset = tables.Float64Col(dflt=0.0) # Create output name def createOutputName(self): self.rawName = str(self.displayStackPath + self.run + '/' + self.target + '/ImageStacks/' + 'ImageStack_' + self.obsTS + '_' + str(self.integrationTime) + 's') if self.useWavelengthCalibration and self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_' + str(int(self.lowerWavelengthCutoff)) + '-' + str(int(self.upperWavelengthCutoff)) + '_hp.h5') elif self.useWavelengthCalibration and not self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_' + str(int(self.lowerWavelengthCutoff)) + '-' + str(int(self.upperWavelengthCutoff)) + '.h5') elif not self.useWavelengthCalibration and self.useHotPixelMasking: self.outputFilename = str(self.rawName + '_hp.h5') else: self.outputFilename = str(self.rawName + '.h5') def createH5File(self): # Create header and data group and table names headerGroupName = 'header' headerTableName = 'header' dataGroupName = 'stack' dataTableName = 'stack' timeTableName = 'time' # Create lookup names for header information runColName = 'run' targetColName = 'targetName' obsFileColName = 'obsFileName' wvlCalFileColName = 'wvlCalFileName' flatCalFileColName = 'flatCalFileName' nRowColName = 'nRow' nColColName = 'nCol' RAColName = 'RA' DecColName = 'Dec' deadPixColName = 'deadPixFileName' hotPixColName = 'hotPixFileName' lowWvlColName = 'lowWvlCutoff' highWvlColName = 'highWvlCutoff' expTimeColName = 'exptime' lstColName = 'lst' integrationTimeColName = 'integrationTime' HA_offsetColName = 'HA_offset' # Create and h5 output file, create header and data groups fileh = tables.openFile(self.outputFilename, mode='w') headerGroup = fileh.createGroup("/", headerGroupName, 'Header') stackGroup = fileh.createGroup("/", dataGroupName, 'Image Stack') # Create row for header information headerTable = fileh.createTable(headerGroup, headerTableName, self.headerDescription, 'Header Info') header = headerTable.row # Fill in the header with possibly useful information. header[runColName] = self.run header[targetColName] = self.target header[obsFileColName] = self.obsFn header[nColColName] = self.numberCols header[nRowColName] = self.numberRows header[RAColName] = self.RA header[DecColName] = self.Dec header[expTimeColName] = self.exptime header[lstColName] = self.lst header[integrationTimeColName] = self.integrationTime header[HA_offsetColName] = self.hourAngleOffset if self.useDeadPixelMasking: header[deadPixColName] = self.deadPixelFilename if self.useHotPixelMasking: header[hotPixColName] = self.hotPixelFilename if self.useWavelengthCalibration: header[wvlCalFileColName] = self.ob.wvlCalFileName header[lowWvlColName] = self.lowerWavelengthCutoff header[highWvlColName] = self.upperWavelengthCutoff if self.useFlatCalibration: header[flatCalFileColName] = self.flatCalFilename header.append() # Create an h5 array for the midtime of each frame in the image cube. timeTable = fileh.createCArray(stackGroup, timeTableName, Float64Atom(), (1,len(self.times))) timeTable[:] = self.times # Create an h5 table for the image cube. stackTable = fileh.createCArray(stackGroup, dataTableName, Float64Atom(), (self.numberRows,self.numberCols, self.cube.shape[2])) stackTable[:] = self.cube # Flush the h5 output file fileh.flush() fileh.close() # Start process for creating image stacks def stackProcess(self): # Check for valid params file if self.paramFileExists: # Load settings choosen from gui self.loadSettings() if self.validSettings: # Loop through all files in input list for iFile in range(self.fileCount): # Create ObsFile instance self.obsTS = str(self.currentUTCDate) + '-' + self.ui.inputList.item(iFile).text() self.obsFn = str(FileName(run=self.run,date=self.currentSunsetDate,tstamp=self.obsTS).obs()) print 'Processing file ' + self.obsFn + '...' self.ob = ObsFile(self.obsFn) self.numberRows = self.ob.nRow self.numberCols = self.ob.nCol # Load time adjustment file if self.useTimeAdjustment: print 'Loading time adjustment file...' self.ob.loadTimeAdjustmentFile(FileName(run=self.run).timeAdjustments()) # Load hot pixel mask if self.useHotPixelMasking: print 'Loading hot pixel mask...' self.loadHotMask() # Load wave cal solution if self.useWavelengthCalibration: if self.useBestWavelengthCalibration: print 'Loading best wavelength calibration...' self.ob.loadBestWvlCalFile() else: print 'Loading selected wavelength calibration...' self.ob.loadWvlCalFile(self.wvlCalFilename) # Load flatcal solution if self.useFlatCalibration: print 'Loading flat calibration...' self.ob.loadFlatCalFile(self.flatCalFilename) # Load dead pixel mask if self.useDeadPixelMasking: print 'Loading dead pixel mask...' self.loadDeadMask() # Set wavelength cutoffs if self.useWavelengthCalibration: print 'Setting wavelength cutoffs...' self.ob.setWvlCutoffs(self.lowerWavelengthCutoff,self.upperWavelengthCutoff) # Timing self.unix = self.ob.getFromHeader('unixtime') self.startJD = self.unix/86400.+2440587.5 self.exptime = self.ob.getFromHeader('exptime') self.lst = self.ob.getFromHeader('lst') self.times = [] self.frames = [] # Create Image Stack print 'Stacking images...' for iSec in np.arange(0,self.exptime,self.integrationTime): #add seconds offset to julian date, move jd to center of bin self.jd = self.startJD + iSec/(24.*3600.) + self.integrationTime/2./(24.*3600.) self.times.append(self.jd) print 'Creating frame for time ' + str(self.jd) self.frameData = self.ob.getPixelCountImage(firstSec=iSec,integrationTime=self.integrationTime,weighted=self.weighted,getRawCount=self.useRawCounts,scaleByEffInt=self.scaleByEffInt) self.frame = self.frameData['image'] if self.ui.verticalFlipBox.isChecked(): self.frame = np.flipud(self.frame) if self.useDeadPixelMasking: self.frame[self.deadMask == 0] = np.nan self.frames.append(self.frame) self.cube = np.dstack(self.frames) self.times = np.array(self.times) # Create output file self.createOutputName() print 'Saving image stack to ' + self.outputFilename self.createH5File() # Invalid params file else: print 'Invalid parameter file...' # Choose an image stack def chooseStack(self): self.defaultLoadStackDirectory = str(self.displayStackPath) self.stackName = '' self.stackName = QFileDialog.getOpenFileName(parent=None, directory=self.defaultLoadStackDirectory, caption=str("Choose Image Stack"), filter=str("H5 (*.h5)")) if self.stackName == '': print 'No file chosen' else: loadStackApp = LoadImageStack.LoadImageStack(stackName = self.stackName) loadStackApp.show() loadStackApp.exec_()
def main(): #open the sky file for hr9087 run = 'PAL2012' date = '20121210' wvlCal = '20121211-052230' obsTimestamp = '20121211-051650' flatCalDate = '20121211' flatCalTstamp = '20121212-074700' obsFN = FileName(run=run,date=date,tstamp=obsTimestamp) obsFileName = obsFN.obs() timeMaskFileName = obsFN.timeMask() wvlFileName = FileName(run=run,date=date,tstamp=wvlCal).calSoln() flatFileName = FileName(run=run,date=flatCalDate,tstamp=flatCalTstamp).flatSoln() if not os.path.exists(timeMaskFileName): print 'Running hotpix for ',obsFileName hp.findHotPixels(obsFileName,timeMaskFileName) print "Flux file pixel mask saved to %s"%(timeMaskFileName) obs = ObsFile(obsFileName) obs.loadTimeAdjustmentFile(FileName(run='PAL2012').timeAdjustments()) obs.loadWvlCalFile(wvlFileName) obs.loadFlatCalFile(flatFileName) obs.loadHotPixCalFile(timeMaskFileName) #obs.setWvlCutoffs(4000,8000) #get image before and after flat cal print 'getting images' beforeImgDict = obs.getPixelCountImage(weighted=False,fluxWeighted=False,scaleByEffInt=True) rawCubeDict = obs.getSpectralCube(weighted=False) rawCube = np.array(rawCubeDict['cube'],dtype=np.double) effIntTime = rawCubeDict['effIntTime'] maxIntTime = np.max(effIntTime) #add third dimension for broadcasting effIntTime3d = np.reshape(effIntTime,np.shape(effIntTime)+(1,)) rawCube *= maxIntTime / effIntTime3d rawCube[np.isnan(rawCube)] = 0 rawCube[rawCube == np.inf] = 0 beforeImg = np.sum(rawCube,axis=-1) print 'finished first cube' flatCubeDict = obs.getSpectralCube(weighted=True) flatCube = np.array(flatCubeDict['cube'],dtype=np.double) effIntTime = flatCubeDict['effIntTime'] maxIntTime = np.max(effIntTime) #add third dimension for broadcasting effIntTime3d = np.reshape(effIntTime,np.shape(effIntTime)+(1,)) flatCube *= maxIntTime / effIntTime3d flatCube[np.isnan(flatCube)] = 0 flatCube[flatCube == np.inf] = 0 afterImg = np.sum(flatCube,axis=-1) plotArray(title='before flatcal',image=beforeImg) plotArray(title='after flatcal',image=afterImg) print 'before sdev',np.std(beforeImg[afterImg!=0]) print 'after sdev',np.std(afterImg[afterImg!=0]) np.savez('flatCubeGem.npz',beforeImg=beforeImg,afterImg=afterImg,rawCube=rawCube,flatCube=flatCube)
ob = ObsFile(obsFn) print 'Loading wavelength calibration solution: ' + wvlCalFilenames[0] ob.loadWvlCalFile(wvlCalFilenames[0]) print 'Loading flat calibration solution: ' + flatCalFilenames[0] ob.loadFlatCalFile(flatCalFilenames[0]) ob.loadFluxCalFile(fluxCalFileNames[0]) #load/generate hot pixel mask file HotPixFile = getTimeMaskFileName(obsFn) if not os.path.exists(HotPixFile): hp.findHotPixels(obsFn,HotPixFile) print "Flux file pixel mask saved to %s"%(HotPixFile) ob.loadHotPixCalFile(HotPixFile) print "Hot pixel mask loaded %s"%(HotPixFile) frame = ob.getPixelCountImage(firstSec=0,integrationTime=300,weighted=True) #hotPixMask = hotPixels.checkInterval(image=frame, firstSec=0, intTime=300, weighted=True, display=False)['mask'] #summed_array,bin_edges=ob.getApertureSpectrum(pixelCol=14,pixelRow=8,radius=7) ob.plotApertureSpectrum(pixelCol=14,pixelRow=8,radius=7,weighted = True,fluxWeighted=True,lowCut=3000,highCut=9000) ''' h = 6.626068*10**-34 c = 299792458.0 k = 1.3806503*10**-23 T = 10000.0 numerator = 6*10**-29 denominator= (bin_edges*10**-10)**5*(np.exp(((h*c)/(bin_edges*k*T*10**-10))) - 1) bbcurve = numerator/denominator
# ax.plot(bins[0:-1],s2) # plt.show() startJD = ob.getFromHeader('jd') nSecInFile = ob.getFromHeader('exptime') deadMask = ob.getDeadPixels() for sec in range(0,nSecInFile,integrationTime): jd = startJD + sec/(24.*3600.)#add seconds offset to julian date print count,jd count+=1 times.append(jd) titles.append('%.6f'%jd) #make 30s flat-fielded,hot pixel masked image #hotPixMaskRaw = hotPixels.findHotPixels(obsFile=ob,firstSec=sec,intTime=integrationTime)['badflag'] #hotPixMask = hotPixels.findHotPixels(obsFile=ob,firstSec=sec,intTime=integrationTime,weighted=True)['badflag'] frame = ob.getPixelCountImage(firstSec=sec,integrationTime=integrationTime,weighted=True) hotPixMask = hotPixels.findHotPixels(image=frame,firstSec=sec,intTime=integrationTime,weighted=True)['badflag'] # plt.show() showFrame = np.array(frame) # utils.plotArray(showFrame,cbar=True,normMax=np.mean(showFrame)+3*np.std(showFrame)) # showFrame[hotPixMaskRaw == 1] = 0 # utils.plotArray(showFrame,cbar=True) showFrame[hotPixMask == 1] = 0 # utils.plotArray(showFrame,cbar=True) showframes.append(showFrame) # frame[hotPixMaskRaw == 1] = np.nan frame[hotPixMask == 1] = np.nan frame[deadMask == 0] = np.nan frames.append(frame)