Inheritance diagram for lsst.meas.base.forcedMeasurement.ForcedMeasurementTask:

Public Member Functions
def	__init__ (self, refSchema, algMetadata=None, **kwds)

def	run (self, measCat, exposure, refCat, refWcs, exposureId=None, beginOrder=None, endOrder=None)

def	generateMeasCat (self, exposure, refCat, refWcs, idFactory=None)

def	attachTransformedFootprints (self, sources, refCat, exposure, refWcs)

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
	mapper

	schema

	undeblendedPlugins

	metadata

	log

	config

Static Public Attributes
	ConfigClass = ForcedMeasurementConfig

	plugins = None

	algMetadata = None

Detailed Description

Measure sources on an image, constrained by a reference catalog.

A subtask for measuring the properties of sources on a single image,
using an existing "reference" catalog to constrain some aspects of the
measurement.

Parameters
----------
refSchema : `lsst.afw.table.Schema`
    Schema of the reference catalog.  Must match the catalog later passed
    to 'ForcedMeasurementTask.generateMeasCat` and/or
    `ForcedMeasurementTask.run`.
algMetadata : `lsst.daf.base.PropertyList` or `None`
    Will be updated in place to to record information about each
    algorithm. An empty `~lsst.daf.base.PropertyList` will be created if
    `None`.
**kwds
    Keyword arguments are passed to the supertask constructor.

Notes
-----
Note that while `SingleFrameMeasurementTask` is passed an initial
`~lsst.afw.table.Schema` that is appended to in order to create the output
`~lsst.afw.table.Schema`, `ForcedMeasurementTask` is initialized with the
`~lsst.afw.table.Schema` of the reference catalog, from which a new
`~lsst.afw.table.Schema` for the output catalog is created.  Fields to be
copied directly from the reference `~lsst.afw.table.Schema` are added
before ``Plugin`` fields are added.

Definition at line 216 of file forcedMeasurement.py.

Constructor & Destructor Documentation

◆ init()

def lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.__init__	(		self,
			refSchema,
			algMetadata = `None`,
		**	kwds
	)

Definition at line 249 of file forcedMeasurement.py.

     def __init__(self, refSchema, algMetadata=None, **kwds):
         super(ForcedMeasurementTask, self).__init__(algMetadata=algMetadata, **kwds)
         self.mapper = lsst.afw.table.SchemaMapper(refSchema)
         self.mapper.addMinimalSchema(lsst.afw.table.SourceTable.makeMinimalSchema(), False)
         self.config.slots.setupSchema(self.mapper.editOutputSchema())
         for refName, targetName in self.config.copyColumns.items():
             refItem = refSchema.find(refName)
             self.mapper.addMapping(refItem.key, targetName)
         self.config.slots.setupSchema(self.mapper.editOutputSchema())
         self.initializePlugins(schemaMapper=self.mapper)
         self.schema = self.mapper.getOutputSchema()
         self.schema.checkUnits(parse_strict=self.config.checkUnitsParseStrict)
  

Member Function Documentation

◆ reduce()

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

inherited

Pickler.

Reimplemented in lsst.pipe.drivers.multiBandDriver.MultiBandDriverTask, and lsst.pipe.drivers.coaddDriver.CoaddDriverTask.

Definition at line 432 of file task.py.

     def __reduce__(self):
         """Pickler.
         """
         return self._unpickle_via_factory, (self.__class__, [], self._reduce_kwargs())

◆ attachTransformedFootprints()

def lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.attachTransformedFootprints	(	self,
		sources,
		refCat,
		exposure,
		refWcs
	)

Attach Footprints to blank sources prior to measurement.

Notes
-----
`~lsst.afw.detection.Footprint`\s for forced photometry must be in the
pixel coordinate system of the image being measured, while the actual
detections may start out in a different coordinate system. This
default implementation transforms the Footprints from the reference
catalog from the WCS to the exposure's WCS, which downgrades
``HeavyFootprint``\s into regular `~lsst.afw.detection.Footprint`\s,
destroying deblend information.

See the documentation for `run` for information about the
relationships between `run`, `generateMeasCat`, and
`attachTransformedFootprints`.

Definition at line 425 of file forcedMeasurement.py.

     def attachTransformedFootprints(self, sources, refCat, exposure, refWcs):
         r"""Attach Footprints to blank sources prior to measurement.
  
         Notes
         -----
         `~lsst.afw.detection.Footprint`\s for forced photometry must be in the
         pixel coordinate system of the image being measured, while the actual
         detections may start out in a different coordinate system. This
         default implementation transforms the Footprints from the reference
         catalog from the WCS to the exposure's WCS, which downgrades
         ``HeavyFootprint``\s into regular `~lsst.afw.detection.Footprint`\s,
         destroying deblend information.
  
         See the documentation for `run` for information about the
         relationships between `run`, `generateMeasCat`, and
         `attachTransformedFootprints`.
         """
         exposureWcs = exposure.getWcs()
         region = exposure.getBBox(lsst.afw.image.PARENT)
         for srcRecord, refRecord in zip(sources, refCat):
             srcRecord.setFootprint(refRecord.getFootprint().transform(refWcs, exposureWcs, region))

◆ 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 166 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()
  

◆ generateMeasCat()

def lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.generateMeasCat	(	self,
		exposure,
		refCat,
		refWcs,
		idFactory = `None`
	)

Initialize an output catalog from the reference catalog.

Parameters
----------
exposure : `lsst.afw.image.exposureF`
    Image to be measured.
refCat : iterable of `lsst.afw.table.SourceRecord`
    Catalog of reference sources.
refWcs : `lsst.afw.geom.SkyWcs`
    Defines the X,Y coordinate system of ``refCat``.
idFactory : `lsst.afw.table.IdFactory`, optional
    Factory for creating IDs for sources.

Returns
-------
meascat : `lsst.afw.table.SourceCatalog`
    Source catalog ready for measurement.

Notes
-----
This generates a new blank `~lsst.afw.table.SourceRecord` for each
record in ``refCat``. Note that this method does not attach any
`~lsst.afw.detection.Footprint`\ s.  Doing so is up to the caller (who
may call `attachedTransformedFootprints` or define their own method -
see `run` for more information).

Definition at line 386 of file forcedMeasurement.py.

     def generateMeasCat(self, exposure, refCat, refWcs, idFactory=None):
         r"""Initialize an output catalog from the reference catalog.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.exposureF`
             Image to be measured.
         refCat : iterable of `lsst.afw.table.SourceRecord`
             Catalog of reference sources.
         refWcs : `lsst.afw.geom.SkyWcs`
             Defines the X,Y coordinate system of ``refCat``.
         idFactory : `lsst.afw.table.IdFactory`, optional
             Factory for creating IDs for sources.
  
         Returns
         -------
         meascat : `lsst.afw.table.SourceCatalog`
             Source catalog ready for measurement.
  
         Notes
         -----
         This generates a new blank `~lsst.afw.table.SourceRecord` for each
         record in ``refCat``. Note that this method does not attach any
         `~lsst.afw.detection.Footprint`\ s.  Doing so is up to the caller (who
         may call `attachedTransformedFootprints` or define their own method -
         see `run` for more information).
         """
         if idFactory is None:
             idFactory = lsst.afw.table.IdFactory.makeSimple()
         table = lsst.afw.table.SourceTable.make(self.schema, idFactory)
         measCat = lsst.afw.table.SourceCatalog(table)
         table = measCat.table
         table.setMetadata(self.algMetadata)
         table.preallocate(len(refCat))
         for ref in refCat:
             newSource = measCat.addNew()
             newSource.assign(ref, self.mapper)
         return measCat
  

◆ 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 204 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 229 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 256 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 274 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
   implementation 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 172 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
            implementation 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 288 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:

.. code-block:: python

    class OtherTaskConfig(lsst.pex.config.Config):
        aSubtask = ATaskClass.makeField("brief description of task")

Definition at line 359 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:
  
         .. code-block:: python
  
             class OtherTaskConfig(lsst.pex.config.Config):
                 aSubtask = ATaskClass.makeField("brief description of task")
         """
         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
`~lsst.pex.config.ConfigurableField` or
`~lsst.pex.config.RegistryField`.

Definition at line 299 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
         `~lsst.pex.config.ConfigurableField` or
         `~lsst.pex.config.RegistryField`.
         """
         taskField = getattr(self.config, name, None)
         if taskField is None:
             raise KeyError(f"{self.getFullName()}'s config does not have field {name!r}")
         subtask = taskField.apply(name=name, parentTask=self, **keyArgs)
         setattr(self, name, subtask)
  

◆ run()

def lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.run	(	self,
		measCat,
		exposure,
		refCat,
		refWcs,
		exposureId = `None`,
		beginOrder = `None`,
		endOrder = `None`
	)

Perform forced measurement.

Parameters
----------
exposure : `lsst.afw.image.exposureF`
    Image to be measured. Must have at least a `lsst.afw.geom.SkyWcs`
    attached.
measCat : `lsst.afw.table.SourceCatalog`
    Source catalog for measurement results; must be initialized with
    empty records already corresponding to those in ``refCat`` (via
    e.g. `generateMeasCat`).
refCat : `lsst.afw.table.SourceCatalog`
    A sequence of `lsst.afw.table.SourceRecord` objects that provide
    reference information for the measurement.  These will be passed
    to each plugin in addition to the output
    `~lsst.afw.table.SourceRecord`.
refWcs : `lsst.afw.geom.SkyWcs`
    Defines the X,Y coordinate system of ``refCat``.
exposureId : `int`, optional
    Optional unique exposureId used to calculate random number
    generator seed in the NoiseReplacer.
beginOrder : `int`, optional
    Beginning execution order (inclusive). Algorithms with
    ``executionOrder`` < ``beginOrder`` are not executed. `None` for no limit.
endOrder : `int`, optional
    Ending execution order (exclusive). Algorithms with
    ``executionOrder`` >= ``endOrder`` are not executed. `None` for no limit.

Notes
-----
Fills the initial empty `~lsst.afw.table.SourceCatalog` with forced
measurement results.  Two steps must occur before `run` can be called:

- `generateMeasCat` must be called to create the output ``measCat``
  argument.
- `~lsst.afw.detection.Footprint`\ s appropriate for the forced sources
  must be attached to the ``measCat`` records. The
  `attachTransformedFootprints` method can be used to do this, but
  this degrades "heavy" (i.e., including pixel values)
  `~lsst.afw.detection.Footprint`\s to regular
  `~lsst.afw.detection.Footprint`\s, leading to non-deblended
  measurement, so most callers should provide
  `~lsst.afw.detection.Footprint`\s some other way. Typically, calling
  code will have access to information that will allow them to provide
  heavy footprints - for instance, `ForcedPhotCoaddTask` uses the
  heavy footprints from deblending run in the same band just before
  non-forced is run measurement in that band.

Definition at line 262 of file forcedMeasurement.py.

     def run(self, measCat, exposure, refCat, refWcs, exposureId=None, beginOrder=None, endOrder=None):
         r"""Perform forced measurement.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.exposureF`
             Image to be measured. Must have at least a `lsst.afw.geom.SkyWcs`
             attached.
         measCat : `lsst.afw.table.SourceCatalog`
             Source catalog for measurement results; must be initialized with
             empty records already corresponding to those in ``refCat`` (via
             e.g. `generateMeasCat`).
         refCat : `lsst.afw.table.SourceCatalog`
             A sequence of `lsst.afw.table.SourceRecord` objects that provide
             reference information for the measurement.  These will be passed
             to each plugin in addition to the output
             `~lsst.afw.table.SourceRecord`.
         refWcs : `lsst.afw.geom.SkyWcs`
             Defines the X,Y coordinate system of ``refCat``.
         exposureId : `int`, optional
             Optional unique exposureId used to calculate random number
             generator seed in the NoiseReplacer.
         beginOrder : `int`, optional
             Beginning execution order (inclusive). Algorithms with
             ``executionOrder`` < ``beginOrder`` are not executed. `None` for no limit.
         endOrder : `int`, optional
             Ending execution order (exclusive). Algorithms with
             ``executionOrder`` >= ``endOrder`` are not executed. `None` for no limit.
  
         Notes
         -----
         Fills the initial empty `~lsst.afw.table.SourceCatalog` with forced
         measurement results.  Two steps must occur before `run` can be called:
  
         - `generateMeasCat` must be called to create the output ``measCat``
           argument.
         - `~lsst.afw.detection.Footprint`\ s appropriate for the forced sources
           must be attached to the ``measCat`` records. The
           `attachTransformedFootprints` method can be used to do this, but
           this degrades "heavy" (i.e., including pixel values)
           `~lsst.afw.detection.Footprint`\s to regular
           `~lsst.afw.detection.Footprint`\s, leading to non-deblended
           measurement, so most callers should provide
           `~lsst.afw.detection.Footprint`\s some other way. Typically, calling
           code will have access to information that will allow them to provide
           heavy footprints - for instance, `ForcedPhotCoaddTask` uses the
           heavy footprints from deblending run in the same band just before
           non-forced is run measurement in that band.
         """
         # First check that the reference catalog does not contain any children
         # for which any member of their parent chain is not within the list.
         # This can occur at boundaries when the parent is outside and one of
         # the children is within.  Currently, the parent chain is always only
         # one deep, but just in case, this code checks for any case where when
         # the parent chain to a child's topmost parent is broken and raises an
         # exception if it occurs.
         #
         # I.e. this code checks that this precondition is satisfied by
         # whatever reference catalog provider is being paired with it.
         refCatIdDict = {ref.getId(): ref.getParent() for ref in refCat}
         for ref in refCat:
             refId = ref.getId()
             topId = refId
             while(topId > 0):
                 if topId not in refCatIdDict:
                     raise RuntimeError("Reference catalog contains a child for which at least "
                                        "one parent in its parent chain is not in the catalog.")
                 topId = refCatIdDict[topId]
  
         # Construct a footprints dict which looks like
         # {ref.getId(): (ref.getParent(), source.getFootprint())}
         # (i.e. getting the footprint from the transformed source footprint)
         footprints = {ref.getId(): (ref.getParent(), measRecord.getFootprint())
                       for (ref, measRecord) in zip(refCat, measCat)}
  
         self.log.info("Performing forced measurement on %d source%s", len(refCat),
                       "" if len(refCat) == 1 else "s")
  
         if self.config.doReplaceWithNoise:
             noiseReplacer = NoiseReplacer(self.config.noiseReplacer, exposure,
                                           footprints, log=self.log, exposureId=exposureId)
             algMetadata = measCat.getTable().getMetadata()
             if algMetadata is not None:
                 algMetadata.addInt("NOISE_SEED_MULTIPLIER", self.config.noiseReplacer.noiseSeedMultiplier)
                 algMetadata.addString("NOISE_SOURCE", self.config.noiseReplacer.noiseSource)
                 algMetadata.addDouble("NOISE_OFFSET", self.config.noiseReplacer.noiseOffset)
                 if exposureId is not None:
                     algMetadata.addLong("NOISE_EXPOSURE_ID", exposureId)
         else:
             noiseReplacer = DummyNoiseReplacer()
  
         # Create parent cat which slices both the refCat and measCat (sources)
         # first, get the reference and source records which have no parent
         refParentCat, measParentCat = refCat.getChildren(0, measCat)
         for parentIdx, (refParentRecord, measParentRecord) in enumerate(zip(refParentCat, measParentCat)):
  
             # first process the records which have the current parent as children
             refChildCat, measChildCat = refCat.getChildren(refParentRecord.getId(), measCat)
             # TODO: skip this loop if there are no plugins configured for single-object mode
             for refChildRecord, measChildRecord in zip(refChildCat, measChildCat):
                 noiseReplacer.insertSource(refChildRecord.getId())
                 self.callMeasure(measChildRecord, exposure, refChildRecord, refWcs,
                                  beginOrder=beginOrder, endOrder=endOrder)
                 noiseReplacer.removeSource(refChildRecord.getId())
  
             # then process the parent record
             noiseReplacer.insertSource(refParentRecord.getId())
             self.callMeasure(measParentRecord, exposure, refParentRecord, refWcs,
                              beginOrder=beginOrder, endOrder=endOrder)
             self.callMeasureN(measParentCat[parentIdx:parentIdx+1], exposure,
                               refParentCat[parentIdx:parentIdx+1],
                               beginOrder=beginOrder, endOrder=endOrder)
             # measure all the children simultaneously
             self.callMeasureN(measChildCat, exposure, refChildCat,
                               beginOrder=beginOrder, endOrder=endOrder)
             noiseReplacer.removeSource(refParentRecord.getId())
         noiseReplacer.end()
  
         # Undeblended plugins only fire if we're running everything
         if endOrder is None:
             for measRecord, refRecord in zip(measCat, refCat):
                 for plugin in self.undeblendedPlugins.iter():
                     self.doMeasurement(plugin, measRecord, exposure, refRecord, refWcs)
  

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

.. code-block:: python

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

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

Definition at line 327 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:
  
         .. code-block:: python
  
             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.

◆ config

lsst.pipe.base.task.Task.config

inherited

Definition at line 162 of file task.py.

◆ ConfigClass

lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.ConfigClass = ForcedMeasurementConfig

static

Definition at line 247 of file forcedMeasurement.py.

◆ log

lsst.pipe.base.task.Task.log

inherited

Definition at line 161 of file task.py.

◆ mapper

lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.mapper

Definition at line 251 of file forcedMeasurement.py.

◆ metadata

lsst.pipe.base.task.Task.metadata

inherited

Definition at line 134 of file task.py.

◆ plugins

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

staticinherited

Definition at line 217 of file baseMeasurement.py.

◆ schema

lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.schema

Definition at line 259 of file forcedMeasurement.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/0.4.3/Linux64/meas_base/21.0.0-7-g04766d7+cd19d05db2/python/lsst/meas/base/forcedMeasurement.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __reduce__()

◆ attachTransformedFootprints()

◆ callMeasure()

◆ callMeasureN()

◆ doMeasurement()

◆ doMeasurementN()

◆ emptyMetadata()

◆ generateMeasCat()

◆ getAllSchemaCatalogs()

◆ getFullMetadata()

◆ getFullName()

◆ getName()

◆ getPluginLogName()

◆ getSchemaCatalogs()

◆ getTaskDict()

◆ initializePlugins()

◆ makeField()

◆ makeSubtask()

◆ run()

◆ timer()

Member Data Documentation

◆ algMetadata

◆ config

◆ ConfigClass

◆ log

◆ mapper

◆ metadata

◆ plugins

◆ schema

◆ undeblendedPlugins

◆ init()

◆ reduce()