Coverage for python/lsst/meas/base/catalogCalculation.py: 32%
81 statements
« prev ^ index » next coverage.py v6.5.0, created at 2023-03-09 11:19 +0000
« prev ^ index » next coverage.py v6.5.0, created at 2023-03-09 11:19 +0000
1# This file is part of meas_base.
2#
3# Developed for the LSST Data Management System.
4# This product includes software developed by the LSST Project
5# (https://www.lsst.org).
6# See the COPYRIGHT file at the top-level directory of this distribution
7# for details of code ownership.
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 3 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program. If not, see <https://www.gnu.org/licenses/>.
22from collections import namedtuple
24import lsst.pipe.base
25import lsst.pex.config
26import lsst.daf.base
27from lsst.utils.timer import timeMethod
29from .pluginsBase import BasePlugin, BasePluginConfig
30from .pluginRegistry import PluginRegistry, PluginMap
31from ._measBaseLib import FatalAlgorithmError, MeasurementError
33# Exceptions that the measurement tasks should always propagate up to their
34# callers
35FATAL_EXCEPTIONS = (MemoryError, FatalAlgorithmError)
37__all__ = ("CatalogCalculationPluginConfig", "CatalogCalculationPlugin", "CatalogCalculationConfig",
38 "CatalogCalculationTask")
41class CatalogCalculationPluginConfig(BasePluginConfig):
42 """Default configuration class for catalog calcuation plugins.
43 """
44 pass
47class CatalogCalculationPlugin(BasePlugin):
48 """Base class for catalog calculation plugins.
50 Parameters
51 ----------
52 config : `CatalogCalculationPlugin.ConfigClass`
53 Plugin configuration.
54 name : `str`
55 The string the plugin was registered with.
56 schema : `lsst.afw.table.Schema`
57 The source schema, New fields should be added here to
58 hold output produced by this plugin.
59 metadata : `lsst.daf.base.PropertySet`
60 Plugin metadata that will be attached to the output catalog
61 """
63 ConfigClass = CatalogCalculationPluginConfig # documentation inherited
65 registry = PluginRegistry(CatalogCalculationPluginConfig)
66 """List of available plugins (`lsst.meas.base.PluginRegistry`).
67 """
69 plugType = 'single'
70 """Does the plugin operate on a single source or the whole catalog (`str`)?
72 If the plugin operates on a single source at a time, this should be set to
73 ``"single"``; if it expects the whoe catalog, to ``"multi"``. If the
74 plugin is of type ``"multi"``, the `fail` method must be implemented to
75 accept the whole catalog. If the plugin is of type ``"single"``, `fail`
76 should accept a single source record.
77 """
79 def __init__(self, config, name, schema, metadata):
80 BasePlugin.__init__(self, config, name)
82 @classmethod
83 def getExecutionOrder(cls):
84 r"""Used to set the relative order of plugin execution.
86 The values returned by `getExecutionOrder` are compared across all
87 plugins, and smaller numbers run first.
89 Notes
90 -----
91 `CatalogCalculationPlugin`\s must run with
92 `BasePlugin.DEFAULT_CATALOGCALCULATION` or higher.
94 All plugins must implement this method with an appropriate run level
95 """
96 raise NotImplementedError()
98 def calculate(self, cat, **kwargs):
99 """Perform the calculation specified by this plugin.
101 This method can either be used to operate on a single catalog record
102 or a whole catalog, populating it with the output defined by this
103 plugin.
105 Note that results may be added to catalog records as new columns, or
106 may result in changes to existing values.
108 Parameters
109 ----------
110 cat : `lsst.afw.table.SourceCatalog` or `lsst.afw.table.SourceRecord`
111 May either be a `~lsst.afw.table.SourceCatalog` or a single
112 `~lsst.afw.table.SourceRecord`, depending on the plugin type. Will
113 be updated in place to contain the results of plugin execution.
114 **kwargs
115 Any additional keyword arguments that may be passed to the plugin.
116 """
117 raise NotImplementedError()
120class CCContext:
121 """Handle errors that are thrown by catalog calculation plugins.
123 This is a context manager.
125 Parameters
126 ----------
127 plugin : `CatalogCalculationPlugin`
128 The plugin that is to be run.
129 cat : `lsst.afw.table.SourceCatalog` or `lsst.afw.table.SourceRecord`
130 May either be a `~lsst.afw.table.SourceCatalog` or a single
131 `~lsst.afw.table.SourceRecord`, depending on the plugin type.
132 log : `lsst.log.Log` or `logging.Logger`
133 A logger. Generally, this should be the logger of the object in which
134 the context manager is being used.
135 """
136 def __init__(self, plugin, cat, log):
137 self.plugin = plugin
138 self.cat = cat
139 self.log = log
141 def __enter__(self):
142 return
144 def __exit__(self, exc_type, exc_value, traceback):
145 if exc_type is None:
146 return True
147 if exc_type in FATAL_EXCEPTIONS:
148 raise exc_value
149 elif exc_type is MeasurementError:
150 self.plugin.fail(self.cat, exc_value)
151 else:
152 self.log.warning("Error in %s.calculate: %s", self.plugin.name, exc_value)
153 return True
156class CatalogCalculationConfig(lsst.pex.config.Config):
157 """Config class for the catalog calculation driver task.
159 Specifies which plugins will execute when the `CatalogCalculationTask`
160 associated with this configuration is run.
161 """
163 plugins = CatalogCalculationPlugin.registry.makeField(
164 multi=True,
165 default=["base_ClassificationExtendedness",
166 "base_FootprintArea"],
167 doc="Plugins to be run and their configuration")
170class CatalogCalculationTask(lsst.pipe.base.Task):
171 """Run plugins which operate on a catalog of sources.
173 This task facilitates running plugins which will operate on a source
174 catalog. These plugins may do things such as classifying an object based
175 on source record entries inserted during a measurement task.
177 Parameters
178 ----------
179 plugMetaData : `lsst.daf.base.PropertyList` or `None`
180 Will be modified in-place to contain metadata about the plugins being
181 run. If `None`, an empty `~lsst.daf.base.PropertyList` will be
182 created.
183 **kwargs
184 Additional arguments passed to the superclass constructor.
186 Notes
187 -----
188 Plugins may either take an entire catalog to work on at a time, or work on
189 individual records.
190 """
191 ConfigClass = CatalogCalculationConfig
192 _DefaultName = "catalogCalculation"
194 def __init__(self, schema, plugMetadata=None, **kwargs):
195 lsst.pipe.base.Task.__init__(self, **kwargs)
196 self.schema = schema
197 if plugMetadata is None:
198 plugMetadata = lsst.daf.base.PropertyList()
199 self.plugMetadata = plugMetadata
200 self.plugins = PluginMap()
202 self.initializePlugins()
204 def initializePlugins(self):
205 """Initialize the plugins according to the configuration.
206 """
208 pluginType = namedtuple('pluginType', 'single multi')
209 self.executionDict = {}
210 # Read the properties for each plugin. Allocate a dictionary entry for each run level. Verify that
211 # the plugins are above the minimum run level for an catalogCalculation plugin. For each run level,
212 # the plugins are sorted into either single record, or multi record groups to later be run
213 # appropriately
214 for executionOrder, name, config, PluginClass in sorted(self.config.plugins.apply()):
215 if executionOrder not in self.executionDict:
216 self.executionDict[executionOrder] = pluginType(single=[], multi=[])
217 if PluginClass.getExecutionOrder() >= BasePlugin.DEFAULT_CATALOGCALCULATION:
218 plug = PluginClass(config, name, self.schema, metadata=self.plugMetadata)
219 self.plugins[name] = plug
220 if plug.plugType == 'single':
221 self.executionDict[executionOrder].single.append(plug)
222 elif plug.plugType == 'multi':
223 self.executionDict[executionOrder].multi.append(plug)
224 else:
225 errorTuple = (PluginClass, PluginClass.getExecutionOrder(),
226 BasePlugin.DEFAULT_CATALOGCALCULATION)
227 raise ValueError("{} has an execution order less than the minimum for an catalogCalculation "
228 "plugin. Value {} : Minimum {}".format(*errorTuple))
230 @timeMethod
231 def run(self, measCat):
232 """The entry point for the catalog calculation task.
234 Parameters
235 ----------
236 meascat : `lsst.afw.table.SourceCatalog`
237 Catalog for measurement.
238 """
239 self.callCompute(measCat)
241 def callCompute(self, catalog):
242 """Run each of the plugins on the catalog.
244 Parameters
245 ----------
246 catalog : `lsst.afw.table.SourceCatalog`
247 The catalog on which the plugins will operate.
248 """
249 for runlevel in sorted(self.executionDict):
250 # Run all of the plugins which take a whole catalog first
251 for plug in self.executionDict[runlevel].multi:
252 with CCContext(plug, catalog, self.log):
253 plug.calculate(catalog)
254 # Run all the plugins which take single catalog entries
255 for measRecord in catalog:
256 for plug in self.executionDict[runlevel].single:
257 with CCContext(plug, measRecord, self.log):
258 plug.calculate(measRecord)