lsst.pipe.tasks.calibrate.CalibrateTask Class Reference

Calibrate an exposure: measure sources and perform astrometric and photometric calibration. More...

Inheritance diagram for lsst.pipe.tasks.calibrate.CalibrateTask:

Public Member Functions
def	__init__ (self, butler=None, astromRefObjLoader=None, photoRefObjLoader=None, icSourceSchema=None, initInputs=None, **kwargs)
	Construct a CalibrateTask. More...
def	runDataRef (self, dataRef, exposure=None, background=None, icSourceCat=None, doUnpersist=True)
	Calibrate an exposure, optionally unpersisting inputs and persisting outputs. More...
def	runQuantum (self, butlerQC, inputRefs, outputRefs)
def	run (self, exposure, exposureIdInfo=None, background=None, icSourceCat=None)
	Calibrate an exposure (science image or coadd) More...
def	writeOutputs (self, dataRef, exposure, background, sourceCat, astromMatches, matchMeta)
def	getSchemaCatalogs (self)
def	setMetadata (self, exposure, photoRes=None)
	Set task and exposure metadata. More...
def	copyIcSourceFields (self, icSourceCat, sourceCat)
	Match sources in icSourceCat and sourceCat and copy the specified fields. More...

Public Attributes
	schemaMapper
	calibSourceKey
	schema
	algMetadata
	skySourceKey
	outputSchema

Static Public Attributes
	ConfigClass = CalibrateConfig
	RunnerClass = pipeBase.ButlerInitializedTaskRunner

Detailed Description

Calibrate an exposure: measure sources and perform astrometric and photometric calibration.

Contents

• pipe_tasks_calibrate_Purpose
• pipe_tasks_calibrate_Initialize
• pipe_tasks_calibrate_IO
• pipe_tasks_calibrate_Config
• pipe_tasks_calibrate_Metadata
• pipe_tasks_calibrate_Debug

@section pipe_tasks_calibrate_Purpose  Description

Given an exposure with a good PSF model and aperture correction map
(e.g. as provided by @ref CharacterizeImageTask), perform the following
 operations:
- Run detection and measurement
- Run astrometry subtask to fit an improved WCS
- Run photoCal subtask to fit the exposure's photometric zero-point

@section pipe_tasks_calibrate_Initialize  Task initialisation

@copydoc \_\_init\_\_

@section pipe_tasks_calibrate_IO  Invoking the Task

If you want this task to unpersist inputs or persist outputs, then call
the `runDataRef` method (a wrapper around the `run` method).

If you already have the inputs unpersisted and do not want to persist the
output then it is more direct to call the `run` method:

@section pipe_tasks_calibrate_Config  Configuration parameters

See @ref CalibrateConfig

@section pipe_tasks_calibrate_Metadata  Quantities set in exposure Metadata

Exposure metadata
<dl>
    <dt>MAGZERO_RMS  <dd>MAGZERO's RMS == sigma reported by photoCal task
    <dt>MAGZERO_NOBJ <dd>Number of stars used == ngood reported by photoCal
                         task
    <dt>COLORTERM1   <dd>?? (always 0.0)
    <dt>COLORTERM2   <dd>?? (always 0.0)
    <dt>COLORTERM3   <dd>?? (always 0.0)
</dl>

@section pipe_tasks_calibrate_Debug  Debug variables

The @link lsst.pipe.base.cmdLineTask.CmdLineTask command line task@endlink
interface supports a flag
`--debug` to import `debug.py` from your `$PYTHONPATH`; see @ref baseDebug
for more about `debug.py`.

CalibrateTask has a debug dictionary containing one key:
<dl>
<dt>calibrate
<dd>frame (an int; <= 0 to not display) in which to display the exposure,
    sources and matches. See @ref lsst.meas.astrom.displayAstrometry for
    the meaning of the various symbols.
</dl>

For example, put something like:
@code{.py}
    import lsstDebug
    def DebugInfo(name):
        di = lsstDebug.getInfo(name)  # N.b. lsstDebug.Info(name) would
                                      # call us recursively
        if name == "lsst.pipe.tasks.calibrate":
            di.display = dict(
                calibrate = 1,
            )

        return di

    lsstDebug.Info = DebugInfo
@endcode
into your `debug.py` file and run `calibrateTask.py` with the `--debug`
flag.

Some subtasks may have their own debug variables; see individual Task
documentation.

Definition at line 337 of file calibrate.py.

Constructor & Destructor Documentation

__init__()

def lsst.pipe.tasks.calibrate.CalibrateTask.__init__	(		self,
			butler = None,
			astromRefObjLoader = None,
			photoRefObjLoader = None,
			icSourceSchema = None,
			initInputs = None,
		**	kwargs
	)

Construct a CalibrateTask.

    @param[in] butler  The butler is passed to the refObjLoader constructor
        in case it is needed.  Ignored if the refObjLoader argument
        provides a loader directly.
    @param[in] astromRefObjLoader  An instance of LoadReferenceObjectsTasks
        that supplies an external reference catalog for astrometric
        calibration.  May be None if the desired loader can be constructed
        from the butler argument or all steps requiring a reference catalog
        are disabled.
    @param[in] photoRefObjLoader  An instance of LoadReferenceObjectsTasks
        that supplies an external reference catalog for photometric
        calibration.  May be None if the desired loader can be constructed
        from the butler argument or all steps requiring a reference catalog
        are disabled.
    @param[in] icSourceSchema  schema for icSource catalog, or None.
        Schema values specified in config.icSourceFieldsToCopy will be
        taken from this schema. If set to None, no values will be
        propagated from the icSourceCatalog
    @param[in,out] kwargs  other keyword arguments for
        lsst.pipe.base.CmdLineTask

Definition at line 434 of file calibrate.py.

                 initInputs=None, **kwargs):
        """!Construct a CalibrateTask
 
        @param[in] butler  The butler is passed to the refObjLoader constructor
            in case it is needed.  Ignored if the refObjLoader argument
            provides a loader directly.
        @param[in] astromRefObjLoader  An instance of LoadReferenceObjectsTasks
            that supplies an external reference catalog for astrometric
            calibration.  May be None if the desired loader can be constructed
            from the butler argument or all steps requiring a reference catalog
            are disabled.
        @param[in] photoRefObjLoader  An instance of LoadReferenceObjectsTasks
            that supplies an external reference catalog for photometric
            calibration.  May be None if the desired loader can be constructed
            from the butler argument or all steps requiring a reference catalog
            are disabled.
        @param[in] icSourceSchema  schema for icSource catalog, or None.
            Schema values specified in config.icSourceFieldsToCopy will be
            taken from this schema. If set to None, no values will be
            propagated from the icSourceCatalog
        @param[in,out] kwargs  other keyword arguments for
            lsst.pipe.base.CmdLineTask
        """
        super().__init__(**kwargs)
 
        if icSourceSchema is None and butler is not None:
            # Use butler to read icSourceSchema from disk.
            icSourceSchema = butler.get("icSrc_schema", immediate=True).schema
 
        if icSourceSchema is None and butler is None and initInputs is not None:
            icSourceSchema = initInputs['icSourceSchema'].schema
 
        if icSourceSchema is not None:
            # use a schema mapper to avoid copying each field separately
            self.schemaMapper = afwTable.SchemaMapper(icSourceSchema)
            minimumSchema = afwTable.SourceTable.makeMinimalSchema()
            self.schemaMapper.addMinimalSchema(minimumSchema, False)
 
            # Add fields to copy from an icSource catalog
            # and a field to indicate that the source matched a source in that
            # catalog. If any fields are missing then raise an exception, but
            # first find all missing fields in order to make the error message
            # more useful.
            self.calibSourceKey = self.schemaMapper.addOutputField(
                afwTable.Field["Flag"]("calib_detected",
                                       "Source was detected as an icSource"))
            missingFieldNames = []
            for fieldName in self.config.icSourceFieldsToCopy:
                try:
                    schemaItem = icSourceSchema.find(fieldName)
                except Exception:
                    missingFieldNames.append(fieldName)
                else:
                    # field found; if addMapping fails then raise an exception
                    self.schemaMapper.addMapping(schemaItem.getKey())
 
            if missingFieldNames:
                raise RuntimeError("isSourceCat is missing fields {} "
                                   "specified in icSourceFieldsToCopy"
                                   .format(missingFieldNames))
 
            # produce a temporary schema to pass to the subtasks; finalize it
            # later
            self.schema = self.schemaMapper.editOutputSchema()
        else:
            self.schemaMapper = None
            self.schema = afwTable.SourceTable.makeMinimalSchema()
        self.makeSubtask('detection', schema=self.schema)
 
        self.algMetadata = dafBase.PropertyList()
 
        # Only create a subtask for fakes if configuration option is set
        # N.B. the config for fake object task must be retargeted to a child
        # of BaseFakeSourcesTask
        if self.config.doInsertFakes:
            self.makeSubtask("insertFakes")
 
        if self.config.doDeblend:
            self.makeSubtask("deblend", schema=self.schema)
        if self.config.doSkySources:
            self.makeSubtask("skySources")
            self.skySourceKey = self.schema.addField("sky_source", type="Flag", doc="Sky objects.")
        self.makeSubtask('measurement', schema=self.schema,
                         algMetadata=self.algMetadata)
        self.makeSubtask("setPrimaryFlags", schema=self.schema, isSingleFrame=True)
        if self.config.doApCorr:
            self.makeSubtask('applyApCorr', schema=self.schema)
        self.makeSubtask('catalogCalculation', schema=self.schema)
 
        if self.config.doAstrometry:
            if astromRefObjLoader is None and butler is not None:
                self.makeSubtask('astromRefObjLoader', butler=butler)
                astromRefObjLoader = self.astromRefObjLoader
            self.makeSubtask("astrometry", refObjLoader=astromRefObjLoader,
                             schema=self.schema)
        if self.config.doPhotoCal:
            if photoRefObjLoader is None and butler is not None:
                self.makeSubtask('photoRefObjLoader', butler=butler)
                photoRefObjLoader = self.photoRefObjLoader
            self.makeSubtask("photoCal", refObjLoader=photoRefObjLoader,
                             schema=self.schema)
        if self.config.doComputeSummaryStats:
            self.makeSubtask('computeSummaryStats')
 
        if initInputs is not None and (astromRefObjLoader is not None or photoRefObjLoader is not None):
            raise RuntimeError("PipelineTask form of this task should not be initialized with "
                               "reference object loaders.")
 
        if self.schemaMapper is not None:
            # finalize the schema
            self.schema = self.schemaMapper.getOutputSchema()
        self.schema.checkUnits(parse_strict=self.config.checkUnitsParseStrict)
 
        sourceCatSchema = afwTable.SourceCatalog(self.schema)
        sourceCatSchema.getTable().setMetadata(self.algMetadata)
        self.outputSchema = sourceCatSchema
 

Member Function Documentation

copyIcSourceFields()

def lsst.pipe.tasks.calibrate.CalibrateTask.copyIcSourceFields	(		self,
			icSourceCat,
			sourceCat
	)

Match sources in icSourceCat and sourceCat and copy the specified fields.

    @param[in] icSourceCat  catalog from which to copy fields
    @param[in,out] sourceCat  catalog to which to copy fields

    The fields copied are those specified by `config.icSourceFieldsToCopy`
    that actually exist in the schema. This was set up by the constructor
    using self.schemaMapper.

Definition at line 888 of file calibrate.py.

    def copyIcSourceFields(self, icSourceCat, sourceCat):
        """!Match sources in icSourceCat and sourceCat and copy the specified fields
 
        @param[in] icSourceCat  catalog from which to copy fields
        @param[in,out] sourceCat  catalog to which to copy fields
 
        The fields copied are those specified by `config.icSourceFieldsToCopy`
        that actually exist in the schema. This was set up by the constructor
        using self.schemaMapper.
        """
        if self.schemaMapper is None:
            raise RuntimeError("To copy icSource fields you must specify "
                               "icSourceSchema nd icSourceKeys when "
                               "constructing this task")
        if icSourceCat is None or sourceCat is None:
            raise RuntimeError("icSourceCat and sourceCat must both be "
                               "specified")
        if len(self.config.icSourceFieldsToCopy) == 0:
            self.log.warning("copyIcSourceFields doing nothing because "
                             "icSourceFieldsToCopy is empty")
            return
 
        mc = afwTable.MatchControl()
        mc.findOnlyClosest = False  # return all matched objects
        matches = afwTable.matchXy(icSourceCat, sourceCat,
                                   self.config.matchRadiusPix, mc)
        if self.config.doDeblend:
            deblendKey = sourceCat.schema["deblend_nChild"].asKey()
            # if deblended, keep children
            matches = [m for m in matches if m[1].get(deblendKey) == 0]
 
        # Because we had to allow multiple matches to handle parents, we now
        # need to prune to the best matches
        # closest matches as a dict of icSourceCat source ID:
        # (icSourceCat source, sourceCat source, distance in pixels)
        bestMatches = {}
        for m0, m1, d in matches:
            id0 = m0.getId()
            match = bestMatches.get(id0)
            if match is None or d <= match[2]:
                bestMatches[id0] = (m0, m1, d)
        matches = list(bestMatches.values())
 
        # Check that no sourceCat sources are listed twice (we already know
        # that each match has a unique icSourceCat source ID, due to using
        # that ID as the key in bestMatches)
        numMatches = len(matches)
        numUniqueSources = len(set(m[1].getId() for m in matches))
        if numUniqueSources != numMatches:
            self.log.warning("%d icSourceCat sources matched only %d sourceCat "
                             "sources", numMatches, numUniqueSources)
 
        self.log.info("Copying flags from icSourceCat to sourceCat for "
                      "%d sources", numMatches)
 
        # For each match: set the calibSourceKey flag and copy the desired
        # fields
        for icSrc, src, d in matches:
            src.setFlag(self.calibSourceKey, True)
            # src.assign copies the footprint from icSrc, which we don't want
            # (DM-407)
            # so set icSrc's footprint to src's footprint before src.assign,
            # then restore it
            icSrcFootprint = icSrc.getFootprint()
            try:
                icSrc.setFootprint(src.getFootprint())
                src.assign(icSrc, self.schemaMapper)
            finally:
                icSrc.setFootprint(icSrcFootprint)

getSchemaCatalogs()

def lsst.pipe.tasks.calibrate.CalibrateTask.getSchemaCatalogs

(

self

)

Return a dict of empty catalogs for each catalog dataset produced
by this task.

Definition at line 847 of file calibrate.py.

    def getSchemaCatalogs(self):
        """Return a dict of empty catalogs for each catalog dataset produced
        by this task.
        """
        sourceCat = afwTable.SourceCatalog(self.schema)
        sourceCat.getTable().setMetadata(self.algMetadata)
        return {"src": sourceCat}
 

run()

def lsst.pipe.tasks.calibrate.CalibrateTask.run	(		self,
			exposure,
			exposureIdInfo = None,
			background = None,
			icSourceCat = None
	)

Calibrate an exposure (science image or coadd)

    @param[in,out] exposure  exposure to calibrate (an
        lsst.afw.image.ExposureF or similar);
        in:
        - MaskedImage
        - Psf
        out:
        - MaskedImage has background subtracted
        - Wcs is replaced
        - PhotoCalib is replaced
    @param[in] exposureIdInfo  ID info for exposure (an
        lsst.obs.base.ExposureIdInfo) If not provided, returned
        SourceCatalog IDs will not be globally unique.
    @param[in,out] background  background model already subtracted from
        exposure (an lsst.afw.math.BackgroundList). May be None if no
        background has been subtracted, though that is unusual for
        calibration. A refined background model is output.
    @param[in] icSourceCat  A SourceCatalog from CharacterizeImageTask
        from which we can copy some fields.

    @return pipe_base Struct containing these fields:
    - exposure  calibrate science exposure with refined WCS and PhotoCalib
    - background  model of background subtracted from exposure (an
      lsst.afw.math.BackgroundList)
    - sourceCat  catalog of measured sources
    - astromMatches  list of source/refObj matches from the astrometry
      solver

Definition at line 648 of file calibrate.py.

            icSourceCat=None):
        """!Calibrate an exposure (science image or coadd)
 
        @param[in,out] exposure  exposure to calibrate (an
            lsst.afw.image.ExposureF or similar);
            in:
            - MaskedImage
            - Psf
            out:
            - MaskedImage has background subtracted
            - Wcs is replaced
            - PhotoCalib is replaced
        @param[in] exposureIdInfo  ID info for exposure (an
            lsst.obs.base.ExposureIdInfo) If not provided, returned
            SourceCatalog IDs will not be globally unique.
        @param[in,out] background  background model already subtracted from
            exposure (an lsst.afw.math.BackgroundList). May be None if no
            background has been subtracted, though that is unusual for
            calibration. A refined background model is output.
        @param[in] icSourceCat  A SourceCatalog from CharacterizeImageTask
            from which we can copy some fields.
 
        @return pipe_base Struct containing these fields:
        - exposure  calibrate science exposure with refined WCS and PhotoCalib
        - background  model of background subtracted from exposure (an
          lsst.afw.math.BackgroundList)
        - sourceCat  catalog of measured sources
        - astromMatches  list of source/refObj matches from the astrometry
          solver
        """
        # detect, deblend and measure sources
        if exposureIdInfo is None:
            exposureIdInfo = ExposureIdInfo()
 
        if background is None:
            background = BackgroundList()
        sourceIdFactory = exposureIdInfo.makeSourceIdFactory()
        table = SourceTable.make(self.schema, sourceIdFactory)
        table.setMetadata(self.algMetadata)
 
        detRes = self.detection.run(table=table, exposure=exposure,
                                    doSmooth=True)
        sourceCat = detRes.sources
        if detRes.fpSets.background:
            for bg in detRes.fpSets.background:
                background.append(bg)
        if self.config.doSkySources:
            skySourceFootprints = self.skySources.run(mask=exposure.mask, seed=exposureIdInfo.expId)
            if skySourceFootprints:
                for foot in skySourceFootprints:
                    s = sourceCat.addNew()
                    s.setFootprint(foot)
                    s.set(self.skySourceKey, True)
        if self.config.doDeblend:
            self.deblend.run(exposure=exposure, sources=sourceCat)
        self.measurement.run(
            measCat=sourceCat,
            exposure=exposure,
            exposureId=exposureIdInfo.expId
        )
        if self.config.doApCorr:
            self.applyApCorr.run(
                catalog=sourceCat,
                apCorrMap=exposure.getInfo().getApCorrMap()
            )
        self.catalogCalculation.run(sourceCat)
 
        self.setPrimaryFlags.run(sourceCat)
 
        if icSourceCat is not None and \
           len(self.config.icSourceFieldsToCopy) > 0:
            self.copyIcSourceFields(icSourceCat=icSourceCat,
                                    sourceCat=sourceCat)
 
        # TODO DM-11568: this contiguous check-and-copy could go away if we
        # reserve enough space during SourceDetection and/or SourceDeblend.
        # NOTE: sourceSelectors require contiguous catalogs, so ensure
        # contiguity now, so views are preserved from here on.
        if not sourceCat.isContiguous():
            sourceCat = sourceCat.copy(deep=True)
 
        # perform astrometry calibration:
        # fit an improved WCS and update the exposure's WCS in place
        astromMatches = None
        matchMeta = None
        if self.config.doAstrometry:
            try:
                astromRes = self.astrometry.run(
                    exposure=exposure,
                    sourceCat=sourceCat,
                )
                astromMatches = astromRes.matches
                matchMeta = astromRes.matchMeta
            except Exception as e:
                if self.config.requireAstrometry:
                    raise
                self.log.warning("Unable to perform astrometric calibration "
                                 "(%s): attempting to proceed", e)
 
        # compute photometric calibration
        if self.config.doPhotoCal:
            try:
                photoRes = self.photoCal.run(exposure, sourceCat=sourceCat, expId=exposureIdInfo.expId)
                exposure.setPhotoCalib(photoRes.photoCalib)
                # TODO: reword this to phrase it in terms of the calibration factor?
                self.log.info("Photometric zero-point: %f",
                              photoRes.photoCalib.instFluxToMagnitude(1.0))
                self.setMetadata(exposure=exposure, photoRes=photoRes)
            except Exception as e:
                if self.config.requirePhotoCal:
                    raise
                self.log.warning("Unable to perform photometric calibration "
                                 "(%s): attempting to proceed", e)
                self.setMetadata(exposure=exposure, photoRes=None)
 
        if self.config.doInsertFakes:
            self.insertFakes.run(exposure, background=background)
 
            table = SourceTable.make(self.schema, sourceIdFactory)
            table.setMetadata(self.algMetadata)
 
            detRes = self.detection.run(table=table, exposure=exposure,
                                        doSmooth=True)
            sourceCat = detRes.sources
            if detRes.fpSets.background:
                for bg in detRes.fpSets.background:
                    background.append(bg)
            if self.config.doDeblend:
                self.deblend.run(exposure=exposure, sources=sourceCat)
            self.measurement.run(
                measCat=sourceCat,
                exposure=exposure,
                exposureId=exposureIdInfo.expId
            )
            if self.config.doApCorr:
                self.applyApCorr.run(
                    catalog=sourceCat,
                    apCorrMap=exposure.getInfo().getApCorrMap()
                )
            self.catalogCalculation.run(sourceCat)
 
            if icSourceCat is not None and len(self.config.icSourceFieldsToCopy) > 0:
                self.copyIcSourceFields(icSourceCat=icSourceCat,
                                        sourceCat=sourceCat)
 
        if self.config.doComputeSummaryStats:
            summary = self.computeSummaryStats.run(exposure=exposure,
                                                   sources=sourceCat,
                                                   background=background)
            exposure.getInfo().setSummaryStats(summary)
 
        frame = getDebugFrame(self._display, "calibrate")
        if frame:
            displayAstrometry(
                sourceCat=sourceCat,
                exposure=exposure,
                matches=astromMatches,
                frame=frame,
                pause=False,
            )
 
        return pipeBase.Struct(
            exposure=exposure,
            background=background,
            sourceCat=sourceCat,
            astromMatches=astromMatches,
            matchMeta=matchMeta,
            # These are duplicate entries with different names for use with
            # gen3 middleware
            outputExposure=exposure,
            outputCat=sourceCat,
            outputBackground=background,
        )
 

runDataRef()

def lsst.pipe.tasks.calibrate.CalibrateTask.runDataRef	(		self,
			dataRef,
			exposure = None,
			background = None,
			icSourceCat = None,
			doUnpersist = True
	)

Calibrate an exposure, optionally unpersisting inputs and persisting outputs.

This is a wrapper around the run method that unpersists inputs (if doUnpersist true) and persists outputs (if config.doWrite true)

Parameters

[in]	dataRef	butler data reference corresponding to a science image
[in,out]	exposure	characterized exposure (an lsst.afw.image.ExposureF or similar), or None to unpersist existing icExp and icBackground. See run method for details of what is read and written.
[in,out]	background	initial model of background already subtracted from exposure (an lsst.afw.math.BackgroundList). May be None if no background has been subtracted, though that is unusual for calibration. A refined background model is output. Ignored if exposure is None.
[in]	icSourceCat	catalog from which to copy the fields specified by icSourceKeys, or None;
[in]	doUnpersist	unpersist data: if True, exposure, background and icSourceCat are read from dataRef and those three arguments must all be None; if False the exposure must be provided; background and icSourceCat are optional. True is intended for running as a command-line task, False for running as a subtask

Returns

same data as the calibrate method

Definition at line 554 of file calibrate.py.

                   doUnpersist=True):
        """!Calibrate an exposure, optionally unpersisting inputs and
            persisting outputs.
 
        This is a wrapper around the `run` method that unpersists inputs
        (if `doUnpersist` true) and persists outputs (if `config.doWrite` true)
 
        @param[in] dataRef  butler data reference corresponding to a science
            image
        @param[in,out] exposure  characterized exposure (an
            lsst.afw.image.ExposureF or similar), or None to unpersist existing
            icExp and icBackground. See `run` method for details of what is
            read and written.
        @param[in,out] background  initial model of background already
            subtracted from exposure (an lsst.afw.math.BackgroundList). May be
            None if no background has been subtracted, though that is unusual
            for calibration. A refined background model is output. Ignored if
            exposure is None.
        @param[in] icSourceCat  catalog from which to copy the fields specified
            by icSourceKeys, or None;
        @param[in] doUnpersist  unpersist data:
            - if True, exposure, background and icSourceCat are read from
              dataRef and those three arguments must all be None;
            - if False the exposure must be provided; background and
              icSourceCat are optional. True is intended for running as a
              command-line task, False for running as a subtask
        @return same data as the calibrate method
        """
        self.log.info("Processing %s", dataRef.dataId)
 
        if doUnpersist:
            if any(item is not None for item in (exposure, background,
                                                 icSourceCat)):
                raise RuntimeError("doUnpersist true; exposure, background "
                                   "and icSourceCat must all be None")
            exposure = dataRef.get("icExp", immediate=True)
            background = dataRef.get("icExpBackground", immediate=True)
            icSourceCat = dataRef.get("icSrc", immediate=True)
        elif exposure is None:
            raise RuntimeError("doUnpersist false; exposure must be provided")
 
        exposureIdInfo = dataRef.get("expIdInfo")
 
        calRes = self.run(
            exposure=exposure,
            exposureIdInfo=exposureIdInfo,
            background=background,
            icSourceCat=icSourceCat,
        )
 
        if self.config.doWrite:
            self.writeOutputs(
                dataRef=dataRef,
                exposure=calRes.exposure,
                background=calRes.background,
                sourceCat=calRes.sourceCat,
                astromMatches=calRes.astromMatches,
                matchMeta=calRes.matchMeta,
            )
 
        return calRes
 

runQuantum()

def lsst.pipe.tasks.calibrate.CalibrateTask.runQuantum	(		self,
			butlerQC,
			inputRefs,
			outputRefs
	)

Definition at line 617 of file calibrate.py.

    def runQuantum(self, butlerQC, inputRefs, outputRefs):
        inputs = butlerQC.get(inputRefs)
        inputs['exposureIdInfo'] = ExposureIdInfo.fromDataId(butlerQC.quantum.dataId, "visit_detector")
 
        if self.config.doAstrometry:
            refObjLoader = ReferenceObjectLoader(dataIds=[ref.datasetRef.dataId
                                                          for ref in inputRefs.astromRefCat],
                                                 refCats=inputs.pop('astromRefCat'),
                                                 config=self.config.astromRefObjLoader, log=self.log)
            self.astrometry.setRefObjLoader(refObjLoader)
 
        if self.config.doPhotoCal:
            photoRefObjLoader = ReferenceObjectLoader(dataIds=[ref.datasetRef.dataId
                                                      for ref in inputRefs.photoRefCat],
                                                      refCats=inputs.pop('photoRefCat'),
                                                      config=self.config.photoRefObjLoader,
                                                      log=self.log)
            self.photoCal.match.setRefObjLoader(photoRefObjLoader)
 
        outputs = self.run(**inputs)
 
        if self.config.doWriteMatches and self.config.doAstrometry:
            normalizedMatches = afwTable.packMatches(outputs.astromMatches)
            normalizedMatches.table.setMetadata(outputs.matchMeta)
            if self.config.doWriteMatchesDenormalized:
                denormMatches = denormalizeMatches(outputs.astromMatches, outputs.matchMeta)
                outputs.matchesDenormalized = denormMatches
            outputs.matches = normalizedMatches
        butlerQC.put(outputs, outputRefs)
 

setMetadata()

def lsst.pipe.tasks.calibrate.CalibrateTask.setMetadata	(		self,
			exposure,
			photoRes = None
	)

Set task and exposure metadata.

    Logs a warning and continues if needed data is missing.

    @param[in,out] exposure  exposure whose metadata is to be set
    @param[in]  photoRes  results of running photoCal; if None then it was
        not run

Definition at line 855 of file calibrate.py.

    def setMetadata(self, exposure, photoRes=None):
        """!Set task and exposure metadata
 
        Logs a warning and continues if needed data is missing.
 
        @param[in,out] exposure  exposure whose metadata is to be set
        @param[in]  photoRes  results of running photoCal; if None then it was
            not run
        """
        if photoRes is None:
            return
 
        metadata = exposure.getMetadata()
 
        # convert zero-point to (mag/sec/adu) for task MAGZERO metadata
        try:
            exposureTime = exposure.getInfo().getVisitInfo().getExposureTime()
            magZero = photoRes.zp - 2.5*math.log10(exposureTime)
        except Exception:
            self.log.warning("Could not set normalized MAGZERO in header: no "
                             "exposure time")
            magZero = math.nan
 
        try:
            metadata.set('MAGZERO', magZero)
            metadata.set('MAGZERO_RMS', photoRes.sigma)
            metadata.set('MAGZERO_NOBJ', photoRes.ngood)
            metadata.set('COLORTERM1', 0.0)
            metadata.set('COLORTERM2', 0.0)
            metadata.set('COLORTERM3', 0.0)
        except Exception as e:
            self.log.warning("Could not set exposure metadata: %s", e)
 

writeOutputs()

def lsst.pipe.tasks.calibrate.CalibrateTask.writeOutputs	(		self,
			dataRef,
			exposure,
			background,
			sourceCat,
			astromMatches,
			matchMeta
	)

Write output data to the output repository

@param[in] dataRef  butler data reference corresponding to a science
    image
@param[in] exposure  exposure to write
@param[in] background  background model for exposure
@param[in] sourceCat  catalog of measured sources
@param[in] astromMatches  list of source/refObj matches from the
    astrometry solver

Definition at line 823 of file calibrate.py.

                     astromMatches, matchMeta):
        """Write output data to the output repository
 
        @param[in] dataRef  butler data reference corresponding to a science
            image
        @param[in] exposure  exposure to write
        @param[in] background  background model for exposure
        @param[in] sourceCat  catalog of measured sources
        @param[in] astromMatches  list of source/refObj matches from the
            astrometry solver
        """
        dataRef.put(sourceCat, "src")
        if self.config.doWriteMatches and astromMatches is not None:
            normalizedMatches = afwTable.packMatches(astromMatches)
            normalizedMatches.table.setMetadata(matchMeta)
            dataRef.put(normalizedMatches, "srcMatch")
            if self.config.doWriteMatchesDenormalized:
                denormMatches = denormalizeMatches(astromMatches, matchMeta)
                dataRef.put(denormMatches, "srcMatchFull")
        if self.config.doWriteExposure:
            dataRef.put(exposure, "calexp")
            dataRef.put(background, "calexpBackground")
 

Member Data Documentation

algMetadata

lsst.pipe.tasks.calibrate.CalibrateTask.algMetadata

Definition at line 505 of file calibrate.py.

calibSourceKey

lsst.pipe.tasks.calibrate.CalibrateTask.calibSourceKey

Definition at line 479 of file calibrate.py.

ConfigClass

lsst.pipe.tasks.calibrate.CalibrateTask.ConfigClass = CalibrateConfig

static

Definition at line 430 of file calibrate.py.

outputSchema

lsst.pipe.tasks.calibrate.CalibrateTask.outputSchema

Definition at line 551 of file calibrate.py.

RunnerClass

lsst.pipe.tasks.calibrate.CalibrateTask.RunnerClass = pipeBase.ButlerInitializedTaskRunner

static

Definition at line 432 of file calibrate.py.

schema

lsst.pipe.tasks.calibrate.CalibrateTask.schema

Definition at line 499 of file calibrate.py.

schemaMapper

lsst.pipe.tasks.calibrate.CalibrateTask.schemaMapper

Definition at line 470 of file calibrate.py.

skySourceKey

lsst.pipe.tasks.calibrate.CalibrateTask.skySourceKey

Definition at line 517 of file calibrate.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/pipe_tasks/21.0.0-172-gfb10e10a+18fedfabac/python/lsst/pipe/tasks/calibrate.py