def test(self, data, dataId): self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) if len(self.visits) == 0: visitList = [ dataId['visit'], ] else: visitList = self.visits # Implement for 1 visit comparison visit = visitList[0] self.visitMatches = data.getVisitMatchesBySensor( self.database, visit, dataId) # create containers for data we're interested in self.dRa = raftCcdData.RaftCcdVector(self.detector) self.dDec = raftCcdData.RaftCcdVector(self.detector) self.x = raftCcdData.RaftCcdVector(self.detector) self.y = raftCcdData.RaftCcdVector(self.detector) if data.cameraInfo.name == "coadd": badFlags = measAlg.Flags.SATUR_CENTER | measAlg.Flags.EDGE # coadds have excessive area covered by INTERP_CENTER flags else: badFlags = measAlg.Flags.INTERP_CENTER | measAlg.Flags.SATUR_CENTER | measAlg.Flags.EDGE for key in self.matchListDictSrc.keys(): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() # All detections matched to ref objects srcMatchList = self.matchListDictSrc[key]['matched'] # All visit dets in footprint of original image visMatchList = self.visitMatches[key] # List of reference object ids srcObjIds = num.array([x[0].getId() for x in srcMatchList]) visObjIds = num.array([x[0].getId() for x in visMatchList]) common = list(set(srcObjIds) & set(visObjIds)) self.log.log(self.log.INFO, "%s : " % (key)) if len(common) == 0: self.log.log( self.log.WARN, " No overlap, Using pre-to-post PT1.2 objectID mapping..." ) # Try objectID hack from PT1.2 to post-PT1.2: visObjIds *= 2 isStar = (num.array( [x[0].getFlagForDetection() for x in visMatchList]) & measAlg.Flags.STAR) > 0 visObjIds += isStar common = list(set(srcObjIds) & set(visObjIds)) self.log.log(self.log.INFO, " Found %d matches" % (len(common))) # Iterate over all object ids for i in range(len(common)): srcObjId = common[i] idxS = num.where(srcObjIds == srcObjId)[0] idxV = num.where(visObjIds == srcObjId)[0] # only take 1-to-1 matches if len(idxS) != 1 or len(idxV) != 1: continue sref1 = srcMatchList[idxS[0]][0] srcv1 = srcMatchList[idxS[0]][1] sref2 = visMatchList[idxV[0]][0] srcv2 = visMatchList[idxV[0]][1] #coord1 = afwCoord.Coord(afwGeom.Point2D(srcv1.getRa(), srcv1.getDec())) # coords originally in degrees #coord2 = afwCoord.Coord(afwGeom.Point2D(srcv2.getRa(), srcv2.getDec())) # coords originally in degrees #angle = coord1.angularSeparation(coord2) # Measurment flags; note no star/gal separation yet flags1 = srcv1.getFlagForDetection() flags2 = srcv2.getFlagForDetection() # Get star/gal info here isStar = sref1.getFlagForDetection() & measAlg.Flags.STAR if (not flags1 & badFlags) and ( not flags2 & badFlags) and isStar: ra1, dec1, ra2, dec2 = [ x * num.pi / 180.0 for x in (srcv1.getRa(), srcv1.getDec(), srcv2.getRa(), srcv2.getDec()) ] dRa = (ra1 - ra2) * abs(num.cos(dec1)) dDec = (dec1 - dec2) self.dRa.append(raft, ccd, dRa) self.dDec.append(raft, ccd, dDec) self.x.append(raft, ccd, srcv1.getXAstrom()) self.y.append(raft, ccd, srcv1.getYAstrom()) testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) self.medErrArcsec = raftCcdData.RaftCcdData(self.detector) self.medThetaRad = raftCcdData.RaftCcdData(self.detector) for raft, ccd in self.dRa.raftCcdKeys(): dRa = self.dRa.get(raft, ccd) dDec = self.dDec.get(raft, ccd) errArcsec = 206265.0 * num.sqrt(dRa**2 + dDec**2) thetaRad = num.arctan2(dDec, dRa) if len(errArcsec) > 0: stat = afwMath.makeStatistics(errArcsec, afwMath.NPOINT | afwMath.MEDIAN) medErrArcsec = stat.getValue(afwMath.MEDIAN) stat = afwMath.makeStatistics(thetaRad, afwMath.NPOINT | afwMath.MEDIAN) medThetaRad = stat.getValue(afwMath.MEDIAN) n = stat.getValue(afwMath.NPOINT) else: medErrArcsec = -1.0 medThetaRad = 0.0 n = 0 self.medErrArcsec.set(raft, ccd, medErrArcsec) self.medThetaRad.set(raft, ccd, medThetaRad) areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "median astrometry error " comment = "median sqrt(dRa^2+dDec^2) (arcsec, nstar=%d)" % (n) test = testCode.Test(label, medErrArcsec, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test)
def test(self, data, dataId): # get data self.ssDict = data.getSourceSetBySensor(dataId) self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) # create containers for data we're interested in self.x = raftCcdData.RaftCcdVector(self.detector) self.y = raftCcdData.RaftCcdVector(self.detector) self.xmat = raftCcdData.RaftCcdVector(self.detector) self.ymat = raftCcdData.RaftCcdVector(self.detector) # fill containers with values we need for our test filter = None self.size = raftCcdData.RaftCcdData(self.detector, initValue=[1.0, 1.0]) for key, ss in self.ssDict.items(): xKey = self.sCatDummy.XAstromKey yKey = self.sCatDummy.YAstromKey raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() bbox = self.detector[key].getAllPixels(True) size = [ bbox.getMaxX() - bbox.getMinX(), bbox.getMaxY() - bbox.getMinY() ] self.size.set(raft, ccd, size) filter = self.filter[key].getName() for s in ss: self.x.append(raft, ccd, s.getD(xKey)) self.y.append(raft, ccd, s.getD(yKey)) if self.matchListDictSrc.has_key(key): for m in self.matchListDictSrc[key]['matched']: sref, s, dist = m self.xmat.append(raft, ccd, s.getD(xKey)) self.ymat.append(raft, ccd, s.getD(yKey)) # create a testset testSet = self.getTestSet(data, dataId) # this normally gets set in the plot as that's where the caching happens, # here we're stashing the nDetection and nCcd values, so we need to set it early. testSet.setUseCache(self.useCache) testSet.addMetadata({"Description": self.description}) # analyse each sensor and put the values in a raftccd container self.emptySectors = raftCcdData.RaftCcdData(self.detector, initValue=self.nx * self.ny) self.emptySectorsMat = raftCcdData.RaftCcdData(self.detector, initValue=self.nx * self.ny) countBase = "countShelf" nShelf = testSet.unshelve(countBase) for raft, ccd in self.emptySectors.raftCcdKeys(): x, y = self.x.get(raft, ccd), self.y.get(raft, ccd) xmat, ymat = self.xmat.get(raft, ccd), self.ymat.get(raft, ccd) xwid, ywid = self.size.get(raft, ccd) xlo, ylo = 0.0, 0.0 if data.cameraInfo.name == 'coadd': xlo, ylo, xhi, yhi = x.min(), y.min(), x.max(), y.max() xwid, ywid = xhi - xlo, yhi - ylo def countEmptySectors(x, y): counts = numpy.zeros([self.nx, self.ny]) for i in range(len(x)): xi, yi = int(self.nx * x[i] / xwid), int(self.ny * y[i] / ywid) if xi >= 0 and xi < self.nx and yi >= 0 and yi < self.ny: counts[xi, yi] += 1 whereEmpty = numpy.where(counts.flatten() == 0)[0] nEmpty = len(whereEmpty) return nEmpty nEmpty = countEmptySectors(x - xlo, y - ylo) nEmptyMat = countEmptySectors(xmat - xlo, ymat - ylo) self.emptySectors.set(raft, ccd, nEmpty) self.emptySectorsMat.set(raft, ccd, nEmptyMat) # add tests for acceptible numpy of empty sectors areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "empty ccd regions" comment = "%dx%d (nstar=%d)" % (self.nx, self.ny, len(x)) test = testCode.Test(label, nEmpty, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test) test = testCode.Test(label + " (matched)", nEmptyMat, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test) nShelf[ccd] = len(x) testSet.shelve(countBase, nShelf) nCcd, nDet = 0, 0 for k, v in nShelf.items(): if v > 0: nCcd += 1 nDet += v # a bit sketchy adding tests in the plot section, but these are dummies # they pass useful numbers through to the display, but don't actually test # anything useful test = testCode.Test("nDetections", nDet, [1, None], "number of detected sources", areaLabel="all") testSet.addTest(test) test = testCode.Test("nCcd", nCcd, [1, None], "number of ccds processed", areaLabel="all") testSet.addTest(test)
def test(self, data, dataId, fluxType="psf"): testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) self.fluxType = fluxType self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.orphan = raftCcdData.RaftCcdVector(self.detector) self.matchedStar = raftCcdData.RaftCcdVector(self.detector) self.blendedStar = raftCcdData.RaftCcdVector(self.detector) self.undetectedStar = raftCcdData.RaftCcdVector(self.detector) self.matchedGalaxy = raftCcdData.RaftCcdVector(self.detector) self.blendedGalaxy = raftCcdData.RaftCcdVector(self.detector) self.undetectedGalaxy = raftCcdData.RaftCcdVector(self.detector) self.depth = raftCcdData.RaftCcdData(self.detector) if hasMinuit: self.fit = raftCcdData.RaftCcdData(self.detector, initValue=[0.0, 0.0]) sCatDummy = pqaSource.Catalog().catalog sCatSchema = sCatDummy.getSchema() srefCatDummy = pqaSource.RefCatalog().catalog srefCatSchema = srefCatDummy.getSchema() psfKey = sCatSchema.find('PsfFlux').key psfErrKey = sCatSchema.find('PsfFluxErr').key apKey = sCatSchema.find('ApFlux').key apErrKey = sCatSchema.find('ApFluxErr').key extKey = sCatSchema.find('Extendedness').key refPsfKey = srefCatSchema.find('PsfFlux').key self.faintest = 0.0 for key in self.detector.keys(): raftId = self.detector[key].getParent().getId().getName() ccdId = self.detector[key].getId().getName() filterName = self.filter[key].getName() if self.matchListDictSrc.has_key(key): # Detections matchSet = [[ self.matchListDictSrc[key]['matched'], self.matchedStar, self.matchedGalaxy ], [ self.matchListDictSrc[key]['blended'], self.blendedStar, self.blendedGalaxy ]] for mset in matchSet: mdict, starvec, galvec = mset stars = [] galaxies = [] for m in mdict: sref, s, dist = m if fluxType == "psf": fref = sref.getD(refPsfKey) f = s.getD(psfKey) ferr = s.getD(psfErrKey) else: fref = sref.getD(refPsfKey) f = s.getD(apKey) ferr = s.getD(apErrKey) if (fref > 0.0 and f > 0.0): # Use known catalog mag mrefmag = -2.5 * num.log10(fref) if num.isfinite(mrefmag): if mrefmag > self.faintest: self.faintest == mrefmag if s.getD(extKey) > 0.0: galaxies.append(mrefmag) else: stars.append(mrefmag) starvec.set(raftId, ccdId, num.array(stars)) galvec.set(raftId, ccdId, num.array(galaxies)) # Non-detections undetectedStars = [] undetectedGalaxies = [] for nondet in self.matchListDictSrc[key]['undetected']: mag = nondet.getMag(filterName) if mag > self.faintest: self.faintest = mag if nondet.getIsStar(): undetectedStars.append(mag) else: undetectedGalaxies.append(mag) self.undetectedStar.set(raftId, ccdId, num.array(undetectedStars)) self.undetectedGalaxy.set(raftId, ccdId, num.array(undetectedGalaxies)) # Orphans orphans = [] for orphan in self.matchListDictSrc[key]['orphan']: if self.fluxType == "psf": f = orphan.getD(psfKey) else: f = orphan.getD(apKey) if f > 0.0: orphmag = -2.5 * num.log10(f) orphans.append(orphmag) if orphmag > self.faintest: self.faintest = orphmag self.orphan.set(raftId, ccdId, num.array(orphans)) ############ Calculate limiting mag maxDepth = self.limitingMag(raftId, ccdId) self.depth.set(raftId, ccdId, maxDepth) areaLabel = data.cameraInfo.getDetectorName(raftId, ccdId) label = "photometric depth " comment = "magnitude where star completeness drops below 0.5" test = testCode.Test(label, maxDepth, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test)
def test(self, data, dataId): # get data self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) #self.clusters = data.getSourceClusters(dataId) # compute the mean ra, dec for each source cluster self.dRa = raftCcdData.RaftCcdVector(self.detector) self.dDec = raftCcdData.RaftCcdVector(self.detector) self.x = raftCcdData.RaftCcdVector(self.detector) self.y = raftCcdData.RaftCcdVector(self.detector) self.sCatDummy = pqaSource.Catalog() sCatDummy = self.sCatDummy.catalog sCatSchema = sCatDummy.getSchema() self.srefCatDummy = pqaSource.RefCatalog() srefCatDummy = self.srefCatDummy.catalog srefCatSchema = srefCatDummy.getSchema() xKey = sCatSchema.find('XAstrom').key yKey = sCatSchema.find('YAstrom').key raKey = sCatSchema.find('Ra').key decKey = sCatSchema.find('Dec').key refRaKey = srefCatSchema.find('Ra').key refDecKey = srefCatSchema.find('Dec').key filter = None key = None for key in self.matchListDictSrc.keys(): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() filter = self.filter[key].getName() matchList = self.matchListDictSrc[key]['matched'] for m in matchList: sref, s, dist = m ra, dec, raRef, decRef = \ [numpy.radians(x) for x in [s.getD(raKey), s.getD(decKey), \ sref.getD(refRaKey), sref.getD(refDecKey)]] dDec = decRef - dec dRa = (raRef - ra)*abs(numpy.cos(decRef)) intcen = s.getD(self.sCatDummy.FlagPixInterpCenKey) satcen = s.getD(self.sCatDummy.FlagPixSaturCenKey) edge = s.getD(self.sCatDummy.FlagPixEdgeKey) if data.cameraInfo.name == 'coadd': flagit = (satcen or edge) # coadds have excessive area covered by InterpCen flags else: flagit = (intcen or satcen or edge) if not (flagit): self.dRa.append(raft, ccd, dRa) self.dDec.append(raft, ccd, dDec) self.x.append(raft, ccd, s.getD(xKey)) self.y.append(raft, ccd, s.getD(yKey)) testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) self.medErrArcsec = raftCcdData.RaftCcdData(self.detector) self.medThetaRad = raftCcdData.RaftCcdData(self.detector) for raft, ccd in self.dRa.raftCcdKeys(): dRa = self.dRa.get(raft, ccd).copy() dDec = self.dDec.get(raft, ccd).copy() if len(dRa) > 0: dRaMed = numpy.median(dRa) dDecMed = numpy.median(dDec) else: dRaMed = 0.0 dDecMed = 0.0 sysErr = numpy.sqrt(dRaMed**2 + dDecMed**2)*afwGeom.radians sysErrArcsec = sysErr.asArcseconds() sysThetaRad = numpy.arctan2(dDecMed, dRaMed) dRa -= dRaMed dDec -= dDecMed rmsErr = numpy.sqrt(dRa**2 + dDec**2) rmsThetaRad = numpy.arctan2(dDec, dRa) if len(rmsErr) > 0: stat = afwMath.makeStatistics(rmsErr, afwMath.NPOINT | afwMath.MEDIAN) medRmsErr = stat.getValue(afwMath.MEDIAN) stat = afwMath.makeStatistics(rmsThetaRad, afwMath.NPOINT | afwMath.MEDIAN) medRmsThetaRad = stat.getValue(afwMath.MEDIAN) n = stat.getValue(afwMath.NPOINT) else: medRmsErr = -1.0 medRmsThetaRad = 0.0 n = 0 medRmsErr = medRmsErr*afwGeom.radians self.medErrArcsec.set(raft, ccd, sysErrArcsec) self.medThetaRad.set(raft, ccd, sysThetaRad) areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "median systematic astrometry error " comment = "median sqrt(dRa^2+dDec^2) (arcsec, nstar=%d)" % (n) test = testCode.Test(label, sysErrArcsec, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test) label = "median random astrometry error " comment = "median sqrt((dRa-dRaMed)^2+(dDec-dDecMed)^2) (arcsec, nstar=%d)" % (n) test = testCode.Test(label, medRmsErr.asArcseconds(), self.limits, comment, areaLabel=areaLabel) testSet.addTest(test)
def test(self, data, dataId): # get data self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) self.derr = raftCcdData.RaftCcdVector(self.detector) self.diff = raftCcdData.RaftCcdVector(self.detector) self.mag = raftCcdData.RaftCcdVector(self.detector) self.x = raftCcdData.RaftCcdVector(self.detector) self.y = raftCcdData.RaftCcdVector(self.detector) self.star = raftCcdData.RaftCcdVector(self.detector) filter = None self.matchListDictSrc = None self.ssDict = None # if we're asked to compare catalog fluxes ... we need a matchlist if self.magType1 == "cat" or self.magType2 == "cat": self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') for key in self.matchListDictSrc.keys(): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() filter = self.filter[key].getName() matchList = self.matchListDictSrc[key]['matched'] #qaAnaUtil.isStar(matchList) for m in matchList: sref, s, dist = m f1 = self._getFlux(self.magType1, s, sref) f2 = self._getFlux(self.magType2, s, sref) df1 = self._getFluxErr(self.magType1, s, sref) df2 = self._getFluxErr(self.magType2, s, sref) #badFlags = pqaSource.INTERP_CENTER | pqaSource.SATUR_CENTER | pqaSource.EDGE intcen = s.getD(self.sCatDummy.FlagPixInterpCenKey) satcen = s.getD(self.sCatDummy.FlagPixSaturCenKey) edge = s.getD(self.sCatDummy.FlagPixEdgeKey) if data.cameraInfo.name == 'coadd': flagit = ( satcen or edge ) # coadds have excessive area covered by InterpCen flags else: flagit = (intcen or satcen or edge) if (f1 > 0.0 and f2 > 0.0 and not flagit): m1 = -2.5 * numpy.log10(f1) m2 = -2.5 * numpy.log10(f2) dm1 = 2.5 / numpy.log(10.0) * df1 / f1 dm2 = 2.5 / numpy.log(10.0) * df2 / f2 star = 0 if s.getD( self.sCatDummy.ExtendednessKey) else 1 if numpy.isfinite(m1) and numpy.isfinite(m2): self.derr.append(raft, ccd, numpy.sqrt(dm1**2 + dm2**2)) self.diff.append(raft, ccd, m1 - m2) self.mag.append(raft, ccd, m1) self.x.append(raft, ccd, s.getD(self.sCatDummy.XAstromKey)) self.y.append(raft, ccd, s.getD(self.sCatDummy.YAstromKey)) self.star.append(raft, ccd, star) # if we're not asked for catalog fluxes, we can just use a sourceSet else: self.ssDict = data.getSourceSetBySensor(dataId) for key, ss in self.ssDict.items(): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() filter = self.filter[key].getName() #qaAnaUtil.isStar(ss) # sets the 'STAR' flag for s in ss: f1 = self._getFlux(self.magType1, s, s) f2 = self._getFlux(self.magType2, s, s) df1 = self._getFluxErr(self.magType1, s, s) df2 = self._getFluxErr(self.magType2, s, s) intcen = s.getD(self.sCatDummy.FlagPixInterpCenKey) satcen = s.getD(self.sCatDummy.FlagPixSaturCenKey) edge = s.getD(self.sCatDummy.FlagPixEdgeKey) if data.cameraInfo.name == 'coadd': flagit = ( satcen or edge ) # coadds have excessive area covered by InterpCen flags else: flagit = (intcen or satcen or edge) if ((f1 > 0.0 and f2 > 0.0) and not flagit): m1 = -2.5 * numpy.log10( f1) #self.calib[key].getMagnitude(f1) m2 = -2.5 * numpy.log10( f2) #self.calib[key].getMagnitude(f2) dm1 = 2.5 / numpy.log(10.0) * df1 / f1 dm2 = 2.5 / numpy.log(10.0) * df2 / f2 star = 0 if s.getD( self.sCatDummy.ExtendednessKey) else 1 #if star: # print "isStar: ", star if numpy.isfinite(m1) and numpy.isfinite(m2): self.derr.append(raft, ccd, numpy.sqrt(dm1**2 + dm2**2)) self.diff.append(raft, ccd, m1 - m2) self.mag.append(raft, ccd, m1) self.x.append(raft, ccd, s.getD(self.sCatDummy.XAstromKey)) self.y.append(raft, ccd, s.getD(self.sCatDummy.YAstromKey)) self.star.append(raft, ccd, star) testSet = self.getTestSet(data, dataId, label=self.magType1 + "-" + self.magType2) testSet.addMetadata('magType1', self.magType1) testSet.addMetadata('magType2', self.magType2) testSet.addMetadata({"Description": self.description}) self.means = raftCcdData.RaftCcdData(self.detector) self.medians = raftCcdData.RaftCcdData(self.detector) self.stds = raftCcdData.RaftCcdData(self.detector) self.derrs = raftCcdData.RaftCcdData(self.detector) self.trend = raftCcdData.RaftCcdData(self.detector, initValue=[0.0, 0.0]) self.dmagMax = 0.4 allMags = numpy.array([]) allDiffs = numpy.array([]) for raft, ccd in self.mag.raftCcdKeys(): dmag0 = self.diff.get(raft, ccd) mag0 = self.mag.get(raft, ccd) derr0 = self.derr.get(raft, ccd) star = self.star.get(raft, ccd) wGxy = numpy.where((mag0 > 10) & (mag0 < self.magCut) & (star == 0) & (numpy.abs(dmag0) < 1.0))[0] w = numpy.where((mag0 > 10) & (mag0 < self.magCut) & (star > 0))[0] mag = mag0[w] dmag = dmag0[w] derr = derr0[w] allMags = numpy.append(allMags, mag) allDiffs = numpy.append(allDiffs, dmag) # already using NaN for 'no-data' for this ccd # (because we can't test for 'None' in a numpy masked_array) # unfortunately, these failures will have to do mean = 99.0 median = 99.0 std = 99.0 derrmed = 99.0 n = 0 lineFit = [[99.0, 0.0, 0.0, 0.0]] * 3 lineCoeffs = [[99.0, 0.0]] * 3 if len(dmag) > 0: stat = afwMath.makeStatistics( dmag, afwMath.NPOINT | afwMath.MEANCLIP | afwMath.STDEVCLIP | afwMath.MEDIAN) mean = stat.getValue(afwMath.MEANCLIP) median = stat.getValue(afwMath.MEDIAN) std = stat.getValue(afwMath.STDEVCLIP) n = stat.getValue(afwMath.NPOINT) derrmed = afwMath.makeStatistics( derr, afwMath.MEDIAN).getValue(afwMath.MEDIAN) # get trendlines for stars/galaxies # for alldata, use trendline for stars if len(dmag) > 1: lineFit[0] = qaAnaUtil.robustPolyFit(mag, dmag, 1) lineCoeffs[0] = lineFit[0][0], lineFit[0][2] if len(wGxy) > 1: lineFit[1] = qaAnaUtil.robustPolyFit( mag0[wGxy], dmag0[wGxy], 1) lineCoeffs[1] = lineFit[1][0], lineFit[1][2] lineFit[2] = lineFit[0] lineCoeffs[2] = lineCoeffs[0] tag = self.magType1 + "_vs_" + self.magType2 dtag = self.magType1 + "-" + self.magType2 self.means.set(raft, ccd, mean) areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "mean " + tag # +" " + areaLabel comment = "mean " + dtag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmag), n) testSet.addTest( testCode.Test(label, mean, self.deltaLimits, comment, areaLabel=areaLabel)) self.medians.set(raft, ccd, median) label = "median " + tag #+" "+areaLabel comment = "median " + dtag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmag), n) testSet.addTest( testCode.Test(label, median, self.deltaLimits, comment, areaLabel=areaLabel)) self.stds.set(raft, ccd, std) label = "stdev " + tag #+" " + areaLabel comment = "stdev of " + dtag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmag), n) testSet.addTest( testCode.Test(label, std, self.rmsLimits, comment, areaLabel=areaLabel)) self.derrs.set(raft, ccd, derrmed) label = "derr " + tag comment = "add phot err in quad for " + dtag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmag), n) testSet.addTest( testCode.Test(label, derrmed, self.derrLimits, comment, areaLabel=areaLabel)) self.trend.set(raft, ccd, lineFit) label = "slope " + tag #+" " + areaLabel slopeLimits = self.slopeLimits[0] * lineFit[0][ 1], self.slopeLimits[1] * lineFit[0][1] comment = "slope of "+dtag+" (mag lt %.1f, nstar/clip=%d/%d) limits=(%.1f,%.1f)sigma" % \ (self.magCut, len(dmag), n, self.slopeLimits[0], self.slopeLimits[1]) testSet.addTest( testCode.Test(label, lineCoeffs[0][0], slopeLimits, comment, areaLabel=areaLabel)) # do a test of all CCDs for the slope ... suffering small number problems # on indiv ccds and could miss a problem lineFit = [99.0, 0.0, 0.0, 0.0] lineCoeffs = [99.0, 0.0] if len(allDiffs) > 1: lineFit = qaAnaUtil.robustPolyFit(allMags, allDiffs, 1) lineCoeffs = lineFit[0], lineFit[2] label = "slope" slopeLimits = self.slopeLimits[0] * lineFit[1], self.slopeLimits[ 1] * lineFit[1] comment = "slope for all ccds (mag lt %.1f, nstar=%d) limits=(%.1f,%.1f sigma)" % ( self.magCut, len(allDiffs), self.slopeLimits[0], self.slopeLimits[1]) testSet.addTest( testCode.Test(label, lineCoeffs[0], slopeLimits, comment, areaLabel="all"))
def test(self, data, dataId): self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.detector = data.getDetectorBySensor(dataId) if type(self.ownFilt) == type(None): filt = data.getFilterBySensor(dataId) self.ownFilt = filt.values()[0] if len(self.visits) == 0: visitList = [ dataId['visit'], ] else: visitList = self.visits for visit in visitList: self.visitMatches[visit] = data.getVisitMatchesBySensor( self.database, visit, dataId) kvs = self.visitMatches[visit].keys() self.visitFilters[visit] = None if len(kvs) > 0: for kv in kvs: if len(self.visitMatches[visit][kv]) > 0: self.visitFilters[visit] = self.visitMatches[visit][ kv][0][2] break # create containers for data we're interested in self.mag[visit] = raftCcdData.RaftCcdVector(self.detector) self.magErr[visit] = raftCcdData.RaftCcdVector(self.detector) self.refMag[visit] = raftCcdData.RaftCcdVector(self.detector) self.visitMag[visit] = raftCcdData.RaftCcdVector(self.detector) self.visitMagErr[visit] = raftCcdData.RaftCcdVector(self.detector) self.visitRefMag[visit] = raftCcdData.RaftCcdVector(self.detector) self.refId[visit] = raftCcdData.RaftCcdVector(self.detector) self.star[visit] = raftCcdData.RaftCcdVector(self.detector) if data.cameraInfo.name == "coadd": badFlags = measAlg.Flags.SATUR_CENTER | measAlg.Flags.EDGE # coadds have excessive area covered by INTERP_CENTER flags else: badFlags = measAlg.Flags.INTERP_CENTER | measAlg.Flags.SATUR_CENTER | measAlg.Flags.EDGE for key in self.matchListDictSrc.keys(): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() # All detections matched to ref objects srcMatchList = self.matchListDictSrc[key]['matched'] # All visit dets in footprint of original image visMatchList = self.visitMatches[visit][key] # List of reference object ids srcObjIds = num.array([x[0].getId() for x in srcMatchList]) visObjIds = num.array([x[0].getId() for x in visMatchList]) common = list(set(srcObjIds) & set(visObjIds)) self.log.log(self.log.INFO, "%s :" % (key)) if len(common) == 0: self.log.log( self.log.INFO, " No overlap, Using pre-to-post PT1.2 objectID mapping..." ) # Try objectID hack from PT1.2 to post-PT1.2: visObjIds *= 2 isStar = (num.array( [x[0].getFlagForDetection() for x in visMatchList]) & measAlg.Flags.STAR) > 0 visObjIds += isStar common = list(set(srcObjIds) & set(visObjIds)) self.log.log(self.log.INFO, "Found %d matches" % (len(common))) # Iterate over all object ids for i in range(len(common)): srcObjId = common[i] idxS = num.where(srcObjIds == srcObjId)[0] idxV = num.where(visObjIds == srcObjId)[0] # only take 1-to-1 matches if len(idxS) != 1 or len(idxV) != 1: continue sref1 = srcMatchList[idxS[0]][0] srcv1 = srcMatchList[idxS[0]][1] sref2 = visMatchList[idxV[0]][0] srcv2 = visMatchList[idxV[0]][1] f1 = self._getFlux(self.magType, srcv1, sref1) f2 = self._getFlux(self.magType, srcv2, sref2) df1 = self._getFluxErr(self.magType, srcv1, sref1) df2 = self._getFluxErr(self.magType, srcv2, sref2) fref1 = self._getFlux("cat", srcv1, sref1) fref2 = self._getFlux("cat", srcv2, sref2) # Measurment flags; note no star/gal separation yet flags1 = srcv1.getFlagForDetection() flags2 = srcv2.getFlagForDetection() # Get star/gal info here isStar = sref1.getFlagForDetection() & measAlg.Flags.STAR if (f1 > 0.0 and f2 > 0.0) and ( not flags1 & badFlags) and (not flags2 & badFlags): m1 = -2.5 * num.log10(f1) m2 = -2.5 * num.log10(f2) dm1 = 2.5 / num.log(10.0) * df1 / f1 dm2 = 2.5 / num.log(10.0) * df2 / f2 M1 = -2.5 * num.log10(fref1) M2 = -2.5 * num.log10(fref2) if num.isfinite(m1) and num.isfinite( m2) and num.isfinite(M1) and num.isfinite(M2): self.mag[visit].append(raft, ccd, m1) self.magErr[visit].append(raft, ccd, dm1) self.visitMag[visit].append(raft, ccd, m2) self.visitMagErr[visit].append(raft, ccd, dm2) self.refMag[visit].append(raft, ccd, M1) self.visitRefMag[visit].append(raft, ccd, M2) self.refId[visit].append(raft, ccd, srcObjId) self.star[visit].append(raft, ccd, isStar) # TMI #testLabel = "%s_%s_%s" % (self.database, visit, self.magType) #testLabel = "%s-%s" % (visit, self.magType) testLabel = "%s" % (self.magType) testSet = self.getTestSet(data, dataId, label=testLabel) testSet.addMetadata( "magType", "%s mags from %s" % (self.magType, self.database)) testSet.addMetadata({"Description": self.description}) self.meanDmags[visit] = raftCcdData.RaftCcdData(self.detector) self.medianDmags[visit] = raftCcdData.RaftCcdData(self.detector) self.stdDmags[visit] = raftCcdData.RaftCcdData(self.detector) for raft, ccd in self.mag[visit].raftCcdKeys(): m1 = self.mag[visit].get(raft, ccd) m2 = self.visitMag[visit].get(raft, ccd) dm1 = self.magErr[visit].get(raft, ccd) dm2 = self.visitMagErr[visit].get(raft, ccd) M1 = self.refMag[visit].get(raft, ccd) M2 = self.visitRefMag[visit].get(raft, ccd) star = self.star[visit].get(raft, ccd) idxS = num.where((M1 > 10) & (M1 < self.magCut) & (star > 0))[0] dmS = m1[idxS] - m2[idxS] - (M1[idxS] - M2[idxS]) ddmS = num.sqrt(dm1[idxS]**2 + dm2[idxS]**2) if len(dmS) > 0: stat = afwMath.makeStatistics( dmS, afwMath.NPOINT | afwMath.MEANCLIP | afwMath.STDEVCLIP | afwMath.MEDIAN) mean = stat.getValue(afwMath.MEANCLIP) median = stat.getValue(afwMath.MEDIAN) std = stat.getValue(afwMath.STDEVCLIP) npts = stat.getValue(afwMath.NPOINT) # Common tag = self.magType areaLabel = data.cameraInfo.getDetectorName(raft, ccd) # MEAN self.meanDmags[visit].set(raft, ccd, mean) label = "mean " + tag comment = "mean " + tag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmS), npts) testSet.addTest( testCode.Test(label, mean, self.deltaLimits, comment, areaLabel=areaLabel)) # MEDIAN self.medianDmags[visit].set(raft, ccd, median) label = "median " + tag comment = "median " + tag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmS), npts) testSet.addTest( testCode.Test(label, median, self.deltaLimits, comment, areaLabel=areaLabel)) # STD self.stdDmags[visit].set(raft, ccd, std) label = "stdev " + tag comment = "stdev " + tag + " (mag lt %.1f, nstar/clip=%d/%d)" % ( self.magCut, len(dmS), npts) testSet.addTest( testCode.Test(label, std, self.rmsLimits, comment, areaLabel=areaLabel))
def test(self, data, dataId): self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) # create containers for data we're interested in self.mem = raftCcdData.RaftCcdData(self.detector) self.testRuntime = raftCcdData.RaftCcdData(self.detector) self.plotRuntime = raftCcdData.RaftCcdData(self.detector) # create a testset testSet = self.getTestSet(data, dataId) # this normally gets set in the plot as that's where the caching happens, # here we're stashing the nDetection and nCcd values, so we need to set it early. testSet.setUseCache(self.useCache) testSet.addMetadata({"Description": self.description}) performBase = "performShelf" mb = testSet.unshelve(performBase) for raft, ccd in self.mem.raftCcdKeys(): # add tests for acceptible numpy of empty sectors areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "memory usage" mem = getMemUsageThisPid() / 1024 # MB comment = "memory usage in MB (%.2f%% of %.0fMB sys.)" % ( 100.0 * mem / self.memtotal, self.memtotal) test = testCode.Test(label, mem, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test) mb[ccd] = mem self.mem.set(raft, ccd, mem) testRuntime = data.getPerformance(dataId, 'total', 'test-runtime') if testRuntime is None: testRuntime = 0.0 self.testRuntime.set(raft, ccd, testRuntime) plotRuntime = data.getPerformance(dataId, 'total', 'plot-runtime') # if running with plot() forked, plot times are not defined. if plotRuntime is None: plotRuntime = 0.0 self.plotRuntime.set(raft, ccd, plotRuntime) tTest = testCode.Test("test-runtime", testRuntime, [0.0, 3600], "Runtime for test()[s]", areaLabel=areaLabel) testSet.addTest(tTest) pTest = testCode.Test("plot-runtime", plotRuntime, [0.0, 3600], "Runtime for plot()[s] (%d plots)" % (qaFig.QaFigure.count), areaLabel=areaLabel) testSet.addTest(pTest) info = self.node + " " + " ".join(self.dist) infoTest = testCode.Test("generalInfo", 0.5, [0.0, 1.0], info, areaLabel=areaLabel) testSet.addTest(infoTest) testSet.shelve(performBase, mb)
def test(self, data, dataId, fluxType="psf"): testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) self.fluxType = fluxType self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) self.calib = data.getCalibBySensor(dataId) self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') # Ignore blends in this analysis self.orphan = raftCcdData.RaftCcdVector(self.detector) self.matchedStar = raftCcdData.RaftCcdData(self.detector) self.undetectedStar = raftCcdData.RaftCcdVector(self.detector) self.matchedGalaxy = raftCcdData.RaftCcdData(self.detector) self.undetectedGalaxy = raftCcdData.RaftCcdVector(self.detector) # Results self.zeroPoint = raftCcdData.RaftCcdData(self.detector) self.medOffset = raftCcdData.RaftCcdData(self.detector) if data.cameraInfo.name == "coadd": badFlags = pqaSource.SATUR_CENTER | pqaSource.EDGE # coadds have excessive area covered by INTERP_CENTER flags else: badFlags = pqaSource.INTERP_CENTER | pqaSource.SATUR_CENTER | pqaSource.EDGE for key in self.detector.keys(): raftId = self.detector[key].getParent().getId().getName() ccdId = self.detector[key].getId().getName() filterName = self.filter[key].getName() self.matchedStar.set( raftId, ccdId, { "Refmag": num.array([]), "Imgmag": num.array([]), "Imgerr": num.array([]), }) self.matchedGalaxy.set( raftId, ccdId, { "Refmag": num.array([]), "Imgmag": num.array([]), "Imgerr": num.array([]) }) self.undetectedStar.set(raftId, ccdId, num.array([])) self.undetectedGalaxy.set(raftId, ccdId, num.array([])) self.orphan.set(raftId, ccdId, num.array([])) fmag0 = self.calib[key].getFluxMag0()[0] if fmag0 <= 0.0: self.zeroPoint.set(raftId, ccdId, NaN) continue zpt = -2.5 * num.log10(fmag0) self.zeroPoint.set(raftId, ccdId, zpt) if self.matchListDictSrc.has_key(key): # Matched mdict = self.matchListDictSrc[key]['matched'] stars = [] galaxies = [] for m in mdict: sref, s, dist = m if fluxType == "psf": fref = sref.getD(self.srefCatDummy.PsfFluxKey) f = s.getD(self.sCatDummy.PsfFluxKey) ferr = s.getD(self.sCatDummy.PsfFluxErrKey) else: fref = sref.getD(self.srefCatDummy.PsfFluxKey) f = s.getD(self.sCatDummy.ApFluxKey) ferr = s.getD(self.sCatDummy.ApFluxErrKey) # un-calibrate the magnitudes f *= fmag0 intcen = s.getD(self.sCatDummy.FlagPixInterpCenKey) satcen = s.getD(self.sCatDummy.FlagPixSaturCenKey) edge = s.getD(self.sCatDummy.FlagPixEdgeKey) if data.cameraInfo.name == 'coadd': flagit = ( satcen or edge ) # coadds have excessive area covered by InterpCen flags else: flagit = (intcen or satcen or edge) if (fref > 0.0 and f > 0.0 and not flagit): mrefmag = -2.5 * num.log10(fref) mimgmag = -2.5 * num.log10(f) mimgmerr = 2.5 / num.log(10.0) * ferr / f star = 0 if s.getD( self.sCatDummy.ExtendednessKey) else 1 if num.isfinite(mrefmag) and num.isfinite(mimgmag): if star: stars.append((mrefmag, mimgmag, mimgmerr)) else: galaxies.append((mrefmag, mimgmag, mimgmerr)) self.matchedStar.set( raftId, ccdId, { "Refmag": num.array([x[0] for x in stars]), "Imgmag": num.array([x[1] for x in stars]), "Imgerr": num.array([x[2] for x in stars]) }) self.matchedGalaxy.set( raftId, ccdId, { "Refmag": num.array([x[0] for x in galaxies]), "Imgmag": num.array([x[1] for x in galaxies]), "Imgerr": num.array([x[2] for x in galaxies]) }) # Non-detections undetectedStars = [] undetectedGalaxies = [] for nondet in self.matchListDictSrc[key]['undetected']: mag = nondet.getMag(filterName) if nondet.getIsStar(): undetectedStars.append(mag) else: undetectedGalaxies.append(mag) self.undetectedStar.set(raftId, ccdId, num.array(undetectedStars)) self.undetectedGalaxy.set(raftId, ccdId, num.array(undetectedGalaxies)) # Orphans orphans = [] for orphan in self.matchListDictSrc[key]['orphan']: if self.fluxType == "psf": f = orphan.getD(self.sCatDummy.PsfFluxKey) else: f = orphan.getD(self.sCatDummy.ApFluxKey) if f > 0.0: # un-calibrate the magnitudes f *= fmag0 orphans.append(-2.5 * num.log10(f)) self.orphan.set(raftId, ccdId, num.array(orphans)) # Metrics offset = num.array( self.matchedStar.get(raftId, ccdId)["Imgmag"]) # make a copy offset -= self.zeroPoint.get(raftId, ccdId) offset -= self.matchedStar.get(raftId, ccdId)["Refmag"] med = num.median(offset) self.medOffset.set(raftId, ccdId, med) areaLabel = data.cameraInfo.getDetectorName(raftId, ccdId) label = "median offset from zeropoint" comment = "Median offset of calibrated stellar magnitude to zeropoint fit" test = testCode.Test(label, med, self.limits, comment, areaLabel=areaLabel) testSet.addTest(test) label = "median zeropoint" comment = "Median zeropoint measured for sensor" test = testCode.Test(label, zpt, [None, 0], comment, areaLabel=areaLabel) testSet.addTest(test)
def test(self, data, dataId): # get data self.ssDict = data.getSourceSetBySensor(dataId) self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) self.calexpDict = data.getCalexpBySensor(dataId) self.wcs = data.getWcsBySensor(dataId) # create containers for data in the focal plane self.x = raftCcdData.RaftCcdVector(self.detector) self.y = raftCcdData.RaftCcdVector(self.detector) self.ra = raftCcdData.RaftCcdVector(self.detector) self.dec = raftCcdData.RaftCcdVector(self.detector) self.ellip = raftCcdData.RaftCcdVector(self.detector) self.theta = raftCcdData.RaftCcdVector(self.detector) # compute values of interest filter = None sigmaToFwhm = 2.0 * numpy.sqrt(2.0 * numpy.log(2.0)) fwhmByKey = {} for key, ss in self.ssDict.items(): if self.detector.has_key(key): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() else: continue #qaAnaUtil.isStar(ss) fwhmByKey[key] = 0.0 fwhmTmp = 0.0 for s in ss: ixx = s.getD(self.sCatDummy.IxxKey) iyy = s.getD(self.sCatDummy.IyyKey) ixy = s.getD(self.sCatDummy.IxyKey) tmp = 0.25 * (ixx - iyy)**2 + ixy**2 if tmp < 0: continue a2 = 0.5 * (ixx + iyy) + numpy.sqrt(tmp) b2 = 0.5 * (ixx + iyy) - numpy.sqrt(tmp) if a2 == 0 or b2 / a2 < 0: continue ellip = 1.0 - numpy.sqrt(b2 / a2) theta = 0.5 * numpy.arctan2(2.0 * ixy, ixx - iyy) # vectors have no direction, so default to pointing in +ve 'y' # - failing to do this caused a stats bug when alignment is near pi/2 # both +/- pi/2 arise but are essentially the same, ... and the mean is near zero if theta < 0.0: theta += numpy.pi #print ixx, iyy, ixy, a2, b2, ellip, theta isStar = 0 if s.getD(self.sCatDummy.ExtendednessKey) else 1 flux = s.getD(self.sCatDummy.PsfFluxKey) mag = 99.0 if flux > 0: mag = -2.5 * numpy.log10(s.getD(self.sCatDummy.PsfFluxKey)) if numpy.isfinite(ellip) and numpy.isfinite( theta) and isStar and mag < 20: self.ellip.append(raft, ccd, ellip) self.theta.append(raft, ccd, theta) self.x.append(raft, ccd, s.getD(self.sCatDummy.XAstromKey)) self.y.append(raft, ccd, s.getD(self.sCatDummy.YAstromKey)) self.ra.append(raft, ccd, s.getD(self.sCatDummy.RaKey)) self.dec.append(raft, ccd, s.getD(self.sCatDummy.DecKey)) fwhmTmp += sigmaToFwhm * numpy.sqrt(0.5 * (a2 + b2)) nFwhm = len(self.x.get(raft, ccd)) if nFwhm: fwhmByKey[key] = fwhmTmp / nFwhm else: fwhmByKey[key] = 0.0 # create a testset and add values testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) # gets the stats for each sensor and put the values in the raftccd container self.ellipMedians = raftCcdData.RaftCcdData(self.detector) self.thetaMedians = raftCcdData.RaftCcdData(self.detector) for raft, ccd in self.ellip.raftCcdKeys(): ellip = self.ellip.get(raft, ccd) theta = self.theta.get(raft, ccd) if len(ellip) > 0: stat = afwMath.makeStatistics(ellip, afwMath.NPOINT | afwMath.MEDIAN) ellipMed = stat.getValue(afwMath.MEDIAN) stat = afwMath.makeStatistics(theta, afwMath.NPOINT | afwMath.MEDIAN) thetaMed = stat.getValue(afwMath.MEDIAN) n = stat.getValue(afwMath.NPOINT) else: ellipMed = -1.0 thetaMed = 0.0 n = 0 # add a test for acceptible psf ellipticity self.ellipMedians.set(raft, ccd, ellipMed) areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "median psf ellipticity " comment = "median psf ellipticity (nstar=%d)" % (n) testSet.addTest( testCode.Test(label, ellipMed, self.limitsEllip, comment, areaLabel=areaLabel)) # stash the angles. We'll use them to make figures in plot() self.thetaMedians.set(raft, ccd, thetaMed) # And the Fwhm self.fwhm = raftCcdData.RaftCcdData(self.detector) for key, item in self.calexpDict.items(): if (self.detector.has_key(key) and hasattr(self.detector[key], 'getParent') and hasattr(self.detector[key], 'getId')): raft = self.detector[key].getParent().getId().getName() ccd = self.detector[key].getId().getName() else: continue wcs = self.wcs[key] fwhmTmp = float(fwhmByKey[key] * wcs.pixelScale().asArcseconds()) #item['fwhm'] #print fwhmTmp, item['fwhm'], type(fwhmTmp), type(item['fwhm']) self.fwhm.set(raft, ccd, fwhmTmp) areaLabel = data.cameraInfo.getDetectorName(raft, ccd) label = "psf fwhm (arcsec) " comment = "psf fwhm (arcsec)" testSet.addTest( testCode.Test(label, item['fwhm'], self.limitsFwhm, comment, areaLabel=areaLabel))
def test(self, data, dataId): testSet = self.getTestSet(data, dataId) testSet.addMetadata({"Description": self.description}) self.detector = data.getDetectorBySensor(dataId) self.filter = data.getFilterBySensor(dataId) self.matchListDictSrc = data.getMatchListBySensor(dataId, useRef='src') self.dmag = raftCcdData.RaftCcdVector(self.detector) self.ids = raftCcdData.RaftCcdVector(self.detector) self.radius = raftCcdData.RaftCcdVector(self.detector) self.medianOffset = raftCcdData.RaftCcdData(self.detector) self.rmsOffset = raftCcdData.RaftCcdData(self.detector) #badFlags = pqaSource.INTERP_CENTER | pqaSource.SATUR_CENTER | pqaSource.EDGE for key in self.detector.keys(): if self.detector[key] is None: continue raftId = self.detector[key].getParent().getId().getName() ccdId = self.detector[key].getId().getName() # We have a trimmed detector self.detector[key].setTrimmed(True) pixelSize = self.detector[key].getPixelSize() # mm centerXm, centerYm = self.detector[key].getCenter().getMm( ) # focal plane mm bbox = self.detector[key].getAllPixels() startX = bbox.getBeginX() startY = bbox.getBeginY() endX = bbox.getEndX() endY = bbox.getEndY() centerXp = 0.5 * (endX - startX) centerYp = 0.5 * (endY - startY) if self.matchListDictSrc.has_key(key): mdict = self.matchListDictSrc[key]['matched'] for m in mdict: sref, s, dist = m if s.getD( self.sCatDummy.ExtendednessKey): # if non-stellar continue f1 = self._getFlux(self.magType1, s, sref) f2 = self._getFlux(self.magType2, s, sref) intcen = s.getD(self.sCatDummy.FlagPixInterpCenKey) satcen = s.getD(self.sCatDummy.FlagPixSaturCenKey) edge = s.getD(self.sCatDummy.FlagPixEdgeKey) if data.cameraInfo.name == 'coadd': flagit = ( satcen or edge ) # coadds have excessive area covered by InterpCen flags else: flagit = (intcen or satcen or edge) if (f1 > 0.0 and f2 > 0.0 and not flagit): m1 = -2.5 * num.log10(f1) m2 = -2.5 * num.log10(f2) if m2 > self.maxMag: continue if num.isfinite(m1) and num.isfinite(m2): self.dmag.append(raftId, ccdId, m1 - m2) self.ids.append(raftId, ccdId, str(s.getId())) if data.cameraInfo.name == 'lsstSim': # XY switched xmm = centerXm + ( s.getD(self.sCatDummy.YAstromKey) - centerXp) * pixelSize ymm = centerYm + ( s.getD(self.sCatDummy.XAstromKey) - centerYp) * pixelSize radiusp = num.sqrt(xmm**2 + ymm**2) / pixelSize else: # XY not switch, and pixel centers not in mm xmm = centerXm + (s.getD( self.sCatDummy.XAstromKey) - centerXp) ymm = centerYm + (s.getD( self.sCatDummy.YAstromKey) - centerYp) radiusp = num.sqrt(xmm**2 + ymm**2) self.radius.append(raftId, ccdId, radiusp) # Calculate stats dmags = self.dmag.get(raftId, ccdId) if len(dmags) > 0: med = num.median(dmags) else: med = 0.0 std = 0.0 if len(dmags) > 1: stat = afwMath.makeStatistics(dmags, afwMath.IQRANGE) std = 0.741 * stat.getValue(afwMath.IQRANGE) self.medianOffset.set(raftId, ccdId, med) self.rmsOffset.set(raftId, ccdId, std) areaLabel = data.cameraInfo.getDetectorName(raftId, ccdId) label = "median offset " comment = "median offset from cat mag" test = testCode.Test(label, med, self.medLimits, comment, areaLabel=areaLabel) testSet.addTest(test) label = "stddev offset " comment = "stddev of offset from cat mag" test = testCode.Test(label, std, self.rmsLimits, comment, areaLabel=areaLabel) testSet.addTest(test)