def makeMovies(self,beginTick, endTick, backgroundFrame, accumulate=False):
tick0 = np.uint64(beginTick)
tick1 = np.uint64(endTick)
for iRow in range(cosmic.file.nRow):
for iCol in range(cosmic.file.nCol):
gtpl = self.getTimedPacketList(iRow,iCol,sec0,1)
timestamps = gtpl['timestamps']
timestamps *= cosmic.file.ticksPerSec
ts32 = timestamps.astype(np.uint32)
for ts in ts32:
tindex = ts-t0
try:
listOfPixelsToMark[tindex].append((iRow,iCol))
except IndexError:
pass
for tick in range(t0,t1):
frames.append(frameSum)
title = makeTitle(tick,t0,t1)
titles.append(title)
mfn0 = "m-%s-%s-%s-%s-%010d-%010d-i.gif"%(run,sundownDate,obsDate,seq,t0,t1)
utils.makeMovie(frames, titles, outName=mfn0, delay=0.1, colormap=mpl.cm.gray,
listOfPixelsToMark=listOfPixelsToMark,
pixelMarkColor='red')
for i in range(len(listOfPixelsToMark)-1):
listOfPixelsToMark[i+1].extend(listOfPixelsToMark[i])
mfn1 = "m-%s-%s-%s-%s-%010d-%010d-a.gif"%(run,sundownDate,obsDate,seq,t0,t1)
utils.makeMovie(frames, titles, outName=mfn1, delay=0.1, colormap=mpl.cm.gray,
listOfPixelsToMark=listOfPixelsToMark,
pixelMarkColor='green')
def main():
objectName = "hz21"
fileNum=0
energyBinWidth = 0.1
#make bins for 3000 to 13000
wvlStart = 3000
wvlStop = 13000
wvlBinEdges = ObsFile.makeWvlBins(energyBinWidth,wvlStart,wvlStop)
nWvlBins = len(wvlBinEdges)-1
binWidths = np.empty(nWvlBins)
print "Showing bin widths for %i bins"%(nWvlBins)
for i in xrange(nWvlBins):
binWidths[i] = wvlBinEdges[i+1]-wvlBinEdges[i]
print binWidths
nVirtPixX=250
nVirtPixY=250
cube = np.zeros((nVirtPixX,nVirtPixY,nWvlBins),dtype=float)
for n in xrange(nWvlBins):
print "Making image for wvls %i to %i"%(wvlBinEdges[n], wvlBinEdges[n+1])
virtualImage, imageStack, medImage = makeImageStack(fileNames='photons_*.h5', dir=os.getenv('MKID_PROC_PATH', default="/Scratch")+'/photonLists/20131209',
detImage=False, saveFileName='stackedImage.pkl', wvlMin=wvlBinEdges[n],
wvlMax=wvlBinEdges[n+1], doWeighted=True, medCombine=False, vPlateScale=0.2,
nPixRA=nVirtPixX,nPixDec=nVirtPixY)
print virtualImage
print virtualImage.image
print np.shape(virtualImage.image)
cube[:,:,n] = virtualImage.image
#calculate midpoints of wvl bins for plotting
wvls = np.empty((nWvlBins),dtype=float)
for n in xrange(nWvlBins):
binsize=wvlBinEdges[n+1]-wvlBinEdges[n]
wvls[n] = (wvlBinEdges[n]+(binsize/2.0))
print "wvls ",wvls
#reshape cube for makeMovie
movieCube = np.zeros((nWvlBins,np.shape(cube)[0],np.shape(cube)[1]),dtype=float)
for i in xrange(nWvlBins):
movieCube[i,:,:] = cube[:,:,i]
#show individual frames as they are made to debug
#plt.matshow(movieCube[i],vmin = 0, vmax = 100)
#plt.show()
print "movieCube shape ", np.shape(movieCube)
print "wvls shape ", np.shape(wvls)
#print cube
#print "--------------------------"
#print movieCube
np.savez('%s_raw_%s.npz'%(objectName,fileNum),stack=movieCube,wvls=wvls)
utils.makeMovie(movieCube,frameTitles=wvls,cbar=True,outName='%s_pl_raw_%s.gif'%(objectName,fileNum), normMin=0, normMax=1000)
'''
def loadAbsoluteSpectrum(self):
'''
extract the ARCONS measured spectrum of the spectrophotometric standard by breaking data into spectral cube
and performing photometry (aper or psf) on each spectral frame
'''
if self.verbose:print "Making spectral cube"
cubeDict = self.fluxFile.getSpectralCube(firstSec=self.startTime, integrationTime=self.intTime, weighted=True, fluxWeighted=False)
cube= np.array(cubeDict['cube'], dtype=np.double)
effIntTime= cubeDict['effIntTime']
if self.verbose: print "median effective integration time in flux file cube = ", np.median(effIntTime)
if self.verbose: print "cube shape ", np.shape(cube)
if self.verbose: print "effIntTime shape ", np.shape(effIntTime)
#add third dimension to effIntTime for broadcasting
effIntTime = np.reshape(effIntTime,np.shape(effIntTime)+(1,))
#put cube into counts/s in each pixel
cube /= effIntTime
#get dead time correction factors
DTCorr = self.getDeadTimeCorrection(self.fluxFile)
cube*=DTCorr #cube now in units of counts/s and corrected for dead time
if self.plots and not 'figureHeader' in sys.modules:
if self.verbose: print "Saving spectral frames as movie..."
movieCube = np.zeros((self.nWvlBins,np.shape(cube)[0],np.shape(cube)[1]),dtype=float)
for i in xrange(self.nWvlBins):
movieCube[i,:,:] = cube[:,:,i]
makeMovie(movieCube,frameTitles=self.binCenters,cbar=True,outName=self.plotSavePath+'FluxCal_Cube_%s.gif'%(self.objectName), normMin=0, normMax=50)
if self.verbose: print "Movie saved in %s"%self.plotSavePath
LCplot=False #light curve pop-ups not compatible with FLuxCal plotting 2/18/15
#if self.photometry=='PSF': LCplot = False
LC = LightCurve.LightCurve(verbose=self.verbose, showPlot=LCplot)
self.fluxSpectrum=np.empty((self.nWvlBins),dtype=float)
self.skySpectrum=np.zeros((self.nWvlBins),dtype=float)
for i in xrange(self.nWvlBins):
frame = cube[:,:,i]
if self.verbose: print "%s photometry on frame %i of cube, central wvl = %f Angstroms"%(self.photometry,i,self.binCenters[i])
if self.photometry == 'aperture':
fDict = LC.performPhotometry(self.photometry,frame,[[self.centroidCol,self.centroidRow]],expTime=None,aper_radius = self.aperture, annulus_inner = self.annulusInner, annulus_outer = self.annulusOuter, interpolation="linear")
self.fluxSpectrum[i] = fDict['flux']
self.skySpectrum[i] = fDict['skyFlux']
print "Sky estimate = ", fDict['skyFlux']
else:
fDict = LC.performPhotometry(self.photometry,frame,[[self.centroidCol,self.centroidRow]],expTime=None,aper_radius = self.aperture)
self.fluxSpectrum[i] = fDict['flux']
self.fluxSpectrum=self.fluxSpectrum/self.binWidths/self.collectingArea #spectrum now in counts/s/Angs/cm^2
self.skySpectrum=self.skySpectrum/self.binWidths/self.collectingArea
return self.fluxSpectrum, self.skySpectrum
def testMakeMovie0(self):
"""
make a simple movie all 0 and 1
"""
nrow = 20
ncol = 10
listOfFrameObj = []
frameTitles = []
for iFrame in range(nrow):
#print "iFrame=",iFrame
frame = []
for iRow in range(nrow):
if (iRow < iFrame):
row = [1]*ncol
else:
row = [0]*ncol
frame.append(row)
listOfFrameObj.append(np.array(frame))
frameTitles.append("frame=%03d"%iFrame)
utils.makeMovie(listOfFrameObj, frameTitles, outName='movie0')
def testMakeMovie1(self):
"""
make a simple movie all 0 and 1 and values in between
"""
nrow = 5
ncol = 10
listOfFrameObj = []
frameTitles = []
listOfPixelsToMark = []
for iFrame in range(nrow):
print "iFrame=",iFrame
frame = []
for iRow in range(nrow):
row = [float(iRow)/nrow]*ncol
if (iRow <= iFrame):
row[ncol/2] = 1
frame.append(row)
listOfFrameObj.append(np.array(frame))
frameTitles.append("frame=%03d"%iFrame)
listOfPixelsToMark.append([(iFrame,iFrame)])
utils.makeMovie(listOfFrameObj, frameTitles, outName='movie1',
delay=1.0, colormap=mpl.cm.gray,
listOfPixelsToMark=listOfPixelsToMark,
pixelMarkColor='red')
# for iCol in range(np.shape(frame)[1]):
# ax2.scatter(range(46),frame[:,iCol],c='red',marker='o',alpha=.5,label='data')
# ax2.scatter(range(46),fitimg[:,iCol],c='blue',marker='^',alpha=.5,label='fit')
# ax2.set_title('Fit seen along Rows')
# plt.show()
plt.close()
print 'closed'
cube = np.array(fitImgList)
chisqs = np.array(chisqList)
params = np.array(paramsList)
errors = np.array(errorsList)
np.savez(npzfitpsf,fitImg=cube,params=params,errors=errors,chisqs=chisqs,wvls=wvls)
print 'saved'
utils.makeMovie(fitImgList,frameTitles=wvls, cbar=True, outName=giffitpsf, normMin=0, normMax=50)
def main():
"""
params = []
paramfile = sys.argv[1]
f = open(paramfile,'r')
for line in f:
params.append(line)
f.close()
datadir = params[0].split('=')[1].strip()
flatdir = params[1].split('=')[1].strip()
fluxdir = params[2].split('=')[1].strip()
wvldir = params[3].split('=')[1].strip()
obsfile = params[4].split('=')[1].strip()
skyfile = params[5].split('=')[1].strip()
flatfile = params[6].split('=')[1].strip()
fluxfile = params[7].split('=')[1].strip()
wvlfile = params[8].split('=')[1].strip()
objectName = params[9].split('=')[1].strip()
fluxCalObject = params[10].split('=')[1].strip()
obsFileName = os.path.join(datadir, obsfile)
skyFileName = os.path.join(datadir, skyfile)
wvlCalFileName = os.path.join(wvldir, wvlfile)
flatCalFileName = os.path.join(flatdir, flatfile)
fluxCalFileName = os.path.join(fluxdir, fluxfile)
"""
if len(sys.argv) >2:
fileNum = str(sys.argv[2])
else:
fileNum = '0'
#science object parameter file
params = []
paramfile = sys.argv[1]
f = open(paramfile,'r')
for line in f:
params.append(line)
f.close()
datadir = params[0].split('=')[1].strip()
flatdir = params[1].split('=')[1].strip()
wvldir = params[2].split('=')[1].strip()
obsfile = params[3].split('=')[1].strip()
skyfile = params[4].split('=')[1].strip()
flatfile = params[5].split('=')[1].strip()
wvlfile = params[6].split('=')[1].strip()
objectName = params[9].split('=')[1].strip()
wvldir = "/Scratch/waveCalSolnFiles/oldbox_numbers/20121206"
if len(params)>10:
xpix = int(params[10].split('=')[1].strip())
ypix = int(params[11].split('=')[1].strip())
apertureRadius = int(params[12].split('=')[1].strip())
startTime = int(params[13].split('=')[1].strip())
intTime =int(params[14].split('=')[1].strip())
obsFileName = os.path.join(datadir, obsfile)
skyFileName = os.path.join(datadir, skyfile)
wvlCalFileName = os.path.join(wvldir, wvlfile)
flatCalFileName = os.path.join(flatdir, flatfile)
obs = ObsFile(obsFileName)
obs.loadWvlCalFile(wvlCalFileName)
obs.loadFlatCalFile(flatCalFileName)
print "analyzing file %s"%(obsFileName)
print "loaded data file and calibrations\n---------------------\n"
nRow = obs.nRow
nCol = obs.nCol
obsTime = obs.getFromHeader("exptime")
#wvlBinEdges,obsSpectra = loadSpectra(obs,nCol,nRow)
#nWvlBins=len(wvlBinEdges)-1
#print np.shape(obsSpectra)
#print nRow
#print nCol
#print nWvlBins
#load/generate hot pixel mask file
HotPixFile = getTimeMaskFileName(obsFileName)
if not os.path.exists(HotPixFile):
hp.findHotPixels(obsFileName,HotPixFile)
print "Flux file pixel mask saved to %s"%(HotPixFile)
obs.loadHotPixCalFile(HotPixFile)
print "Hot pixel mask loaded %s"%(HotPixFile)
print "Making spectral cube"
#for pg0220 first sec should be 80 since object is moving around before this
#for pg0220A first sec should be 70, integration time is 140
#for landolt 9542 first sec should be 20, int time is -1
cubeDict = obs.getSpectralCube(firstSec=startTime, integrationTime=intTime, weighted=False)
cube= np.array(cubeDict['cube'], dtype=np.double)
wvlBinEdges= cubeDict['wvlBinEdges']
effIntTime= cubeDict['effIntTime']
print "median effective integration time = ", np.median(effIntTime)
nWvlBins=len(wvlBinEdges)-1
print "cube shape ", np.shape(cube)
print "effIntTime shape ", np.shape(effIntTime)
#add third dimension to effIntTime for broadcasting
effIntTime = np.reshape(effIntTime,np.shape(effIntTime)+(1,))
cube /= effIntTime
#calculate midpoints of wvl bins for plotting
wvls = np.empty((nWvlBins),dtype=float)
for n in xrange(nWvlBins):
binsize=wvlBinEdges[n+1]-wvlBinEdges[n]
wvls[n] = (wvlBinEdges[n]+(binsize/2.0))
print "wvls ",wvls
#reshape cube for makeMovie
movieCube = np.zeros((nWvlBins,np.shape(cube)[0],np.shape(cube)[1]),dtype=float)
for i in xrange(nWvlBins):
movieCube[i,:,:] = cube[:,:,i]
#show individual frames as they are made to debug
#plt.matshow(movieCube[i],vmin = 0, vmax = 100)
#plt.show()
print "movieCube shape ", np.shape(movieCube)
print "wvls shape ", np.shape(wvls)
#print cube
#print "--------------------------"
#print movieCube
np.savez('%s_raw_%s.npz'%(objectName,fileNum),stack=movieCube,wvls=wvls)
utils.makeMovie(movieCube,frameTitles=wvls,cbar=True,outName='%s_raw_%s.gif'%(objectName,fileNum), normMin=0, normMax=50)
'''
def main():
"""
params = []
paramfile = sys.argv[1]
f = open(paramfile,'r')
for line in f:
params.append(line)
f.close()
datadir = params[0].split('=')[1].strip()
flatdir = params[1].split('=')[1].strip()
fluxdir = params[2].split('=')[1].strip()
wvldir = params[3].split('=')[1].strip()
obsfile = params[4].split('=')[1].strip()
skyfile = params[5].split('=')[1].strip()
flatfile = params[6].split('=')[1].strip()
fluxfile = params[7].split('=')[1].strip()
wvlfile = params[8].split('=')[1].strip()
objectName = params[9].split('=')[1].strip()
fluxCalObject = params[10].split('=')[1].strip()
obsFileName = os.path.join(datadir, obsfile)
skyFileName = os.path.join(datadir, skyfile)
wvlCalFileName = os.path.join(wvldir, wvlfile)
flatCalFileName = os.path.join(flatdir, flatfile)
fluxCalFileName = os.path.join(fluxdir, fluxfile)
"""
if len(sys.argv) > 2:
fileNum = str(sys.argv[2])
else:
fileNum = "0"
# science object parameter file
params = []
paramfile = sys.argv[1]
f = open(paramfile, "r")
for line in f:
params.append(line)
f.close()
datadir = params[0].split("=")[1].strip()
flatdir = params[1].split("=")[1].strip()
wvldir = params[2].split("=")[1].strip()
obsfile = params[3].split("=")[1].strip()
skyfile = params[4].split("=")[1].strip()
flatfile = params[5].split("=")[1].strip()
wvlfile = params[6].split("=")[1].strip()
objectName = params[9].split("=")[1].strip()
# wvldir = "/Scratch/waveCalSolnFiles/oldbox_numbers/20121205"
# objectName = "crabNight1"
if len(params) > 10:
xpix = int(params[10].split("=")[1].strip())
ypix = int(params[11].split("=")[1].strip())
apertureRadius = int(params[12].split("=")[1].strip())
startTime = int(params[13].split("=")[1].strip())
intTime = int(params[14].split("=")[1].strip())
obsFileName = os.path.join(datadir, obsfile)
skyFileName = os.path.join(datadir, skyfile)
wvlCalFileName = os.path.join(wvldir, wvlfile)
flatCalFileName = os.path.join(flatdir, flatfile)
obs = ObsFile(obsFileName)
# obs.loadWvlCalFile(wvlCalFileName)
obs.loadBestWvlCalFile()
obs.loadFlatCalFile(flatCalFileName)
print "analyzing file %s" % (obsFileName)
print "loaded data file and calibrations\n---------------------\n"
nRow = obs.nRow
nCol = obs.nCol
obsTime = obs.getFromHeader("exptime")
# wvlBinEdges,obsSpectra = loadSpectra(obs,nCol,nRow)
# nWvlBins=len(wvlBinEdges)-1
# print np.shape(obsSpectra)
# print nRow
# print nCol
# print nWvlBins
# Apply Hot pixel masking before getting dead time correction
# HotPixFile = getTimeMaskFileName(obsFileName)
HotPixFile = FileName(obsFile=obs).timeMask()
print "making hot pixel file ", HotPixFile
if not os.path.exists(HotPixFile): # check if hot pix file already exists
hp.findHotPixels(inputFileName=obsFileName, outputFileName=HotPixFile)
print "Flux file pixel mask saved to %s" % (HotPixFile)
obs.loadHotPixCalFile(HotPixFile)
print "Hot pixel mask loaded %s" % (HotPixFile)
# GET RAW PIXEL COUNT IMAGE TO CALCULATE CORRECTION FACTORS
print "Making raw cube to get dead time correction"
cubeDict = obs.getSpectralCube(firstSec=startTime, integrationTime=intTime, weighted=False)
cube = np.array(cubeDict["cube"], dtype=np.double)
wvlBinEdges = cubeDict["wvlBinEdges"]
effIntTime = cubeDict["effIntTime"]
print "median effective integration time = ", np.median(effIntTime)
nWvlBins = len(wvlBinEdges) - 1
print "cube shape ", np.shape(cube)
print "effIntTime shape ", np.shape(effIntTime)
# add third dimension to effIntTime for broadcasting
effIntTime = np.reshape(effIntTime, np.shape(effIntTime) + (1,))
# put cube into counts/s in each pixel
cube /= effIntTime
# CALCULATE DEADTIME CORRECTION
# NEED TOTAL COUNTS PER SECOND FOR EACH PIXEL TO DO PROPERLY
# ASSUMES SAME CORRECTION FACTOR APPLIED FOR EACH WAVELENGTH, MEANING NO WL DEPENDANCE ON DEAD TIME EFFECT
DTCorr = np.zeros((np.shape(cube)[0], np.shape(cube)[1]), dtype=float)
for f in range(0, np.shape(cube)[2]):
print cube[:, :, f]
print "-----------------------"
DTCorr += cube[:, :, f]
print DTCorr
print "\n=====================\n"
# Correct for 100 us dead time
DTCorrNew = DTCorr / (1 - DTCorr * 100e-6)
CorrFactors = DTCorrNew / DTCorr # This is what the frames need to be multiplied by to get their true values
print "Dead time correction factors = "
print CorrFactors
# REMAKE CUBE WITH FLAT WEIGHTS AND APPLY DEAD TIME CORRECTION AS WELL
print "Making Weighted cube"
# load/generate hot pixel mask file
# HotPixFile = getTimeMaskFileName(obsFileName)
HotPixFile = FileName(obsFile=obs).timeMask()
if not os.path.exists(HotPixFile): # check if hot pix file already exists
hp.findHotPixels(inputFileName=obsFileName, outputFileName=HotPixFile)
print "Flux file pixel mask saved to %s" % (HotPixFile)
obs.loadHotPixCalFile(HotPixFile)
print "Hot pixel mask loaded %s" % (HotPixFile)
cubeDict = obs.getSpectralCube(firstSec=startTime, integrationTime=intTime, weighted=True, fluxWeighted=False)
# cubeDict = obs.getSpectralCube(firstSec=startTime, integrationTime=intTime, weighted=True, fluxWeighted=True)
cube = np.array(cubeDict["cube"], dtype=np.double)
wvlBinEdges = cubeDict["wvlBinEdges"]
effIntTime = cubeDict["effIntTime"]
print "median effective integration time = ", np.median(effIntTime)
nWvlBins = len(wvlBinEdges) - 1
print "cube shape ", np.shape(cube)
print "effIntTime shape ", np.shape(effIntTime)
# add third dimension to effIntTime for broadcasting
effIntTime = np.reshape(effIntTime, np.shape(effIntTime) + (1,))
# put cube into counts/s in each pixel
cube /= effIntTime
# add third dimension to CorrFactors for broadcasting
CorrFactors = np.reshape(CorrFactors, np.shape(CorrFactors) + (1,))
# apply dead time correction factors
cube *= CorrFactors
# calculate midpoints of wvl bins for plotting
wvls = np.empty((nWvlBins), dtype=float)
for n in xrange(nWvlBins):
binsize = wvlBinEdges[n + 1] - wvlBinEdges[n]
wvls[n] = wvlBinEdges[n] + (binsize / 2.0)
print "wvls ", wvls
# reshape cube for makeMovie
movieCube = np.zeros((nWvlBins, np.shape(cube)[0], np.shape(cube)[1]), dtype=float)
for i in xrange(nWvlBins):
movieCube[i, :, :] = cube[:, :, i]
# show individual frames as they are made to debug
# plt.matshow(movieCube[i],vmin = 0, vmax = 100)
# plt.show()
print "movieCube shape ", np.shape(movieCube)
print "wvls shape ", np.shape(wvls)
# print cube
# print "--------------------------"
# print movieCube
outdir = "/home/srmeeker/scratch/standards/"
np.savez(outdir + "%s_raw_%s.npz" % (objectName, fileNum), stack=movieCube, wvls=wvls)
utils.makeMovie(
movieCube,
frameTitles=wvls,
cbar=True,
outName=outdir + "%s_raw_%s.gif" % (objectName, fileNum),
normMin=0,
normMax=50,
)
"""
files = glob.glob(os.path.join(directory, "ImageStack*.npz"))
frames = []
jds = []
for fname in files:
sDict = np.load(fname)
#print sDict
stack = sDict['stack']
jd = sDict['jd']
print fname
print jd
print np.shape(stack)
print np.shape(jd)
#print stack
#print jd
for i in xrange(len(stack[0,0,:])):
print i
frames.append(stack[:,:,i])
jds.append(jd[i])
#plt.matshow(stack[:,:,i])
#plt.show()
print frames
print jds
np.savez(str(directory+outFname), stack=frames, jd=jds)
utils.makeMovie(frames,frameTitles=jds,cbar=True,outName=directory+'AllImageStack_20121208_30s_4000-5000_hp.gif', normMin=100, normMax=5000)
# utils.plotArray(frame,cbar=True)
# utils.plotArray(maFrame,cbar=True)
# utils.plotArray(fitimg,cbar=True)
# plt.show()
# utils.confirm('Enter to continue.')
frame[nanMask]=np.nan
# fig = plt.figure()
# ax1=fig.add_subplot(211)
# ax2 = fig.add_subplot(212)
# for iRow in range(len(frame)):
# ax1.scatter(range(44),frame[iRow,:],c='red',marker='o',alpha=.5,label='data')
# ax1.scatter(range(44),fitimg[iRow,:],c='blue',marker='^',alpha=.5,label='fit')
# ax1.set_title('Fit seen along Cols')
# for iCol in range(np.shape(frame)[1]):
# ax2.scatter(range(46),frame[:,iCol],c='red',marker='o',alpha=.5,label='data')
# ax2.scatter(range(46),fitimg[:,iCol],c='blue',marker='^',alpha=.5,label='fit')
# ax2.set_title('Fit seen along Rows')
# plt.show()
utils.makeMovie(fitImgList,cbar=True,outName='fit5.gif',normMax=1000)
cube = np.array(fitImgList)
chisqs = np.array(chisqList)
params = np.array(paramsList)
errors = np.array(errorsList)
np.savez('nlttFit5.npz',fitImg=cube,params=params,errors=errors,chisqs=chisqs,jd=jd)
fluxTstamp='ones'
flatTstamp='20131209'
obsFileName = FileName(run=run, date=date, tstamp=tstamp)
obsFile = ObsFile(obsFileName.obs())
frames = []
print '-----------------------'
print tstamp
for i in xrange(30):
print "making frame ", i
frame = obsFile.getFrame(10*i,10)
#plt.matshow(frame,vmin=10000,vmax=40000,cmap=plt.cm.gray)
#plt.show()
frames.append(frame)
makeMovie(frames,frameTitles=np.arange(30)*10,cbar=True,outName='%s.gif'%(tstamp), normMin=400, normMax=4000)
CentFile = FileName(run=run,date=date,tstamp=tstamp).centroidList()
obsFile.loadCentroidListFile(CentFile)
xs = obsFile.centroidListFile.getNode('/centroidlist/xPositions').read()
ys = obsFile.centroidListFile.getNode('/centroidlist/yPositions').read()
plt.figure()
ax1 = plt.subplot(111)
plt.plot(np.arange(len(xs)),xs,label="xs")
plt.plot(np.arange(len(ys)),ys,label='ys')
plt.legend()
plt.title(tstamp)
#plt.show()
plt.savefig(tstamp)
# plt.close()
# plt.close()
frame[nanMask]=np.nan
# fig = plt.figure()
# ax1=fig.add_subplot(211)
# ax2 = fig.add_subplot(212)
# for iRow in range(len(frame)):
# ax1.scatter(range(44),frame[iRow,:],c='red',marker='o',alpha=.5,label='data')
# ax1.scatter(range(44),fitimg[iRow,:],c='blue',marker='^',alpha=.5,label='fit')
# ax1.set_title('Fit seen along Cols')
# for iCol in range(np.shape(frame)[1]):
# ax2.scatter(range(46),frame[:,iCol],c='red',marker='o',alpha=.5,label='data')
# ax2.scatter(range(46),fitimg[:,iCol],c='blue',marker='^',alpha=.5,label='fit')
# ax2.set_title('Fit seen along Rows')
# plt.show()
plt.close()
print 'closed'
cube = np.array(fitImgList)
chisqs = np.array(chisqList)
params = np.array(paramsList)
errors = np.array(errorsList)
np.savez(npzfitpsf,fitImg=cube,params=params,errors=errors,chisqs=chisqs,jd=jd)
print 'saved'
utils.makeMovie(fitImgList,frameTitles=jd, cbar=True,outName=giffitpsf,normMin=200, normMax=5000)
timestamps = gtpl['timestamps']
timestamps *= cosmic.file.ticksPerSec
ts64 = timestamps.astype(np.uint64)
for ts in ts64:
tindex = ts-t0
try:
listOfPixelsToMark[tindex].append((iRow,iCol))
except IndexError:
pass
for tick in range(t0,t1):
frames.append(frameSum)
title = makeTitle(tick,t0,t1)
titles.append(title)
mfn0 = "m-%s-%s-%s-%s-%010d-%010d-i.gif"%(run,sundownDate,obsDate,seq,t0,t1)
utils.makeMovie(frames, titles, outName=mfn0, delay=0.1, colormap=mpl.cm.gray,
listOfPixelsToMark=listOfPixelsToMark,
pixelMarkColor='red')
for i in range(len(listOfPixelsToMark)-1):
listOfPixelsToMark[i+1].extend(listOfPixelsToMark[i])
mfn1 = "m-%s-%s-%s-%s-%010d-%010d-a.gif"%(run,sundownDate,obsDate,seq,t0,t1)
utils.makeMovie(frames, titles, outName=mfn1, delay=0.1, colormap=mpl.cm.gray,
listOfPixelsToMark=listOfPixelsToMark,
pixelMarkColor='green')
if __name__ == "__main__":
import sys
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)
# plt.close()
frame[nanMask]=np.nan
# fig = plt.figure()
# ax1=fig.add_subplot(211)
# ax2 = fig.add_subplot(212)
# for iRow in range(len(frame)):
# ax1.scatter(range(44),frame[iRow,:],c='red',marker='o',alpha=.5,label='data')
# ax1.scatter(range(44),fitimg[iRow,:],c='blue',marker='^',alpha=.5,label='fit')
# ax1.set_title('Fit seen along Cols')
# for iCol in range(np.shape(frame)[1]):
# ax2.scatter(range(46),frame[:,iCol],c='red',marker='o',alpha=.5,label='data')
# ax2.scatter(range(46),fitimg[:,iCol],c='blue',marker='^',alpha=.5,label='fit')
# ax2.set_title('Fit seen along Rows')
# plt.show()
plt.close()
print 'closed'
cube = np.array(fitImgList)
chisqs = np.array(chisqList)
params = np.array(paramsList)
errors = np.array(errorsList)
np.savez(npzfitpsf,fitImg=cube,params=params,errors=errors,chisqs=chisqs,jd=jd)
print 'saved'
utils.makeMovie(fitImgList,cbar=True,outName=giffitpsf)
#,normMax=1000)
guessX = param['guessX'][0]
guessY = param['guessY'][0]
stackDict = np.load(npzLoadFile)
stack = stackDict['stack']
wvls = stackDict['wvls']
print "The file actually has this many: ", len(wvls)
paramsList = []
errorsList = []
fitImgList = []
chisqList = []
plt.ion()
#remake hz21 gif with better color bar scaling
utils.makeMovie(stack,frameTitles=wvls,cbar=True,outName='hz21_raw_0.gif', normMin=0, normMax=2000)
for iFrame in range(0,np.shape(stack)[0]):
frame = stack[iFrame,:,:]
#print "Frame max= ", np.nanmax(frame,axis=None)
#frame *= CorrFactors
#print "Corrected Frame max= ", np.nanmax(frame,axis=None)
nanMask = np.isnan(frame)
#for interval in xrange(len(NumFrames)-1):
# if NumFrames[interval] != NumFrames[interval+1]:
# if NumFrames[interval] < iFrame <= NumFrames[interval+1]:
# guessX = guessX[interval]
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)
cube = np.dstack(frames)
times = np.array(times)
np.savez('nlttImageStack6000.npz',stack=cube,jd=times)
utils.makeMovie(showframes,cbar=True,frameTitles=titles,outName='nlttImageStack6000.gif')
