def timePL(tstamp,obsPath,centroidPath): obs = ObsFile(obsPath) obs.loadAllCals() obs.setWvlCutoffs(3000,11000) obs.loadCentroidListFile(centroidPath) writePhotonList(obs,photListDescription=PulsarPhotonList,checkForExisting=False) del obs
def generateObsObjectList(obsFNs,wvlLowerLimit=3000, wvlUpperLimit=13000,beammapFileName = None,loadHotPix=True,loadWvlCal=True,loadFlatCal=True,loadSpectralCal=True): obsFiles = [] for obsFN in obsFNs: if type(obsFN) == type(''): #Full path to obs file obs = ObsFile(obsFN) else: #FileName object obs = ObsFile(obsFN.obs()) if beammapFileName is not None and os.path.isfile(beammapFileName): obs.loadBeammapFile(beammapFileName) obs.setWvlCutoffs(wvlLowerLimit=wvlLowerLimit, wvlUpperLimit=wvlUpperLimit) if loadHotPix: if not os.path.isfile(FileName(obsFile=obs).timeMask()): print "generating hp file ", FileName(obsFile=obs).timeMask() hp.findHotPixels(obsFile=obs,outputFileName=FileName(obsFile=obs).timeMask()) obs.loadHotPixCalFile(FileName(obsFile=obs).timeMask(),reasons=['hot pixel','dead pixel']) if loadWvlCal: obs.loadBestWvlCalFile() if loadFlatCal: #obs.loadFlatCalFile(FileName(obsFile=obs).flatSoln()) obs.loadFlatCalFile('/Scratch/flatCalSolnFiles/flatsol_1s.h5') if loadSpectralCal: pass obsFiles.append(obs) return obsFiles
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
def centroidObs(obsPath,centroidPath,centroidRa,centroidDec,haOffset,xGuess,yGuess,hotPath,flatPath): obs = ObsFile(obsPath) print obsPath,obs.getFromHeader('exptime'),obs if not os.path.exists(hotPath): hp.findHotPixels(obsFile=obs,outputFileName=hotPath) obs.loadHotPixCalFile(hotPath,switchOnMask=False) obs.loadBestWvlCalFile() obs.loadFlatCalFile(flatPath) obs.setWvlCutoffs(3000,8000) cc.centroidCalc(obs,centroidRa,centroidDec,guessTime=300,integrationTime=30,secondMaxCountsForDisplay=2000,HA_offset=haOffset,xyapprox=[xGuess,yGuess],outputFileName=centroidPath) print 'done centroid',centroidPath del obs
def centroidObs(obsPath,centroidPath,centroidRa,centroidDec,haOffset,xGuess,yGuess): obs = ObsFile(obsPath) print obsPath,obs.getFromHeader('exptime'),obs obs.loadAllCals() # obs.loadBestWvlCalFile() # obs.loadFlatCalFile(flatPath) obs.setWvlCutoffs(3000,11000) # if not os.path.exists(hotPath): # hp.findHotPixels(obsFile=obs,outputFileName=hotPath,display=True,fwhm=2.,boxSize=5, nSigmaHot=4.0,) # obs.loadHotPixCalFile(hotPath,switchOnMask=True) cc.centroidCalc(obs,centroidRa,centroidDec,guessTime=300,integrationTime=30,secondMaxCountsForDisplay=2000,HA_offset=haOffset,xyapprox=[xGuess,yGuess],outputFileName=centroidPath,usePsfFit=True,radiusOfSearch=8) print 'done centroid',centroidPath del obs
sunsetDate = sunsetDates[iSeq] for i,ts in enumerate(timestampList): print 'loading',ts obsFn = FileName(run=run,date=sunsetDate,tstamp=ts).obs() ob = ObsFile(obsFn) ob.loadTimeAdjustmentFile(FileName(run=run).timeAdjustments()) index1 = obsFn.find('_') hotPixFn = '/Scratch/timeMasks/timeMask' + obsFn[index1:] if not os.path.exists(hotPixFn): hp.findHotPixels(obsFn,hotPixFn) print "Flux file pixel mask saved to %s"%(hotPixFn) ob.loadHotPixCalFile(hotPixFn,switchOnMask=True) ob.loadWvlCalFile(wfn) ob.loadFlatCalFile(ffn) ob.setWvlCutoffs(wvlLowerCutoff,wvlUpperCutoff) bad_solution_mask=np.zeros((46,44)) bad_count=0; for y in range(46): for x in range(44): if (ob.wvlRangeTable[y][x][1] < wvlUpperCutoff) or (ob.wvlRangeTable[y][x][0] > wvlLowerCutoff): 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
print 'Loading obs file and performing calibrations ...' obsFn = FileName(run=run,date=sunsetDate,tstamp=obsTimestamp).obs() ob = ObsFile(obsFn) # Load roach time delay corrections. ob.loadTimeAdjustmentFile(FileName(run=run).timeAdjustments()) # Search for time mask for given observation file. If the time mask does not exist, create it. index1 = obsFn.find('_') hotPixFn = '/Scratch/timeMasks/timeMask' + obsFn[index1:] if not os.path.exists(hotPixFn): hp.findHotPixels(obsFn,hotPixFn) print "Flux file pixel mask saved to %s"%(hotPixFn) # Load time mask, wavelength calibration, and flat calibration and set wavelenth cutoffs. ob.loadHotPixCalFile(hotPixFn,switchOnMask=True) ob.loadWvlCalFile(wvlCalFilename) ob.loadFlatCalFile(flatCalFilename) ob.setWvlCutoffs(3000,5000) print 'Total load time: ' + str(time()-tic) + 's' tic = time() print 'Retrieving photon timestamps...' # Define the area of an observation containing the object. appMask = aperture(15,8,8) yValues,xValues = np.where(appMask==0) # Get a list of timestamps with photons from each pixel in the aperture. timestamps=[] for j in range(len(xValues)): x=ob.getPixelWvlList(iRow=yValues[j],iCol=xValues[j]) timestamps = np.append(timestamps,x['timestamps']) print 'Total retrieval time: ' + str(time()-tic) + 's' # Use timestamp data to perform periodograms.
secondMaxCountsForDisplay = 500 obsFn = FileName(run=run,date=sunsetDate,tstamp=centroidTimestamp).obs() wfn = FileName(run=run,date=sunsetDate,tstamp=calTimestamp).calSoln() ffn = FileName(run=run,date=sunsetDate,tstamp=calTimestamp).flatSoln() ffn = '/Scratch/flatCalSolnFiles/20121207/flatsol_20121207.h5' # Create ObsFile instance ob = ObsFile(obsFn) # Load wavelength and flat cal solutions ob.loadWvlCalFile(wfn) ob.loadFlatCalFile(ffn) ob.setWvlCutoffs(3000,8000) # Load/generate hot pixel mask file index1 = obsFn.find('_') index2 = obsFn.find('-') hotPixFn = '/Scratch/timeMasks/timeMask' + obsFn[index1:] if not os.path.exists(hotPixFn): hp.findHotPixels(obsFn,hotPixFn) print "Flux file pixel mask saved to %s"%(hotPixFn) ob.loadHotPixCalFile(hotPixFn,switchOnMask=False) print "Hot pixel mask loaded %s"%(hotPixFn) centroidCalc(ob, centroid_RA, centroid_DEC, guessTime=300, integrationTime=30, secondMaxCountsForDisplay=500)
obsPath = obsFN.obs() flatPath = FileName(run=run,date=date).flatSoln() hotPath = obsFN.timeMask() centroidPath = obsFN.centroidList() fluxPath = FileName(run='PAL2012',date='20121211',tstamp='absolute_021727').fluxSoln() obs = ObsFile(obsPath) if not os.path.exists(hotPath): hp.findHotPixels(obsPath,hotPath) obs.loadHotPixCalFile(hotPath,switchOnMask=False) obs.loadBestWvlCalFile() obs.loadFlatCalFile(flatPath) obs.loadFluxCalFile(fluxPath) obs.loadCentroidListFile(centroidPath) obs.setWvlCutoffs(3000,11000) 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) writePhotonList(obs,photListDescription=PulsarPhotonList)
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):
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_()
if not os.path.exists(timeMaskFileName): print 'Running hotpix for ',obsFileName hp.findHotPixels(inputFileName=obsFileName,outputFileName=timeMaskFileName) print "Flux file pixel mask saved to %s"%(timeMaskFileName) obs = ObsFile(obsFileName) exptime = obs.getFromHeader('exptime') #obs.loadTimeAdjustmentFile(FileName(run='PAL2012').timeAdjustments()) if wvlCal != '': obs.loadWvlCalFile(wvlFileName) else: obs.loadBestWvlCalFile() obs.loadHotPixCalFile(timeMaskFileName) obs.setWvlCutoffs(lowerWvlCut,upperWvlCut) obs.loadFlatCalFile(flatFileName) #get image before and after flat cal #print 'getting images' 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 rawImg = np.sum(rawCube,axis=-1) rawImg[rawImg == 0] = np.nan rawImg[~np.isfinite(rawImg)] = np.nan #print 'finished raw cube'