lsst.meas.base  14.0-13-gd9a51ef
forcedPhotImage.py
Go to the documentation of this file.
1 #!/usr/bin/env python
2 #
3 # LSST Data Management System
4 # Copyright 2008, 2009, 2010, 2014 LSST Corporation.
5 #
6 # This product includes software developed by the
7 # LSST Project (http://www.lsst.org/).
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 LSST License Statement and
20 # the GNU General Public License along with this program. If not,
21 # see <http://www.lsstcorp.org/LegalNotices/>.
22 #
23 
24 """Base command-line driver task for forced measurement. Must be inherited to specialize for
25 a specific dataset to be used (see ForcedPhotCcdTask, ForcedPhotCoaddTask).
26 """
27 
28 import lsst.afw.table
29 import lsst.pex.config
30 import lsst.daf.base
31 import lsst.pipe.base
32 import lsst.pex.config
33 
34 from .references import MultiBandReferencesTask
35 from .forcedMeasurement import ForcedMeasurementTask
36 from .applyApCorr import ApplyApCorrTask
37 from .catalogCalculation import CatalogCalculationTask
38 
39 __all__ = ("ForcedPhotImageConfig", "ForcedPhotImageTask")
40 
41 
42 class ForcedPhotImageConfig(lsst.pex.config.Config):
43  """!Config class for forced measurement driver task."""
44 
45  references = lsst.pex.config.ConfigurableField(
46  target=MultiBandReferencesTask,
47  doc="subtask to retrieve reference source catalog"
48  )
49  measurement = lsst.pex.config.ConfigurableField(
50  target=ForcedMeasurementTask,
51  doc="subtask to do forced measurement"
52  )
53  coaddName = lsst.pex.config.Field(
54  doc="coadd name: typically one of deep or goodSeeing",
55  dtype=str,
56  default="deep",
57  )
58  doApCorr = lsst.pex.config.Field(
59  dtype=bool,
60  default=True,
61  doc="Run subtask to apply aperture corrections"
62  )
63  applyApCorr = lsst.pex.config.ConfigurableField(
64  target=ApplyApCorrTask,
65  doc="Subtask to apply aperture corrections"
66  )
67  catalogCalculation = lsst.pex.config.ConfigurableField(
68  target=CatalogCalculationTask,
69  doc="Subtask to run catalogCalculation plugins on catalog"
70  )
71 
72  def setDefaults(self):
73  # Make catalogCalculation a no-op by default as no modelFlux is setup by default in
74  # ForcedMeasurementTask
75  self.catalogCalculation.plugins.names = []
76 
77 
83 
84 
85 class ForcedPhotImageTask(lsst.pipe.base.CmdLineTask):
86  """!A base class for command-line forced measurement drivers.
87 
88  This is a an abstract class, which is the common ancestor for ForcedPhotCcdTask
89  and ForcedPhotCoaddTask. It provides the run() method that does most of the
90  work, while delegating a few customization tasks to other methods that are
91  overridden by subclasses.
92 
93  This task is not directly usable as a CmdLineTask; subclasses must:
94  - Set the _DefaultName class attribute
95  - Implement makeIdFactory
96  - Implement fetchReferences
97  - (optional) Implement attachFootprints
98  """
99  ConfigClass = ForcedPhotImageConfig
100  _DefaultName = "processImageForcedTask"
101 
102  def __init__(self, butler=None, refSchema=None, **kwds):
103  """Initialize the task.
104 
105  ForcedPhotImageTask takes two keyword arguments beyond the usual CmdLineTask arguments:
106  - refSchema: the Schema of the reference catalog, passed to the constructor of the references
107  subtask
108  - butler: a butler that will be passed to the references subtask to allow it to load its Schema
109  from disk
110  At least one of these arguments must be present; if both are, schema takes precedence.
111  """
112  super(lsst.pipe.base.CmdLineTask, self).__init__(**kwds)
113  self.makeSubtask("references", butler=butler, schema=refSchema)
114  if refSchema is None:
115  refSchema = self.references.schema
116  self.makeSubtask("measurement", refSchema=refSchema)
117  # It is necessary to get the schema internal to the forced measurement task until such a time
118  # that the schema is not owned by the measurement task, but is passed in by an external caller
119  if self.config.doApCorr:
120  self.makeSubtask("applyApCorr", schema=self.measurement.schema)
121  self.makeSubtask('catalogCalculation', schema=self.measurement.schema)
122 
123  def run(self, dataRef):
124  """!Measure a single exposure using forced detection for a reference catalog.
125 
126  @param[in] dataRef An lsst.daf.persistence.ButlerDataRef. It is passed to the
127  references subtask to obtain the reference WCS, the getExposure()
128  method (implemented by derived classes) to read the measurement
129  image, and the fetchReferences() method (implemented by derived
130  classes) to get the exposure and load the reference catalog (see
131  the CoaddSrcReferencesTask for more information). Sources are
132  generated with generateMeasCat() in the measurement subtask. These
133  are passed to measurement's run method which fills the source
134  catalog with the forced measurement results. The sources are then
135  passed to the writeOutputs() method (implemented by derived classes)
136  which writes the outputs. See derived class documentation for which
137  datasets and data ID keys are used.
138  """
139  refWcs = self.references.getWcs(dataRef)
140  exposure = self.getExposure(dataRef)
141  refCat = self.fetchReferences(dataRef, exposure)
142  measCat = self.measurement.generateMeasCat(exposure, refCat, refWcs,
143  idFactory=self.makeIdFactory(dataRef))
144  self.log.info("Performing forced measurement on %s" % (dataRef.dataId,))
145  self.attachFootprints(measCat, refCat, exposure, refWcs, dataRef)
146 
147  self.measurement.run(measCat, exposure, refCat, refWcs, exposureId=self.getExposureId(dataRef))
148 
149  if self.config.doApCorr:
150  self.applyApCorr.run(
151  catalog=measCat,
152  apCorrMap=exposure.getInfo().getApCorrMap()
153  )
154  self.catalogCalculation.run(measCat)
155 
156  self.writeOutput(dataRef, measCat)
157 
158  def makeIdFactory(self, dataRef):
159  """!Hook for derived classes to define how to make an IdFactory for forced sources.
160 
161  Note that this is for forced source IDs, not object IDs, which are usually handled by
162  the measurement.copyColumns config option.
163  """
164  raise NotImplementedError()
165 
166  def getExposureId(self, dataRef):
167  raise NotImplementedError()
168 
169  def fetchReferences(self, dataRef, exposure):
170  """!Hook for derived classes to define how to get references objects.
171 
172  Derived classes should call one of the fetch* methods on the references subtask,
173  but which one they call depends on whether the region to get references for is a
174  easy to describe in patches (as it would be when doing forced measurements on a
175  coadd), or is just an arbitrary box (as it would be for CCD forced measurements).
176  """
177  raise NotImplementedError()
178 
179  def attachFootprints(self, sources, refCat, exposure, refWcs, dataRef):
180  """!Hook for derived classes to define how to attach Footprints to blank sources prior to measurement
181 
182  Footprints for forced photometry must be in the pixel coordinate system of the image being
183  measured, while the actual detections may start out in a different coordinate system.
184 
185  Subclasses for ForcedPhotImageTask must implement this method to define how those Footprints
186  should be generated.
187 
188  The default implementation (defined in forcedMeasurement.py) transforms the Footprints from
189  the reference catalog from the refWcs to the exposure's Wcs, which downgrades HeavyFootprints
190  into regular Footprints, destroying deblend information.
191  """
192  return self.measurement.attachTransformedFootprints(sources, refCat, exposure, refWcs)
193 
194  def getExposure(self, dataRef):
195  """!Read input exposure on which to perform the measurements
196 
197  @param dataRef Data reference from butler.
198  """
199  return dataRef.get(self.dataPrefix + "calexp", immediate=True)
200 
201  def writeOutput(self, dataRef, sources):
202  """!Write forced source table
203 
204  @param dataRef Data reference from butler; the forced_src dataset (with self.dataPrefix included)
205  is all that will be modified.
206  @param sources SourceCatalog to save
207  """
208  dataRef.put(sources, self.dataPrefix + "forced_src", flags=lsst.afw.table.SOURCE_IO_NO_FOOTPRINTS)
209 
210  def getSchemaCatalogs(self):
211  """!Get a dict of Schema catalogs that will be used by this Task.
212 
213  In the case of forced taks, there is only one schema for each type of forced measurement.
214  The dataset type for this measurement is defined in the mapper.
215  """
216  catalog = lsst.afw.table.SourceCatalog(self.measurement.schema)
217  catalog.getTable().setMetadata(self.measurement.algMetadata)
218  datasetType = self.dataPrefix + "forced_src"
219  return {datasetType: catalog}
220 
221  def _getConfigName(self):
222  """!Return the name of the config dataset. Forces config comparison from run-to-run
223  """
224  return self.dataPrefix + "forced_config"
225 
226  def _getMetadataName(self):
227  """!Return the name of the metadata dataset. Forced metadata to be saved
228  """
229  return self.dataPrefix + "forced_metadata"
A base class for command-line forced measurement drivers.
def getExposure(self, dataRef)
Read input exposure on which to perform the measurements.
def fetchReferences(self, dataRef, exposure)
Hook for derived classes to define how to get references objects.
def run(self, dataRef)
Measure a single exposure using forced detection for a reference catalog.
def makeIdFactory(self, dataRef)
Hook for derived classes to define how to make an IdFactory for forced sources.
def __init__(self, butler=None, refSchema=None, kwds)
def getSchemaCatalogs(self)
Get a dict of Schema catalogs that will be used by this Task.
def writeOutput(self, dataRef, sources)
Write forced source table.
def attachFootprints(self, sources, refCat, exposure, refWcs, dataRef)
Hook for derived classes to define how to attach Footprints to blank sources prior to measurement...
Config class for forced measurement driver task.