lsst.meas.base.applyApCorr.ApplyApCorrTask Class Reference

Inheritance diagram for lsst.meas.base.applyApCorr.ApplyApCorrTask:

Public Member Functions
	__init__ (self, schema, **kwds)
	run (self, catalog, apCorrMap)

Public Attributes
	apCorrInfoDict

Static Public Attributes
	ConfigClass = ApplyApCorrConfig

Static Protected Attributes
str	_DefaultName = "applyApCorr"

Detailed Description

Apply aperture corrections.

Parameters
----------
schema : `lsst.afw.table.Schema`

Definition at line 187 of file applyApCorr.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.base.applyApCorr.ApplyApCorrTask.__init__	(		self,
			schema,
		**	kwds )

Definition at line 197 of file applyApCorr.py.

    def __init__(self, schema, **kwds):
        lsst.pipe.base.Task.__init__(self, **kwds)
 
        self.apCorrInfoDict = dict()
        apCorrNameSet = getApCorrNameSet()
        ignoreSet = set(self.config.ignoreList)
        missingNameSet = ignoreSet - set(apCorrNameSet)
        if missingNameSet:
            self.log.warning("Fields in ignoreList that are not in fluxCorrectList: %s",
                             sorted(missingNameSet))
        for name in sorted(apCorrNameSet - ignoreSet):
            if name + "_instFlux" not in schema:
                # if a field in the registry is missing from the schema, silently ignore it.
                continue
            self.apCorrInfoDict[name] = ApCorrInfo(schema=schema, model=name)
 
        for name, model in self.config.proxies.items():
            if name in apCorrNameSet:
                # Already done or ignored
                continue
            if name + "_instFlux" not in schema:
                # Silently ignore
                continue
            self.apCorrInfoDict[name] = ApCorrInfo(schema=schema, model=model, name=name)
 

Member Function Documentation

run()

lsst.meas.base.applyApCorr.ApplyApCorrTask.run	(		self,
			catalog,
			apCorrMap )

Apply aperture corrections to a catalog of sources.

Parameters
----------
catalog : `lsst.afw.table.SourceCatalog`
    Catalog of sources. Will be updated in place.
apCorrMap : `lsst.afw.image.ApCorrMap`
    Aperture correction map

Notes
-----
If you show debug-level log messages then you will see statistics for
the effects of aperture correction.

Definition at line 222 of file applyApCorr.py.

    def run(self, catalog, apCorrMap):
        """Apply aperture corrections to a catalog of sources.
 
        Parameters
        ----------
        catalog : `lsst.afw.table.SourceCatalog`
            Catalog of sources. Will be updated in place.
        apCorrMap : `lsst.afw.image.ApCorrMap`
            Aperture correction map
 
        Notes
        -----
        If you show debug-level log messages then you will see statistics for
        the effects of aperture correction.
        """
        self.log.info("Applying aperture corrections to %d instFlux fields", len(self.apCorrInfoDict))
        if UseNaiveFluxErr:
            self.log.debug("Use naive instFlux sigma computation")
        else:
            self.log.debug("Use complex instFlux sigma computation that double-counts photon noise "
                           "and thus over-estimates instFlux uncertainty")
 
        # Wrap the task logger to a periodic logger.
        periodicLog = PeriodicLogger(self.log)
 
        for apCorrIndex, apCorrInfo in enumerate(self.apCorrInfoDict.values()):
            apCorrModel = apCorrMap.get(apCorrInfo.modelName)
            apCorrErrModel = apCorrMap.get(apCorrInfo.modelSigmaName)
            if None in (apCorrModel, apCorrErrModel):
                missingNames = [(apCorrInfo.modelName, apCorrInfo.modelSigmaName)[i]
                                for i, model in enumerate((apCorrModel, apCorrErrModel)) if model is None]
                self.log.warning("Cannot aperture correct %s because could not find %s in apCorrMap",
                                 apCorrInfo.name, " or ".join(missingNames))
                for source in catalog:
                    source.set(apCorrInfo.apCorrFlagKey, True)
                continue
 
            # Say we've failed before we start; we'll unset these flags on success.
            catalog[apCorrInfo.apCorrFlagKey] = True
            oldFluxFlagState = np.zeros(len(catalog), dtype=np.bool_)
            if self.config.doFlagApCorrFailures:
                oldFluxFlagState = catalog[apCorrInfo.fluxFlagKey]
                catalog[apCorrInfo.fluxFlagKey] = True
 
            apCorr = apCorrModel.evaluate(catalog["slot_Centroid_x"], catalog["slot_Centroid_y"])
            if not UseNaiveFluxErr:
                apCorrErr = apCorrErrModel.evaluate(
                    catalog["slot_Centroid_x"],
                    catalog["slot_Centroid_y"],
                )
            else:
                apCorrErr = np.zeros(len(catalog))
 
            if apCorrInfo.doApCorrColumn:
                catalog[apCorrInfo.apCorrKey] = apCorr
                catalog[apCorrInfo.apCorrErrKey] = apCorrErr
 
            # Check bad values that are not finite (possible for coadds).
            good = np.isfinite(apCorr) & (apCorr > 0.0) & (apCorrErr >= 0.0)
 
            if good.sum() == 0:
                continue
 
            instFlux = catalog[apCorrInfo.instFluxKey]
            instFluxErr = catalog[apCorrInfo.instFluxErrKey]
            catalog[apCorrInfo.instFluxKey][good] = instFlux[good]*apCorr[good]
            if UseNaiveFluxErr:
                catalog[apCorrInfo.instFluxErrKey][good] = instFluxErr[good]*apCorr[good]
            else:
                a = instFluxErr[good]/instFlux[good]
                b = apCorrErr[good]/apCorr[good]
                err = np.abs(instFlux[good]*apCorr[good])*np.sqrt(a*a + b*b)
                catalog[apCorrInfo.instFluxErrKey][good] = err
 
            flags = catalog[apCorrInfo.apCorrFlagKey].copy()
            flags[good] = False
            catalog[apCorrInfo.apCorrFlagKey] = flags
            if self.config.doFlagApCorrFailures:
                fluxFlags = catalog[apCorrInfo.fluxFlagKey].copy()
                fluxFlags[good] = oldFluxFlagState[good]
                catalog[apCorrInfo.fluxFlagKey] = fluxFlags
 
            # Log a message if it has been a while since the last log.
            periodicLog.log("Aperture corrections applied to %d fields out of %d",
                            apCorrIndex + 1, len(self.apCorrInfoDict))
 
            if self.log.isEnabledFor(self.log.DEBUG):
                # log statistics on the effects of aperture correction
                apCorrArr = np.array([s.get(apCorrInfo.apCorrKey) for s in catalog])
                apCorrErrArr = np.array([s.get(apCorrInfo.apCorrErrKey) for s in catalog])
                self.log.debug("For instFlux field %r: mean apCorr=%s, stdDev apCorr=%s, "
                               "mean apCorrErr=%s, stdDev apCorrErr=%s for %s sources",
                               apCorrInfo.name, apCorrArr.mean(), apCorrArr.std(),
                               apCorrErrArr.mean(), apCorrErrArr.std(), len(catalog))

Member Data Documentation

_DefaultName

str lsst.meas.base.applyApCorr.ApplyApCorrTask._DefaultName = "applyApCorr"

staticprotected

Definition at line 195 of file applyApCorr.py.

apCorrInfoDict

lsst.meas.base.applyApCorr.ApplyApCorrTask.apCorrInfoDict

Definition at line 200 of file applyApCorr.py.

ConfigClass

lsst.meas.base.applyApCorr.ApplyApCorrTask.ConfigClass = ApplyApCorrConfig

static

Definition at line 194 of file applyApCorr.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_base/g212a7c68fe+04a9158687/python/lsst/meas/base/applyApCorr.py