lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask Class Reference

Inheritance diagram for lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask:

Public Member Functions
def	__init__ (self, *args, **kwargs)
def	batchWallTime (cls, time, parsedCmd, numCores)
def	runDataRef (self, expRef)
def	readImage (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 = VisualizeVisitConfig

Detailed Description

Definition at line 75 of file visualizeVisit.py.

Constructor & Destructor Documentation

__init__()

def lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 79 of file visualizeVisit.py.

    def __init__(self, *args, **kwargs):
        BatchPoolTask.__init__(self, *args, **kwargs)
        self._storedButler = False  # Stored butler in the Pool? Doing this once increases efficiency
 

Member Function Documentation

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.visualizeVisit.VisualizeVisitTask.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 92 of file visualizeVisit.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
 

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

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)
 

readImage()

def lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask.readImage	(		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 136 of file visualizeVisit.py.

    def readImage(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)
        return (exposure.getDetector().getId(),
                afwMath.binImage(exposure.getMaskedImage(), self.config.binning))
 

runDataRef()

def lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask.runDataRef	(		self,
			expRef
	)

Generate an image of the entire visit

Only the master node executes this method; it controls the slave nodes,
which do the data retrieval.

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

Definition at line 110 of file visualizeVisit.py.

    def runDataRef(self, expRef):
        """Generate an image of the entire visit
 
        Only the master node executes this method; it controls the slave nodes,
        which do the data retrieval.
 
        Parameters
        ----------
        expRef : `lsst.daf.persistence.ButlerDataRef`
            Data reference for exposure.
        """
        pool = Pool()
 
        if not self._storedButler:
            pool.storeSet(butler=expRef.getButler())
 
        with self.logOperation("processing %s" % (expRef.dataId,)):
            camera = expRef.get("camera")
            dataIdList = [ccdRef.dataId for ccdRef in expRef.subItems("ccd") if
                          ccdRef.datasetExists("calexp")]
 
            exposures = pool.map(self.readImage, dataIdList)
            exposures = dict(keyValue for keyValue in exposures if keyValue is not None)
            image = makeCameraImage(camera, exposures, self.config.binning)
            expRef.put(image, "calexp_camera")
 

Member Data Documentation

ConfigClass

lsst.pipe.drivers.visualizeVisit.VisualizeVisitTask.ConfigClass = VisualizeVisitConfig

static

Definition at line 76 of file visualizeVisit.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+a28f4c53b1/python/lsst/pipe/drivers/visualizeVisit.py