LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
lsst.pipe.drivers.coaddDriver.CoaddDriverTask Class Reference
Inheritance diagram for lsst.pipe.drivers.coaddDriver.CoaddDriverTask:
lsst.ctrl.pool.parallel.BatchPoolTask lsst.ctrl.pool.parallel.BatchCmdLineTask

Public Member Functions

def __init__ (self, reuse=tuple(), **kwargs)
 
def __reduce__ (self)
 
def batchWallTime (cls, time, parsedCmd, numCores)
 Return walltime request for batch job. More...
 
def runDataRef (self, tractPatchRefList, butler, selectIdList=[])
 Determine which tracts are non-empty before processing. More...
 
def run (self, patchRefList, butler, selectDataList=[])
 Run stacking on a tract. More...
 
def readSelection (self, cache, selectId)
 Read Wcs of selected inputs. More...
 
def checkTract (self, cache, tractId, selectIdList)
 Check whether a tract has any overlapping inputs. More...
 
def warp (self, cache, patchId, selectDataList)
 Warp all images for a patch. More...
 
def coadd (self, cache, data)
 Construct coadd for a patch and measure. More...
 
def selectExposures (self, patchRef, selectDataList)
 Select exposures to operate upon, via the SelectImagesTask. More...
 
def writeMetadata (self, dataRef)
 
def parseAndRun (cls, *args, **kwargs)
 
def parseAndSubmit (cls, args=None, **kwargs)
 
def batchCommand (cls, args)
 Return command to run CmdLineTask. More...
 
def logOperation (self, operation, catch=False, trace=True)
 Provide a context manager for logging an operation. More...
 

Public Attributes

 reuse
 
 calexpType
 

Static Public Attributes

 ConfigClass = CoaddDriverConfig
 
 RunnerClass = CoaddDriverTaskRunner
 

Detailed Description

Definition at line 84 of file coaddDriver.py.

Constructor & Destructor Documentation

◆ __init__()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.__init__ (   self,
  reuse = tuple(),
**  kwargs 
)

Definition at line 89 of file coaddDriver.py.

89  def __init__(self, reuse=tuple(), **kwargs):
90  BatchPoolTask.__init__(self, **kwargs)
91  self.reuse = reuse
92  self.makeSubtask("select")
93  self.makeSubtask("makeCoaddTempExp", reuse=("makeCoaddTempExp" in self.reuse))
94  self.makeSubtask("backgroundReference")
95  self.makeSubtask("assembleCoadd")
96  self.makeSubtask("detectCoaddSources")
97  if self.config.hasFakes:
98  self.calexpType = "fakes_calexp"
99  else:
100  self.calexpType = "calexp"
101 

Member Function Documentation

◆ __reduce__()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.__reduce__ (   self)
Pickler

Definition at line 102 of file coaddDriver.py.

102  def __reduce__(self):
103  """Pickler"""
104  return unpickle, (self.__class__, [], dict(config=self.config, name=self._name,
105  parentTask=self._parentTask, log=self.log,
106  reuse=self.reuse))
107 

◆ batchCommand()

def lsst.ctrl.pool.parallel.BatchCmdLineTask.batchCommand (   cls,
  args 
)
inherited

Return command to run CmdLineTask.

    @param cls: Class
    @param args: Parsed batch job arguments (from BatchArgumentParser)

Definition at line 476 of file parallel.py.

476  def batchCommand(cls, args):
477  """!Return command to run CmdLineTask
478 
479  @param cls: Class
480  @param args: Parsed batch job arguments (from BatchArgumentParser)
481  """
482  job = args.job if args.job is not None else "job"
483  module = cls.__module__
484  script = ("import os; os.umask(%#05o); " +
485  "import lsst.base; lsst.base.disableImplicitThreading(); " +
486  "import lsst.ctrl.pool.log; lsst.ctrl.pool.log.jobLog(\"%s\"); ") % (UMASK, job)
487 
488  if args.batchStats:
489  script += ("import lsst.ctrl.pool.parallel; import atexit; " +
490  "atexit.register(lsst.ctrl.pool.parallel.printProcessStats); ")
491 
492  script += "import %s; %s.%s.parseAndRun();" % (module, module, cls.__name__)
493 
494  profilePre = "import cProfile; import os; cProfile.run(\"\"\""
495  profilePost = "\"\"\", filename=\"profile-" + job + "-%s-%d.dat\" % (os.uname()[1], os.getpid()))"
496 
497  return ("python -c '" + (profilePre if args.batchProfile else "") + script +
498  (profilePost if args.batchProfile else "") + "' " + shCommandFromArgs(args.leftover) +
499  " --noExit")
500 
def shCommandFromArgs(args)
Definition: parallel.py:42

◆ batchWallTime()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.batchWallTime (   cls,
  time,
  parsedCmd,
  numCores 
)

Return walltime request for batch job.

Parameters
timeRequested time per iteration
parsedCmdResults of argument parsing
numCoresNumber of cores
Returns
float walltime request length

Reimplemented from lsst.ctrl.pool.parallel.BatchCmdLineTask.

Definition at line 125 of file coaddDriver.py.

125  def batchWallTime(cls, time, parsedCmd, numCores):
126  """!
127  Return walltime request for batch job
128 
129  @param time: Requested time per iteration
130  @param parsedCmd: Results of argument parsing
131  @param numCores: Number of cores
132  @return float walltime request length
133  """
134  numTargets = len(parsedCmd.selectId.refList)
135  return time*numTargets/float(numCores)
136 

◆ checkTract()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.checkTract (   self,
  cache,
  tractId,
  selectIdList 
)

Check whether a tract has any overlapping inputs.

    This method only runs on slave nodes.

    @param cache: Pool cache
    @param tractId: Data identifier for tract
    @param selectDataList: List of selection data
    @return whether tract has any overlapping inputs

Definition at line 223 of file coaddDriver.py.

223  def checkTract(self, cache, tractId, selectIdList):
224  """!Check whether a tract has any overlapping inputs
225 
226  This method only runs on slave nodes.
227 
228  @param cache: Pool cache
229  @param tractId: Data identifier for tract
230  @param selectDataList: List of selection data
231  @return whether tract has any overlapping inputs
232  """
233  def makePolygon(wcs, bbox):
234  """Return a polygon for the image, given Wcs and bounding box"""
235  boxPixelCorners = geom.Box2D(bbox).getCorners()
236  boxSkyCorners = wcs.pixelToSky(boxPixelCorners)
237  return lsst.sphgeom.ConvexPolygon.convexHull([coord.getVector() for coord in boxSkyCorners])
238 
239  skymap = cache.skymap
240  tract = skymap[tractId]
241  tractWcs = tract.getWcs()
242  tractPoly = makePolygon(tractWcs, tract.getBBox())
243 
244  for selectData in selectIdList:
245  if not hasattr(selectData, "poly"):
246  selectData.poly = makePolygon(selectData.wcs, selectData.bbox)
247  if tractPoly.intersects(selectData.poly):
248  return True
249  return False
250 
A floating-point coordinate rectangle geometry.
Definition: Box.h:413
static ConvexPolygon convexHull(std::vector< UnitVector3d > const &points)
convexHull returns the convex hull of the given set of points if it exists and throws an exception ot...
Definition: ConvexPolygon.h:65

◆ coadd()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.coadd (   self,
  cache,
  data 
)

Construct coadd for a patch and measure.

    Only slave nodes execute this method.

    Because only one argument may be passed, it is expected to
    contain multiple elements, which are:

    @param patchRef: data reference for patch
    @param selectDataList: List of SelectStruct for inputs

Definition at line 269 of file coaddDriver.py.

269  def coadd(self, cache, data):
270  """!Construct coadd for a patch and measure
271 
272  Only slave nodes execute this method.
273 
274  Because only one argument may be passed, it is expected to
275  contain multiple elements, which are:
276 
277  @param patchRef: data reference for patch
278  @param selectDataList: List of SelectStruct for inputs
279  """
280  patchRef = getDataRef(cache.butler, data.patchId, cache.coaddType)
281  selectDataList = data.selectDataList
282  coadd = None
283 
284  # We skip the assembleCoadd step if either the *Coadd dataset exists
285  # or we aren't configured to write it, we're supposed to reuse
286  # detectCoaddSources outputs too, and those outputs already exist.
287  canSkipDetection = (
288  "detectCoaddSources" in self.reuse and
289  patchRef.datasetExists(self.detectCoaddSources.config.coaddName+"Coadd_det", write=True)
290  )
291  if "assembleCoadd" in self.reuse:
292  if patchRef.datasetExists(cache.coaddType, write=True):
293  self.log.info("%s: Skipping assembleCoadd for %s; outputs already exist." %
294  (NODE, patchRef.dataId))
295  coadd = patchRef.get(cache.coaddType, immediate=True)
296  elif not self.config.assembleCoadd.doWrite and self.config.doDetection and canSkipDetection:
297  self.log.info(
298  "%s: Skipping assembleCoadd and detectCoaddSources for %s; outputs already exist." %
299  (NODE, patchRef.dataId)
300  )
301  return
302  if coadd is None:
303  with self.logOperation("coadding %s" % (patchRef.dataId,), catch=True):
304  coaddResults = self.assembleCoadd.runDataRef(patchRef, selectDataList)
305  if coaddResults is not None:
306  coadd = coaddResults.coaddExposure
307  canSkipDetection = False # can't skip it because coadd may have changed
308  if coadd is None:
309  return
310 
311  # The section of code below determines if the detection task should be
312  # run. If detection is run, then the products are written out as
313  # deepCoadd_calexp. If detection is not run, then the outputs of the
314  # assemble task are written out as deepCoadd.
315  if self.config.doDetection:
316  if canSkipDetection:
317  self.log.info("%s: Skipping detectCoaddSources for %s; outputs already exist." %
318  (NODE, patchRef.dataId))
319  return
320  with self.logOperation("detection on {}".format(patchRef.dataId),
321  catch=True):
322  idFactory = self.detectCoaddSources.makeIdFactory(patchRef)
323  expId = int(patchRef.get(self.config.coaddName + "CoaddId"))
324  # This includes background subtraction, so do it before writing
325  # the coadd
326  detResults = self.detectCoaddSources.run(coadd, idFactory, expId=expId)
327  self.detectCoaddSources.write(detResults, patchRef)
328  else:
329  if self.config.hasFakes:
330  patchRef.put(coadd, "fakes_" + self.assembleCoadd.config.coaddName + "Coadd")
331  else:
332  patchRef.put(coadd, self.assembleCoadd.config.coaddName + "Coadd")
333 
void write(OutputArchiveHandle &handle) const override
def run(self, coaddExposures, bbox, wcs)
Definition: getTemplate.py:603
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
def getDataRef(butler, dataId, datasetType="raw")
Definition: utils.py:16

◆ logOperation()

def lsst.ctrl.pool.parallel.BatchCmdLineTask.logOperation (   self,
  operation,
  catch = False,
  trace = True 
)
inherited

Provide a context manager for logging an operation.

    @param operation: description of operation (string)
    @param catch: Catch all exceptions?
    @param trace: Log a traceback of caught exception?

    Note that if 'catch' is True, all exceptions are swallowed, but there may
    be other side-effects such as undefined variables.

Definition at line 502 of file parallel.py.

502  def logOperation(self, operation, catch=False, trace=True):
503  """!Provide a context manager for logging an operation
504 
505  @param operation: description of operation (string)
506  @param catch: Catch all exceptions?
507  @param trace: Log a traceback of caught exception?
508 
509  Note that if 'catch' is True, all exceptions are swallowed, but there may
510  be other side-effects such as undefined variables.
511  """
512  self.log.info("%s: Start %s" % (NODE, operation))
513  try:
514  yield
515  except Exception:
516  if catch:
517  cls, e, _ = sys.exc_info()
518  self.log.warn("%s: Caught %s while %s: %s" % (NODE, cls.__name__, operation, e))
519  if trace:
520  self.log.info("%s: Traceback:\n%s" % (NODE, traceback.format_exc()))
521  return
522  raise
523  finally:
524  self.log.info("%s: Finished %s" % (NODE, operation))
525 
526 

◆ parseAndRun()

def lsst.ctrl.pool.parallel.BatchPoolTask.parseAndRun (   cls,
args,
**  kwargs 
)
inherited
Run with a MPI process pool

Definition at line 534 of file parallel.py.

534  def parseAndRun(cls, *args, **kwargs):
535  """Run with a MPI process pool"""
536  pool = startPool()
537  super(BatchPoolTask, cls).parseAndRun(*args, **kwargs)
538  pool.exit()
539 
540 
def startPool(comm=None, root=0, killSlaves=True)
Start a process pool.
Definition: pool.py:1216

◆ parseAndSubmit()

def lsst.ctrl.pool.parallel.BatchCmdLineTask.parseAndSubmit (   cls,
  args = None,
**  kwargs 
)
inherited

Definition at line 435 of file parallel.py.

435  def parseAndSubmit(cls, args=None, **kwargs):
436  taskParser = cls._makeArgumentParser(doBatch=True, add_help=False)
437  batchParser = BatchArgumentParser(parent=taskParser)
438  batchArgs = batchParser.parse_args(config=cls.ConfigClass(), args=args, override=cls.applyOverrides,
439  **kwargs)
440 
441  if not cls.RunnerClass(cls, batchArgs.parent).precall(batchArgs.parent): # Write config, schema
442  taskParser.error("Error in task preparation")
443 
444  setBatchType(batchArgs.batch)
445 
446  if batchArgs.batch is None: # don't use a batch system
447  sys.argv = [sys.argv[0]] + batchArgs.leftover # Remove all batch arguments
448 
449  return cls.parseAndRun()
450  else:
451  if batchArgs.walltime > 0:
452  walltime = batchArgs.walltime
453  else:
454  numCores = batchArgs.cores if batchArgs.cores > 0 else batchArgs.nodes*batchArgs.procs
455  walltime = cls.batchWallTime(batchArgs.time, batchArgs.parent, numCores)
456 
457  command = cls.batchCommand(batchArgs)
458  batchArgs.batch.run(command, walltime=walltime)
459 
def setBatchType(batchType)
Definition: pool.py:101

◆ readSelection()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.readSelection (   self,
  cache,
  selectId 
)

Read Wcs of selected inputs.

    This method only runs on slave nodes.
    This method is similar to SelectDataIdContainer.makeDataRefList,
    creating a Struct like a SelectStruct, except with a dataId instead
    of a dataRef (to ease MPI).

    @param cache: Pool cache
    @param selectId: Data identifier for selected input
    @return a SelectStruct with a dataId instead of dataRef

Definition at line 200 of file coaddDriver.py.

200  def readSelection(self, cache, selectId):
201  """!Read Wcs of selected inputs
202 
203  This method only runs on slave nodes.
204  This method is similar to SelectDataIdContainer.makeDataRefList,
205  creating a Struct like a SelectStruct, except with a dataId instead
206  of a dataRef (to ease MPI).
207 
208  @param cache: Pool cache
209  @param selectId: Data identifier for selected input
210  @return a SelectStruct with a dataId instead of dataRef
211  """
212  try:
213  ref = getDataRef(cache.butler, selectId, self.calexpType)
214  self.log.info("Reading Wcs from %s" % (selectId,))
215  md = ref.get("calexp_md", immediate=True)
216  wcs = afwGeom.makeSkyWcs(md)
217  data = Struct(dataId=selectId, wcs=wcs, bbox=afwImage.bboxFromMetadata(md))
218  except FitsError:
219  self.log.warn("Unable to construct Wcs from %s" % (selectId,))
220  return None
221  return data
222 
std::shared_ptr< SkyWcs > makeSkyWcs(daf::base::PropertySet &metadata, bool strip=false)
Construct a SkyWcs from FITS keywords.
Definition: SkyWcs.cc:521
lsst::geom::Box2I bboxFromMetadata(daf::base::PropertySet &metadata)
Determine the image bounding box from its metadata (FITS header)
Definition: Image.cc:680

◆ run()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.run (   self,
  patchRefList,
  butler,
  selectDataList = [] 
)

Run stacking on a tract.

    This method only runs on the master node.

    @param patchRefList: List of patch data references for tract
    @param butler: Data butler
    @param selectDataList: List of SelectStruct for inputs

Definition at line 173 of file coaddDriver.py.

173  def run(self, patchRefList, butler, selectDataList=[]):
174  """!Run stacking on a tract
175 
176  This method only runs on the master node.
177 
178  @param patchRefList: List of patch data references for tract
179  @param butler: Data butler
180  @param selectDataList: List of SelectStruct for inputs
181  """
182  pool = Pool("stacker")
183  pool.cacheClear()
184  pool.storeSet(butler=butler, warpType=self.config.coaddName + "Coadd_directWarp",
185  coaddType=self.config.coaddName + "Coadd")
186  patchIdList = [patchRef.dataId for patchRef in patchRefList]
187 
188  selectedData = pool.map(self.warp, patchIdList, selectDataList)
189  if self.config.doBackgroundReference:
190  self.backgroundReference.runDataRef(patchRefList, selectDataList)
191 
192  def refNamer(patchRef):
193  return tuple(map(int, patchRef.dataId["patch"].split(",")))
194 
195  lookup = dict(zip(map(refNamer, patchRefList), selectedData))
196  coaddData = [Struct(patchId=patchRef.dataId, selectDataList=lookup[refNamer(patchRef)]) for
197  patchRef in patchRefList]
198  pool.map(self.coadd, coaddData)
199 

◆ runDataRef()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.runDataRef (   self,
  tractPatchRefList,
  butler,
  selectIdList = [] 
)

Determine which tracts are non-empty before processing.

    @param tractPatchRefList: List of tracts and patches to include in the coaddition
    @param butler: butler reference object
    @param selectIdList: List of data Ids (i.e. visit, ccd) to consider when making the coadd
    @return list of references to sel.runTract function evaluation for each tractPatchRefList member

Definition at line 138 of file coaddDriver.py.

138  def runDataRef(self, tractPatchRefList, butler, selectIdList=[]):
139  """!Determine which tracts are non-empty before processing
140 
141  @param tractPatchRefList: List of tracts and patches to include in the coaddition
142  @param butler: butler reference object
143  @param selectIdList: List of data Ids (i.e. visit, ccd) to consider when making the coadd
144  @return list of references to sel.runTract function evaluation for each tractPatchRefList member
145  """
146  pool = Pool("tracts")
147  pool.storeSet(butler=butler, skymap=butler.get(
148  self.config.coaddName + "Coadd_skyMap"))
149  tractIdList = []
150  for patchRefList in tractPatchRefList:
151  tractSet = set([patchRef.dataId["tract"]
152  for patchRef in patchRefList])
153  assert len(tractSet) == 1
154  tractIdList.append(tractSet.pop())
155 
156  selectDataList = [data for data in pool.mapNoBalance(self.readSelection, selectIdList) if
157  data is not None]
158  nonEmptyList = pool.mapNoBalance(
159  self.checkTract, tractIdList, selectDataList)
160  tractPatchRefList = [patchRefList for patchRefList, nonEmpty in
161  zip(tractPatchRefList, nonEmptyList) if nonEmpty]
162  self.log.info("Non-empty tracts (%d): %s" % (len(tractPatchRefList),
163  [patchRefList[0].dataId["tract"] for patchRefList in
164  tractPatchRefList]))
165  # Install the dataRef in the selectDataList
166  for data in selectDataList:
167  data.dataRef = getDataRef(butler, data.dataId, self.calexpType)
168 
169  # Process the non-empty tracts
170  return [self.run(patchRefList, butler, selectDataList) for patchRefList in tractPatchRefList]
171 
daf::base::PropertySet * set
Definition: fits.cc:912

◆ selectExposures()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.selectExposures (   self,
  patchRef,
  selectDataList 
)

Select exposures to operate upon, via the SelectImagesTask.

    This is very similar to CoaddBaseTask.selectExposures, except we return
    a list of SelectStruct (same as the input), so we can plug the results into
    future uses of SelectImagesTask.

    @param patchRef data reference to a particular patch
    @param selectDataList list of references to specific data products (i.e. visit, ccd)
    @return filtered list of SelectStruct

Definition at line 334 of file coaddDriver.py.

334  def selectExposures(self, patchRef, selectDataList):
335  """!Select exposures to operate upon, via the SelectImagesTask
336 
337  This is very similar to CoaddBaseTask.selectExposures, except we return
338  a list of SelectStruct (same as the input), so we can plug the results into
339  future uses of SelectImagesTask.
340 
341  @param patchRef data reference to a particular patch
342  @param selectDataList list of references to specific data products (i.e. visit, ccd)
343  @return filtered list of SelectStruct
344  """
345  def key(dataRef):
346  return tuple(dataRef.dataId[k] for k in sorted(dataRef.dataId))
347  inputs = dict((key(select.dataRef), select)
348  for select in selectDataList)
349  skyMap = patchRef.get(self.config.coaddName + "Coadd_skyMap")
350  tract = skyMap[patchRef.dataId["tract"]]
351  patch = tract[(tuple(int(i)
352  for i in patchRef.dataId["patch"].split(",")))]
353  bbox = patch.getOuterBBox()
354  wcs = tract.getWcs()
355  cornerPosList = geom.Box2D(bbox).getCorners()
356  coordList = [wcs.pixelToSky(pos) for pos in cornerPosList]
357  dataRefList = self.select.runDataRef(
358  patchRef, coordList, selectDataList=selectDataList).dataRefList
359  return [inputs[key(dataRef)] for dataRef in dataRefList]
360 

◆ warp()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.warp (   self,
  cache,
  patchId,
  selectDataList 
)

Warp all images for a patch.

    Only slave nodes execute this method.

    Because only one argument may be passed, it is expected to
    contain multiple elements, which are:

    @param patchRef: data reference for patch
    @param selectDataList: List of SelectStruct for inputs
    @return selectDataList with non-overlapping elements removed

Definition at line 251 of file coaddDriver.py.

251  def warp(self, cache, patchId, selectDataList):
252  """!Warp all images for a patch
253 
254  Only slave nodes execute this method.
255 
256  Because only one argument may be passed, it is expected to
257  contain multiple elements, which are:
258 
259  @param patchRef: data reference for patch
260  @param selectDataList: List of SelectStruct for inputs
261  @return selectDataList with non-overlapping elements removed
262  """
263  patchRef = getDataRef(cache.butler, patchId, cache.coaddType)
264  selectDataList = self.selectExposures(patchRef, selectDataList)
265  with self.logOperation("warping %s" % (patchRef.dataId,), catch=True):
266  self.makeCoaddTempExp.runDataRef(patchRef, selectDataList)
267  return selectDataList
268 

◆ writeMetadata()

def lsst.pipe.drivers.coaddDriver.CoaddDriverTask.writeMetadata (   self,
  dataRef 
)

Definition at line 361 of file coaddDriver.py.

361  def writeMetadata(self, dataRef):
362  pass
def writeMetadata(self, dataRefList)
No metadata to write, and not sure how to write it for a list of dataRefs.

Member Data Documentation

◆ calexpType

lsst.pipe.drivers.coaddDriver.CoaddDriverTask.calexpType

Definition at line 98 of file coaddDriver.py.

◆ ConfigClass

lsst.pipe.drivers.coaddDriver.CoaddDriverTask.ConfigClass = CoaddDriverConfig
static

Definition at line 85 of file coaddDriver.py.

◆ reuse

lsst.pipe.drivers.coaddDriver.CoaddDriverTask.reuse

Definition at line 91 of file coaddDriver.py.

◆ RunnerClass

lsst.pipe.drivers.coaddDriver.CoaddDriverTask.RunnerClass = CoaddDriverTaskRunner
static

Definition at line 87 of file coaddDriver.py.


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