Inheritance diagram for lsst.meas.base.diaCalculation.DiaObjectCalculationTask:

Public Member Functions
def	__init__ (self, plugMetadata=None, **kwargs)

def	initializePlugins (self)

def	run (self, diaObjectCat, diaSourceCat, updatedDiaObjectIds, filterNames)

def	callCompute (self, diaObjectCat, diaSourceCat, updatedDiaObjectIds, filterNames)

def	run (self, measCat)

def	callCompute (self, catalog)

Public Attributes
	plugMetadata

	plugins

	outputCols

	executionDict

	schema

Static Public Attributes
	ConfigClass = DiaObjectCalculationConfig

Detailed Description

Run plugins which operate on a catalog of DIA sources.

This task facilitates running plugins which will operate on a source
catalog. These plugins may do things such as classifying an object based
on source record entries inserted during a measurement task.

This task differs from CatalogCaculationTask in the following ways:

-No multi mode is available for plugins. All plugins are assumed to run
 in single mode.

-Input and output catalog types are assumed to be `pandas.DataFrames` with
 columns following those used in the Apdb.

-No schema argument is passed to the plugins. Each plugin specifies
 output columns and required inputs.

Parameters
----------
plugMetaData : `lsst.daf.base.PropertyList` or `None`
    Will be modified in-place to contain metadata about the plugins being
    run. If `None`, an empty `~lsst.daf.base.PropertyList` will be
    created.
**kwargs
    Additional arguments passed to the superclass constructor.

Notes
-----
Plugins may either take an entire catalog to work on at a time, or work on
individual records.

Definition at line 171 of file diaCalculation.py.

Constructor & Destructor Documentation

◆ init()

def lsst.meas.base.diaCalculation.DiaObjectCalculationTask.__init__	(		self,
			plugMetadata = `None`,
		**	kwargs
	)

Definition at line 206 of file diaCalculation.py.

     def __init__(self, plugMetadata=None, **kwargs):
         lsst.pipe.base.Task.__init__(self, **kwargs)
         if plugMetadata is None:
             plugMetadata = lsst.daf.base.PropertyList()
         self.plugMetadata = plugMetadata
         self.plugins = PluginMap()
         self.outputCols = []
  
         self.initializePlugins()
  

Member Function Documentation

◆ callCompute() [1/2]

def lsst.meas.base.catalogCalculation.CatalogCalculationTask.callCompute	(	self,
		catalog
	)

inherited

Run each of the plugins on the catalog.

Parameters
----------
catalog : `lsst.afw.table.SourceCatalog`
    The catalog on which the plugins will operate.

Definition at line 240 of file catalogCalculation.py.

     def callCompute(self, catalog):
         """Run each of the plugins on the catalog.
  
         Parameters
         ----------
         catalog : `lsst.afw.table.SourceCatalog`
             The catalog on which the plugins will operate.
         """
         for runlevel in sorted(self.executionDict):
             # Run all of the plugins which take a whole catalog first
             for plug in self.executionDict[runlevel].multi:
                 with CCContext(plug, catalog, self.log):
                     plug.calculate(catalog)
             # Run all the plugins which take single catalog entries
             for measRecord in catalog:
                 for plug in self.executionDict[runlevel].single:
                     with CCContext(plug, measRecord, self.log):
                         plug.calculate(measRecord)

◆ callCompute() [2/2]

def lsst.meas.base.diaCalculation.DiaObjectCalculationTask.callCompute	(	self,
		diaObjectCat,
		diaSourceCat,
		updatedDiaObjectIds,
		filterNames
	)

Run each of the plugins on the catalog.

For catalog column names see the lsst.cat schema definitions for the
DiaObject and DiaSource tables (http://github.com/lsst/cat).

Parameters
----------
diaObjectCat : `pandas.DataFrame`
    DiaObjects to update values of and append new objects to. DataFrame
    should be indexed on "diaObjectId"
diaSourceCat : `pandas.DataFrame`
    DiaSources associated with the DiaObjects in diaObjectCat.
    DataFrame must be indexed on
    ["diaObjectId", "filterName", "diaSourceId"]`
updatedDiaObjectIds : `numpy.ndarray`
    Integer ids of the DiaObjects to update and create.
filterNames : `list` of `str`
    List of string names of filters to be being processed.

Returns
-------
returnStruct : `lsst.pipe.base.Struct`
    Struct containing:

    ``diaObjectCat``
        Full set of DiaObjects including both un-updated and
        updated/new DiaObjects (`pandas.DataFrame`).
    ``updatedDiaObjects``
        Catalog of DiaObjects  that were updated or created by this
        task (`pandas.DataFrame`).

Raises
------
KeyError
    Raises if `pandas.DataFrame` indexing is not properly set.

Definition at line 345 of file diaCalculation.py.

                     filterNames):
         """Run each of the plugins on the catalog.
  
         For catalog column names see the lsst.cat schema definitions for the
         DiaObject and DiaSource tables (http://github.com/lsst/cat).
  
         Parameters
         ----------
         diaObjectCat : `pandas.DataFrame`
             DiaObjects to update values of and append new objects to. DataFrame
             should be indexed on "diaObjectId"
         diaSourceCat : `pandas.DataFrame`
             DiaSources associated with the DiaObjects in diaObjectCat.
             DataFrame must be indexed on
             ["diaObjectId", "filterName", "diaSourceId"]`
         updatedDiaObjectIds : `numpy.ndarray`
             Integer ids of the DiaObjects to update and create.
         filterNames : `list` of `str`
             List of string names of filters to be being processed.
  
         Returns
         -------
         returnStruct : `lsst.pipe.base.Struct`
             Struct containing:
  
             ``diaObjectCat``
                 Full set of DiaObjects including both un-updated and
                 updated/new DiaObjects (`pandas.DataFrame`).
             ``updatedDiaObjects``
                 Catalog of DiaObjects  that were updated or created by this
                 task (`pandas.DataFrame`).
  
         Raises
         ------
         KeyError
             Raises if `pandas.DataFrame` indexing is not properly set.
         """
         # DiaObjects will be updated in place.
         diaObjectsToUpdate = diaObjectCat.loc[updatedDiaObjectIds, :]
         self.log.info("Calculating summary stats for %i DiaObjects",
                       len(diaObjectsToUpdate))
  
         updatingDiaSources = diaSourceCat.loc[updatedDiaObjectIds, :]
         diaSourcesGB = updatingDiaSources.groupby(level=0)
         for runlevel in sorted(self.executionDict):
             for plug in self.executionDict[runlevel].single:
                 if plug.needsFilter:
                     continue
                 for updatedDiaObjectId in updatedDiaObjectIds:
  
                     # Sub-select diaSources associated with this diaObject.
                     objDiaSources = updatingDiaSources.loc[updatedDiaObjectId]
  
                     # Sub-select on diaSources observed in the current filter.
                     with CCContext(plug, updatedDiaObjectId, self.log):
                         # We feed the catalog we need to update and the id
                         # so as to get a few into the catalog and not a copy.
                         # This updates the values in the catalog.
                         plug.calculate(diaObjects=diaObjectsToUpdate,
                                        diaObjectId=updatedDiaObjectId,
                                        diaSources=objDiaSources,
                                        filterDiaSources=None,
                                        filterName=None)
             for plug in self.executionDict[runlevel].multi:
                 if plug.needsFilter:
                     continue
                 with CCContext(plug, diaObjectsToUpdate, self.log):
                     plug.calculate(diaObjects=diaObjectsToUpdate,
                                    diaSources=diaSourcesGB,
                                    filterDiaSources=None,
                                    filterName=None)
  
         for filterName in filterNames:
             try:
                 updatingFilterDiaSources = updatingDiaSources.loc[
                     (slice(None), filterName), :
                 ]
             except KeyError:
                 self.log.warning("No DiaSource data with fitler=%s. "
                                  "Continuing...", filterName)
                 continue
             # Level=0 here groups by diaObjectId.
             filterDiaSourcesGB = updatingFilterDiaSources.groupby(level=0)
  
             for runlevel in sorted(self.executionDict):
                 for plug in self.executionDict[runlevel].single:
                     if not plug.needsFilter:
                         continue
                     for updatedDiaObjectId in updatedDiaObjectIds:
  
                         # Sub-select diaSources associated with this diaObject.
                         objDiaSources = updatingDiaSources.loc[updatedDiaObjectId]
  
                         # Sub-select on diaSources observed in the current filter.
                         try:
                             filterObjDiaSources = objDiaSources.loc[filterName]
                         except KeyError:
                             self.log.warning(
                                 "DiaObjectId={updatedDiaObjectId} has no "
                                 "DiaSources for filter=%s. "
                                 "Continuing...", filterName)
                         with CCContext(plug, updatedDiaObjectId, self.log):
                             # We feed the catalog we need to update and the id
                             # so as to get a few into the catalog and not a copy.
                             # This updates the values in the catalog.
                             plug.calculate(diaObjects=diaObjectsToUpdate,
                                            diaObjectId=updatedDiaObjectId,
                                            diaSources=objDiaSources,
                                            filterDiaSources=filterObjDiaSources,
                                            filterName=filterName)
                 for plug in self.executionDict[runlevel].multi:
                     if not plug.needsFilter:
                         continue
                     with CCContext(plug, diaObjectsToUpdate, self.log):
                         plug.calculate(diaObjects=diaObjectsToUpdate,
                                        diaSources=diaSourcesGB,
                                        filterDiaSources=filterDiaSourcesGB,
                                        filterName=filterName)
         # Need to store the newly updated diaObjects directly as the editing
         # a view into diaObjectsToUpdate does not update the values of
         # diaObjectCat.
         diaObjectCat.loc[updatedDiaObjectIds, :] = diaObjectsToUpdate
         return lsst.pipe.base.Struct(
             diaObjectCat=diaObjectCat,
             updatedDiaObjects=diaObjectsToUpdate)
  

◆ initializePlugins()

def lsst.meas.base.diaCalculation.DiaObjectCalculationTask.initializePlugins ( self )

Initialize the plugins according to the configuration.

Reimplemented from lsst.meas.base.catalogCalculation.CatalogCalculationTask.

Definition at line 216 of file diaCalculation.py.

     def initializePlugins(self):
         """Initialize the plugins according to the configuration.
         """
  
         pluginType = namedtuple('pluginType', 'single multi')
         self.executionDict = {}
         # Read the properties for each plugin. Allocate a dictionary entry for
         # each run level. Verify that the plugins are above the minimum run
         # level for an catalogCalculation plugin. For each run level, the
         # plugins are sorted into either single record, or multi record groups
         # to later be run appropriately
         for executionOrder, name, config, PluginClass in sorted(self.config.plugins.apply()):
             if executionOrder not in self.executionDict:
                 self.executionDict[executionOrder] = pluginType(single=[], multi=[])
             if PluginClass.getExecutionOrder() >= BasePlugin.DEFAULT_CATALOGCALCULATION:
                 plug = PluginClass(config, name, metadata=self.plugMetadata)
  
                 self._validatePluginCols(plug)
  
                 self.plugins[name] = plug
                 if plug.plugType == 'single':
                     self.executionDict[executionOrder].single.append(plug)
                 elif plug.plugType == 'multi':
                     self.executionDict[executionOrder].multi.append(plug)
             else:
                 errorTuple = (PluginClass, PluginClass.getExecutionOrder(),
                               BasePlugin.DEFAULT_CATALOGCALCULATION)
                 raise ValueError("{} has an execution order less than the minimum for an catalogCalculation "
                                  "plugin. Value {} : Minimum {}".format(*errorTuple))
  

◆ run() [1/2]

def lsst.meas.base.diaCalculation.DiaObjectCalculationTask.run	(	self,
		diaObjectCat,
		diaSourceCat,
		updatedDiaObjectIds,
		filterNames
	)

The entry point for the DIA catalog calculation task.

Run method both updates the values in the diaObjectCat and appends
newly created DiaObjects to the catalog. For catalog column names
see the lsst.cat schema definitions for the DiaObject and DiaSource
tables (http://github.com/lsst/cat).

Parameters
----------
diaObjectCat : `pandas.DataFrame`
    DiaObjects to update values of and append new objects to. DataFrame
    should be indexed on "diaObjectId"
diaSourceCat : `pandas.DataFrame`
    DiaSources associated with the DiaObjects in diaObjectCat.
    DataFrame should be indexed on
    `["diaObjectId", "filterName", "diaSourceId"]`
updatedDiaObjectIds : `numpy.ndarray`
    Integer ids of the DiaObjects to update and create.
filterNames : `list` of `str`
    List of string names of filters to be being processed.

Returns
-------
returnStruct : `lsst.pipe.base.Struct`
    Struct containing:

    ``diaObjectCat``
        Full set of DiaObjects including both un-updated and
        updated/new DiaObjects (`pandas.DataFrame`).
    ``updatedDiaObjects``
        Catalog of DiaObjects  that were updated or created by this
        task (`pandas.DataFrame`).

Definition at line 277 of file diaCalculation.py.

             filterNames):
         """The entry point for the DIA catalog calculation task.
  
         Run method both updates the values in the diaObjectCat and appends
         newly created DiaObjects to the catalog. For catalog column names
         see the lsst.cat schema definitions for the DiaObject and DiaSource
         tables (http://github.com/lsst/cat).
  
         Parameters
         ----------
         diaObjectCat : `pandas.DataFrame`
             DiaObjects to update values of and append new objects to. DataFrame
             should be indexed on "diaObjectId"
         diaSourceCat : `pandas.DataFrame`
             DiaSources associated with the DiaObjects in diaObjectCat.
             DataFrame should be indexed on
             `["diaObjectId", "filterName", "diaSourceId"]`
         updatedDiaObjectIds : `numpy.ndarray`
             Integer ids of the DiaObjects to update and create.
         filterNames : `list` of `str`
             List of string names of filters to be being processed.
  
         Returns
         -------
         returnStruct : `lsst.pipe.base.Struct`
             Struct containing:
  
             ``diaObjectCat``
                 Full set of DiaObjects including both un-updated and
                 updated/new DiaObjects (`pandas.DataFrame`).
             ``updatedDiaObjects``
                 Catalog of DiaObjects  that were updated or created by this
                 task (`pandas.DataFrame`).
         """
         if diaObjectCat.index.name is None:
             diaObjectCat.set_index("diaObjectId", inplace=True, drop=False)
         elif diaObjectCat.index.name != "diaObjectId":
             self.log.warning(
                 "Input diaObjectCat is indexed on column(s) incompatible with "
                 "this task. Should be indexed on 'diaObjectId'. Trying to set "
                 "index regardless")
             diaObjectCat.set_index("diaObjectId", inplace=True, drop=False)
  
         # ``names`` by default is FrozenList([None]) hence we access the first
         # element and test for None.
         if diaSourceCat.index.names[0] is None:
             diaSourceCat.set_index(
                 ["diaObjectId", "filterName", "diaSourceId"],
                 inplace=True,
                 drop=False)
         elif (diaSourceCat.index.names
               != ["diaObjectId", "filterName", "diaSourceId"]):
             diaSourceCat.reset_index(inplace=True)
             diaSourceCat.set_index(
                 ["diaObjectId", "filterName", "diaSourceId"],
                 inplace=True,
                 drop=False)
  
         return self.callCompute(diaObjectCat,
                                 diaSourceCat,
                                 updatedDiaObjectIds,
                                 filterNames)
  

◆ run() [2/2]

def lsst.meas.base.catalogCalculation.CatalogCalculationTask.run	(	self,
		measCat
	)

inherited

The entry point for the catalog calculation task.

Parameters
----------
meascat : `lsst.afw.table.SourceCatalog`
    Catalog for measurement.

Definition at line 230 of file catalogCalculation.py.

     def run(self, measCat):
         """The entry point for the catalog calculation task.
  
         Parameters
         ----------
         meascat : `lsst.afw.table.SourceCatalog`
             Catalog for measurement.
         """
         self.callCompute(measCat)
  

Member Data Documentation

◆ ConfigClass

lsst.meas.base.diaCalculation.DiaObjectCalculationTask.ConfigClass = DiaObjectCalculationConfig

static

Definition at line 203 of file diaCalculation.py.

◆ executionDict

lsst.meas.base.diaCalculation.DiaObjectCalculationTask.executionDict

Definition at line 221 of file diaCalculation.py.

◆ outputCols

lsst.meas.base.diaCalculation.DiaObjectCalculationTask.outputCols

Definition at line 212 of file diaCalculation.py.

◆ plugins

lsst.meas.base.diaCalculation.DiaObjectCalculationTask.plugins

Definition at line 211 of file diaCalculation.py.

◆ plugMetadata

lsst.meas.base.diaCalculation.DiaObjectCalculationTask.plugMetadata

Definition at line 210 of file diaCalculation.py.

◆ schema

lsst.meas.base.catalogCalculation.CatalogCalculationTask.schema

inherited

Definition at line 195 of file catalogCalculation.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-19-g93a5c75+d23f2fb6d8/python/lsst/meas/base/diaCalculation.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ callCompute() [1/2]

◆ callCompute() [2/2]

◆ initializePlugins()

◆ run() [1/2]

◆ run() [2/2]

Member Data Documentation

◆ ConfigClass

◆ executionDict

◆ outputCols

◆ plugins

◆ plugMetadata

◆ schema

◆ init()