Inheritance diagram for lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa:

Public Member Functions
def	__init__ (self, nKernelSpatial)

def	makeMetricMap (self)

def	addToSchema (self, inSourceCatalog)

def	apply (cls, candidateList, spatialKernel, spatialBackground, dof=0)

Static Public Member Functions
def	aggregate (sourceCatalog, metadata, wcsresids, diaSources=None)

Public Attributes
	fields

Detailed Description

Quality Assessment class for Kernel Candidates

Definition at line 36 of file kernelCandidateQa.py.

Constructor & Destructor Documentation

◆ init()

def lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.__init__	(	self,
		nKernelSpatial
	)

Class to undertake QA of KernelCandidates after modeling of
the Psf-matching kernel.  Both directly--fitted diffim (LOCAL)
and spatially--interpolated kernel diffim (SPATIAL) metrics
are calculated, based on the distribution of residuals in the
KernelCandidates stamp.

Parameters
----------
nKernelSpatial : `int`
    Number of terms in the spatial model; needed to initialize per-basis QA arrays

Definition at line 39 of file kernelCandidateQa.py.

     def __init__(self, nKernelSpatial):
         """Class to undertake QA of KernelCandidates after modeling of
         the Psf-matching kernel.  Both directly--fitted diffim (LOCAL)
         and spatially--interpolated kernel diffim (SPATIAL) metrics
         are calculated, based on the distribution of residuals in the
         KernelCandidates stamp.
  
         Parameters
         ----------
         nKernelSpatial : `int`
             Number of terms in the spatial model; needed to initialize per-basis QA arrays
         """
         self.fields = []
         self.fields.append(afwTable.Field["PointD"](
             "RegisterRefPosition",
             "Position of reference object for registration (radians)."))
         # TODO check units of the following angles
         self.fields.append(afwTable.Field["Angle"]("RegisterResidualBearing",
                                                    "Angle of residual wrt declination parallel in radians"))
  
         self.fields.append(afwTable.Field["Angle"]("RegisterResidualDistance",
                                                    "Offset of residual in radians"))
         metricMap = self.makeMetricMap()
  
         for kType in ("LOCAL", "SPATIAL"):
             for k in metricMap:
                 commentAndUnit = metricMap[k]['comment']
                 self.fields.append(afwTable.Field[metricMap[k]['type']](k%(kType), *commentAndUnit))
  
         self.fields.append(afwTable.Field["I"]("KCKernelStatus_LOCAL",
                                                "Status of the KernelCandidate"))
  
         self.fields.append(afwTable.Field["ArrayD"]("KernelCoeffValues_LOCAL",
                                                     "Original basis coefficients",
                                                     nKernelSpatial))
  
         self.fields.append(afwTable.Field["F"]("BackgroundValue_LOCAL",
                                                "Evaluation of background model at this point"))
  
         self.fields.append(afwTable.Field["F"]("KCDiffimMseKernel_SPATIAL",
                                                "Mean squared error of spatial kernel estimate"))
  

Member Function Documentation

◆ addToSchema()

def lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.addToSchema	(	self,
		inSourceCatalog
	)

Add the to-be-generated QA keys to the Source schema

Definition at line 113 of file kernelCandidateQa.py.

     def addToSchema(self, inSourceCatalog):
         """Add the to-be-generated QA keys to the Source schema"""
         schema = inSourceCatalog.getSchema()
         inKeys = []
         psfDef = inSourceCatalog.schema.getAliasMap().get("slot_PsfFlux")
         centroidDef = inSourceCatalog.getCentroidDefinition()
         shapeDef = inSourceCatalog.getShapeDefinition()
         for n in schema.getNames():
             inKeys.append(schema[n].asKey())
  
         for field in self.fields:
             schema.addField(field)
         outSourceCatalog = afwTable.SourceCatalog(schema)
         for source in inSourceCatalog:
             rec = outSourceCatalog.addNew()
             for k in inKeys:
                 if k.getTypeString() == 'Coord':
                     rec.setCoord(source.getCoord())
                 else:
                     setter = getattr(rec, "set"+k.getTypeString())
                     getter = getattr(source, "get"+k.getTypeString())
                     setter(k, getter(k))
         outSourceCatalog.definePsfFlux(psfDef)
         outSourceCatalog.defineCentroid(centroidDef)
         outSourceCatalog.defineShape(shapeDef)
         return outSourceCatalog
  

◆ aggregate()

def lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.aggregate	(	sourceCatalog,
		metadata,
		wcsresids,
		diaSources = `None`
	)

static

Generate aggregate metrics (e.g. total numbers of false
positives) from all the Sources in the sourceCatalog

Definition at line 296 of file kernelCandidateQa.py.

     def aggregate(sourceCatalog, metadata, wcsresids, diaSources=None):
         """Generate aggregate metrics (e.g. total numbers of false
         positives) from all the Sources in the sourceCatalog"""
         for source in sourceCatalog:
             sourceId = source.getId()
             if sourceId in wcsresids:
                 # Note that the residuals are not delta RA, delta Dec
                 # From the source code "bearing (angle wrt a declination parallel) and distance
                 coord, resids = wcsresids[sourceId]
                 key = source.schema["RegisterResidualBearing"].asKey()
                 setter = getattr(source, "set"+key.getTypeString())
                 setter(key, resids[0])
                 key = source.schema["RegisterResidualDistance"].asKey()
                 setter = getattr(source, "set"+key.getTypeString())
                 setter(key, resids[1])
                 key = source.schema["RegisterRefPosition"].asKey()
                 setter = getattr(source, "set"+key.getTypeString())
                 setter(key, geom.Point2D(coord.getRa().asRadians(),
                                          coord.getDec().asRadians()))
         if diaSources:
             metadata.add("NFalsePositivesTotal", len(diaSources))
             nRefMatch = 0
             nSrcMatch = 0
             nunmatched = 0
             for source in diaSources:
                 refId = source.get("refMatchId")
                 srcId = source.get("srcMatchId")
                 if refId > 0:
                     nRefMatch += 1
                 if srcId > 0:
                     nSrcMatch += 1
                 if refId == 0 and srcId == 0:
                     nunmatched += 1
             metadata.add("NFalsePositivesRefAssociated", nRefMatch)
             metadata.add("NFalsePositivesSrcAssociated", nSrcMatch)
             metadata.add("NFalsePositivesUnassociated", nunmatched)
         for kType in ("LOCAL", "SPATIAL"):
             for sName in ("KCDiffimMean", "KCDiffimMedian", "KCDiffimIQR", "KCDiffimStDev",
                           "KCDiffimKSProb", "KCDiffimADSig", "KCDiffimChiSq",
                           "KCDiffimMseResids", "KCDiffimMseKernel"):
                 if sName == "KCDiffimMseKernel" and kType == "LOCAL":
                     continue
                 kName = "%s_%s" % (sName, kType)
                 vals = np.array([s.get(kName) for s in sourceCatalog])
                 idx = np.isfinite(vals)
                 metadata.add("%s_MEAN" % (kName), np.mean(vals[idx]))
                 metadata.add("%s_MEDIAN" % (kName), np.median(vals[idx]))
                 metadata.add("%s_STDEV" % (kName), np.std(vals[idx]))

◆ apply()

def lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.apply	(	cls,
		candidateList,
		spatialKernel,
		spatialBackground,
		dof = `0`
	)

Evaluate the QA metrics for all KernelCandidates in the
candidateList; set the values of the metrics in their
associated Sources

Definition at line 200 of file kernelCandidateQa.py.

     def apply(cls, candidateList, spatialKernel, spatialBackground, dof=0):
         """Evaluate the QA metrics for all KernelCandidates in the
         candidateList; set the values of the metrics in their
         associated Sources"""
         for kernelCandidate in candidateList:
             source = kernelCandidate.getSource()
             schema = source.schema
  
             # Calculate ORIG stats (original basis fit)
             if kernelCandidate.getStatus() != afwMath.SpatialCellCandidate.UNKNOWN:
                 kType = getattr(diffimLib.KernelCandidateF, "ORIG")
                 di = kernelCandidate.getDifferenceImage(kType)
                 kernelValues = kernelCandidate.getKernel(kType).getKernelParameters()
                 kernelValues = np.asarray(kernelValues)
  
                 lkim = kernelCandidate.getKernelImage(kType)
                 centx, centy = calcCentroid(lkim.getArray())
                 stdx, stdy = calcWidth(lkim.getArray(), centx, centy)
                 # NOTE
                 # What is the difference between kernelValues and solution?
  
                 localResults = cls._calculateStats(di, dof=dof)
  
                 metrics = {"KCDiffimMean_LOCAL": localResults["mean"],
                            "KCDiffimMedian_LOCAL": localResults["median"],
                            "KCDiffimIQR_LOCAL": localResults["iqr"],
                            "KCDiffimStDev_LOCAL": localResults["stdev"],
                            "KCDiffimKSD_LOCAL": localResults["D"],
                            "KCDiffimKSProb_LOCAL": localResults["prob"],
                            "KCDiffimADA2_LOCAL": localResults["A2"],
                            "KCDiffimADCrit_LOCAL": localResults["crit"],
                            "KCDiffimADSig_LOCAL": localResults["sig"],
                            "KCDiffimChiSq_LOCAL": localResults["rchisq"],
                            "KCDiffimMseResids_LOCAL": localResults["mseResids"],
                            "KCKernelCentX_LOCAL": centx,
                            "KCKernelCentY_LOCAL": centy,
                            "KCKernelStdX_LOCAL": stdx,
                            "KCKernelStdY_LOCAL": stdy,
                            "KernelCandidateId_LOCAL": kernelCandidate.getId(),
                            "KernelCoeffValues_LOCAL": kernelValues}
                 for k in metrics:
                     key = schema[k].asKey()
                     setter = getattr(source, "set"+key.getTypeString())
                     setter(key, metrics[k])
             else:
                 try:
                     kType = getattr(diffimLib.KernelCandidateF, "ORIG")
                     lkim = kernelCandidate.getKernelImage(kType)
                 except Exception:
                     lkim = None
  
             # Calculate spatial model evaluated at each position, for
             # all candidates
             skim = afwImage.ImageD(spatialKernel.getDimensions())
             spatialKernel.computeImage(skim, False, kernelCandidate.getXCenter(),
                                        kernelCandidate.getYCenter())
             centx, centy = calcCentroid(skim.getArray())
             stdx, stdy = calcWidth(skim.getArray(), centx, centy)
  
             sk = afwMath.FixedKernel(skim)
             sbg = spatialBackground(kernelCandidate.getXCenter(), kernelCandidate.getYCenter())
             di = kernelCandidate.getDifferenceImage(sk, sbg)
             spatialResults = cls._calculateStats(di, dof=dof)
  
             # Kernel mse
             if lkim is not None:
                 skim -= lkim
                 bias = np.mean(skim.getArray())
                 variance = np.mean(np.power(skim.getArray(), 2.))
                 mseKernel = bias**2 + variance
             else:
                 mseKernel = -99.999
  
             metrics = {"KCDiffimMean_SPATIAL": spatialResults["mean"],
                        "KCDiffimMedian_SPATIAL": spatialResults["median"],
                        "KCDiffimIQR_SPATIAL": spatialResults["iqr"],
                        "KCDiffimStDev_SPATIAL": spatialResults["stdev"],
                        "KCDiffimKSD_SPATIAL": spatialResults["D"],
                        "KCDiffimKSProb_SPATIAL": spatialResults["prob"],
                        "KCDiffimADA2_SPATIAL": spatialResults["A2"],
                        "KCDiffimADCrit_SPATIAL": spatialResults["crit"],
                        "KCDiffimADSig_SPATIAL": spatialResults["sig"],
                        "KCDiffimChiSq_SPATIAL": spatialResults["rchisq"],
                        "KCDiffimMseResids_SPATIAL": spatialResults["mseResids"],
                        "KCDiffimMseKernel_SPATIAL": mseKernel,
                        "KCKernelCentX_SPATIAL": centx,
                        "KCKernelCentY_SPATIAL": centy,
                        "KCKernelStdX_SPATIAL": stdx,
                        "KCKernelStdY_SPATIAL": stdy,
                        "KernelCandidateId_SPATIAL": kernelCandidate.getId()}
             for k in metrics:
                 key = schema[k].asKey()
                 setter = getattr(source, "set"+key.getTypeString())
                 setter(key, metrics[k])
  

◆ makeMetricMap()

def lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.makeMetricMap ( self )

Definition at line 81 of file kernelCandidateQa.py.

     def makeMetricMap(self):
         nameList = ['KCDiffimMean_%s', 'KCDiffimMedian_%s', 'KCDiffimIQR_%s', 'KCDiffimStDev_%s',
                     'KCDiffimKSD_%s', 'KCDiffimKSProb_%s', 'KCDiffimADA2_%s', 'KCDiffimADCrit_%s',
                     'KCDiffimADSig_%s', 'KCDiffimChiSq_%s', 'KCDiffimMseResids_%s', 'KCKernelCentX_%s',
                     'KCKernelCentY_%s', 'KCKernelStdX_%s', 'KCKernelStdY_%s', 'KernelCandidateId_%s']
         typeList = ['F', 'F', 'F', 'F', 'F', 'F', 'F', 'ArrayD', 'ArrayD', 'F', 'F', 'F',
                     'F', 'F', 'F', 'I']
         commentList = [
             ("Mean of KernelCandidate diffim", "sigma"),
             ("Median of KernelCandidate diffim", "sigma"),
             ("Inner quartile range of KernelCandidate diffim", "sigma"),
             ("Standard deviation of KernelCandidate diffim", "sigma"),
             ("D from K-S test of diffim pixels relative to Normal", ),
             ("Prob from K-S test of diffim pixels relative to Normal", "likelihood"),
             ("Anderson-Darling test statistic of diffim pixels relative to Normal", ),
             ("Critical values for the significance levels in KCDiffimADSig.  If A2 is greater "
              "than this number, hypothesis that the distributions are similar can be rejected.", 5),
             ("Anderson-Darling significance levels for the Normal distribution", 5),
             ("Reduced chi^2 of the residual.", "likelihood"),
             ("Mean squared error in diffim : Variance + Bias**2",),
             ("Centroid in X for this Kernel", "pixel"),
             ("Centroid in Y for this Kernel", "pixel"),
             ("Standard deviation in X for this Kernel", "pixel"),
             ("Standard deviation in Y for this Kernel", "pixel"),
             ("Id for this KernelCandidate",),
         ]
         metricMap = {}
         for name, mtype, comment in zip(nameList, typeList, commentList):
             metricMap[name] = {'type': mtype, 'comment': comment}
  
         return metricMap
  

Member Data Documentation

◆ fields

lsst.ip.diffim.kernelCandidateQa.KernelCandidateQa.fields

Definition at line 51 of file kernelCandidateQa.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_diffim/22.0.1-24-g1ad7a390+a9625a72a8/python/lsst/ip/diffim/kernelCandidateQa.py

Public Member Functions

Static Public Member Functions

Public Attributes