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	attachPsfShapeFootprints (self, sources, exposure, scaling=3)

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)

Public Attributes
	mapper

	schema

	undeblendedPlugins

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 220 of file forcedMeasurement.py.

Constructor & Destructor Documentation

◆ init()

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

Definition at line 253 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

◆ attachPsfShapeFootprints()

def lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.attachPsfShapeFootprints	(	self,
		sources,
		exposure,
		scaling = `3`
	)

Attach Footprints to blank sources prior to measurement, by
creating elliptical Footprints from the PSF moments.

Parameters
----------
sources : `lsst.afw.table.SourceCatalog`
    Blank catalog (with all rows and columns, but values other than
    ``coord_ra``, ``coord_dec`` unpopulated).
    to which footprints should be attached.
exposure : `lsst.afw.image.Exposure`
    Image object from which peak values and the PSF are obtained.
scaling : `int`, optional
    Scaling factor to apply to the PSF second-moments ellipse in order
    to determine the footprint boundary.

Notes
-----
This is a utility function for use by parent tasks; see
`attachTransformedFootprints` for more information.

Definition at line 463 of file forcedMeasurement.py.

     def attachPsfShapeFootprints(self, sources, exposure, scaling=3):
         """Attach Footprints to blank sources prior to measurement, by
         creating elliptical Footprints from the PSF moments.
  
         Parameters
         ----------
         sources : `lsst.afw.table.SourceCatalog`
             Blank catalog (with all rows and columns, but values other than
             ``coord_ra``, ``coord_dec`` unpopulated).
             to which footprints should be attached.
         exposure : `lsst.afw.image.Exposure`
             Image object from which peak values and the PSF are obtained.
         scaling : `int`, optional
             Scaling factor to apply to the PSF second-moments ellipse in order
             to determine the footprint boundary.
  
         Notes
         -----
         This is a utility function for use by parent tasks; see
         `attachTransformedFootprints` for more information.
         """
         psf = exposure.getPsf()
         if psf is None:
             raise RuntimeError("Cannot construct Footprints from PSF shape without a PSF.")
         bbox = exposure.getBBox()
         wcs = exposure.getWcs()
         for record in sources:
             localPoint = wcs.skyToPixel(record.getCoord())
             localIntPoint = lsst.geom.Point2I(localPoint)
             assert bbox.contains(localIntPoint), (
                 f"Center for record {record.getId()} is not in exposure; this should be guaranteed by "
                 "generateMeasCat."
             )
             ellipse = lsst.afw.geom.ellipses.Ellipse(psf.computeShape(localPoint), localPoint)
             ellipse.getCore().scale(scaling)
             spans = lsst.afw.geom.SpanSet.fromShape(ellipse)
             footprint = lsst.afw.detection.Footprint(spans.clippedTo(bbox), bbox)
             footprint.addPeak(localIntPoint.getX(), localIntPoint.getY(),
                               exposure.image._get(localIntPoint, lsst.afw.image.PARENT))
             record.setFootprint(footprint)

◆ attachTransformedFootprints()

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

Attach Footprints to blank sources prior to measurement, by
transforming Footprints attached to the reference catalog.

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 440 of file forcedMeasurement.py.

     def attachTransformedFootprints(self, sources, refCat, exposure, refWcs):
         r"""Attach Footprints to blank sources prior to measurement, by
         transforming Footprints attached to the reference catalog.
  
         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 295 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 381 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 339 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:
             self.log.getChild(plugin.name).debug(
                 "MeasurementError in %s.measure on record %s: %s",
                 plugin.name, measRecord.getId(), error)
             plugin.fail(measRecord, error)
         except Exception as error:
             self.log.getChild(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 424 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:
                 self.log.getChild(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)
                 self.log.getChild(plugin.name).debug(
                     "Exception in %s.measureN on records %s-%s: %s",
                     plugin.name, measCat[0].getId(), measCat[-1].getId(), error)

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

◆ 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 240 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 getattr(PluginClass, "hasLogName", False):
                 self.plugins[name] = PluginClass(config, name, metadata=self.algMetadata,
                                                  logName=self.log.getChild(name).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
             if getattr(PluginClass, "hasLogName", False):
                 self.undeblendedPlugins[name] = PluginClass(config, undeblendedName,
                                                             metadata=self.algMetadata,
                                                             logName=self.log.getChild(undeblendedName).name,
                                                             **kwds)
             else:
                 self.undeblendedPlugins[name] = PluginClass(config, undeblendedName,
                                                             metadata=self.algMetadata, **kwds)
  

◆ 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 266 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")
         nextLogTime = time.time() + self.config.loggingInterval
  
         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)
         childrenIter = refCat.getChildren((refParentRecord.getId() for refParentRecord in refCat), measCat)
         for parentIdx, records in enumerate(zip(refParentCat, measParentCat, childrenIter)):
             # Unpack records
             refParentRecord, measParentRecord, (refChildCat, measChildCat) = records
             # First process the records which have the current parent as children
             # 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())
             # Log a message if it has been a while since the last log.
             if (currentTime := time.time()) > nextLogTime:
                 self.log.verbose("Forced measurement complete for %d parents (and their children) out of %d",
                                  parentIdx + 1, len(refParentCat))
                 nextLogTime = currentTime + self.config.loggingInterval
         noiseReplacer.end()
  
         # Undeblended plugins only fire if we're running everything
         if endOrder is None:
             for recordIndex, (measRecord, refRecord) in enumerate(zip(measCat, refCat)):
                 for plugin in self.undeblendedPlugins.iter():
                     self.doMeasurement(plugin, measRecord, exposure, refRecord, refWcs)
                 if (currentTime := time.time()) > nextLogTime:
                     self.log.verbose("Undeblended forced measurement complete for %d sources out of %d",
                                      recordIndex + 1, len(refCat))
                     nextLogTime = currentTime + self.config.loggingInterval
  

Member Data Documentation

◆ algMetadata

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

staticinherited

Definition at line 225 of file baseMeasurement.py.

◆ ConfigClass

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

static

Definition at line 251 of file forcedMeasurement.py.

◆ mapper

lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.mapper

Definition at line 255 of file forcedMeasurement.py.

◆ plugins

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

staticinherited

Definition at line 218 of file baseMeasurement.py.

◆ schema

lsst.meas.base.forcedMeasurement.ForcedMeasurementTask.schema

Definition at line 263 of file forcedMeasurement.py.

◆ undeblendedPlugins

lsst.meas.base.baseMeasurement.BaseMeasurementTask.undeblendedPlugins

inherited

Definition at line 235 of file baseMeasurement.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_base/22.0.1-25-gb120d7b+8b5510f75f/python/lsst/meas/base/forcedMeasurement.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ attachPsfShapeFootprints()

◆ attachTransformedFootprints()

◆ callMeasure()

◆ callMeasureN()

◆ doMeasurement()

◆ doMeasurementN()

◆ generateMeasCat()

◆ initializePlugins()

◆ run()

Member Data Documentation

◆ algMetadata

◆ ConfigClass

◆ mapper

◆ plugins

◆ schema

◆ undeblendedPlugins

◆ init()