Task to measure aperture correction. More...

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

Public Member Functions
def	__init__
	Construct a MeasureApCorrTask. More...

def	run
	Measure aperture correction. More...

Public Attributes
	refFluxKeys

	toCorrect

	inputFilterFlag

Static Public Attributes
	ConfigClass = MeasureApCorrConfig

Static Private Attributes
string	_DefaultName = "measureApCorr"

Detailed Description

Task to measure aperture correction.

Description

Task to measure aperture correction.

This task measures aperture correction for the flux fields returned by lsst.meas.base.getApCorrNameSet()

The main method is run.

Configuration parameters

See MeasureApCorrConfig

Debug variables

This task has no debug variables.

Definition at line 98 of file measureApCorr.py.

Constructor & Destructor Documentation

def lsst.meas.base.measureApCorr.MeasureApCorrTask.__init__	(	self,
		schema,
		kwds
	)

Construct a MeasureApCorrTask.

For every name in lsst.meas.base.getApCorrNameSet():

If the corresponding flux fields exist in the schema:
- Add a new field apcorr_{name}_used
- Add an entry to the self.toCorrect dict
Otherwise silently skip the name

Definition at line 127 of file measureApCorr.py.

 
     def __init__(self, schema, **kwds):
         """!Construct a MeasureApCorrTask
 
         For every name in lsst.meas.base.getApCorrNameSet():
         - If the corresponding flux fields exist in the schema:
             - Add a new field apcorr_{name}_used
             - Add an entry to the self.toCorrect dict
         - Otherwise silently skip the name
         """
         Task.__init__(self, **kwds)
         self.refFluxKeys = FluxKeys(self.config.refFluxName, schema)
         self.toCorrect = {} # dict of flux field name prefix: FluxKeys instance
         for name in getApCorrNameSet():
             try:
                 self.toCorrect[name] = FluxKeys(name, schema)
             except KeyError:
                 # if a field in the registry is missing, just ignore it.
                 pass
         self.inputFilterFlag = schema.find(self.config.inputFilterFlag).key

lsst::meas::base.measureApCorr.FluxKeys

Definition: measureApCorr.py:34

lsst::meas::base.apCorrRegistry.getApCorrNameSet

def getApCorrNameSet

Return a copy of the set of field name prefixes for fluxes that should be aperture corrected...

Definition: apCorrRegistry.py:42

lsst::meas::base.measureApCorr.MeasureApCorrTask.inputFilterFlag

inputFilterFlag

Definition: measureApCorr.py:145

lsst::meas::base.measureApCorr.MeasureApCorrTask.refFluxKeys

refFluxKeys

Definition: measureApCorr.py:137

lsst::meas::base.measureApCorr.MeasureApCorrTask.__init__

def __init__

Construct a MeasureApCorrTask.

Definition: measureApCorr.py:127

lsst::meas::base.measureApCorr.MeasureApCorrTask.toCorrect

toCorrect

Definition: measureApCorr.py:138

def lsst.meas.base.measureApCorr.MeasureApCorrTask.run	(	self,
		bbox,
		catalog
	)

Measure aperture correction.

Returns

an lsst.pipe.base.Struct containing:

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

Definition at line 147 of file measureApCorr.py.

 
     def run(self, bbox, catalog):
         """!Measure aperture correction
 
         @return an lsst.pipe.base.Struct containing:
         - apCorrMap: an aperture correction map (lsst.afw.image.ApCorrMap) that contains two entries
             for each flux field:
             - flux field (e.g. base_PsfFlux_flux): 2d model
             - flux sigma field (e.g. base_PsfFlux_fluxSigma): 2d model of error
         """
         self.log.info("Measuring aperture corrections for %d flux fields" % (len(self.toCorrect),))
         # First, create a subset of the catalog that contains only objects with inputFilterFlag set
         # and non-flagged reference fluxes.
         subset1 = [record for record in catalog
                    if record.get(self.inputFilterFlag) and not record.get(self.refFluxKeys.flag)]
 
         apCorrMap = ApCorrMap()
 
         # Outer loop over the fields we want to correct
         for name, keys in self.toCorrect.iteritems():
             fluxName = name + "_flux"
             fluxSigmaName = name + "_fluxSigma"
 
             # Create a more restricted subset with only the objects where the to-be-correct flux
             # is not flagged.
             subset2 = [record for record in subset1 if not record.get(keys.flag)]
 
             # Check that we have enough data points that we have at least the minimum of degrees of
             # freedom specified in the config.
             if len(subset2) - 1 < self.config.minDegreesOfFreedom:
                 self.log.warn("Only %d sources for calculation of aperture correction for '%s'; "
                               "setting to 1.0" % (len(subset2), name,))
                 apCorrMap[fluxName] = ChebyshevBoundedField(bbox, numpy.ones((1,1), dtype=float))
                 apCorrMap[fluxSigmaName] = ChebyshevBoundedField(bbox, numpy.zeros((1,1), dtype=float))
                 continue
 
             # If we don't have enough data points to constrain the fit, reduce the order until we do
             ctrl = self.config.fitConfig.makeControl()
             while len(subset2) - ctrl.computeSize() < self.config.minDegreesOfFreedom:
                 if ctrl.orderX > 0:
                     ctrl.orderX -= 1
                 if ctrl.orderY > 0:
                     ctrl.orderY -= 1
 
             # Fill numpy arrays with positions and the ratio of the reference flux to the to-correct flux
             x = numpy.zeros(len(subset2), dtype=float)
             y = numpy.zeros(len(subset2), dtype=float)
             apCorrData = numpy.zeros(len(subset2), dtype=float)
             indices = numpy.arange(len(subset2), dtype=int)
             for n, record in enumerate(subset2):
                 x[n] = record.getX()
                 y[n] = record.getY()
                 apCorrData[n] = record.get(self.refFluxKeys.flux)/record.get(keys.flux)
 
             for _i in range(self.config.numIter):
 
                 # Do the fit, save it in the output map
                 apCorrField = ChebyshevBoundedField.fit(bbox, x, y, apCorrData, ctrl)
 
                 # Compute errors empirically, using the RMS difference between the true reference flux and the
                 # corrected to-be-corrected flux.
                 apCorrDiffs = apCorrField.evaluate(x, y)
                 apCorrDiffs -= apCorrData
                 apCorrErr = numpy.mean(apCorrDiffs**2)**0.5
 
                 # Clip bad data points
                 apCorrDiffLim = self.config.numSigmaClip * apCorrErr
                 keep = numpy.fabs(apCorrDiffs) < apCorrDiffLim
                 x = x[keep]
                 y = y[keep]
                 apCorrData = apCorrData[keep]
                 indices = indices[keep]
 
             # Final fit after clipping
             apCorrField = ChebyshevBoundedField.fit(bbox, x, y, apCorrData, ctrl)
 
             self.log.info("Aperture correction for %s: RMS %f from %d" %
                           (name, numpy.mean((apCorrField.evaluate(x, y) - apCorrData)**2)**0.5, len(indices)))
 
             # 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[fluxName] = apCorrField
             apCorrErrCoefficients = numpy.array([[apCorrErr]], dtype=float)
             apCorrMap[fluxSigmaName] = ChebyshevBoundedField(bbox, apCorrErrCoefficients)
 
             # Record which sources were used
             for i in indices:
                 subset2[i].set(keys.used, True)
 
         return Struct(
             apCorrMap = apCorrMap,
         )

Public Member Functions

Public Attributes

Static Public Attributes

Static Private Attributes

Detailed Description

Contents

Description

Configuration parameters

Debug variables

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation