lsst.meas.algorithms.measureApCorr.MeasureApCorrTask Class Reference

Inheritance diagram for lsst.meas.algorithms.measureApCorr.MeasureApCorrTask:

Public Member Functions
	__init__ (self, schema, namesToCorrect=None, **kwargs)
	run (self, exposure, catalog)

Public Attributes
	refFluxNames = _FluxNames(self.config.refFluxName, schema)
dict	toCorrect = {}

Static Public Attributes
	ConfigClass = MeasureApCorrConfig

Static Protected Attributes
str	_DefaultName = "measureApCorr"

Detailed Description

Task to measure aperture correction.

For every name to correct, a new field apcorr_{name}_used will
be added, and will be logged in self.toCorrect.

Parameters
----------
schema : `lsst.afw.table.Schema`
    Schema for the input table; will be modified in place to
    add ``apcorr_{name}_used`` fields.
namesToCorrect : `list` [`str`], optional
    List of names to correct.  If `None` then the set of
    registered fields in lsst.meas.base.getApCorrNameSet()
    will be used.
**kwargs : `dict`
    Additional kwargs to pass to lsst.pipe.base.Task.__init__()

Raises
------
MeasureApCorrError if any of the names to correct fails and is
not in the config.allowFailure list.

Definition at line 186 of file measureApCorr.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.algorithms.measureApCorr.MeasureApCorrTask.__init__	(		self,
			schema,
			namesToCorrect = None,
		**	kwargs )

Definition at line 212 of file measureApCorr.py.

    def __init__(self, schema, namesToCorrect=None, **kwargs):
        Task.__init__(self, **kwargs)
        self.refFluxNames = _FluxNames(self.config.refFluxName, schema)
        self.toCorrect = {}  # dict of flux field name prefix: FluxKeys instance
        names = namesToCorrect if namesToCorrect else getApCorrNameSet()
        for name in sorted(names):
            try:
                self.toCorrect[name] = _FluxNames(name, schema)
            except KeyError:
                # if a field in the registry is missing, just ignore it.
                pass
        self.makeSubtask("sourceSelector")
 

Member Function Documentation

run()

lsst.meas.algorithms.measureApCorr.MeasureApCorrTask.run	(		self,
			exposure,
			catalog )

Measure aperture correction

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure aperture corrections are being measured on. The
    bounding box is retrieved from it, and it is passed to the
    sourceSelector. The output aperture correction map is *not*
    added to the exposure; this is left to the caller.
catalog : `lsst.afw.table.SourceCatalog`
    SourceCatalog containing measurements to be used to
    compute aperture corrections.

Returns
-------
Struct : `lsst.pipe.base.Struct`
    Contains the following:

    ``apCorrMap``
        aperture correction map (`lsst.afw.image.ApCorrMap`)
        that contains two entries for each flux field:
        - flux field (e.g. base_PsfFlux_instFlux): 2d model
        - flux sigma field (e.g. base_PsfFlux_instFluxErr): 2d model of error

Definition at line 225 of file measureApCorr.py.

    def run(self, exposure, catalog):
        """Measure aperture correction
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure aperture corrections are being measured on. The
            bounding box is retrieved from it, and it is passed to the
            sourceSelector. The output aperture correction map is *not*
            added to the exposure; this is left to the caller.
        catalog : `lsst.afw.table.SourceCatalog`
            SourceCatalog containing measurements to be used to
            compute aperture corrections.
 
        Returns
        -------
        Struct : `lsst.pipe.base.Struct`
            Contains the following:
 
            ``apCorrMap``
                aperture correction map (`lsst.afw.image.ApCorrMap`)
                that contains two entries for each flux field:
                - flux field (e.g. base_PsfFlux_instFlux): 2d model
                - flux sigma field (e.g. base_PsfFlux_instFluxErr): 2d model of error
        """
        bbox = exposure.getBBox()
        import lsstDebug
        display = lsstDebug.Info(__name__).display
        doPause = lsstDebug.Info(__name__).doPause
 
        self.log.info("Measuring aperture corrections for %d flux fields", len(self.toCorrect))
 
        # First, create a subset of the catalog that contains only selected stars
        # with non-flagged reference fluxes.
        selected = self.sourceSelector.run(catalog, exposure=exposure)
 
        use = (
            ~selected.sourceCat[self.refFluxNames.flagName]
            & (np.isfinite(selected.sourceCat[self.refFluxNames.fluxName]))
        )
        goodRefCat = selected.sourceCat[use].copy()
 
        apCorrMap = ApCorrMap()
 
        # Outer loop over the fields we want to correct
        for name, fluxNames in self.toCorrect.items():
            # Create a more restricted subset with only the objects where the to-be-correct flux
            # is not flagged.
            fluxes = goodRefCat[fluxNames.fluxName]
            with np.errstate(invalid="ignore"):  # suppress NaN warnings.
                isGood = (
                    (~goodRefCat[fluxNames.flagName])
                    & (np.isfinite(fluxes))
                    & (fluxes > 0.0)
                )
 
            # The 1 is the minimum number of ctrl.computeSize() when the order
            # drops to 0 in both x and y.
            if (isGood.sum() - 1) < self.config.minDegreesOfFreedom:
                if name in self.config.allowFailure:
                    self.log.warning("Unable to measure aperture correction for '%s': "
                                     "only %d sources, but require at least %d.",
                                     name, isGood.sum(), self.config.minDegreesOfFreedom + 1)
                    continue
                else:
                    raise MeasureApCorrError(name=name, nSources=isGood.sum(),
                                             ndof=self.config.minDegreesOfFreedom + 1)
 
            goodCat = goodRefCat[isGood].copy()
 
            x = goodCat['slot_Centroid_x']
            y = goodCat['slot_Centroid_y']
            z = goodCat[self.refFluxNames.fluxName]/goodCat[fluxNames.fluxName]
            ids = goodCat['id']
 
            # We start with an initial fit that is the median offset; this
            # works well in practice.
            fitValues = np.median(z)
 
            ctrl = self.config.fitConfig.makeControl()
 
            allBad = False
            for iteration in range(self.config.numIter):
                resid = z - fitValues
                # We add a small (epsilon) amount of floating-point slop because
                # the median_abs_deviation may give a value that is just larger than 0
                # even if given a completely flat residual field (as in tests).
                apCorrErr = median_abs_deviation(resid, scale="normal") + 1e-7
                keep = np.abs(resid) <= self.config.numSigmaClip * apCorrErr
 
                self.log.debug("Removing %d sources as outliers.", len(resid) - keep.sum())
 
                x = x[keep]
                y = y[keep]
                z = z[keep]
                ids = ids[keep]
 
                while (len(x) - ctrl.computeSize()) < self.config.minDegreesOfFreedom:
                    if ctrl.orderX > 0:
                        ctrl.orderX -= 1
                    else:
                        allBad = True
                        break
                    if ctrl.orderY > 0:
                        ctrl.orderY -= 1
                    else:
                        allBad = True
                        break
 
                if allBad:
                    if name in self.config.allowFailure:
                        self.log.warning("Unable to measure aperture correction for '%s': "
                                         "only %d sources remain, but require at least %d." %
                                         (name, keep.sum(), self.config.minDegreesOfFreedom + 1))
                        break
                    else:
                        raise MeasureApCorrError(name=name, nSources=keep.sum(),
                                                 ndof=self.config.minDegreesOfFreedom + 1,
                                                 iteration=iteration+1)
 
                apCorrField = ChebyshevBoundedField.fit(bbox, x, y, z, ctrl)
                fitValues = apCorrField.evaluate(x, y)
 
            if allBad:
                continue
 
            if self.config.doFinalMedianShift:
                med = np.median(fitValues - z)
                coeffs = apCorrField.getCoefficients().copy()
                coeffs[0, 0] -= med
                apCorrField = ChebyshevBoundedField(bbox, coeffs)
                fitValues = apCorrField.evaluate(x, y)
 
            self.log.info(
                "Aperture correction for %s from %d stars: med %f, MAD %f, RMS %f",
                name,
                len(x),
                np.median(fitValues - z),
                median_abs_deviation(fitValues - z, scale="normal"),
                np.mean((fitValues - z)**2.)**0.5,
            )
 
            if display:
                plotApCorr(bbox, x, y, z, apCorrField, "%s, final" % (name,), doPause)
 
            # Record which sources were used.
            used = np.zeros(len(catalog), dtype=bool)
            used[np.searchsorted(catalog['id'], ids)] = True
            catalog[fluxNames.usedName] = used
 
            # Save the result in the output map
            # The error is constant spatially (we could imagine being
            # more clever, but we're not yet sure if it's worth the effort).
            # We save the errors as a 0th-order ChebyshevBoundedField
            apCorrMap[fluxNames.fluxName] = apCorrField
            apCorrMap[fluxNames.errName] = ChebyshevBoundedField(
                bbox,
                np.array([[apCorrErr]]),
            )
 
        return Struct(
            apCorrMap=apCorrMap,
        )
 
 

Member Data Documentation

_DefaultName

str lsst.meas.algorithms.measureApCorr.MeasureApCorrTask._DefaultName = "measureApCorr"

staticprotected

Definition at line 210 of file measureApCorr.py.

ConfigClass

lsst.meas.algorithms.measureApCorr.MeasureApCorrTask.ConfigClass = MeasureApCorrConfig

static

Definition at line 209 of file measureApCorr.py.

refFluxNames

lsst.meas.algorithms.measureApCorr.MeasureApCorrTask.refFluxNames = _FluxNames(self.config.refFluxName, schema)

Definition at line 214 of file measureApCorr.py.

toCorrect

lsst.meas.algorithms.measureApCorr.MeasureApCorrTask.toCorrect = {}

Definition at line 215 of file measureApCorr.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/meas_algorithms/g325378336f+5d73323c8f/python/lsst/meas/algorithms/measureApCorr.py