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

Public Member Functions
def	run (self, measCat, exposure, noiseImage=None, exposureId=None, beginOrder=None, endOrder=None)

def	runPlugins (self, noiseReplacer, measCat, exposure, beginOrder=None, endOrder=None)

def	measure (self, measCat, exposure)

def	getPluginLogName (self, pluginName)

def	initializePlugins (self, kwds)

def	callMeasure (self, measRecord, args, kwds)

def	doMeasurement (self, plugin, measRecord, args, kwds)

def	callMeasureN (self, measCat, args, kwds)

def	doMeasurementN (self, plugin, measCat, args, kwds)

def	emptyMetadata (self)

def	getSchemaCatalogs (self)

def	getAllSchemaCatalogs (self)

def	getFullMetadata (self)

def	getFullName (self)

def	getName (self)

def	getTaskDict (self)

def	makeSubtask (self, name, keyArgs)

def	timer (self, name, logLevel=Log.DEBUG)

def	makeField (cls, doc)

def	__reduce__ (self)

Public Attributes
	schema

	doBlendedness

	blendPlugin

	undeblendedPlugins

	metadata

	log

	config

Static Public Attributes
	ConfigClass = DipoleMeasurementConfig

string	NOISE_SEED_MULTIPLIER = "NOISE_SEED_MULTIPLIER"

string	NOISE_SOURCE = "NOISE_SOURCE"

string	NOISE_OFFSET = "NOISE_OFFSET"

string	NOISE_EXPOSURE_ID = "NOISE_EXPOSURE_ID"

	plugins = None

	algMetadata = None

Detailed Description

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

Parameters
----------
sources : 'lsst.afw.table.SourceCatalog'
    Sources that will be measured
badFlags : `list` of `dict`
    A list of flags that will be used to determine if there was a measurement problem

Notes
-----
The list of badFlags will be used to make a list of keys to check for measurement flags on.  By
default the centroid keys are added to this list

Description

This class provides a default configuration for running Source measurement on image differences.

.. code-block:: py

    class DipoleMeasurementConfig(SingleFrameMeasurementConfig):
        "Measurement of detected diaSources as dipoles"
        def setDefaults(self):
            SingleFrameMeasurementConfig.setDefaults(self)
            self.plugins = ["base_CircularApertureFlux",
                            "base_PixelFlags",
                            "base_SkyCoord",
                            "base_PsfFlux",
                            "ip_diffim_NaiveDipoleCentroid",
                            "ip_diffim_NaiveDipoleFlux",
                            "ip_diffim_PsfDipoleFlux",
                            "ip_diffim_ClassificationDipole",
                            ]
            self.slots.calibFlux = None
            self.slots.modelFlux = None
            self.slots.instFlux = None
            self.slots.shape = None
            self.slots.centroid = "ip_diffim_NaiveDipoleCentroid"
            self.doReplaceWithNoise = False

These plugins enabled by default 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
ip_diffim_NaiveDipoleCentroid* and ip_diffim_NaiveDipoleFlux*

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 ip_diffim_PsfDipoleFlux*.

Because this Task is just a config for SingleFrameMeasurementTask, the same result may be acheived by
manually editing the config and running SingleFrameMeasurementTask. For example:

.. code-block:: py

    config = SingleFrameMeasurementConfig()
    config.plugins.names = ["base_PsfFlux",
                            "ip_diffim_PsfDipoleFlux",
                            "ip_diffim_NaiveDipoleFlux",
                            "ip_diffim_NaiveDipoleCentroid",
                            "ip_diffim_ClassificationDipole",
                            "base_CircularApertureFlux",
                            "base_SkyCoord"]

    config.slots.calibFlux = None
    config.slots.modelFlux = None
    config.slots.instFlux = None
    config.slots.shape = None
    config.slots.centroid = "ip_diffim_NaiveDipoleCentroid"
    config.doReplaceWithNoise = False

    schema = afwTable.SourceTable.makeMinimalSchema()
    task = SingleFrameMeasurementTask(schema, config=config)-

Debug variables

The ``lsst.pipe.base.cmdLineTask.CmdLineTask`` 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:

.. code-block:: py

    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          # display mask transparency
            di.displayDiaSources = True       # show exposure with dipole results
        return di
    lsstDebug.Info = DebugInfo
    lsstDebug.frame = 1

    config.slots.calibFlux = None
    config.slots.modelFlux = None
    config.slots.gaussianFlux = None
    config.slots.shape = None
    config.slots.centroid = "ip_diffim_NaiveDipoleCentroid"
    config.doReplaceWithNoise = False

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

.. code-block:: none

    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).

.. code-block:: py

    if __name__ == "__main__":
        import argparse
        parser = argparse.ArgumentParser(
            description="Demonstrate the use of SourceDetectionTask and DipoleMeasurementTask")
        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(e, file=sys.stderr)
        run(args)

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

.. code-block:: py

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

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

.. code-block:: py

    schema = afwTable.SourceTable.makeMinimalSchema()

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

.. code-block:: py

        # 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()
    config.plugins.names.remove('base_SkyCoord')
    algMetadata = dafBase.PropertyList()
    measureTask = DipoleMeasurementTask(schema, algMetadata, config=config)

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

.. code-block:: py

    # Create the output table
    tab = afwTable.SourceTable.make(schema)

Run detection:

.. code-block:: py

    # Process the data
    results = detectionTask.run(tab, exposure)

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

.. code-block:: py

    # 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:

.. code-block:: py

    measureTask.run(diaSources, exposure)

Optionally display debugging information:

.. code-block:: py

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

Definition at line 123 of file dipoleMeasurement.py.

Member Function Documentation

◆ reduce()

def lsst.pipe.base.task.Task.__reduce__ ( self )

inherited

Pickler.

Definition at line 373 of file task.py.

     def __reduce__(self):
         """Pickler.
         """
         return self.__class__, (self.config, self._name, self._parentTask, None)
 

◆ callMeasure()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.callMeasure	(	self,
		measRecord,
		args,
		kwds
	)

inherited

Call ``measure`` on all plugins and consistently handle exceptions.

Parameters
----------
measRecord : `lsst.afw.table.SourceRecord`
    The record corresponding to the object being measured. Will be
    updated in-place with the results of measurement.
*args
    Positional arguments forwarded to ``plugin.measure``
**kwds
    Keyword arguments. Two are handled locally:

    beginOrder : `int`
Beginning execution order (inclusive). Measurements with
``executionOrder`` < ``beginOrder`` are not executed. `None`
for no limit.

    endOrder : `int`
Ending execution order (exclusive). Measurements with
``executionOrder`` >= ``endOrder`` are not executed. `None`
for no limit.

    Others are forwarded to ``plugin.measure()``.

Notes
-----
This method can be used with plugins that have different signatures;
the only requirement is that ``measRecord`` be the first argument.
Subsequent positional arguments and keyword arguments are forwarded
directly to the plugin.

This method should be considered "protected": it is intended for use by
derived classes, not users.

Definition at line 289 of file baseMeasurement.py.

     def callMeasure(self, measRecord, *args, **kwds):
         """Call ``measure`` on all plugins and consistently handle exceptions.
 
         Parameters
         ----------
         measRecord : `lsst.afw.table.SourceRecord`
             The record corresponding to the object being measured. Will be
             updated in-place with the results of measurement.
         *args
             Positional arguments forwarded to ``plugin.measure``
         **kwds
             Keyword arguments. Two are handled locally:
 
             beginOrder : `int`
                 Beginning execution order (inclusive). Measurements with
                 ``executionOrder`` < ``beginOrder`` are not executed. `None`
                 for no limit.
 
             endOrder : `int`
                 Ending execution order (exclusive). Measurements with
                 ``executionOrder`` >= ``endOrder`` are not executed. `None`
                 for no limit.
 
             Others are forwarded to ``plugin.measure()``.
 
         Notes
         -----
         This method can be used with plugins that have different signatures;
         the only requirement is that ``measRecord`` be the first argument.
         Subsequent positional arguments and keyword arguments are forwarded
         directly to the plugin.
 
         This method should be considered "protected": it is intended for use by
         derived classes, not users.
         """
         beginOrder = kwds.pop("beginOrder", None)
         endOrder = kwds.pop("endOrder", None)
         for plugin in self.plugins.iter():
             if beginOrder is not None and plugin.getExecutionOrder() < beginOrder:
                 continue
             if endOrder is not None and plugin.getExecutionOrder() >= endOrder:
                 break
             self.doMeasurement(plugin, measRecord, *args, **kwds)
 

◆ callMeasureN()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.callMeasureN	(	self,
		measCat,
		args,
		kwds
	)

inherited

Call ``measureN`` on all plugins and consistently handle exceptions.

Parameters
----------
measCat : `lsst.afw.table.SourceCatalog`
    Catalog containing only the records for the source family to be
    measured, and where outputs should be written.
*args
    Positional arguments forwarded to ``plugin.measure()``
**kwds
    Keyword arguments. Two are handled locally:

    beginOrder:
Beginning execution order (inclusive): Measurements with
``executionOrder`` < ``beginOrder`` are not executed. `None`
for no limit.
    endOrder:
Ending execution order (exclusive): measurements with
``executionOrder`` >= ``endOrder`` are not executed. `None` for
no ``limit``.

    Others are are forwarded to ``plugin.measure()``.

Notes
-----
This method can be used with plugins that have different signatures;
the only requirement is that ``measRecord`` be the first argument.
Subsequent positional arguments and keyword arguments are forwarded
directly to the plugin.

This method should be considered "protected": it is intended for use by
derived classes, not users.

Definition at line 375 of file baseMeasurement.py.

     def callMeasureN(self, measCat, *args, **kwds):
         """Call ``measureN`` on all plugins and consistently handle exceptions.
 
         Parameters
         ----------
         measCat : `lsst.afw.table.SourceCatalog`
             Catalog containing only the records for the source family to be
             measured, and where outputs should be written.
         *args
             Positional arguments forwarded to ``plugin.measure()``
         **kwds
             Keyword arguments. Two are handled locally:
 
             beginOrder:
                 Beginning execution order (inclusive): Measurements with
                 ``executionOrder`` < ``beginOrder`` are not executed. `None`
                 for no limit.
             endOrder:
                 Ending execution order (exclusive): measurements with
                 ``executionOrder`` >= ``endOrder`` are not executed. `None` for
                 no ``limit``.
 
             Others are are forwarded to ``plugin.measure()``.
 
         Notes
         -----
         This method can be used with plugins that have different signatures;
         the only requirement is that ``measRecord`` be the first argument.
         Subsequent positional arguments and keyword arguments are forwarded
         directly to the plugin.
 
         This method should be considered "protected": it is intended for use by
         derived classes, not users.
         """
         beginOrder = kwds.pop("beginOrder", None)
         endOrder = kwds.pop("endOrder", None)
         for plugin in self.plugins.iterN():
             if beginOrder is not None and plugin.getExecutionOrder() < beginOrder:
                 continue
             if endOrder is not None and plugin.getExecutionOrder() >= endOrder:
                 break
             self.doMeasurementN(plugin, measCat, *args, **kwds)
 

◆ doMeasurement()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.doMeasurement	(	self,
		plugin,
		measRecord,
		args,
		kwds
	)

inherited

Call ``measure`` on the specified plugin.

Exceptions are handled in a consistent way.

Parameters
----------
plugin : subclass of `BasePlugin`
    Plugin that will be executed.
measRecord : `lsst.afw.table.SourceRecord`
    The record corresponding to the object being measured. Will be
    updated in-place with the results of measurement.
*args
    Positional arguments forwarded to ``plugin.measure()``.
**kwds
    Keyword arguments forwarded to ``plugin.measure()``.

Notes
-----
This method can be used with plugins that have different signatures;
the only requirement is that ``plugin`` and ``measRecord`` be the first
two arguments.  Subsequent positional arguments and keyword arguments
are forwarded directly to the plugin.

This method should be considered "protected": it is intended for use by
derived classes, not users.

Definition at line 333 of file baseMeasurement.py.

     def doMeasurement(self, plugin, measRecord, *args, **kwds):
         """Call ``measure`` on the specified plugin.
 
         Exceptions are handled in a consistent way.
 
         Parameters
         ----------
         plugin : subclass of `BasePlugin`
             Plugin that will be executed.
         measRecord : `lsst.afw.table.SourceRecord`
             The record corresponding to the object being measured. Will be
             updated in-place with the results of measurement.
         *args
             Positional arguments forwarded to ``plugin.measure()``.
         **kwds
             Keyword arguments forwarded to ``plugin.measure()``.
 
         Notes
         -----
         This method can be used with plugins that have different signatures;
         the only requirement is that ``plugin`` and ``measRecord`` be the first
         two arguments.  Subsequent positional arguments and keyword arguments
         are forwarded directly to the plugin.
 
         This method should be considered "protected": it is intended for use by
         derived classes, not users.
         """
         try:
             plugin.measure(measRecord, *args, **kwds)
         except FATAL_EXCEPTIONS:
             raise
         except MeasurementError as error:
             lsst.log.Log.getLogger(self.getPluginLogName(plugin.name)).debug(
                 "MeasurementError in %s.measure on record %s: %s"
                 % (plugin.name, measRecord.getId(), error))
             plugin.fail(measRecord, error)
         except Exception as error:
             lsst.log.Log.getLogger(self.getPluginLogName(plugin.name)).debug(
                 "Exception in %s.measure on record %s: %s"
                 % (plugin.name, measRecord.getId(), error))
             plugin.fail(measRecord)
 

◆ doMeasurementN()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.doMeasurementN	(	self,
		plugin,
		measCat,
		args,
		kwds
	)

inherited

Call ``measureN`` on the specified plugin.

Exceptions are handled in a consistent way.

Parameters
----------
plugin : subclass of `BasePlugin`
    Plugin that will be executed.
measCat : `lsst.afw.table.SourceCatalog`
    Catalog containing only the records for the source family to be
    measured, and where outputs should be written.
*args
    Positional arguments forwarded to ``plugin.measureN()``.
**kwds
    Keyword arguments forwarded to ``plugin.measureN()``.

Notes
-----
This method can be used with plugins that have different signatures;
the only requirement is that the ``plugin`` and ``measCat`` be the
first two arguments. Subsequent positional arguments and keyword
arguments are forwarded directly to the plugin.

This method should be considered "protected": it is intended for use by
derived classes, not users.

Definition at line 418 of file baseMeasurement.py.

     def doMeasurementN(self, plugin, measCat, *args, **kwds):
         """Call ``measureN`` on the specified plugin.
 
         Exceptions are handled in a consistent way.
 
         Parameters
         ----------
         plugin : subclass of `BasePlugin`
             Plugin that will be executed.
         measCat : `lsst.afw.table.SourceCatalog`
             Catalog containing only the records for the source family to be
             measured, and where outputs should be written.
         *args
             Positional arguments forwarded to ``plugin.measureN()``.
         **kwds
             Keyword arguments forwarded to ``plugin.measureN()``.
 
         Notes
         -----
         This method can be used with plugins that have different signatures;
         the only requirement is that the ``plugin`` and ``measCat`` be the
         first two arguments. Subsequent positional arguments and keyword
         arguments are forwarded directly to the plugin.
 
         This method should be considered "protected": it is intended for use by
         derived classes, not users.
         """
         try:
             plugin.measureN(measCat, *args, **kwds)
         except FATAL_EXCEPTIONS:
             raise
 
         except MeasurementError as error:
             for measRecord in measCat:
                 lsst.log.Log.getLogger(self.getPluginLogName(plugin.name)).debug(
                     "MeasurementError in %s.measureN on records %s-%s: %s"
                     % (plugin.name, measCat[0].getId(), measCat[-1].getId(), error))
                 plugin.fail(measRecord, error)
         except Exception as error:
             for measRecord in measCat:
                 plugin.fail(measRecord)
                 lsst.log.Log.getLogger(self.getPluginLogName(plugin.name)).debug(
                     "Exception in %s.measureN on records %s-%s: %s"
                     % (plugin.name, measCat[0].getId(), measCat[-1].getId(), error))

◆ emptyMetadata()

def lsst.pipe.base.task.Task.emptyMetadata ( self )

inherited

Empty (clear) the metadata for this Task and all sub-Tasks.

Definition at line 153 of file task.py.

     def emptyMetadata(self):
         """Empty (clear) the metadata for this Task and all sub-Tasks.
         """
         for subtask in self._taskDict.values():
             subtask.metadata = dafBase.PropertyList()
 

◆ getAllSchemaCatalogs()

def lsst.pipe.base.task.Task.getAllSchemaCatalogs ( self )

inherited

Get schema catalogs for all tasks in the hierarchy, combining the results into a single dict.

Returns
-------
schemacatalogs : `dict`
    Keys are butler dataset type, values are a empty catalog (an instance of the appropriate
    lsst.afw.table Catalog type) for all tasks in the hierarchy, from the top-level task down
    through all subtasks.

Notes
-----
This method may be called on any task in the hierarchy; it will return the same answer, regardless.

The default implementation should always suffice. If your subtask uses schemas the override
`Task.getSchemaCatalogs`, not this method.

Definition at line 188 of file task.py.

     def getAllSchemaCatalogs(self):
         """Get schema catalogs for all tasks in the hierarchy, combining the results into a single dict.
 
         Returns
         -------
         schemacatalogs : `dict`
             Keys are butler dataset type, values are a empty catalog (an instance of the appropriate
             lsst.afw.table Catalog type) for all tasks in the hierarchy, from the top-level task down
             through all subtasks.
 
         Notes
         -----
         This method may be called on any task in the hierarchy; it will return the same answer, regardless.
 
         The default implementation should always suffice. If your subtask uses schemas the override
         `Task.getSchemaCatalogs`, not this method.
         """
         schemaDict = self.getSchemaCatalogs()
         for subtask in self._taskDict.values():
             schemaDict.update(subtask.getSchemaCatalogs())
         return schemaDict
 

◆ getFullMetadata()

def lsst.pipe.base.task.Task.getFullMetadata ( self )

inherited

Get metadata for all tasks.

Returns
-------
metadata : `lsst.daf.base.PropertySet`
    The `~lsst.daf.base.PropertySet` keys are the full task name. Values are metadata
    for the top-level task and all subtasks, sub-subtasks, etc..

Notes
-----
The returned metadata includes timing information (if ``@timer.timeMethod`` is used)
and any metadata set by the task. The name of each item consists of the full task name
with ``.`` replaced by ``:``, followed by ``.`` and the name of the item, e.g.::

    topLevelTaskName:subtaskName:subsubtaskName.itemName

using ``:`` in the full task name disambiguates the rare situation that a task has a subtask
and a metadata item with the same name.

Definition at line 210 of file task.py.

     def getFullMetadata(self):
         """Get metadata for all tasks.
 
         Returns
         -------
         metadata : `lsst.daf.base.PropertySet`
             The `~lsst.daf.base.PropertySet` keys are the full task name. Values are metadata
             for the top-level task and all subtasks, sub-subtasks, etc..
 
         Notes
         -----
         The returned metadata includes timing information (if ``@timer.timeMethod`` is used)
         and any metadata set by the task. The name of each item consists of the full task name
         with ``.`` replaced by ``:``, followed by ``.`` and the name of the item, e.g.::
 
             topLevelTaskName:subtaskName:subsubtaskName.itemName
 
         using ``:`` in the full task name disambiguates the rare situation that a task has a subtask
         and a metadata item with the same name.
         """
         fullMetadata = dafBase.PropertySet()
         for fullName, task in self.getTaskDict().items():
             fullMetadata.set(fullName.replace(".", ":"), task.metadata)
         return fullMetadata
 

◆ getFullName()

def lsst.pipe.base.task.Task.getFullName ( self )

inherited

Get the task name as a hierarchical name including parent task names.

Returns
-------
fullName : `str`
    The full name consists of the name of the parent task and each subtask separated by periods.
    For example:

    - The full name of top-level task "top" is simply "top".
    - The full name of subtask "sub" of top-level task "top" is "top.sub".
    - The full name of subtask "sub2" of subtask "sub" of top-level task "top" is "top.sub.sub2".

Definition at line 235 of file task.py.

     def getFullName(self):
         """Get the task name as a hierarchical name including parent task names.
 
         Returns
         -------
         fullName : `str`
             The full name consists of the name of the parent task and each subtask separated by periods.
             For example:
 
             - The full name of top-level task "top" is simply "top".
             - The full name of subtask "sub" of top-level task "top" is "top.sub".
             - The full name of subtask "sub2" of subtask "sub" of top-level task "top" is "top.sub.sub2".
         """
         return self._fullName
 

◆ getName()

def lsst.pipe.base.task.Task.getName ( self )

inherited

Get the name of the task.

Returns
-------
taskName : `str`
    Name of the task.

See also
--------
getFullName

Definition at line 250 of file task.py.

     def getName(self):
         """Get the name of the task.
 
         Returns
         -------
         taskName : `str`
             Name of the task.
 
         See also
         --------
         getFullName
         """
         return self._name
 

◆ getPluginLogName()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.getPluginLogName	(	self,
		pluginName
	)

inherited

Definition at line 239 of file baseMeasurement.py.

     def getPluginLogName(self, pluginName):
         return self.log.getName() + '.' + pluginName
 

◆ getSchemaCatalogs()

def lsst.pipe.base.task.Task.getSchemaCatalogs ( self )

inherited

Get the schemas generated by this task.

Returns
-------
schemaCatalogs : `dict`
    Keys are butler dataset type, values are an empty catalog (an instance of the appropriate
    `lsst.afw.table` Catalog type) for this task.

Notes
-----

.. warning::

   Subclasses that use schemas must override this method. The default implemenation returns
   an empty dict.

This method may be called at any time after the Task is constructed, which means that all task
schemas should be computed at construction time, *not* when data is actually processed. This
reflects the philosophy that the schema should not depend on the data.

Returning catalogs rather than just schemas allows us to save e.g. slots for SourceCatalog as well.

See also
--------
Task.getAllSchemaCatalogs

Definition at line 159 of file task.py.

     def getSchemaCatalogs(self):
         """Get the schemas generated by this task.
 
         Returns
         -------
         schemaCatalogs : `dict`
             Keys are butler dataset type, values are an empty catalog (an instance of the appropriate
             `lsst.afw.table` Catalog type) for this task.
 
         Notes
         -----
 
         .. warning::
 
            Subclasses that use schemas must override this method. The default implemenation returns
            an empty dict.
 
         This method may be called at any time after the Task is constructed, which means that all task
         schemas should be computed at construction time, *not* when data is actually processed. This
         reflects the philosophy that the schema should not depend on the data.
 
         Returning catalogs rather than just schemas allows us to save e.g. slots for SourceCatalog as well.
 
         See also
         --------
         Task.getAllSchemaCatalogs
         """
         return {}
 

◆ getTaskDict()

def lsst.pipe.base.task.Task.getTaskDict ( self )

inherited

Get a dictionary of all tasks as a shallow copy.

Returns
-------
taskDict : `dict`
    Dictionary containing full task name: task object for the top-level task and all subtasks,
    sub-subtasks, etc..

Definition at line 264 of file task.py.

     def getTaskDict(self):
         """Get a dictionary of all tasks as a shallow copy.
 
         Returns
         -------
         taskDict : `dict`
             Dictionary containing full task name: task object for the top-level task and all subtasks,
             sub-subtasks, etc..
         """
         return self._taskDict.copy()
 

◆ initializePlugins()

def lsst.meas.base.baseMeasurement.BaseMeasurementTask.initializePlugins	(	self,
		kwds
	)

inherited

Initialize plugins (and slots) according to configuration.

Parameters
----------
**kwds
    Keyword arguments forwarded directly to plugin constructors.

Notes
-----
Derived class constructors should call this method to fill the
`plugins` attribute and add corresponding output fields and slot
aliases to the output schema.

In addition to the attributes added by `BaseMeasurementTask.__init__`,
a ``schema``` attribute holding the output schema must be present
before this method is called.

Keyword arguments are forwarded directly to plugin constructors,
allowing derived classes to use plugins with different signatures.

Definition at line 242 of file baseMeasurement.py.

     def initializePlugins(self, **kwds):
         """Initialize plugins (and slots) according to configuration.
 
         Parameters
         ----------
         **kwds
             Keyword arguments forwarded directly to plugin constructors.
 
         Notes
         -----
         Derived class constructors should call this method to fill the
         `plugins` attribute and add corresponding output fields and slot
         aliases to the output schema.
 
         In addition to the attributes added by `BaseMeasurementTask.__init__`,
         a ``schema``` attribute holding the output schema must be present
         before this method is called.
 
         Keyword arguments are forwarded directly to plugin constructors,
         allowing derived classes to use plugins with different signatures.
         """
         # Make a place at the beginning for the centroid plugin to run first (because it's an OrderedDict,
         # adding an empty element in advance means it will get run first when it's reassigned to the
         # actual Plugin).
         if self.config.slots.centroid is not None:
             self.plugins[self.config.slots.centroid] = None
         # Init the plugins, sorted by execution order.  At the same time add to the schema
         for executionOrder, name, config, PluginClass in sorted(self.config.plugins.apply()):
             #   Pass logName to the plugin if the plugin is marked as using it
             #   The task will use this name to log plugin errors, regardless.
             if hasattr(PluginClass, "hasLogName") and PluginClass.hasLogName:
                 self.plugins[name] = PluginClass(config, name, metadata=self.algMetadata,
                                                  logName=self.getPluginLogName(name), **kwds)
             else:
                 self.plugins[name] = PluginClass(config, name, metadata=self.algMetadata, **kwds)
 
         # In rare circumstances (usually tests), the centroid slot not be coming from an algorithm,
         # which means we'll have added something we don't want to the plugins map, and we should
         # remove it.
         if self.config.slots.centroid is not None and self.plugins[self.config.slots.centroid] is None:
             del self.plugins[self.config.slots.centroid]
         # Initialize the plugins to run on the undeblended image
         for executionOrder, name, config, PluginClass in sorted(self.config.undeblended.apply()):
             undeblendedName = self.config.undeblendedPrefix + name
             self.undeblendedPlugins[name] = PluginClass(config, undeblendedName, metadata=self.algMetadata,
                                                         **kwds)
 

◆ makeField()

def lsst.pipe.base.task.Task.makeField	(	cls,
		doc
	)

inherited

Make a `lsst.pex.config.ConfigurableField` for this task.

Parameters
----------
doc : `str`
    Help text for the field.

Returns
-------
configurableField : `lsst.pex.config.ConfigurableField`
    A `~ConfigurableField` for this task.

Examples
--------
Provides a convenient way to specify this task is a subtask of another task.

Here is an example of use::

    class OtherTaskConfig(lsst.pex.config.Config)
aSubtask = ATaskClass.makeField("a brief description of what this task does")

Definition at line 329 of file task.py.

     def makeField(cls, doc):
         """Make a `lsst.pex.config.ConfigurableField` for this task.
 
         Parameters
         ----------
         doc : `str`
             Help text for the field.
 
         Returns
         -------
         configurableField : `lsst.pex.config.ConfigurableField`
             A `~ConfigurableField` for this task.
 
         Examples
         --------
         Provides a convenient way to specify this task is a subtask of another task.
 
         Here is an example of use::
 
             class OtherTaskConfig(lsst.pex.config.Config)
                 aSubtask = ATaskClass.makeField("a brief description of what this task does")
         """
         return ConfigurableField(doc=doc, target=cls)
 

◆ makeSubtask()

def lsst.pipe.base.task.Task.makeSubtask	(	self,
		name,
		keyArgs
	)

inherited

Create a subtask as a new instance as the ``name`` attribute of this task.

Parameters
----------
name : `str`
    Brief name of the subtask.
keyArgs
    Extra keyword arguments used to construct the task. The following arguments are automatically
    provided and cannot be overridden:

    - "config".
    - "parentTask".

Notes
-----
The subtask must be defined by ``Task.config.name``, an instance of pex_config ConfigurableField
or RegistryField.

Definition at line 275 of file task.py.

     def makeSubtask(self, name, **keyArgs):
         """Create a subtask as a new instance as the ``name`` attribute of this task.
 
         Parameters
         ----------
         name : `str`
             Brief name of the subtask.
         keyArgs
             Extra keyword arguments used to construct the task. The following arguments are automatically
             provided and cannot be overridden:
 
             - "config".
             - "parentTask".
 
         Notes
         -----
         The subtask must be defined by ``Task.config.name``, an instance of pex_config ConfigurableField
         or RegistryField.
         """
         taskField = getattr(self.config, name, None)
         if taskField is None:
             raise KeyError("%s's config does not have field %r" % (self.getFullName(), name))
         subtask = taskField.apply(name=name, parentTask=self, **keyArgs)
         setattr(self, name, subtask)
 

◆ measure()

def lsst.meas.base.sfm.SingleFrameMeasurementTask.measure	(	self,
		measCat,
		exposure
	)

inherited

Backwards-compatibility alias for `run`.

Definition at line 337 of file sfm.py.

     def measure(self, measCat, exposure):
         """Backwards-compatibility alias for `run`.
         """
         self.run(measCat, exposure)

◆ run()

def lsst.meas.base.sfm.SingleFrameMeasurementTask.run	(	self,
		measCat,
		exposure,
		noiseImage = `None`,
		exposureId = `None`,
		beginOrder = `None`,
		endOrder = `None`
	)

inherited

Run single frame measurement over an exposure and source catalog.

Parameters
----------
measCat : `lsst.afw.table.SourceCatalog`
    Catalog to be filled with the results of measurement. Must contain
    all the `lsst.afw.table.SourceRecord`\ s to be measured (with
    `lsst.afw.detection.Footprint`\ s attached), and have a schema
    that is a superset of ``self.schema``.
exposure : `lsst.afw.image.ExposureF`
    Image containing the pixel data to be measured together with
    associated PSF, WCS, etc.
noiseImage : `lsst.afw.image.ImageF`, optional
    Can be used to specify the a predictable noise replacement field
    for testing purposes.
exposureId : `int`, optional
    Unique exposure identifier used to calculate the random number
    generator seed during noise replacement.
beginOrder : `float`, optional
    Start execution order (inclusive): measurements with
    ``executionOrder < beginOrder`` are not executed. `None` for no
    limit.
endOrder : `float`, optional
    Final execution order (exclusive): measurements with
    ``executionOrder >= endOrder`` are not executed. `None` for no
    limit.

Definition at line 207 of file sfm.py.

     def run(self, measCat, exposure, noiseImage=None, exposureId=None, beginOrder=None, endOrder=None):
         r"""Run single frame measurement over an exposure and source catalog.
 
         Parameters
         ----------
         measCat : `lsst.afw.table.SourceCatalog`
             Catalog to be filled with the results of measurement. Must contain
             all the `lsst.afw.table.SourceRecord`\ s to be measured (with
             `lsst.afw.detection.Footprint`\ s attached), and have a schema
             that is a superset of ``self.schema``.
         exposure : `lsst.afw.image.ExposureF`
             Image containing the pixel data to be measured together with
             associated PSF, WCS, etc.
         noiseImage : `lsst.afw.image.ImageF`, optional
             Can be used to specify the a predictable noise replacement field
             for testing purposes.
         exposureId : `int`, optional
             Unique exposure identifier used to calculate the random number
             generator seed during noise replacement.
         beginOrder : `float`, optional
             Start execution order (inclusive): measurements with
             ``executionOrder < beginOrder`` are not executed. `None` for no
             limit.
         endOrder : `float`, optional
             Final execution order (exclusive): measurements with
             ``executionOrder >= endOrder`` are not executed. `None` for no
             limit.
         """
         assert measCat.getSchema().contains(self.schema)
         footprints = {measRecord.getId(): (measRecord.getParent(), measRecord.getFootprint())
                       for measRecord in measCat}
 
         # noiseReplacer is used to fill the footprints with noise and save
         # heavy footprints of the source pixels so that they can be restored
         # one at a time for measurement.  After the NoiseReplacer is
         # constructed, all pixels in the exposure.getMaskedImage() which
         # belong to objects in measCat will be replaced with noise
 
         if self.config.doReplaceWithNoise:
             noiseReplacer = NoiseReplacer(self.config.noiseReplacer, exposure, footprints,
                                           noiseImage=noiseImage, log=self.log, exposureId=exposureId)
             algMetadata = measCat.getMetadata()
             if algMetadata is not None:
                 algMetadata.addInt(self.NOISE_SEED_MULTIPLIER, self.config.noiseReplacer.noiseSeedMultiplier)
                 algMetadata.addString(self.NOISE_SOURCE, self.config.noiseReplacer.noiseSource)
                 algMetadata.addDouble(self.NOISE_OFFSET, self.config.noiseReplacer.noiseOffset)
                 if exposureId is not None:
                     algMetadata.addLong(self.NOISE_EXPOSURE_ID, exposureId)
         else:
             noiseReplacer = DummyNoiseReplacer()
 
         self.runPlugins(noiseReplacer, measCat, exposure, beginOrder, endOrder)
 

◆ runPlugins()

def lsst.meas.base.sfm.SingleFrameMeasurementTask.runPlugins	(	self,
		noiseReplacer,
		measCat,
		exposure,
		beginOrder = `None`,
		endOrder = `None`
	)

inherited

Call the configured measument plugins on an image.

Parameters
----------
noiseReplacer : `NoiseReplacer`
    Used to fill sources not being measured with noise.
measCat : `lsst.afw.table.SourceCatalog`
    Catalog to be filled with the results of measurement. Must contain
    all the `lsst.afw.table.SourceRecord`\ s to be measured (with
    `lsst.afw.detection.Footprint`\ s attached), and have a schema
    that is a superset of ``self.schema``.
exposure : `lsst.afw.image.ExposureF`
    Image containing the pixel data to be measured together with
    associated PSF, WCS, etc.
beginOrder : `float`, optional
    Start execution order (inclusive): measurements with
    ``executionOrder < beginOrder`` are not executed. `None` for no
    limit.
endOrder : `float`, optional
    Final execution order (exclusive): measurements with
    ``executionOrder >= endOrder`` are not executed. `None` for no
    limit.

Definition at line 260 of file sfm.py.

     def runPlugins(self, noiseReplacer, measCat, exposure, beginOrder=None, endOrder=None):
         r"""Call the configured measument plugins on an image.
 
         Parameters
         ----------
         noiseReplacer : `NoiseReplacer`
             Used to fill sources not being measured with noise.
         measCat : `lsst.afw.table.SourceCatalog`
             Catalog to be filled with the results of measurement. Must contain
             all the `lsst.afw.table.SourceRecord`\ s to be measured (with
             `lsst.afw.detection.Footprint`\ s attached), and have a schema
             that is a superset of ``self.schema``.
         exposure : `lsst.afw.image.ExposureF`
             Image containing the pixel data to be measured together with
             associated PSF, WCS, etc.
         beginOrder : `float`, optional
             Start execution order (inclusive): measurements with
             ``executionOrder < beginOrder`` are not executed. `None` for no
             limit.
         endOrder : `float`, optional
             Final execution order (exclusive): measurements with
             ``executionOrder >= endOrder`` are not executed. `None` for no
             limit.
         """
         # First, create a catalog of all parentless sources. Loop through all
         # the parent sources, first processing the children, then the parent.
         measParentCat = measCat.getChildren(0)
 
         nMeasCat = len(measCat)
         nMeasParentCat = len(measParentCat)
         self.log.info("Measuring %d source%s (%d parent%s, %d child%s) ",
                       nMeasCat, ("" if nMeasCat == 1 else "s"),
                       nMeasParentCat, ("" if nMeasParentCat == 1 else "s"),
                       nMeasCat - nMeasParentCat, ("" if nMeasCat - nMeasParentCat == 1 else "ren"))
 
         for parentIdx, measParentRecord in enumerate(measParentCat):
             # first get all the children of this parent, insert footprint in
             # turn, and measure
             measChildCat = measCat.getChildren(measParentRecord.getId())
             # TODO: skip this loop if there are no plugins configured for
             # single-object mode
             for measChildRecord in measChildCat:
                 noiseReplacer.insertSource(measChildRecord.getId())
                 self.callMeasure(measChildRecord, exposure, beginOrder=beginOrder, endOrder=endOrder)
 
                 if self.doBlendedness:
                     self.blendPlugin.cpp.measureChildPixels(exposure.getMaskedImage(), measChildRecord)
 
                 noiseReplacer.removeSource(measChildRecord.getId())
 
             # Then insert the parent footprint, and measure that
             noiseReplacer.insertSource(measParentRecord.getId())
             self.callMeasure(measParentRecord, exposure, beginOrder=beginOrder, endOrder=endOrder)
 
             if self.doBlendedness:
                 self.blendPlugin.cpp.measureChildPixels(exposure.getMaskedImage(), measParentRecord)
 
             # Finally, process both parent and child set through measureN
             self.callMeasureN(measParentCat[parentIdx:parentIdx+1], exposure,
                               beginOrder=beginOrder, endOrder=endOrder)
             self.callMeasureN(measChildCat, exposure, beginOrder=beginOrder, endOrder=endOrder)
             noiseReplacer.removeSource(measParentRecord.getId())
 
         # When done, restore the exposure to its original state
         noiseReplacer.end()
 
         # Undeblended plugins only fire if we're running everything
         if endOrder is None:
             for source in measCat:
                 for plugin in self.undeblendedPlugins.iter():
                     self.doMeasurement(plugin, source, exposure)
         # Now we loop over all of the sources one more time to compute the
         # blendedness metrics
         if self.doBlendedness:
             for source in measCat:
                 self.blendPlugin.cpp.measureParentPixels(exposure.getMaskedImage(), source)
 

◆ timer()

def lsst.pipe.base.task.Task.timer	(	self,
		name,
		logLevel = `Log.DEBUG`
	)

inherited

Context manager to log performance data for an arbitrary block of code.

Parameters
----------
name : `str`
    Name of code being timed; data will be logged using item name: ``Start`` and ``End``.
logLevel
    A `lsst.log` level constant.

Examples
--------
Creating a timer context::

    with self.timer("someCodeToTime"):
pass  # code to time

See also
--------
timer.logInfo

Definition at line 301 of file task.py.

     def timer(self, name, logLevel=Log.DEBUG):
         """Context manager to log performance data for an arbitrary block of code.
 
         Parameters
         ----------
         name : `str`
             Name of code being timed; data will be logged using item name: ``Start`` and ``End``.
         logLevel
             A `lsst.log` level constant.
 
         Examples
         --------
         Creating a timer context::
 
             with self.timer("someCodeToTime"):
                 pass  # code to time
 
         See also
         --------
         timer.logInfo
         """
         logInfo(obj=self, prefix=name + "Start", logLevel=logLevel)
         try:
             yield
         finally:
             logInfo(obj=self, prefix=name + "End", logLevel=logLevel)
 

Member Data Documentation

◆ algMetadata

lsst.meas.base.baseMeasurement.BaseMeasurementTask.algMetadata = None

staticinherited

Definition at line 224 of file baseMeasurement.py.

◆ blendPlugin

lsst.meas.base.sfm.SingleFrameMeasurementTask.blendPlugin

inherited

Definition at line 202 of file sfm.py.

◆ config

lsst.pipe.base.task.Task.config

inherited

Definition at line 149 of file task.py.

◆ ConfigClass

lsst.ip.diffim.dipoleMeasurement.DipoleMeasurementTask.ConfigClass = DipoleMeasurementConfig

static

Definition at line 343 of file dipoleMeasurement.py.

◆ doBlendedness

lsst.meas.base.sfm.SingleFrameMeasurementTask.doBlendedness

inherited

Definition at line 201 of file sfm.py.

◆ log

lsst.pipe.base.task.Task.log

inherited

Definition at line 148 of file task.py.

◆ metadata

lsst.pipe.base.task.Task.metadata

inherited

Definition at line 121 of file task.py.

◆ NOISE_EXPOSURE_ID

string lsst.meas.base.sfm.SingleFrameMeasurementTask.NOISE_EXPOSURE_ID = "NOISE_EXPOSURE_ID"

staticinherited

Definition at line 189 of file sfm.py.

◆ NOISE_OFFSET

string lsst.meas.base.sfm.SingleFrameMeasurementTask.NOISE_OFFSET = "NOISE_OFFSET"

staticinherited

Definition at line 185 of file sfm.py.

◆ NOISE_SEED_MULTIPLIER

string lsst.meas.base.sfm.SingleFrameMeasurementTask.NOISE_SEED_MULTIPLIER = "NOISE_SEED_MULTIPLIER"

staticinherited

Definition at line 177 of file sfm.py.

◆ NOISE_SOURCE

string lsst.meas.base.sfm.SingleFrameMeasurementTask.NOISE_SOURCE = "NOISE_SOURCE"

staticinherited

Definition at line 181 of file sfm.py.

◆ plugins

lsst.meas.base.baseMeasurement.BaseMeasurementTask.plugins = None

staticinherited

Definition at line 217 of file baseMeasurement.py.

◆ schema

lsst.meas.base.sfm.SingleFrameMeasurementTask.schema

inherited

Definition at line 195 of file sfm.py.

◆ undeblendedPlugins

lsst.meas.base.baseMeasurement.BaseMeasurementTask.undeblendedPlugins

inherited

Definition at line 234 of file baseMeasurement.py.

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

/j/snowflake/release/lsstsw/stack/Linux64/ip_diffim/18.1.0-14-g259bd21+21/python/lsst/ip/diffim/dipoleMeasurement.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

◆ __reduce__()

◆ callMeasure()

◆ callMeasureN()

◆ doMeasurement()

◆ doMeasurementN()

◆ emptyMetadata()

◆ getAllSchemaCatalogs()

◆ getFullMetadata()

◆ getFullName()

◆ getName()

◆ getPluginLogName()

◆ getSchemaCatalogs()

◆ getTaskDict()

◆ initializePlugins()

◆ makeField()

◆ makeSubtask()

◆ measure()

◆ run()

◆ runPlugins()

◆ timer()

Member Data Documentation

◆ algMetadata

◆ blendPlugin

◆ config

◆ ConfigClass

◆ doBlendedness

◆ log

◆ metadata

◆ NOISE_EXPOSURE_ID

◆ NOISE_OFFSET

◆ NOISE_SEED_MULTIPLIER

◆ NOISE_SOURCE

◆ plugins

◆ schema

◆ undeblendedPlugins

◆ reduce()