Example #1
0
File: tile.py Project: bmazin/SDR
def darknessSolution():
    tile0 = FreqMapTile(nRows=40, nCols=25, startFreq=4000.0, bandwidth=2000.0, verbosity=2, name="center")
    # tile0.addFreqHole(holeWidth=10.,holeCenter=1000.)
    tile0.minNeighborSeparation = 70
    tile0.minSecondNeighborSeparation = 8
    tile0.maxNeighborSeparation = 550
    tile0.simpleGradientSolution()

    tile1 = FreqMapTile(nRows=40, nCols=25, startFreq=6200.0, bandwidth=2000.0, verbosity=2, name="outer")
    # tile0.addFreqHole(holeWidth=10.,holeCenter=1000.)
    tile1.minNeighborSeparation = 70
    tile1.minSecondNeighborSeparation = 8
    tile1.maxNeighborSeparation = 550
    tile1.simpleGradientSolution()

    np.savetxt("darkness_center.txt", tile0.freqTable)
    np.savetxt("darkness_outer.txt", tile1.freqTable)

    plotArray(tile0[:, :], origin="upper")
    tile0.runSwaps(int(1e4))
    tile1.runSwaps(int(1e4))

    np.savetxt(
        "darkness_center_swap_{}min_{}max.txt".format(tile0.minNeighborSeparation, tile0.maxNeighborSeparation),
        tile0.freqTable,
    )
    np.savetxt(
        "darkness_outer_swap_{}min_{}max.txt".format(tile1.minNeighborSeparation, tile1.maxNeighborSeparation),
        tile1.freqTable,
    )

    combinedTile = np.vstack([tile1[0:20, :], tile0[:, :], tile1[20:, :]])
    np.savetxt("darkness_feedline.txt", combinedTile)

    print "saved!"
Example #2
0
File: tile.py Project: bmazin/SDR
def mecSolution():
    tile0 = FreqMapTile(nRows=73, nCols=14, startFreq=0.0, bandwidth=2000.0, verbosity=2, name="center")
    # tile0.addFreqHole(holeWidth=10.,holeCenter=1000.)
    tile0.minNeighborSeparation = 70
    tile0.minSecondNeighborSeparation = 8
    tile0.maxNeighborSeparation = 550
    tile0.simpleGradientSolution2()

    tile1 = FreqMapTile(nRows=73, nCols=14, startFreq=2200.0, bandwidth=2000.0, verbosity=2, name="outer")
    # tile0.addFreqHole(holeWidth=10.,holeCenter=1000.)
    tile1.minNeighborSeparation = 70
    tile1.minSecondNeighborSeparation = 8
    tile1.maxNeighborSeparation = 550
    tile1.simpleGradientSolution2()

    np.savetxt("mec_center.txt", tile0.freqTable)
    np.savetxt("mec_outer.txt", tile1.freqTable)

    tile0.runSwaps(int(1e4))
    tile1.runSwaps(int(1e4))

    np.savetxt(
        "mec_center_swap_{}min_{}max.txt".format(tile0.minNeighborSeparation, tile0.maxNeighborSeparation),
        tile0.freqTable,
    )
    np.savetxt(
        "mec_outer_swap_{}min_{}max.txt".format(tile1.minNeighborSeparation, tile1.maxNeighborSeparation),
        tile1.freqTable,
    )
    combinedTile = np.vstack([tile1[0:36, :], tile0[:, :], tile1[36:, :]])
    plotArray(combinedTile, origin="upper")
    np.savetxt("mec_feedline.txt", combinedTile, fmt="%.1f")

    print "saved!"
Example #3
0
def checkTile(tile,title=''):
    nRow,nCol= np.shape(tile)
    freqList = np.sort(np.reshape(tile,(-1,)))

    nearestDist = neighborDistClass(tile)
    minDists = ndimage.generic_filter(tile, nearestDist.minFilter, footprint=footprint,mode='constant',cval=np.inf)

    nearestDist = neighborDistClass(tile)
    minDists2 = ndimage.generic_filter(tile, nearestDist.minFilter, footprint=secondNeighborFootprint,mode='constant',cval=np.inf)

    nearestDist = neighborDistClass(tile)
    minDistsWrap = ndimage.generic_filter(tile, nearestDist.minFilter, footprint=sideFootprint,mode='wrap',cval=np.inf)

    nearestDist = neighborDistClass(tile)
    maxDists = ndimage.generic_filter(tile, nearestDist.maxFilter, footprint=footprint,mode='reflect')

    plotArray(title=title,image=tile,normNSigma=2.,origin='upper')
    plotArray(title='{} min dists wrap'.format(title),image=minDistsWrap,normNSigma=2.,origin='upper')
    plotArray(title='{} min dists'.format(title),image=minDists,normNSigma=2.,origin='upper')
    plotArray(title='{} min dists 2nd nearest'.format(title),image=minDists2,normNSigma=2.,origin='upper')
    plotArray(title='{} max dists'.format(title),image=maxDists,normNSigma=2.,origin='upper')

#    def f(thing):
#        thing.axes.hist(minDists.ravel(),bins=100)
#        thing.axes.set_title('{} min dists'.format(title))
#        
#    pop = PopUp(plotFunc=f)

    def f(thing):
        thing.axes.hist(minDists2.ravel(),bins=100)
        thing.axes.set_title('{} second neighbor min dists'.format(title))
        
    pop = PopUp(plotFunc=f)
Example #4
0
File: tile.py Project: bmazin/SDR
    def simpleGradientSolution(self):
        self.makeFreqList()
        idxStep = self.nCols

        # idxStep = int(np.floor(2.5*idxStep))+1
        # idxStep = 69 # min 67 MHz, max 700 MHz
        # idxStep = 87 # min 84 MHz, max 526 MHz

        idxList = np.arange(self.nFreqs)
        modIdxList = (idxList * idxStep) % (self.nFreqs) + ((idxList * idxStep) // self.nFreqs)

        print "idxStep", idxStep
        print "nFreqs", self.nFreqs

        diffIdxList = np.abs(np.diff(modIdxList))

        idxTable = np.reshape(modIdxList, (self.nCols, self.nRows)).T

        # do some flips so neighboring columns aren't next to others with close values
        nRowFlip = 4
        for iRowGroup in xrange(int(np.ceil(1.0 * self.nRows / nRowFlip))):
            slc = slice(iRowGroup * nRowFlip, (iRowGroup + 1) * nRowFlip)
            idxTable[slc, 1::2] = idxTable[slc, 1::2][::-1, :]

        nRowFlip = 8
        for iRowGroup in xrange(int(np.ceil(1.0 * self.nRows / nRowFlip))):
            slc = slice(iRowGroup * nRowFlip, (iRowGroup + 1) * nRowFlip)
            idxTable[slc, 1::2] = idxTable[slc, 1::2][::-1, :]

        # move cols around so 5 cols follows a pattern
        #        idxTable2 = np.array(idxTable)
        #        nColGroup = 5
        #        for i in range(self.nCols/nColGroup):
        #            idxTable[:,i::nColGroup] = idxTable2[:,i*nColGroup:(i+1)*nColGroup]

        # move the lowest frequency rows to the center and alternate placing higher frequency rows outward from center
        #        idxTable2 = np.array(idxTable)
        #        idxTable[0:self.nRows/2,:] = idxTable2[::-2]
        #        idxTable[self.nRows/2:,:] = idxTable2[::2]

        plotArray(idxTable)
        # make sure all the frequencies appear in the table exactly once
        assert np.all(np.sort(np.ravel(idxTable)) == np.arange(self.nFreqs))

        self.freqTable = self.freqList[idxTable]
        np.savetxt("idx.txt", idxTable)
        flatImg.mask = clipMask
        illumImg.mask = clipMask
        
        print 'removed ',np.sum(clipMask)-np.sum(nanMask),'pixels'

    rawList = rawImg[~rawImg.mask]
    flatList = flatImg[~flatImg.mask]
    illumList = illumImg[~illumImg.mask]

    #plotArray(title='with flatcal',image=flatImg)

    print 'raw count',len(rawList)
    print 'flat count',len(flatList)
    print 'illum count',len(illumList)

    plotArray(rawImg,title='raw')
    plotArray(illumImg,title='illumination corrected')
    plotArray(flatImg,title='flatfield corrected')

    binWidth = 20 #counts
    nBins = int(1.*len(flatList)/binWidth)
    rawHist,rawHistEdges = np.histogram(rawList,bins=nBins)
    flatHist,flatHistEdges = np.histogram(flatList,bins=rawHistEdges)
    illumHist,illumHistEdges = np.histogram(illumList,bins=rawHistEdges)

    rawFwhm = peakWidth(rawHistEdges[0:-1],rawHist)
    flatFwhm = peakWidth(flatHistEdges[0:-1],flatHist)
    illumFwhm = peakWidth(illumHistEdges[0:-1],illumHist)

    avgCounts = int(flatFwhm['peakX'])
    rawFwhmPercent = 100.*rawFwhm['sigma']/avgCounts
Example #6
0
File: tile.py Project: bmazin/SDR
    def simpleGradientSolution2(self):
        self.makeFreqList()
        idxStep = self.nCols

        # idxStep = int(np.floor(2.5*idxStep))+1
        # idxStep = 69 # min 67 MHz, max 700 MHz
        # idxStep = 87 # min 84 MHz, max 526 MHz

        idxList = np.arange(self.nFreqs)
        modIdxList = (idxList * idxStep) % (self.nFreqs) + ((idxList * idxStep) // self.nFreqs)

        print "idxStep", idxStep
        print "nFreqs", self.nFreqs

        diffIdxList = np.abs(np.diff(modIdxList))

        idxTable = np.reshape(modIdxList, (self.nCols, self.nRows)).T

        # do some flips so neighboring columns aren't next to others with close values
        nRowFlip = 4
        for iRowGroup in xrange(int(np.ceil(1.0 * self.nRows / nRowFlip))):
            slc = slice(iRowGroup * nRowFlip, (iRowGroup + 1) * nRowFlip)
            idxTable[slc, 1::2] = idxTable[slc, 1::2][::-1, :]

        nRowFlip = 8
        for iRowGroup in xrange(int(np.ceil(1.0 * self.nRows / nRowFlip))):
            slc = slice(iRowGroup * nRowFlip, (iRowGroup + 1) * nRowFlip)
            idxTable[slc, 1::2] = idxTable[slc, 1::2][::-1, :]

        # adjust last row

        idxTable2 = np.array(idxTable)
        idxTable[-1:, 1::2] = idxTable2[-10:-9, 1::2]
        idxTable[-10:-9, 1::2] = idxTable2[-1:, 1::2]

        idxTable[0, :] = idxTable2[8, :]
        idxTable[8, :] = idxTable2[0, :]

        # once more but shift down 1 row to make sure the last row gets a flip
        #        nRowFlip = 15
        #        for iRowGroup in xrange(int(np.ceil(1.*self.nRows/nRowFlip))):
        #            slc = slice(1+iRowGroup*nRowFlip,1+(iRowGroup+1)*nRowFlip)
        #            idxTable[slc,1::2] = idxTable[slc,1::2][::-1,:]

        # reverse order of odd cols
        # idxTable[:,:] = idxTable[:,::-1]

        # regroup cols
        #        idxTable2 = np.array(idxTable)
        #        nColGroup = 2 #nCols should be divisible by this
        #        nColInterleaves = self.nCols/nColGroup
        #        for i in range(nColInterleaves):
        #            idxTable[:,i::nColInterleaves] = idxTable2[:,i*nColGroup:(i+1)*nColGroup]

        # move the lowest frequency rows to the center and alternate placing higher frequency rows outward from center
        idxTable2 = np.array(idxTable)
        idxTable[0 : self.nRows / 2, :] = idxTable2[self.nRows % 2 :: 2, :][::-1, :]
        idxTable[self.nRows / 2 :, :] = idxTable2[::2]

        plotArray(idxTable, origin="upper", cmap="hot")
        # make sure all the frequencies appear in the table exactly once
        assert np.all(np.sort(np.ravel(idxTable)) == np.arange(self.nFreqs))

        self.freqTable = self.freqList[idxTable]
        np.savetxt("idx.txt", idxTable)
    def calculateWeights(self):
        """
        finds flat cal factors as medians/pixelSpectra for each pixel
        """
        cubeWeightsList = []
        self.averageSpectra = []
        deltaWeightsList = []
        for iCube,cube in enumerate(self.spectralCubes):
            effIntTime = self.cubeEffIntTimes[iCube]
            #for each time chunk
            wvlAverages = np.zeros(self.nWvlBins)
            spectra2d = np.reshape(cube,[self.nRow*self.nCol,self.nWvlBins ])
            for iWvl in xrange(self.nWvlBins):
                wvlSlice = spectra2d[:,iWvl]
                goodPixelWvlSlice = np.array(wvlSlice[wvlSlice != 0])#dead pixels need to be taken out before calculating averages
                nGoodPixels = len(goodPixelWvlSlice)

                #goodPixelWvlSlice = np.sort(goodPixelWvlSlice)
                #trimmedSpectrum = goodPixelWvlSlice[self.fractionOfPixelsToTrim*nGoodPixels:(1-self.fractionOfPixelsToTrim)*nGoodPixels]
                #trimmedPixelWeights = 1/np.sqrt(trimmedSpectrum)
                #histGood,binEdges = np.histogram(self.intTime*goodSpectrum,bins=nBins)
                #histTrim,binEdges = np.histogram(self.intTime*trimmedSpectrum,bins=binEdges)
#                plt.plot(binEdges[0:-1],histGood)
#                def f(fig,axes):
#                    axes.plot(binEdges[0:-1],histGood)
#                    axes.plot(binEdges[0:-1],histTrim)
#                pop(plotFunc=f)
#                plt.plot(binEdges[0:-1],histTrim)

                wvlAverages[iWvl] = np.median(goodPixelWvlSlice)
#                plt.show()
            weights = np.divide(wvlAverages,cube)
            weights[weights==0] = np.nan
            weights[weights==np.inf] = np.nan
            cubeWeightsList.append(weights)

            #Now to get uncertainty in weight:
            #Assuming negligible uncertainty in medians compared to single pixel spectra,
            #then deltaWeight=weight*deltaSpectrum/Spectrum
            #deltaWeight=weight*deltaRawCounts/RawCounts
            # with deltaRawCounts=sqrt(RawCounts)#Assuming Poisson noise
            #deltaWeight=weight/sqrt(RawCounts)
            # but 'cube' is in units cps, not raw counts 
            # so multiply by effIntTime before sqrt
            deltaWeights = weights/np.sqrt(effIntTime*cube)

            deltaWeightsList.append(deltaWeights)
            self.averageSpectra.append(wvlAverages)
        cubeWeights = np.array(cubeWeightsList)
        deltaCubeWeights = np.array(deltaWeightsList)
        cubeWeightsMask = np.isnan(cubeWeights)
        self.maskedCubeWeights = np.ma.array(cubeWeights,mask=cubeWeightsMask,fill_value=1.)
        self.maskedCubeDeltaWeights = np.ma.array(deltaCubeWeights,mask=cubeWeightsMask)

        #sort maskedCubeWeights and rearange spectral cubes the same way
        sortedIndices = np.ma.argsort(self.maskedCubeWeights,axis=0)
        identityIndices = np.ma.indices(np.shape(self.maskedCubeWeights))

        sortedWeights = self.maskedCubeWeights[sortedIndices,identityIndices[1],identityIndices[2],identityIndices[3]]
        countCubesReordered = self.countCubes[sortedIndices,identityIndices[1],identityIndices[2],identityIndices[3]]
        cubeDeltaWeightsReordered = self.maskedCubeDeltaWeights[sortedIndices,identityIndices[1],identityIndices[2],identityIndices[3]]

        #trim the beginning and end off the sorted weights for each wvl for each pixel, to exclude extremes from averages
        nCubes = np.shape(self.maskedCubeWeights)[0]
        trimmedWeights = sortedWeights[self.fractionOfChunksToTrim*nCubes:(1-self.fractionOfChunksToTrim)*nCubes,:,:,:]
        trimmedCountCubesReordered = countCubesReordered[self.fractionOfChunksToTrim*nCubes:(1-self.fractionOfChunksToTrim)*nCubes,:,:,:]
        print 'trimmed cubes shape',np.shape(trimmedCountCubesReordered)

        self.totalCube = np.ma.sum(trimmedCountCubesReordered,axis=0)
        self.totalFrame = np.ma.sum(self.totalCube,axis=-1)
        plotArray(self.totalFrame)
    

        trimmedCubeDeltaWeightsReordered = cubeDeltaWeightsReordered[self.fractionOfChunksToTrim*nCubes:(1-self.fractionOfChunksToTrim)*nCubes,:,:,:]

        self.flatWeights,summedAveragingWeights = np.ma.average(trimmedWeights,axis=0,weights=trimmedCubeDeltaWeightsReordered**-2.,returned=True)
        self.deltaFlatWeights = np.sqrt(summedAveragingWeights**-1.)#Uncertainty in weighted average is sqrt(1/sum(averagingWeights))
        self.flatFlags = self.flatWeights.mask

        #normalize weights at each wavelength bin
        wvlWeightMedians = np.ma.median(np.reshape(self.flatWeights,(-1,self.nWvlBins)),axis=0)
        self.flatWeights = np.divide(self.flatWeights,wvlWeightMedians)
    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)

    
iFrameList = range(len(ofs.frameObsInfos))

image_list = []

for iFrame in iFrameList:
    c = data[iFrame]['cube']
    c = np.sum(c, axis = 2)
    t = data[iFrame]['effIntTime']
    image = c/t
    nanspot = np.isnan(image)
    image[nanspot] = 0
    image_list.append(image)

#these are all the matching stars i found in the 66 frames
#frame_list = np.array([image_list[0], image_list[10], image_list[11], image_list[18], image_list[19], image_list[28], image_list[29], image_list[34], image_list[35], image_list[36], image_list[37], image_list[42], image_list[43], image_list[65]])

#these are the frames previously used in chris's example
frame_list = np.array([image_list[0], image_list[28], image_list[29], image_list[65]])

#degPerPix, theta, raArcsecPerSec = ObsFileSeq.ObjectFinder(image_list, fd, RA, Dec)
degPerPix, theta, raArcsecPerSec = mf.ObjectFinder(frame_list, fd, RA, Dec)

ofs.setRm(degPerPix,
          math.degrees((theta)),
          raArcsecPerSec,
        )

mosaic = ofs.makeMosaicImage(range(66))

plotArray(mosaic)
Example #10
0
    phaseFilename = os.path.join(os.path.join('/Scratch/filterData/',date),'ch_snap_r{}p{}_{}secs.dat'.format(roachNum,pixelNum,nSecs))
    dataFile = open(phaseFilename,'r')
    data = dataFile.read()
    nQdrWords=2**19 #for firmware with  qdr longsnap
    nBytesPerWord=4 #bytes in each qdr row/word
    nBytesPerSample=2 #bytes in a fix16_13 phase sample
    nSamples = nQdrWords*(nBytesPerWord/nBytesPerSample)*nSecs
    intValues = struct.unpack('>%dh'%(nSamples),data)
    phaseValuesRad = np.array(intValues,dtype=np.float32)/2**13 #move binary point
    phaseValuesDeg = 180./np.pi*phaseValuesRad

    covDict = covFromData(phaseValuesDeg,size=800,nTrials=None)
    covMatrix = covDict['covMatrix']
    covMatrixInv = covDict['covMatrixInv']
    print 'cov done'
    plotArray(covMatrix,title='cov',origin='upper')
    plotArray(covMatrixInv,title='cov^{-1}',origin='upper')

    maxIndex = np.argmax(template)
    if filterSize < len(template):
        template = template[maxIndex-5:maxIndex-5+filterSize]
    
    matchedFilter = makeMatchedFilter(template,covMatrixInv)
    superMatchedFilter = makeSuperMatchedFilter(template,covMatrixInv)
    print np.shape(superMatchedFilter)
    
    bPlotCoeffs = True
    if bPlotCoeffs:
        fig,ax = plt.subplots(1,1)
        ax.plot(wienerFilterCoeffs,'r.-',label='wiener')
        ax.plot(matchedFilter,'b.-',label='matched')
clippedBeforeImg = sigma_clip(beforeImg,sig=3)
clipMask = clippedBeforeImg.mask
beforeImg[clipMask] = 0
afterImg[clipMask] = 0

deadBeforeImg = (beforeImg == 0)
deadAfterImg = (afterImg == 0)

beforeList = beforeImg[beforeImg != 0]
afterList = afterImg[afterImg != 0]

afterImg[deadAfterImg] = np.nan
beforeImg[deadBeforeImg] = np.nan

plotArray(title='without flatcal',image=beforeImg)
#plotArray(title='with flatcal',image=afterImg)

def plotFunc(fig,axes):
    axes.plot(beforeHistEdges[0:-1],beforeHist,label='without flatcal')
    axes.plot(afterHistEdges[0:-1],afterHist,label='with flatcal')
    axes.set_title('Distribution of pixel counts')
    axes.set_xlabel('Counts')
    axes.set_ylabel('Num of Pixels')
    axes.legend()
#pop(plotFunc=plotFunc)

print 'before count',len(beforeList)
print 'after count',len(afterList)

# Fit a 3rd order, 2d polynomial to the non-flatcal image
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)