Measurement of Sources, specifically ones from difference images, for characterization as dipoles. More...

Inheritance diagram for lsst.ip.diffim.dipoleMeasurement.DipoleMeasurementTask:

Public Member Functions
def	__init__
	Create the Task, and add Task-specific fields to the provided measurement table schema. More...

def	classify
	Create the records needed for dipole classification, and run classifier. More...

def	run
	Run dipole measurement and classification. More...

Public Attributes
	dipoleAnalysis

Static Public Attributes
	ConfigClass = DipoleMeasurementConfig

Static Private Attributes
string	_DefaultName = "dipoleMeasurement"

string	_ClassificationFlag = "classification_dipole"

Detailed Description

Measurement of Sources, specifically ones from difference images, for characterization as dipoles.

Description

This class provies a specialized set of Source measurements that allow the user to test the hypothesis that the Source is a dipole. This includes a set of measurements derived from intermediate base classes DipoleCentroidAlgorithm and DipoleFluxAlgorithm. Their respective algorithm control classes are defined in DipoleCentroidControl and DipoleFluxControl. Each centroid and flux measurement will have .neg (negative) and .pos (positive lobe) fields.

The first set of measurements uses a "naive" alrogithm for centroid and flux measurements, implemented in NaiveDipoleCentroidControl and NaiveDipoleFluxControl. The algorithm uses a naive 3x3 weighted moment around the nominal centroids of each peak in the Source Footprint. These algorithms fill the table fields centroid.dipole.naive.* and flux.dipole.naive.*.

The second set of measurements undertakes a joint-Psf model on the negative and positive lobe simultaneously. This fit simultaneously solves for the negative and positive lobe centroids and fluxes using non-linear least squares minimization. The fields are stored in table elements flux.dipole.psf.*.

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Task initialization

Create the Task, and add Task-specific fields to the provided measurement table schema.

Parameters

[in,out]	schema	Schema object for measurement fields; modified in-place.
[in,out]	algMetadata	Passed to MeasureSources object to be filled with metadata by algorithms (e.g. radii for aperture photometry).
	**kwds	Passed to Task.__init__.

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Invoking the Task

Run dipole measurement and classification.

Parameters

sources	diaSources that will be measured using dipole measurement
exposure	Exposure on which the diaSources were detected
**kwds	Sent to SingleFrameMeasurementTask

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Configuration parameters

See DipoleMeasurementConfig and DipoleClassificationConfig

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Quantities set in Metadata

No specific values are set in the Task metadata. However, the Source schema are modified to store the results of the dipole-specific measurements. These additional fields include:

. classification.dipole : probability of being a dipole

. centroid.dipole.naive.pos : unweighted 3x3 first moment centroid

. centroid.dipole.naive.pos.err : covariance matrix for centroid.dipole.naive.pos

. centroid.dipole.naive.pos.flags : set if the centroid.dipole.naive.pos measurement did not fully succeed

. centroid.dipole.naive.neg : unweighted 3x3 first moment centroid

. centroid.dipole.naive.neg.err : covariance matrix for centroid.dipole.naive.neg

. centroid.dipole.naive.neg.flags : set if the centroid.dipole.naive.neg measurement did not fully succeed

. flux.dipole.naive.pos : raw flux counts

. flux.dipole.naive.pos.err : uncertainty for flux.dipole.naive.pos

. flux.dipole.naive.pos.flags : set if the flux.dipole.naive.pos measurement failed

. flux.dipole.naive.neg : raw flux counts

. flux.dipole.naive.neg.err : uncertainty for flux.dipole.naive.neg

. flux.dipole.naive.neg.flags : set if the flux.dipole.naive.neg measurement failed

. flux.dipole.naive.npos : number of positive pixels

. flux.dipole.naive.nneg : number of negative pixels

. flux.dipole.psf.pos : jointly fitted psf flux counts

. flux.dipole.psf.pos.err : uncertainty for flux.dipole.psf.pos

. flux.dipole.psf.pos.flags : set if the flux.dipole.psf.pos measurement failed

. flux.dipole.psf.neg : jointly fitted psf flux counts

. flux.dipole.psf.neg.err : uncertainty for flux.dipole.psf.neg

. flux.dipole.psf.neg.flags : set if the flux.dipole.psf.neg measurement failed

. flux.dipole.psf.chi2dof : chi2 per degree of freedom of fit

. flux.dipole.psf.centroid : average of the postive and negative lobe positions

. flux.dipole.psf.centroid.err : covariance matrix for flux.dipole.psf.centroid

. flux.dipole.psf.centroid.flags : set if the flux.dipole.psf.centroid measurement did not fully succeed

. flux.dipole.psf.neg.centroid : psf fitted center of negative lobe

. flux.dipole.psf.neg.centroid.err : covariance matrix for flux.dipole.psf.neg.centroid

. flux.dipole.psf.neg.centroid.flags : set if the flux.dipole.psf.neg.centroid measurement did not fully succeed

. flux.dipole.psf.pos.centroid : psf fitted center of positive lobe

. flux.dipole.psf.pos.centroid.err : covariance matrix for flux.dipole.psf.pos.centroid

. flux.dipole.psf.pos.centroid.flags : set if the flux.dipole.psf.pos.centroid measurement did not fully succeed

. flux.dipole.psf.flags.maxpix : set if too large a footprint was sent to the algorithm

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Debug variables

The command line task interface supports a flag -d/–debug to import debug.py from your PYTHONPATH. The relevant contents of debug.py for this Task include:

 import sys
 import lsstDebug
 def DebugInfo(name):
     di = lsstDebug.getInfo(name)
     if name == "lsst.ip.diffim.dipoleMeasurement":
         di.display = True                 # enable debug output
         di.maskTransparency = 90          # ds9 mask transparency
         di.displayDiaSources = True       # show exposure with dipole results
     return di
 lsstDebug.Info = DebugInfo
 lsstDebug.frame = 1

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

A complete example of using DipoleMeasurementTask

This code is dipoleMeasTask.py in the examples directory, and can be run as e.g.

 examples/dipoleMeasTask.py
 examples/dipoleMeasTask.py --debug
 examples/dipoleMeasTask.py --debug --image /path/to/image.fits

Start the processing by parsing the command line, where the user has the option of enabling debugging output and/or sending their own image for demonstration (in case they have not downloaded the afwdata package).

 if __name__ == "__main__":
     import argparse
     parser = argparse.ArgumentParser(
         description="Demonstrate the use of SourceDetectionTask and DipoleMeasurement}Task")
 
     parser.add_argument('--debug', '-d', action="store_true", help="Load debug.py?", default=False)
     parser.add_argument("--image", "-i", help="User defined image", default=None)
 
     args = parser.parse_args()
 
     if args.debug:
         try:
             import debug
             debug.lsstDebug.frame = 2
         except ImportError as e:
             print >> sys.stderr, e
 
     run(args)

The processing occurs in the run function. We first extract an exposure from disk or afwdata, displaying it if requested:

 def run(args):
     exposure = loadData(args.image)
     if args.debug:
         ds9.mtv(exposure, frame=1)

Create a default source schema that we will append fields to as we add more algorithms:

1 schema = afwTable.SourceTable.makeMinimalSchema()

Create the detection and measurement Tasks, with some minor tweaking of their configs:

     # Create the detection task
     config = SourceDetectionTask.ConfigClass()
     config.thresholdPolarity = "both"
     config.background.isNanSafe = True
     config.thresholdValue = 3
     detectionTask = SourceDetectionTask(config=config, schema=schema)
     
     # And the measurement Task
     config = DipoleMeasurementTask.ConfigClass()
     algMetadata = dafBase.PropertyList()
     schema.addField(DipoleMeasurementTask._ClassificationFlag, "F", "probability of being a dipole")
     measureTask = DipoleMeasurementTask(schema, algMetadata, config=config)

Having fully initialied the schema, we create a Source table from it:

1 # Create the output table

2 tab = afwTable.SourceTable.make(schema)

Run detection:

1 # Process the data

2 results = detectionTask.run(tab, exposure)

Because we are looking for dipoles, we need to merge the positive and negative detections:

     # Merge the positve and negative sources
     fpSet = results.fpSets.positive
     growFootprint = 2
     fpSet.merge(results.fpSets.negative, growFootprint, growFootprint, False)
     diaSources = afwTable.SourceCatalog(tab)
     fpSet.makeSources(diaSources)
 
     print "Merged %s Sources into %d diaSources (from %d +ve, %d -ve)" % (len(results.sources), 
         len(diaSources), results.fpSets.numPos, results.fpSets.numNeg)

Finally, perform measurement (both standard and dipole-specialized) on the merged sources:

1 measureTask.measure(exposure, diaSources)

Optionally display debugging information:

     # Display dipoles if debug enabled
     if args.debug:
         dpa = DipoleAnalysis()
         dpa.displayDipoles(exposure, diaSources)

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Definition at line 74 of file dipoleMeasurement.py.

Constructor & Destructor Documentation

def lsst.ip.diffim.dipoleMeasurement.DipoleMeasurementTask.__init__	(	self,
		schema,
		algMetadata = `None`,
		kwds
	)

Create the Task, and add Task-specific fields to the provided measurement table schema.

Parameters

[in,out]	schema	Schema object for measurement fields; modified in-place.
[in,out]	algMetadata	Passed to MeasureSources object to be filled with metadata by algorithms (e.g. radii for aperture photometry).
	**kwds	Passed to Task.__init__.

Definition at line 277 of file dipoleMeasurement.py.

 
     def __init__(self, schema, algMetadata=None, **kwds):
         """!Create the Task, and add Task-specific fields to the provided measurement table schema.
 
         @param[in,out] schema        Schema object for measurement fields; modified in-place.
         @param[in,out] algMetadata   Passed to MeasureSources object to be filled with
                                      metadata by algorithms (e.g. radii for aperture photometry).
         @param         **kwds        Passed to Task.__init__.
         """
         SingleFrameMeasurementTask.__init__(self, schema, algMetadata, **kwds)
         self.dipoleAnalysis = DipoleAnalysis()