LSST Applications g04c3c9f7ca+2075667efa,g1e125bf412+5f448d5fcf,g2079a07aa2+3e9fd84d81,g2305ad1205+b635cf1488,g2bbee38e9b+6c6beb4891,g337abbeb29+6c6beb4891,g33d1c0ed96+6c6beb4891,g3a166c0a6a+6c6beb4891,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+42f171e1e6,g5c3423f6d4+d536b04327,g607f77f49a+d536b04327,g6f43f06aed+ca1339dc19,g858d7b2824+d536b04327,g8ee334c5b4+d7f9608c2f,g9963eaa53e+b3dc1655d3,g998f4353bf+d536b04327,g99cad8db69+8ef2408349,g9ddcbc5298+9a081db1e4,ga1e77700b3+2cbb763275,gadfd92a7e4+aec2f3b930,gae0086650b+585e252eca,gb0e22166c9+0e73c8378f,gb3b7280ab2+cb5fdb229e,gbb8dafda3b+a327199e22,gc120e1dc64+88074880ea,gc28159a63d+6c6beb4891,gcdd4ae20e8+bd241b2308,gcde1bda545+903e937d91,gcf0d15dbbd+bd241b2308,gdaeeff99f8+f9a426f77a,gddc38dedce+585e252eca,ge79ae78c31+6c6beb4891,gfbcc870c63+b310236976,w.2024.23
LSST Data Management Base Package
Loading...
Searching...
No Matches
sourceSelector.py
Go to the documentation of this file.
1# This file is part of meas_algorithms.
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/>.
21
22__all__ = ["BaseSourceSelectorConfig", "BaseSourceSelectorTask", "sourceSelectorRegistry",
23 "ColorLimit", "MagnitudeLimit", "SignalToNoiseLimit", "MagnitudeErrorLimit",
24 "RequireFlags", "RequireUnresolved", "RequireFiniteRaDec", "RequirePrimary",
25 "ScienceSourceSelectorConfig", "ScienceSourceSelectorTask",
26 "ReferenceSourceSelectorConfig", "ReferenceSourceSelectorTask",
27 "NullSourceSelectorTask"
28 ]
29
30import abc
31import numpy as np
32import astropy.units as u
33import pandas
34import astropy.table
35import warnings
36
37import lsst.pex.config as pexConfig
38import lsst.pipe.base as pipeBase
39
40
41class BaseSourceSelectorConfig(pexConfig.Config):
42 pass
43
44
45class BaseSourceSelectorTask(pipeBase.Task, metaclass=abc.ABCMeta):
46 """Base class for source selectors
47
48 Source selectors are classes that perform a selection on a catalog
49 object given a set of criteria or cuts. They return the selected catalog
50 and can optionally set a specified Flag field in the input catalog to
51 identify if the source was selected.
52
53 Register all source selectors with the sourceSelectorRegistry using:
54 sourceSelectorRegistry.register(name, class)
55
56 Attributes
57 ----------
58 usesMatches : `bool`
59 A boolean variable specify if the inherited source selector uses
60 matches to an external catalog, and thus requires the ``matches``
61 argument to ``run()``.
62 """
63
64 ConfigClass = BaseSourceSelectorConfig
65 _DefaultName = "sourceSelector"
66 usesMatches = False
67
68 def __init__(self, **kwargs):
69 pipeBase.Task.__init__(self, **kwargs)
70
71 def run(self, sourceCat, sourceSelectedField=None, matches=None, exposure=None):
72 """Select sources and return them.
73
74 The input catalog must be contiguous in memory.
75
76 Parameters
77 ----------
78 sourceCat : Various table formats
79 Catalog of sources to select from. Can be
80 `lsst.afw.table.SourceCatalog` or `pandas.DataFrame` or
81 `astropy.table.Table`,
82 sourceSelectedField : `str` or None
83 Name of flag field in sourceCat to set for selected sources.
84 If set, will modify sourceCat in-place.
85 matches : `list` of `lsst.afw.table.ReferenceMatch` or None
86 List of matches to use for source selection.
87 If usesMatches is set in source selector this field is required.
88 If not, it is ignored.
89 exposure : `lsst.afw.image.Exposure` or None
90 The exposure the catalog was built from; used for debug display.
91
92 Returns
93 -------
94 struct : `lsst.pipe.base.Struct`
95 The struct contains the following data:
96
97 ``sourceCat``
98 The catalog of sources that were selected.
99 (may not be memory-contiguous)
100 (`lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
101 or `astropy.table.Table`)
102 ``selected``
103 Boolean array of sources that were selected, same length as
104 sourceCat.
105 (`numpy.ndarray` of `bool`)
106
107 Raises
108 ------
109 RuntimeError
110 Raised if ``sourceCat`` is not contiguous.
111 """
112 if hasattr(sourceCat, 'isContiguous'):
113 # Check for continuity on afwTable catalogs
114 if not sourceCat.isContiguous():
115 raise RuntimeError("Input catalogs for source selection must be contiguous.")
116
117 result = self.selectSources(sourceCat=sourceCat,
118 exposure=exposure,
119 matches=matches)
120
121 if sourceSelectedField is not None:
122 sourceCat[sourceSelectedField] = result.selected
123
124 return pipeBase.Struct(sourceCat=sourceCat[result.selected],
125 selected=result.selected)
126
127 @abc.abstractmethod
128 def selectSources(self, sourceCat, matches=None, exposure=None):
129 """Return a selection of sources selected by some criteria.
130
131 Parameters
132 ----------
133 sourceCat : Various table formats
134 Catalog of sources to select from. Supports
135 `lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
136 or `astropy.table.Table`
137 This catalog must be contiguous in memory.
138 matches : `list` of `lsst.afw.table.ReferenceMatch` or None
139 A list of lsst.afw.table.ReferenceMatch objects
140 exposure : `lsst.afw.image.Exposure` or None
141 The exposure the catalog was built from; used for debug display.
142
143 Returns
144 -------
145 struct : `lsst.pipe.base.Struct`
146 The struct contains the following data:
147
148 ``selected``
149 Boolean array of sources that were selected, same length as
150 sourceCat.
151 (`numpy.ndarray` of `bool`)
152 """
153 raise NotImplementedError("BaseSourceSelectorTask is abstract")
154
155
156sourceSelectorRegistry = pexConfig.makeRegistry(
157 doc="A registry of source selectors (subclasses of "
158 "BaseSourceSelectorTask)",
159)
160
161
162class BaseLimit(pexConfig.Config):
163 """Base class for selecting sources by applying a limit
164
165 This object can be used as a `lsst.pex.config.Config` for configuring
166 the limit, and then the `apply` method can be used to identify sources
167 in the catalog that match the configured limit.
168
169 This provides the `maximum` and `minimum` fields in the Config, and
170 a method to apply the limits to an array of values calculated by the
171 subclass.
172 """
173 minimum = pexConfig.Field(dtype=float, optional=True, doc="Select objects with value greater than this")
174 maximum = pexConfig.Field(dtype=float, optional=True, doc="Select objects with value less than this")
175
176 def apply(self, values):
177 """Apply the limits to an array of values
178
179 Subclasses should calculate the array of values and then
180 return the result of calling this method.
181
182 Parameters
183 ----------
184 values : `numpy.ndarray`
185 Array of values to which to apply limits.
186
187 Returns
188 -------
189 selected : `numpy.ndarray`
190 Boolean array indicating for each source whether it is selected
191 (True means selected).
192 """
193 selected = np.ones(len(values), dtype=bool)
194 with np.errstate(invalid="ignore"): # suppress NAN warnings
195 if self.minimum is not None:
196 selected &= values > self.minimum
197 if self.maximum is not None:
198 selected &= values < self.maximum
199 return selected
200
201
203 """Select sources using a color limit
204
205 This object can be used as a `lsst.pex.config.Config` for configuring
206 the limit, and then the `apply` method can be used to identify sources
207 in the catalog that match the configured limit.
208
209 We refer to 'primary' and 'secondary' flux measurements; these are the
210 two components of the color, which is:
211
212 instFluxToMag(cat[primary]) - instFluxToMag(cat[secondary])
213 """
214 primary = pexConfig.Field(dtype=str, doc="Name of column with primary flux measurement")
215 secondary = pexConfig.Field(dtype=str, doc="Name of column with secondary flux measurement")
216
217 def apply(self, catalog):
218 """Apply the color limit to a catalog
219
220 Parameters
221 ----------
222 catalog : Various table formats
223 Catalog of sources to which the limit will be applied.
224 Supports `lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
225 or `astropy.table.Table`
226
227 Returns
228 -------
229 selected : `numpy.ndarray`
230 Boolean array indicating for each source whether it is selected
231 (True means selected).
232 """
233 primary = _getFieldFromCatalog(catalog, self.primary)
234 secondary = _getFieldFromCatalog(catalog, self.secondary)
235
236 primary = (primary*u.nJy).to_value(u.ABmag)
237 secondary = (secondary*u.nJy).to_value(u.ABmag)
238 color = primary - secondary
239 return BaseLimit.apply(self, color)
240
241
243 """Select sources using a flux limit
244
245 This object can be used as a `lsst.pex.config.Config` for configuring
246 the limit, and then the `apply` method can be used to identify sources
247 in the catalog that match the configured limit.
248 """
249 fluxField = pexConfig.Field(dtype=str, default="slot_CalibFlux_instFlux",
250 doc="Name of the source flux field to use.")
251
252 def apply(self, catalog):
253 """Apply the flux limits to a catalog
254
255 Parameters
256 ----------
257 catalog : `lsst.afw.table.SourceCatalog`
258 Catalog of sources to which the limit will be applied.
259
260 Returns
261 -------
262 selected : `numpy.ndarray`
263 Boolean array indicating for each source whether it is selected
264 (True means selected).
265 """
266 flagField = self.fluxField + "_flag"
267 selected = np.logical_not(_getFieldFromCatalog(catalog, flagField, isFlag=True))
268 flux = _getFieldFromCatalog(catalog, self.fluxField)
269
270 selected &= BaseLimit.apply(self, flux)
271 return selected
272
273
275 """Select sources using a magnitude limit
276
277 Note that this assumes that a zero-point has already been applied and
278 the fluxes are in AB fluxes in Jansky. It is therefore principally
279 intended for reference catalogs rather than catalogs extracted from
280 science images.
281
282 This object can be used as a `lsst.pex.config.Config` for configuring
283 the limit, and then the `apply` method can be used to identify sources
284 in the catalog that match the configured limit.
285 """
286 fluxField = pexConfig.Field(dtype=str, default="flux",
287 doc="Name of the source flux field to use.")
288
289 def apply(self, catalog):
290 """Apply the magnitude limits to a catalog
291
292 Parameters
293 ----------
294 catalog : `lsst.afw.table.SourceCatalog`
295 Catalog of sources to which the limit will be applied.
296
297 Returns
298 -------
299 selected : `numpy.ndarray`
300 Boolean array indicating for each source whether it is selected
301 (True means selected).
302 """
303 flagField = self.fluxField + "_flag"
304 selected = np.logical_not(_getFieldFromCatalog(catalog, flagField, isFlag=True))
305 flux = _getFieldFromCatalog(catalog, self.fluxField)
306
307 magnitude = (flux*u.nJy).to_value(u.ABmag)
308 selected &= BaseLimit.apply(self, magnitude)
309 return selected
310
311
313 """Select sources using a flux signal-to-noise limit
314
315 This object can be used as a `lsst.pex.config.Config` for configuring
316 the limit, and then the `apply` method can be used to identify sources
317 in the catalog that match the configured limit.
318 """
319 fluxField = pexConfig.Field(dtype=str, default="flux",
320 doc="Name of the source flux field to use.")
321 errField = pexConfig.Field(dtype=str, default="flux_err",
322 doc="Name of the source flux error field to use.")
323
324 def apply(self, catalog):
325 """Apply the signal-to-noise limits to a catalog
326
327 Parameters
328 ----------
329 catalog : `lsst.afw.table.SourceCatalog`
330 Catalog of sources to which the limit will be applied.
331
332 Returns
333 -------
334 selected : `numpy.ndarray`
335 Boolean array indicating for each source whether it is selected
336 (True means selected).
337 """
338 flagField = self.fluxField + "_flag"
339 selected = np.logical_not(_getFieldFromCatalog(catalog, flagField, isFlag=True))
340 flux = _getFieldFromCatalog(catalog, self.fluxField)
341 err = _getFieldFromCatalog(catalog, self.errField)
342
343 with warnings.catch_warnings():
344 # Suppress NaN warnings; these will be filtered below.
345 warnings.simplefilter("ignore")
346 signalToNoise = flux/err
347
348 selected &= ~np.isnan(signalToNoise)
349 selected &= BaseLimit.apply(self, signalToNoise)
350 return selected
351
352
354 """Select sources using a magnitude error limit
355
356 Because the magnitude error is the inverse of the signal-to-noise
357 ratio, this also works to select sources by signal-to-noise when
358 you only have a magnitude.
359
360 This object can be used as a `lsst.pex.config.Config` for configuring
361 the limit, and then the `apply` method can be used to identify sources
362 in the catalog that match the configured limit.
363 """
364 magErrField = pexConfig.Field(dtype=str, default="mag_err",
365 doc="Name of the source flux error field to use.")
366
367 def apply(self, catalog):
368 """Apply the magnitude error limits to a catalog
369
370 Parameters
371 ----------
372 catalog : `lsst.afw.table.SourceCatalog`
373 Catalog of sources to which the limit will be applied.
374
375 Returns
376 -------
377 selected : `numpy.ndarray`
378 Boolean array indicating for each source whether it is selected
379 (True means selected).
380 """
381 return BaseLimit.apply(self, catalog[self.magErrField])
382
383
384class RequireFlags(pexConfig.Config):
385 """Select sources using flags
386
387 This object can be used as a `lsst.pex.config.Config` for configuring
388 the limit, and then the `apply` method can be used to identify sources
389 in the catalog that match the configured limit.
390 """
391 good = pexConfig.ListField(dtype=str, default=[],
392 doc="List of source flag fields that must be set for a source to be used.")
393 bad = pexConfig.ListField(dtype=str, default=[],
394 doc="List of source flag fields that must NOT be set for a source to be used.")
395
396 def apply(self, catalog):
397 """Apply the flag requirements to a catalog
398
399 Returns whether the source is selected.
400
401 Parameters
402 ----------
403 catalog : `lsst.afw.table.SourceCatalog`
404 Catalog of sources to which the requirements will be applied.
405
406 Returns
407 -------
408 selected : `numpy.ndarray`
409 Boolean array indicating for each source whether it is selected
410 (True means selected).
411 """
412 selected = np.ones(len(catalog), dtype=bool)
413 for flag in self.good:
414 selected &= catalog[flag]
415 for flag in self.bad:
416 selected &= ~catalog[flag]
417 return selected
418
419
421 """Select sources using star/galaxy separation
422
423 This object can be used as a `lsst.pex.config.Config` for configuring
424 the limit, and then the `apply` method can be used to identify sources
425 in the catalog that match the configured limit.
426 """
427 name = pexConfig.Field(dtype=str, default="base_ClassificationSizeExtendedness_value",
428 doc="Name of column for star/galaxy separation")
429
430 def setDefaults(self):
431 """Set default
432
433 Values below the threshold are unresolved.
434 """
435 self.maximummaximum = 0.1
436
437 def apply(self, catalog):
438 """Apply the flag requirements to a catalog
439
440 Returns whether the source is selected.
441
442 Parameters
443 ----------
444 catalog : `lsst.afw.table.SourceCatalog`
445 Catalog of sources to which the requirements will be applied.
446
447 Returns
448 -------
449 selected : `numpy.ndarray`
450 Boolean array indicating for each source whether it is selected
451 (True means selected).
452 """
453 value = catalog[self.name]
454 return BaseLimit.apply(self, value)
455
456
457class RequireIsolated(pexConfig.Config):
458 """Select sources based on whether they are isolated
459
460 This object can be used as a `lsst.pex.config.Config` for configuring
461 the column names to check for "parent" and "nChild" keys.
462
463 Note that this should only be run on a catalog that has had the
464 deblender already run (or else deblend_nChild does not exist).
465 """
466 parentName = pexConfig.Field(dtype=str, default="parent",
467 doc="Name of column for parent")
468 nChildName = pexConfig.Field(dtype=str, default="deblend_nChild",
469 doc="Name of column for nChild")
470
471 def apply(self, catalog):
472 """Apply the isolation requirements to a catalog
473
474 Returns whether the source is selected.
475
476 Parameters
477 ----------
478 catalog : `lsst.afw.table.SourceCatalog`
479 Catalog of sources to which the requirements will be applied.
480
481 Returns
482 -------
483 selected : `numpy.ndarray`
484 Boolean array indicating for each source whether it is selected
485 (True means selected).
486 """
487 selected = ((catalog[self.parentName] == 0)
488 & (catalog[self.nChildName] == 0))
489 return selected
490
491
492class RequireFiniteRaDec(pexConfig.Config):
493 """Select sources that have finite RA and Dec sky coordinate values
494
495 This object can be used as a `lsst.pex.config.Config` for configuring
496 the column names to check for "coord_ra" and "coord_dec" keys.
497
498 This will select against objects for which either the RA or Dec coordinate
499 entries are not numpy.isfinite().
500 """
501 raColName = pexConfig.Field(dtype=str, default="coord_ra", doc="Name of column for RA coordinate")
502 decColName = pexConfig.Field(dtype=str, default="coord_dec", doc="Name of column for Dec coordinate")
503
504 def apply(self, catalog):
505 """Apply the sky coordinate requirements to a catalog
506
507 Returns whether the sources were selected.
508
509 Parameters
510 ----------
511 catalog : `lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
512 or `astropy.table.Table`
513 Catalog of sources to which the requirements will be applied.
514
515 Returns
516 -------
517 selected : `numpy.ndarray`
518 Boolean array indicating for each source whether it is selected
519 (True means selected).
520 """
521 selected = (np.isfinite(_getFieldFromCatalog(catalog, self.raColName))
522 & np.isfinite(_getFieldFromCatalog(catalog, self.decColName)))
523 return selected
524
525
526class RequirePrimary(pexConfig.Config):
527 """Select sources that have the detect_isPrimary flag set.
528
529 This object can be used as a `lsst.pex.config.Config` for configuring
530 the column names to check for "detect_isPrimary". For single frame
531 catalogs this will be True when the source is not a sky object, and is
532 either an isolated parent that is un-modeled or deblended from a parent
533 with multiple children. For meas_deblender, this is equivalent to
534 deblend_nChild=0. For coadd catalogs there is an additional constraint
535 that the source is located on the interior of a patch and tract.
536 """
537 primaryColName = pexConfig.Field(
538 dtype=str,
539 default="detect_isPrimary",
540 doc="Name of primary flag column",
541 )
542
543 def apply(self, catalog):
544 """Apply the primary requirements to a catalog.
545
546 Returns whether the sources were selected.
547
548 Parameters
549 ----------
550 catalog : lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
551 or `astropy.table.Table`
552 Catalog of sources to which the requirement will be applied.
553
554 Returns
555 -------
556 selected : `numpy.ndarray`
557 Boolean array indicating for each source whether it is selected
558 (True means selected).
559 """
560 selected = (_getFieldFromCatalog(catalog, self.primaryColName)).astype(bool)
561
562 return selected
563
564
565class ScienceSourceSelectorConfig(pexConfig.Config):
566 """Configuration for selecting science sources"""
567 doFluxLimit = pexConfig.Field(dtype=bool, default=False, doc="Apply flux limit?")
568 doFlags = pexConfig.Field(dtype=bool, default=False, doc="Apply flag limitation?")
569 doUnresolved = pexConfig.Field(dtype=bool, default=False, doc="Apply unresolved limitation?")
570 doSignalToNoise = pexConfig.Field(dtype=bool, default=False, doc="Apply signal-to-noise limit?")
571 doIsolated = pexConfig.Field(dtype=bool, default=False, doc="Apply isolated limitation?")
572 doRequireFiniteRaDec = pexConfig.Field(dtype=bool, default=False,
573 doc="Apply finite sky coordinate check?")
574 doRequirePrimary = pexConfig.Field(dtype=bool, default=False,
575 doc="Apply source is primary check?")
576 doSkySources = pexConfig.Field(dtype=bool, default=False,
577 doc="Include sky sources, unioned with all other criteria?")
578 fluxLimit = pexConfig.ConfigField(dtype=FluxLimit, doc="Flux limit to apply")
579 flags = pexConfig.ConfigField(dtype=RequireFlags, doc="Flags to require")
580 unresolved = pexConfig.ConfigField(dtype=RequireUnresolved, doc="Star/galaxy separation to apply")
581 signalToNoise = pexConfig.ConfigField(dtype=SignalToNoiseLimit, doc="Signal-to-noise limit to apply")
582 isolated = pexConfig.ConfigField(dtype=RequireIsolated, doc="Isolated criteria to apply")
583 requireFiniteRaDec = pexConfig.ConfigField(dtype=RequireFiniteRaDec,
584 doc="Finite sky coordinate criteria to apply")
585 requirePrimary = pexConfig.ConfigField(dtype=RequirePrimary,
586 doc="Primary source criteria to apply")
587 skyFlag = pexConfig.ConfigField(dtype=RequireFlags, doc="Sky source flag to include")
588
589 def setDefaults(self):
590 pexConfig.Config.setDefaults(self)
591 self.flags.bad = ["base_PixelFlags_flag_edge", "base_PixelFlags_flag_saturated", "base_PsfFlux_flag"]
592 self.signalToNoise.fluxField = "base_PsfFlux_instFlux"
593 self.signalToNoise.errField = "base_PsfFlux_instFluxErr"
594 self.skyFlag.good = ["sky_source"]
595
596
597@pexConfig.registerConfigurable("science", sourceSelectorRegistry)
599 """Science source selector
600
601 By "science" sources, we mean sources that are on images that we
602 are processing, as opposed to sources from reference catalogs.
603
604 This selects (science) sources by (optionally) applying each of a
605 magnitude limit, flag requirements and star/galaxy separation.
606 """
607 ConfigClass = ScienceSourceSelectorConfig
608
609 def selectSources(self, sourceCat, matches=None, exposure=None):
610 """Return a selection of sources selected by specified criteria.
611
612 Parameters
613 ----------
614 sourceCat : `lsst.afw.table.SourceCatalog`
615 Catalog of sources to select from.
616 This catalog must be contiguous in memory.
617 matches : `list` of `lsst.afw.table.ReferenceMatch` or None
618 Ignored in this SourceSelector.
619 exposure : `lsst.afw.image.Exposure` or None
620 The exposure the catalog was built from; used for debug display.
621
622 Returns
623 -------
624 struct : `lsst.pipe.base.Struct`
625 The struct contains the following data:
626
627 ``selected``
628 Boolean array of sources that were selected, same length as
629 sourceCat.
630 (`numpy.ndarray` of `bool`)
631 """
632 selected = np.ones(len(sourceCat), dtype=bool)
633 if self.config.doFluxLimit:
634 selected &= self.config.fluxLimit.apply(sourceCat)
635 if self.config.doFlags:
636 selected &= self.config.flags.apply(sourceCat)
637 if self.config.doUnresolved:
638 selected &= self.config.unresolved.apply(sourceCat)
639 if self.config.doSignalToNoise:
640 selected &= self.config.signalToNoise.apply(sourceCat)
641 if self.config.doIsolated:
642 selected &= self.config.isolated.apply(sourceCat)
643 if self.config.doRequireFiniteRaDec:
644 selected &= self.config.requireFiniteRaDec.apply(sourceCat)
645 if self.config.doRequirePrimary:
646 selected &= self.config.requirePrimary.apply(sourceCat)
647 if self.config.doSkySources:
648 selected |= self.config.skyFlag.apply(sourceCat)
649
650 self.log.info("Selected %d/%d sources", selected.sum(), len(sourceCat))
651
652 return pipeBase.Struct(selected=selected)
653
654
655class ReferenceSourceSelectorConfig(pexConfig.Config):
656 doMagLimit = pexConfig.Field(dtype=bool, default=False, doc="Apply magnitude limit?")
657 doFlags = pexConfig.Field(dtype=bool, default=False, doc="Apply flag limitation?")
658 doUnresolved = pexConfig.Field(dtype=bool, default=False, doc="Apply unresolved limitation?")
659 doSignalToNoise = pexConfig.Field(dtype=bool, default=False, doc="Apply signal-to-noise limit?")
660 doMagError = pexConfig.Field(dtype=bool, default=False, doc="Apply magnitude error limit?")
661 doRequireFiniteRaDec = pexConfig.Field(dtype=bool, default=True,
662 doc="Apply finite sky coordinate check?")
663 magLimit = pexConfig.ConfigField(dtype=MagnitudeLimit, doc="Magnitude limit to apply")
664 flags = pexConfig.ConfigField(dtype=RequireFlags, doc="Flags to require")
665 unresolved = pexConfig.ConfigField(dtype=RequireUnresolved, doc="Star/galaxy separation to apply")
666 requireFiniteRaDec = pexConfig.ConfigField(dtype=RequireFiniteRaDec,
667 doc="Finite sky coordinate criteria to apply")
668 signalToNoise = pexConfig.ConfigField(dtype=SignalToNoiseLimit, doc="Signal-to-noise limit to apply")
669 magError = pexConfig.ConfigField(dtype=MagnitudeErrorLimit, doc="Magnitude error limit to apply")
670 colorLimits = pexConfig.ConfigDictField(keytype=str, itemtype=ColorLimit, default={},
671 doc="Color limits to apply; key is used as a label only")
672
673
674@pexConfig.registerConfigurable("references", sourceSelectorRegistry)
676 """Reference source selector
677
678 This selects reference sources by (optionally) applying each of a
679 magnitude limit, flag requirements and color limits.
680 """
681 ConfigClass = ReferenceSourceSelectorConfig
682
683 def selectSources(self, sourceCat, matches=None, exposure=None):
684 """Return a selection of reference sources selected by some criteria.
685
686 Parameters
687 ----------
688 sourceCat : `lsst.afw.table.SourceCatalog`
689 Catalog of sources to select from.
690 This catalog must be contiguous in memory.
691 matches : `list` of `lsst.afw.table.ReferenceMatch` or None
692 Ignored in this SourceSelector.
693 exposure : `lsst.afw.image.Exposure` or None
694 The exposure the catalog was built from; used for debug display.
695
696 Returns
697 -------
698 struct : `lsst.pipe.base.Struct`
699 The struct contains the following data:
700
701 ``selected``
702 Boolean array of sources that were selected, same length as
703 sourceCat.
704 (`numpy.ndarray` of `bool`)
705 """
706 selected = np.ones(len(sourceCat), dtype=bool)
707 if self.config.doMagLimit:
708 selected &= self.config.magLimit.apply(sourceCat)
709 if self.config.doFlags:
710 selected &= self.config.flags.apply(sourceCat)
711 if self.config.doUnresolved:
712 selected &= self.config.unresolved.apply(sourceCat)
713 if self.config.doSignalToNoise:
714 selected &= self.config.signalToNoise.apply(sourceCat)
715 if self.config.doMagError:
716 selected &= self.config.magError.apply(sourceCat)
717 if self.config.doRequireFiniteRaDec:
718 selected &= self.config.requireFiniteRaDec.apply(sourceCat)
719 for limit in self.config.colorLimits.values():
720 selected &= limit.apply(sourceCat)
721
722 self.log.info("Selected %d/%d references", selected.sum(), len(sourceCat))
723
724 return pipeBase.Struct(selected=selected)
725
726
727@pexConfig.registerConfigurable("null", sourceSelectorRegistry)
729 """Source selector that returns true for all sources.
730
731 Use this when you do not want any sub-selection on your inputs.
732 """
733 ConfigClass = BaseSourceSelectorConfig
734
735 def selectSources(self, sourceCat, **kwargs):
736 # docstring inherited
737 return pipeBase.Struct(selected=np.ones(len(sourceCat), dtype=bool))
738
739
740def _getFieldFromCatalog(catalog, field, isFlag=False):
741 """
742 Get a field from a catalog, for `lsst.afw.table` catalogs or
743 `pandas.DataFrame` or `astropy.table.Table` catalogs.
744
745 Parameters
746 ----------
747 catalog : `lsst.afw.table.SourceCatalog` or `pandas.DataFrame`
748 or `astropy.table.Table`
749 Catalog of sources to extract field array
750 field : `str`
751 Name of field
752 isFlag : `bool`, optional
753 Is this a flag column? If it does not exist, return array
754 of False.
755
756 Returns
757 -------
758 array : `np.ndarray`
759 Array of field values from the catalog.
760 """
761 found = False
762 if isinstance(catalog, (pandas.DataFrame, astropy.table.Table)):
763 if field in catalog.columns:
764 found = True
765 # Sequences must be converted to numpy arrays
766 arr = np.array(catalog[field])
767 else:
768 if field in catalog.schema:
769 found = True
770 arr = catalog[field]
771
772 if isFlag and not found:
773 arr = np.zeros(len(catalog), dtype=bool)
774 elif not found:
775 raise KeyError(f"Could not find field {field} in catalog.")
776
777 return arr
run(self, sourceCat, sourceSelectedField=None, matches=None, exposure=None)
selectSources(self, sourceCat, matches=None, exposure=None)
selectSources(self, sourceCat, matches=None, exposure=None)
selectSources(self, sourceCat, matches=None, exposure=None)
_getFieldFromCatalog(catalog, field, isFlag=False)