Inheritance diagram for lsst.pipe.drivers.skyCorrection.SkyCorrectionTask:

Public Member Functions
def	runQuantum (self, butlerQC, inputRefs, outputRefs)

def	__init__ (self, args, *kwargs)

def	batchWallTime (cls, time, parsedCmd, numCores)

def	runDataRef (self, expRef)

def	focalPlaneBackground (self, camera, pool, dataIdList, config)

def	focalPlaneBackgroundRun (self, camera, cacheExposures, idList, config)

def	run (self, calExpArray, calBkgArray, skyCalibs, camera)

def	loadImage (self, cache, dataId)

def	loadImageRun (self, calExp, calExpBkg)

def	measureSkyFrame (self, cache, dataId)

def	subtractSkyFrame (self, cache, dataId, scale)

def	accumulateModel (self, cache, data)

def	subtractModel (self, cache, dataId, bgModel)

def	subtractModelRun (self, exposure, bgModel)

def	realiseModel (self, cache, dataId, bgModel)

def	collectBinnedImage (self, exposure, image)

def	collect (self, cache)

def	collectOriginal (self, cache, dataId)

def	collectSky (self, cache, dataId)

def	collectMask (self, cache, dataId)

def	write (self, cache, dataId)

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...

Static Public Attributes
	ConfigClass = SkyCorrectionConfig

Detailed Description

Correct sky over entire focal plane

Definition at line 197 of file skyCorrection.py.

Constructor & Destructor Documentation

◆ init()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 220 of file skyCorrection.py.

     def __init__(self, *args, **kwargs):
         super().__init__(**kwargs)
  
         self.makeSubtask("sky")
         self.makeSubtask("maskObjects")
  

Member Function Documentation

◆ accumulateModel()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.accumulateModel	(	self,
		cache,
		data
	)

Fit background model for CCD

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
data : `lsst.pipe.base.Struct`
    Data identifier, with `dataId` (data identifier) and `bgModel`
    (background model) elements.

Returns
-------
bgModel : `lsst.pipe.drivers.background.FocalPlaneBackground`
    Background model.

Definition at line 621 of file skyCorrection.py.

     def accumulateModel(self, cache, data):
         """Fit background model for CCD
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         data : `lsst.pipe.base.Struct`
             Data identifier, with `dataId` (data identifier) and `bgModel`
             (background model) elements.
  
         Returns
         -------
         bgModel : `lsst.pipe.drivers.background.FocalPlaneBackground`
             Background model.
         """
         assert cache.dataId == data.dataId
         data.bgModel.addCcd(cache.exposure)
         return data.bgModel
  

◆ 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.

     def batchCommand(cls, args):
         """!Return command to run CmdLineTask
  
         @param cls: Class
         @param args: Parsed batch job arguments (from BatchArgumentParser)
         """
         job = args.job if args.job is not None else "job"
         module = cls.__module__
         script = ("import os; os.umask(%#05o); " +
                   "import lsst.base; lsst.base.disableImplicitThreading(); " +
                   "import lsst.ctrl.pool.log; lsst.ctrl.pool.log.jobLog(\"%s\"); ") % (UMASK, job)
  
         if args.batchStats:
             script += ("import lsst.ctrl.pool.parallel; import atexit; " +
                        "atexit.register(lsst.ctrl.pool.parallel.printProcessStats); ")
  
         script += "import %s; %s.%s.parseAndRun();" % (module, module, cls.__name__)
  
         profilePre = "import cProfile; import os; cProfile.run(\"\"\""
         profilePost = "\"\"\", filename=\"profile-" + job + "-%s-%d.dat\" % (os.uname()[1], os.getpid()))"
  
         return ("python -c '" + (profilePre if args.batchProfile else "") + script +
                 (profilePost if args.batchProfile else "") + "' " + shCommandFromArgs(args.leftover) +
                 " --noExit")
  

◆ batchWallTime()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.batchWallTime	(	cls,
		time,
		parsedCmd,
		numCores
	)

Return walltime request for batch job

Subclasses should override if the walltime should be calculated
differently (e.g., addition of some serial time).

Parameters
----------
time : `float`
    Requested time per iteration.
parsedCmd : `argparse.Namespace`
    Results of argument parsing.
numCores : `int`
    Number of cores.

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

Definition at line 236 of file skyCorrection.py.

     def batchWallTime(cls, time, parsedCmd, numCores):
         """Return walltime request for batch job
  
         Subclasses should override if the walltime should be calculated
         differently (e.g., addition of some serial time).
  
         Parameters
         ----------
         time : `float`
             Requested time per iteration.
         parsedCmd : `argparse.Namespace`
             Results of argument parsing.
         numCores : `int`
             Number of cores.
         """
         numTargets = len(cls.RunnerClass.getTargetList(parsedCmd))
         return time*numTargets
  

◆ collect()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.collect	(	self,
		cache
	)

Collect exposure for potential visualisation

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.MaskedImage`
    Binned image.

Definition at line 752 of file skyCorrection.py.

     def collect(self, cache):
         """Collect exposure for potential visualisation
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.MaskedImage`
             Binned image.
         """
         return self.collectBinnedImage(cache.exposure, cache.exposure.maskedImage)
  

◆ collectBinnedImage()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.collectBinnedImage	(	self,
		exposure,
		image
	)

Return the binned image required for visualization

This method just helps to cut down on boilerplate.

Parameters
----------
image : `lsst.afw.image.MaskedImage`
    Image to go into visualisation.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.MaskedImage`
    Binned image.

Definition at line 733 of file skyCorrection.py.

     def collectBinnedImage(self, exposure, image):
         """Return the binned image required for visualization
  
         This method just helps to cut down on boilerplate.
  
         Parameters
         ----------
         image : `lsst.afw.image.MaskedImage`
             Image to go into visualisation.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.MaskedImage`
             Binned image.
         """
         return (exposure.getDetector().getId(), afwMath.binImage(image, self.config.binning))
  

◆ collectMask()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.collectMask	(	self,
		cache,
		dataId
	)

Collect mask for visualisation

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.Image`
    Binned image.

Definition at line 814 of file skyCorrection.py.

     def collectMask(self, cache, dataId):
         """Collect mask for visualisation
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.Image`
             Binned image.
         """
         # Convert Mask to floating-point image, because that's what's required for focal plane construction
         image = afwImage.ImageF(cache.exposure.maskedImage.getBBox())
         image.array[:] = cache.exposure.maskedImage.mask.array
         return self.collectBinnedImage(cache.exposure, image)
  

◆ collectOriginal()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.collectOriginal	(	self,
		cache,
		dataId
	)

Collect original image for visualisation

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.MaskedImage`
    Binned image.

Definition at line 771 of file skyCorrection.py.

     def collectOriginal(self, cache, dataId):
         """Collect original image for visualisation
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.MaskedImage`
             Binned image.
         """
         exposure = cache.butler.get("calexp", dataId, immediate=True)
         return self.collectBinnedImage(exposure, exposure.maskedImage)
  

◆ collectSky()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.collectSky	(	self,
		cache,
		dataId
	)

Collect original image for visualisation

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.MaskedImage`
    Binned image.

Definition at line 793 of file skyCorrection.py.

     def collectSky(self, cache, dataId):
         """Collect original image for visualisation
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.MaskedImage`
             Binned image.
         """
         return self.collectBinnedImage(cache.exposure, cache.sky.getImage())
  

◆ focalPlaneBackground()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.focalPlaneBackground	(	self,
		camera,
		pool,
		dataIdList,
		config
	)

Perform full focal-plane background subtraction

This method runs on the master node.

Parameters
----------
camera : `lsst.afw.cameraGeom.Camera`
    Camera description.
pool : `lsst.ctrl.pool.Pool`
    Process pool.
dataIdList : iterable of `dict`
    List of data identifiers for the CCDs.
config : `lsst.pipe.drivers.background.FocalPlaneBackgroundConfig`
    Configuration to use for background subtraction.

Returns
-------
exposures : `list` of `lsst.afw.image.Image`
    List of binned images, for creating focal plane image.

Definition at line 321 of file skyCorrection.py.

     def focalPlaneBackground(self, camera, pool, dataIdList, config):
         """Perform full focal-plane background subtraction
  
         This method runs on the master node.
  
         Parameters
         ----------
         camera : `lsst.afw.cameraGeom.Camera`
             Camera description.
         pool : `lsst.ctrl.pool.Pool`
             Process pool.
         dataIdList : iterable of `dict`
             List of data identifiers for the CCDs.
         config : `lsst.pipe.drivers.background.FocalPlaneBackgroundConfig`
             Configuration to use for background subtraction.
  
         Returns
         -------
         exposures : `list` of `lsst.afw.image.Image`
             List of binned images, for creating focal plane image.
         """
         bgModel = FocalPlaneBackground.fromCamera(config, camera)
         data = [pipeBase.Struct(dataId=dataId, bgModel=bgModel.clone()) for dataId in dataIdList]
         bgModelList = pool.mapToPrevious(self.accumulateModel, data)
         for ii, bg in enumerate(bgModelList):
             self.log.info("Background %d: %d pixels", ii, bg._numbers.array.sum())
             bgModel.merge(bg)
         return pool.mapToPrevious(self.subtractModel, dataIdList, bgModel)
  

◆ focalPlaneBackgroundRun()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.focalPlaneBackgroundRun	(	self,
		camera,
		cacheExposures,
		idList,
		config
	)

Perform full focal-plane background subtraction

This method runs on the master node.

Parameters
----------
camera : `lsst.afw.cameraGeom.Camera`
    Camera description.
cacheExposures : `list` of `lsst.afw.image.Exposures`
    List of loaded and processed input calExp.
idList : `list` of `int`
    List of detector ids to iterate over.
config : `lsst.pipe.drivers.background.FocalPlaneBackgroundConfig`
    Configuration to use for background subtraction.

Returns
-------
exposures : `list` of `lsst.afw.image.Image`
    List of binned images, for creating focal plane image.
newCacheBgList : `list` of `lsst.afwMath.backgroundList`
    Background lists generated.
cacheBgModel : `FocalPlaneBackground`
    Full focal plane background model.

Definition at line 350 of file skyCorrection.py.

     def focalPlaneBackgroundRun(self, camera, cacheExposures, idList, config):
         """Perform full focal-plane background subtraction
  
         This method runs on the master node.
  
         Parameters
         ----------
         camera : `lsst.afw.cameraGeom.Camera`
             Camera description.
         cacheExposures : `list` of `lsst.afw.image.Exposures`
             List of loaded and processed input calExp.
         idList : `list` of `int`
             List of detector ids to iterate over.
         config : `lsst.pipe.drivers.background.FocalPlaneBackgroundConfig`
             Configuration to use for background subtraction.
  
         Returns
         -------
         exposures : `list` of `lsst.afw.image.Image`
             List of binned images, for creating focal plane image.
         newCacheBgList : `list` of `lsst.afwMath.backgroundList`
             Background lists generated.
         cacheBgModel : `FocalPlaneBackground`
             Full focal plane background model.
         """
         bgModel = FocalPlaneBackground.fromCamera(config, camera)
         data = [pipeBase.Struct(id=id, bgModel=bgModel.clone()) for id in idList]
  
         bgModelList = []
         for nodeData, cacheExp in zip(data, cacheExposures):
             nodeData.bgModel.addCcd(cacheExp)
             bgModelList.append(nodeData.bgModel)
  
         for ii, bg in enumerate(bgModelList):
             self.log.info("Background %d: %d pixels", ii, bg._numbers.getArray().sum())
             bgModel.merge(bg)
  
         exposures = []
         newCacheBgList = []
         cacheBgModel = []
         for cacheExp in cacheExposures:
             nodeExp, nodeBgModel, nodeBgList = self.subtractModelRun(cacheExp, bgModel)
             exposures.append(afwMath.binImage(nodeExp.getMaskedImage(), self.config.binning))
             cacheBgModel.append(nodeBgModel)
             newCacheBgList.append(nodeBgList)
  
         return exposures, newCacheBgList, cacheBgModel
  

◆ loadImage()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.loadImage	(	self,
		cache,
		dataId
	)

Load original image and restore the sky

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Returns
-------
exposure : `lsst.afw.image.Exposure`
    Resultant exposure.

Definition at line 504 of file skyCorrection.py.

     def loadImage(self, cache, dataId):
         """Load original image and restore the sky
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
  
         Returns
         -------
         exposure : `lsst.afw.image.Exposure`
             Resultant exposure.
         """
         cache.dataId = dataId
         cache.exposure = cache.butler.get(self.config.calexpType, dataId, immediate=True).clone()
         bgOld = cache.butler.get("calexpBackground", dataId, immediate=True)
         image = cache.exposure.getMaskedImage()
  
         # We're removing the old background, so change the sense of all its components
         for bgData in bgOld:
             statsImage = bgData[0].getStatsImage()
             statsImage *= -1
  
         image -= bgOld.getImage()
         cache.bgList = afwMath.BackgroundList()
         for bgData in bgOld:
             cache.bgList.append(bgData)
  
         if self.config.doMaskObjects:
             self.maskObjects.findObjects(cache.exposure)
  
         return self.collect(cache)
  

◆ loadImageRun()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.loadImageRun	(	self,
		calExp,
		calExpBkg
	)

Serial implementation of self.loadImage() for Gen3.

Load and restore background to calExp and calExpBkg.

Parameters
----------
calExp : `lsst.afw.image.Exposure`
    Detector level calExp image to process.
calExpBkg : `lsst.afw.math.BackgroundList`
    Detector level background list associated with the calExp.

Returns
-------
calExp : `lsst.afw.image.Exposure`
    Background restored calExp.
bgList : `lsst.afw.math.BackgroundList`
    New background list containing the restoration background.

Definition at line 541 of file skyCorrection.py.

     def loadImageRun(self, calExp, calExpBkg):
         """Serial implementation of self.loadImage() for Gen3.
  
         Load and restore background to calExp and calExpBkg.
  
         Parameters
         ----------
         calExp : `lsst.afw.image.Exposure`
             Detector level calExp image to process.
         calExpBkg : `lsst.afw.math.BackgroundList`
             Detector level background list associated with the calExp.
  
         Returns
         -------
         calExp : `lsst.afw.image.Exposure`
             Background restored calExp.
         bgList : `lsst.afw.math.BackgroundList`
             New background list containing the restoration background.
         """
         image = calExp.getMaskedImage()
  
         for bgOld in calExpBkg:
             statsImage = bgOld[0].getStatsImage()
             statsImage *= -1
  
         image -= calExpBkg.getImage()
         bgList = afwMath.BackgroundList()
         for bgData in calExpBkg:
             bgList.append(bgData)
  
         if self.config.doMaskObjects:
             self.maskObjects.findObjects(calExp)
  
         return (calExp, bgList)
  

◆ 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.

     def logOperation(self, operation, catch=False, trace=True):
         """!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.
         """
         self.log.info("%s: Start %s" % (NODE, operation))
         try:
             yield
         except Exception:
             if catch:
                 cls, e, _ = sys.exc_info()
                 self.log.warn("%s: Caught %s while %s: %s" % (NODE, cls.__name__, operation, e))
                 if trace:
                     self.log.info("%s: Traceback:\n%s" % (NODE, traceback.format_exc()))
                 return
             raise
         finally:
             self.log.info("%s: Finished %s" % (NODE, operation))
  
  

◆ measureSkyFrame()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.measureSkyFrame	(	self,
		cache,
		dataId
	)

Measure scale for sky frame

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Returns
-------
scale : `float`
    Scale for sky frame.

Definition at line 576 of file skyCorrection.py.

     def measureSkyFrame(self, cache, dataId):
         """Measure scale for sky frame
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
  
         Returns
         -------
         scale : `float`
             Scale for sky frame.
         """
         assert cache.dataId == dataId
         cache.sky = self.sky.getSkyData(cache.butler, dataId)
         scale = self.sky.measureScale(cache.exposure.getMaskedImage(), cache.sky)
         return scale
  

◆ 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.

     def parseAndRun(cls, *args, **kwargs):
         """Run with a MPI process pool"""
         pool = startPool()
         super(BatchPoolTask, cls).parseAndRun(*args, **kwargs)
         pool.exit()
  
  

◆ parseAndSubmit()

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

inherited

Definition at line 435 of file parallel.py.

     def parseAndSubmit(cls, args=None, **kwargs):
         taskParser = cls._makeArgumentParser(doBatch=True, add_help=False)
         batchParser = BatchArgumentParser(parent=taskParser)
         batchArgs = batchParser.parse_args(config=cls.ConfigClass(), args=args, override=cls.applyOverrides,
                                            **kwargs)
  
         if not cls.RunnerClass(cls, batchArgs.parent).precall(batchArgs.parent):  # Write config, schema
             taskParser.error("Error in task preparation")
  
         setBatchType(batchArgs.batch)
  
         if batchArgs.batch is None:     # don't use a batch system
             sys.argv = [sys.argv[0]] + batchArgs.leftover  # Remove all batch arguments
  
             return cls.parseAndRun()
         else:
             if batchArgs.walltime > 0:
                 walltime = batchArgs.walltime
             else:
                 numCores = batchArgs.cores if batchArgs.cores > 0 else batchArgs.nodes*batchArgs.procs
                 walltime = cls.batchWallTime(batchArgs.time, batchArgs.parent, numCores)
  
             command = cls.batchCommand(batchArgs)
             batchArgs.batch.run(command, walltime=walltime)
  

◆ realiseModel()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.realiseModel	(	self,
		cache,
		dataId,
		bgModel
	)

Generate an image of the background model for visualisation

Useful for debugging.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.
bgModel : `lsst.pipe.drivers.background.FocalPlaneBackround`
    Background model.

Returns
-------
detId : `int`
    Detector identifier.
image : `lsst.afw.image.MaskedImage`
    Binned background model image.

Definition at line 705 of file skyCorrection.py.

     def realiseModel(self, cache, dataId, bgModel):
         """Generate an image of the background model for visualisation
  
         Useful for debugging.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
         bgModel : `lsst.pipe.drivers.background.FocalPlaneBackround`
             Background model.
  
         Returns
         -------
         detId : `int`
             Detector identifier.
         image : `lsst.afw.image.MaskedImage`
             Binned background model image.
         """
         assert cache.dataId == dataId
         exposure = cache.exposure
         detector = exposure.getDetector()
         bbox = exposure.getMaskedImage().getBBox()
         image = bgModel.toCcdBackground(detector, bbox).getImage()
         return self.collectBinnedImage(exposure, image)
  

◆ run()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.run	(	self,
		calExpArray,
		calBkgArray,
		skyCalibs,
		camera
	)

Duplicate runDataRef method without ctrl_pool for Gen3.

Parameters
----------
calExpArray : `list` of `lsst.afw.image.Exposure`
    Array of detector input calExp images for the exposure to
    process.
calBkgArray : `list` of `lsst.afw.math.BackgroundList`
    Array of detector input background lists matching the
    calExps to process.
skyCalibs : `list` of `lsst.afw.image.Exposure`
    Array of SKY calibrations for the input detectors to be
    processed.
camera : `lsst.afw.cameraGeom.Camera`
    Camera matching the input data to process.

Returns
-------
results : `pipeBase.Struct` containing
    calExpCamera : `lsst.afw.image.Exposure`
        Full camera image of the sky-corrected data.
    skyCorr : `list` of `lsst.afw.math.BackgroundList`
        Detector-level sky-corrected background lists.

See Also
--------
~lsst.pipe.drivers.SkyCorrectionTask.runDataRef()

Definition at line 398 of file skyCorrection.py.

     def run(self, calExpArray, calBkgArray, skyCalibs, camera):
         """Duplicate runDataRef method without ctrl_pool for Gen3.
  
         Parameters
         ----------
         calExpArray : `list` of `lsst.afw.image.Exposure`
             Array of detector input calExp images for the exposure to
             process.
         calBkgArray : `list` of `lsst.afw.math.BackgroundList`
             Array of detector input background lists matching the
             calExps to process.
         skyCalibs : `list` of `lsst.afw.image.Exposure`
             Array of SKY calibrations for the input detectors to be
             processed.
         camera : `lsst.afw.cameraGeom.Camera`
             Camera matching the input data to process.
  
         Returns
         -------
         results : `pipeBase.Struct` containing
             calExpCamera : `lsst.afw.image.Exposure`
                 Full camera image of the sky-corrected data.
             skyCorr : `list` of `lsst.afw.math.BackgroundList`
                 Detector-level sky-corrected background lists.
  
         See Also
         --------
         ~lsst.pipe.drivers.SkyCorrectionTask.runDataRef()
         """
         # To allow SkyCorrectionTask to run in the Gen3 butler
         # environment, a new run() method was added that performs the
         # same operations in a serial environment (pipetask processing
         # does not support MPI processing as of 2019-05-03). Methods
         # used in runDataRef() are used as appropriate in run(), but
         # some have been rewritten in serial form. Please ensure that
         # any updates to runDataRef() or the methods it calls with
         # pool.mapToPrevious() are duplicated in run() and its
         # methods.
         #
         # Variable names here should match those in runDataRef() as
         # closely as possible. Variables matching data stored in the
         # pool cache have a prefix indicating this.  Variables that
         # would be local to an MPI processing client have a prefix
         # "node".
         idList = [exp.getDetector().getId() for exp in calExpArray]
  
         # Construct arrays that match the cache in self.runDataRef() after
         # self.loadImage() is map/reduced.
         cacheExposures = []
         cacheBgList = []
         exposures = []
         for calExp, calBgModel in zip(calExpArray, calBkgArray):
             nodeExp, nodeBgList = self.loadImageRun(calExp, calBgModel)
             cacheExposures.append(nodeExp)
             cacheBgList.append(nodeBgList)
             exposures.append(afwMath.binImage(nodeExp.getMaskedImage(), self.config.binning))
  
         if self.config.doBgModel:
             # Generate focal plane background, updating backgrounds in the "cache".
             exposures, newCacheBgList, cacheBgModel = self.focalPlaneBackgroundRun(
                 camera, cacheExposures, idList, self.config.bgModel
             )
             for cacheBg, newBg in zip(cacheBgList, newCacheBgList):
                 cacheBg.append(newBg)
  
         if self.config.doSky:
             # Measure the sky frame scale on all inputs.  Results in
             # values equal to self.measureSkyFrame() and
             # self.sky.solveScales() in runDataRef().
             cacheSky = []
             measScales = []
             for cacheExp, skyCalib in zip(cacheExposures, skyCalibs):
                 skyExp = self.sky.exposureToBackground(skyCalib)
                 cacheSky.append(skyExp)
                 scale = self.sky.measureScale(cacheExp.getMaskedImage(), skyExp)
                 measScales.append(scale)
  
             scale = self.sky.solveScales(measScales)
             self.log.info("Sky frame scale: %s" % (scale, ))
  
             # Subtract sky frame, as in self.subtractSkyFrame(), with
             # appropriate scale from the "cache".
             exposures = []
             newBgList = []
             for cacheExp, nodeSky, nodeBgList in zip(cacheExposures, cacheSky, cacheBgList):
                 self.sky.subtractSkyFrame(cacheExp.getMaskedImage(), nodeSky, scale, nodeBgList)
                 exposures.append(afwMath.binImage(cacheExp.getMaskedImage(), self.config.binning))
  
         if self.config.doBgModel2:
             # As above, generate a focal plane background model and
             # update the cache models.
             exposures, newBgList, cacheBgModel = self.focalPlaneBackgroundRun(
                 camera, cacheExposures, idList, self.config.bgModel2
             )
             for cacheBg, newBg in zip(cacheBgList, newBgList):
                 cacheBg.append(newBg)
  
         # Generate camera-level image of calexp and return it along
         # with the list of sky corrected background models.
         image = makeCameraImage(camera, zip(idList, exposures))
  
         return pipeBase.Struct(
             calExpCamera=image,
             skyCorr=cacheBgList,
         )
  

◆ runDataRef()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.runDataRef	(	self,
		expRef
	)

Perform sky correction on an exposure

We restore the original sky, and remove it again using multiple
algorithms. We optionally apply:

1. A large-scale background model.
    This step removes very-large-scale sky such as moonlight.
2. A sky frame.
3. A medium-scale background model.
    This step removes residual sky (This is smooth on the focal plane).

Only the master node executes this method. The data is held on
the slave nodes, which do all the hard work.

Parameters
----------
expRef : `lsst.daf.persistence.ButlerDataRef`
    Data reference for exposure.

See Also
--------
~lsst.pipe.drivers.SkyCorrectionTask.run

Definition at line 254 of file skyCorrection.py.

     def runDataRef(self, expRef):
         """Perform sky correction on an exposure
  
         We restore the original sky, and remove it again using multiple
         algorithms. We optionally apply:
  
         1. A large-scale background model.
             This step removes very-large-scale sky such as moonlight.
         2. A sky frame.
         3. A medium-scale background model.
             This step removes residual sky (This is smooth on the focal plane).
  
         Only the master node executes this method. The data is held on
         the slave nodes, which do all the hard work.
  
         Parameters
         ----------
         expRef : `lsst.daf.persistence.ButlerDataRef`
             Data reference for exposure.
  
         See Also
         --------
         ~lsst.pipe.drivers.SkyCorrectionTask.run
         """
         if DEBUG:
             extension = "-%(visit)d.fits" % expRef.dataId
  
         with self.logOperation("processing %s" % (expRef.dataId,)):
             pool = Pool()
             pool.cacheClear()
             pool.storeSet(butler=expRef.getButler())
             camera = expRef.get("camera")
  
             dataIdList = [ccdRef.dataId for ccdRef in expRef.subItems("ccd") if
                           ccdRef.datasetExists(self.config.calexpType)]
  
             exposures = pool.map(self.loadImage, dataIdList)
             if DEBUG:
                 makeCameraImage(camera, exposures, "restored" + extension)
                 exposures = pool.mapToPrevious(self.collectOriginal, dataIdList)
                 makeCameraImage(camera, exposures, "original" + extension)
                 exposures = pool.mapToPrevious(self.collectMask, dataIdList)
                 makeCameraImage(camera, exposures, "mask" + extension)
  
             if self.config.doBgModel:
                 exposures = self.focalPlaneBackground(camera, pool, dataIdList, self.config.bgModel)
  
             if self.config.doSky:
                 measScales = pool.mapToPrevious(self.measureSkyFrame, dataIdList)
                 scale = self.sky.solveScales(measScales)
                 self.log.info("Sky frame scale: %s" % (scale,))
  
                 exposures = pool.mapToPrevious(self.subtractSkyFrame, dataIdList, scale)
                 if DEBUG:
                     makeCameraImage(camera, exposures, "skysub" + extension)
                     calibs = pool.mapToPrevious(self.collectSky, dataIdList)
                     makeCameraImage(camera, calibs, "sky" + extension)
  
             if self.config.doBgModel2:
                 exposures = self.focalPlaneBackground(camera, pool, dataIdList, self.config.bgModel2)
  
             # Persist camera-level image of calexp
             image = makeCameraImage(camera, exposures)
             expRef.put(image, "calexp_camera")
  
             pool.mapToPrevious(self.write, dataIdList)
  

◆ runQuantum()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.runQuantum	(	self,
		butlerQC,
		inputRefs,
		outputRefs
	)

Definition at line 202 of file skyCorrection.py.

     def runQuantum(self, butlerQC, inputRefs, outputRefs):
  
         # reorder skyCalibs and calBkgArray per calExpArray
         detectorOrder = [ref.dataId['detector'] for ref in inputRefs.calExpArray]
         inputRefs.skyCalibs = reorderAndPadList(inputRefs.skyCalibs,
                                                 [ref.dataId['detector'] for ref in inputRefs.skyCalibs],
                                                 detectorOrder)
         inputRefs.calBkgArray = reorderAndPadList(inputRefs.calBkgArray,
                                                   [ref.dataId['detector'] for ref in inputRefs.calBkgArray],
                                                   detectorOrder)
         outputRefs.skyCorr = reorderAndPadList(outputRefs.skyCorr,
                                                [ref.dataId['detector'] for ref in outputRefs.skyCorr],
                                                detectorOrder)
         inputs = butlerQC.get(inputRefs)
         inputs.pop("rawLinker", None)
         outputs = self.run(**inputs)
         butlerQC.put(outputs, outputRefs)
  

◆ subtractModel()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.subtractModel	(	self,
		cache,
		dataId,
		bgModel
	)

Subtract background model

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.
bgModel : `lsst.pipe.drivers.background.FocalPlaneBackround`
    Background model.

Returns
-------
exposure : `lsst.afw.image.Exposure`
    Resultant exposure.

Definition at line 643 of file skyCorrection.py.

     def subtractModel(self, cache, dataId, bgModel):
         """Subtract background model
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
         bgModel : `lsst.pipe.drivers.background.FocalPlaneBackround`
             Background model.
  
         Returns
         -------
         exposure : `lsst.afw.image.Exposure`
             Resultant exposure.
         """
         assert cache.dataId == dataId
         exposure = cache.exposure
         image = exposure.getMaskedImage()
         detector = exposure.getDetector()
         bbox = image.getBBox()
         try:
             cache.bgModel = bgModel.toCcdBackground(detector, bbox)
             image -= cache.bgModel.getImage()
         except RuntimeError:
             self.log.error(f"There was an error processing {dataId}, no calib file produced")
             return
         cache.bgList.append(cache.bgModel[0])
         return self.collect(cache)
  

◆ subtractModelRun()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.subtractModelRun	(	self,
		exposure,
		bgModel
	)

Serial implementation of self.subtractModel() for Gen3.

Load and restore background to calExp and calExpBkg.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to subtract the background model from.
bgModel : `lsst.pipe.drivers.background.FocalPlaneBackground`
    Full camera level background model.

Returns
-------
exposure : `lsst.afw.image.Exposure`
    Background subtracted input exposure.
bgModelCcd : `lsst.afw.math.BackgroundList`
    Detector level realization of the full background model.
bgModelMaskedImage : `lsst.afw.image.MaskedImage`
    Background model from the bgModelCcd realization.

Definition at line 676 of file skyCorrection.py.

     def subtractModelRun(self, exposure, bgModel):
         """Serial implementation of self.subtractModel() for Gen3.
  
         Load and restore background to calExp and calExpBkg.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.Exposure`
             Exposure to subtract the background model from.
         bgModel : `lsst.pipe.drivers.background.FocalPlaneBackground`
             Full camera level background model.
  
         Returns
         -------
         exposure : `lsst.afw.image.Exposure`
             Background subtracted input exposure.
         bgModelCcd : `lsst.afw.math.BackgroundList`
             Detector level realization of the full background model.
         bgModelMaskedImage : `lsst.afw.image.MaskedImage`
             Background model from the bgModelCcd realization.
         """
         image = exposure.getMaskedImage()
         detector = exposure.getDetector()
         bbox = image.getBBox()
         bgModelCcd = bgModel.toCcdBackground(detector, bbox)
         image -= bgModelCcd.getImage()
  
         return (exposure, bgModelCcd, bgModelCcd[0])
  

◆ subtractSkyFrame()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.subtractSkyFrame	(	self,
		cache,
		dataId,
		scale
	)

Subtract sky frame

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.
scale : `float`
    Scale for sky frame.

Returns
-------
exposure : `lsst.afw.image.Exposure`
    Resultant exposure.

Definition at line 598 of file skyCorrection.py.

     def subtractSkyFrame(self, cache, dataId, scale):
         """Subtract sky frame
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
         scale : `float`
             Scale for sky frame.
  
         Returns
         -------
         exposure : `lsst.afw.image.Exposure`
             Resultant exposure.
         """
         assert cache.dataId == dataId
         self.sky.subtractSkyFrame(cache.exposure.getMaskedImage(), cache.sky, scale, cache.bgList)
         return self.collect(cache)
  

◆ write()

def lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.write	(	self,
		cache,
		dataId
	)

Write resultant background list

This method runs on the slave nodes.

Parameters
----------
cache : `lsst.pipe.base.Struct`
    Process pool cache.
dataId : `dict`
    Data identifier.

Definition at line 838 of file skyCorrection.py.

     def write(self, cache, dataId):
         """Write resultant background list
  
         This method runs on the slave nodes.
  
         Parameters
         ----------
         cache : `lsst.pipe.base.Struct`
             Process pool cache.
         dataId : `dict`
             Data identifier.
         """
         cache.butler.put(cache.bgList, "skyCorr", dataId)
  

Member Data Documentation

◆ ConfigClass

lsst.pipe.drivers.skyCorrection.SkyCorrectionTask.ConfigClass = SkyCorrectionConfig

static

Definition at line 199 of file skyCorrection.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/pipe_drivers/22.0.0+1ea9a8b2b2/python/lsst/pipe/drivers/skyCorrection.py

Public Member Functions

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ accumulateModel()

◆ batchCommand()

◆ batchWallTime()

◆ collect()

◆ collectBinnedImage()

◆ collectMask()

◆ collectOriginal()

◆ collectSky()

◆ focalPlaneBackground()

◆ focalPlaneBackgroundRun()

◆ loadImage()

◆ loadImageRun()

◆ logOperation()

◆ measureSkyFrame()

◆ parseAndRun()

◆ parseAndSubmit()

◆ realiseModel()

◆ run()

◆ runDataRef()

◆ runQuantum()

◆ subtractModel()

◆ subtractModelRun()

◆ subtractSkyFrame()

◆ write()

Member Data Documentation

◆ ConfigClass

◆ init()