lsst.meas.base.sfm.SingleFrameMeasurementTask Class Reference

A subtask for measuring the properties of sources on a single exposure. More...

Inheritance diagram for lsst.meas.base.sfm.SingleFrameMeasurementTask:

Public Member Functions
def	__init__
	Initialize the task. More...
def	run
	Run single frame measurement over an exposure and source catalog. More...
def	measure
	Backwards-compatibility alias for run() More...

Public Attributes
	schema

Static Public Attributes
	ConfigClass = SingleFrameMeasurementConfig

Detailed Description

A subtask for measuring the properties of sources on a single exposure.

The task is configured with a list of "plugins": each plugin defines the values it measures (i.e. the columns in a table it will fill) and conducts that measurement on each detected source (see SingleFramePlugin). The job of the measurement task is to initialize the set of plugins (which includes setting up the catalog schema) from their configuration, and then invoke each plugin on each source.

When run after the deblender (see lsst.meas.deblender.SourceDeblendTask), SingleFrameMeasurementTask also replaces each source's neighbors with noise before measuring each source, utilizing the HeavyFootprints created by the deblender (see NoiseReplacer).

SingleFrameMeasurementTask has only two methods: init() and run(). For configuration options, see SingleFrameMeasurementConfig.

A complete example of using SingleFrameMeasurementTask

The code below is in examples/runSingleFrameTask.py

See meas_algorithms_detection_Example for more information on SourceDetectionTask.

First, import the required tasks (there are some other standard imports; read the file if you're confused):

from lsst.meas.algorithms.detection import SourceDetectionTask
from lsst.meas.base import SingleFrameMeasurementTask

We need to create our tasks before processing any data as the task constructors can add extra columns to the schema. The most important argument we pass these to these is an lsst.afw.table.Schema object, which contains information about the fields (i.e. columns) of the measurement catalog we'll create, including names, types, and additional documentation. Tasks that operate on a catalog are typically passed a Schema upon construction, to which they add the fields they'll fill later when run. We construct a mostly empty Schema that contains just the fields required for a SourceCatalog like this:

    schema = afwTable.SourceTable.makeMinimalSchema()

Now we can configure and create the SourceDetectionTask:

    #
    # Create the detection task
    #
    config = SourceDetectionTask.ConfigClass()
    config.thresholdPolarity = "both"
    config.background.isNanSafe = True
    config.thresholdValue = 3
    detectionTask = SourceDetectionTask(config=config, schema=schema)

We then move on to configuring the measurement task:

    #
    # And the measurement Task
    #
    config = SingleFrameMeasurementTask.ConfigClass()

While a reasonable set of plugins is configured by default, we'll customize the list. We also need to unset one of the slots at the same time, because we're not running the algorithm that it's set to by default, and that would cause problems later:

    config.plugins.names.clear()
    for plugin in ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux", "base_GaussianFlux"]:
        config.plugins.names.add(plugin)
    config.slots.psfFlux = None

Now, finally, we can construct the measurement task:

    measureTask = SingleFrameMeasurementTask(schema, config=config)

After constructing all the tasks, we can inspect the Schema we've created:

    print schema

All of the fields in the schema can be accessed via the get() method on a record object. See afwTable for more information.

We're now ready to process the data (we could loop over multiple exposures/catalogs using the same task objects). First create the output table and process the image to find sources:

    tab = afwTable.SourceTable.make(schema)
    result = detectionTask.run(tab, exposure)

    sources = result.sources

Then measure them:

    measureTask.run(sources, exposure)

We then might plot the results (e.g. if you set --ds9 on the command line)

    if display:                         # display on ds9 (see also --debug argparse option)
        frame = 1
        ds9.mtv(exposure, frame=frame)

        with ds9.Buffering():
            for s in sources:
                xy = s.getCentroid()
                ds9.dot('+', *xy, ctype=ds9.CYAN if s.get("flags_negative") else ds9.GREEN, frame=frame)
                ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame)

and end up with something like

Definition at line 138 of file sfm.py.

Constructor & Destructor Documentation

def lsst.meas.base.sfm.SingleFrameMeasurementTask.__init__	(		self,
			schema,
			algMetadata = None,
			kwds
	)

Initialize the task.

Set up the execution order of the plugins and initialize the plugins, giving each plugin an opportunity to add its measurement fields to the output schema and to record information in the task metadata.

Parameters

[in,out]	schema	lsst.afw.table.Schema, to be initialized to include the measurement fields from the plugins already
[in,out]	algMetadata	lsst.daf.base.PropertyList used to record information about each algorithm. An empty PropertyList will be created if None.
[in]	**kwds	Keyword arguments forwarded to lsst.pipe.base.Task.__init__

Definition at line 232 of file sfm.py.

    def __init__(self, schema, algMetadata=None, **kwds):
        """!
        Initialize the task. Set up the execution order of the plugins and initialize
        the plugins, giving each plugin an opportunity to add its measurement fields to
        the output schema and to record information in the task metadata.

        @param[in,out] schema      lsst.afw.table.Schema, to be initialized to include the
                                   measurement fields from the plugins already
        @param[in,out] algMetadata lsst.daf.base.PropertyList used to record information about
                                   each algorithm.  An empty PropertyList will be created if None.
        @param[in]     **kwds      Keyword arguments forwarded to lsst.pipe.base.Task.__init__
        """
        super(SingleFrameMeasurementTask, self).__init__(algMetadata=algMetadata, **kwds)
        self.schema = schema
        self.config.slots.setupSchema(self.schema)
        self.initializePlugins(schema=self.schema)
        self.makeSubtask("applyApCorr", schema=self.schema)