lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask Class Reference

Inheritance diagram for lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask:

Public Member Functions
def	run (self, exposure, sources, background)

Static Public Attributes
	ConfigClass = ComputeExposureSummaryStatsConfig

Detailed Description

Task to compute exposure summary statistics.

This task computes various quantities suitable for DPDD and other
downstream processing at the detector centers, including:
- psfSigma
- psfArea
- psfIxx
- psfIyy
- psfIxy
- ra
- decl
- zenithDistance
- zeroPoint
- skyBg
- skyNoise
- meanVar
- raCorners
- decCorners
- astromOffsetMean
- astromOffsetStd

These additional quantities are computed from the stars in the detector:
- psfStarDeltaE1Median
- psfStarDeltaE2Median
- psfStarDeltaE1Scatter
- psfStarDeltaE2Scatter
- psfStarDeltaSizeMedian
- psfStarDeltaSizeScatter
- psfStarScaledDeltaSizeScatter

Definition at line 74 of file computeExposureSummaryStats.py.

Member Function Documentation

run()

def lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.run	(		self,
			exposure,
			sources,
			background
	)

Measure exposure statistics from the exposure, sources, and background.

Parameters
----------
exposure : `lsst.afw.image.ExposureF`
sources : `lsst.afw.table.SourceCatalog`
background : `lsst.afw.math.BackgroundList`

Returns
-------
summary : `lsst.afw.image.ExposureSummary`

Definition at line 109 of file computeExposureSummaryStats.py.

    def run(self, exposure, sources, background):
        """Measure exposure statistics from the exposure, sources, and background.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.ExposureF`
        sources : `lsst.afw.table.SourceCatalog`
        background : `lsst.afw.math.BackgroundList`
 
        Returns
        -------
        summary : `lsst.afw.image.ExposureSummary`
        """
        self.log.info("Measuring exposure statistics")
 
        bbox = exposure.getBBox()
 
        psf = exposure.getPsf()
        if psf is not None:
            shape = psf.computeShape(bbox.getCenter())
            psfSigma = shape.getDeterminantRadius()
            psfIxx = shape.getIxx()
            psfIyy = shape.getIyy()
            psfIxy = shape.getIxy()
            im = psf.computeKernelImage(bbox.getCenter())
            # The calculation of effective psf area is taken from
            # meas_base/src/PsfFlux.cc#L112. See
            # https://github.com/lsst/meas_base/blob/
            # 750bffe6620e565bda731add1509507f5c40c8bb/src/PsfFlux.cc#L112
            psfArea = np.sum(im.array)/np.sum(im.array**2.)
        else:
            psfSigma = np.nan
            psfIxx = np.nan
            psfIyy = np.nan
            psfIxy = np.nan
            psfArea = np.nan
 
        wcs = exposure.getWcs()
        if wcs is not None:
            sph_pts = wcs.pixelToSky(lsst.geom.Box2D(bbox).getCorners())
            raCorners = [float(sph.getRa().asDegrees()) for sph in sph_pts]
            decCorners = [float(sph.getDec().asDegrees()) for sph in sph_pts]
 
            sph_pt = wcs.pixelToSky(bbox.getCenter())
            ra = sph_pt.getRa().asDegrees()
            decl = sph_pt.getDec().asDegrees()
        else:
            raCorners = [float(np.nan)]*4
            decCorners = [float(np.nan)]*4
            ra = np.nan
            decl = np.nan
 
        photoCalib = exposure.getPhotoCalib()
        if photoCalib is not None:
            zeroPoint = 2.5*np.log10(photoCalib.getInstFluxAtZeroMagnitude())
        else:
            zeroPoint = np.nan
 
        visitInfo = exposure.getInfo().getVisitInfo()
        date = visitInfo.getDate()
 
        if date.isValid():
            # We compute the zenithDistance at the center of the detector rather
            # than use the boresight value available via the visitInfo, because
            # the zenithDistance may vary significantly over a large field of view.
            observatory = visitInfo.getObservatory()
            loc = EarthLocation(lat=observatory.getLatitude().asDegrees()*units.deg,
                                lon=observatory.getLongitude().asDegrees()*units.deg,
                                height=observatory.getElevation()*units.m)
            obstime = Time(visitInfo.getDate().get(system=DateTime.MJD),
                           location=loc, format='mjd')
            coord = SkyCoord(ra*units.degree, decl*units.degree, obstime=obstime, location=loc)
            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                altaz = coord.transform_to(AltAz)
 
            zenithDistance = 90.0 - altaz.alt.degree
        else:
            zenithDistance = np.nan
 
        if background is not None:
            bgStats = (bg[0].getStatsImage().getImage().array
                       for bg in background)
            skyBg = sum(np.median(bg[np.isfinite(bg)]) for bg in bgStats)
        else:
            skyBg = np.nan
 
        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setNumSigmaClip(self.config.sigmaClip)
        statsCtrl.setNumIter(self.config.clipIter)
        statsCtrl.setAndMask(afwImage.Mask.getPlaneBitMask(self.config.badMaskPlanes))
        statsCtrl.setNanSafe(True)
 
        statObj = afwMath.makeStatistics(exposure.getMaskedImage(), afwMath.STDEVCLIP,
                                         statsCtrl)
        skyNoise, _ = statObj.getResult(afwMath.STDEVCLIP)
 
        statObj = afwMath.makeStatistics(exposure.getMaskedImage().getVariance(),
                                         exposure.getMaskedImage().getMask(),
                                         afwMath.MEANCLIP, statsCtrl)
        meanVar, _ = statObj.getResult(afwMath.MEANCLIP)
 
        md = exposure.getMetadata()
        if 'SFM_ASTROM_OFFSET_MEAN' in md:
            astromOffsetMean = md['SFM_ASTROM_OFFSET_MEAN']
            astromOffsetStd = md['SFM_ASTROM_OFFSET_STD']
        else:
            astromOffsetMean = np.nan
            astromOffsetStd = np.nan
 
        psfStats = self._computePsfStats(sources)
 
        # Note that all numpy values have to be explicitly converted to
        # python floats for yaml serialization.
        summary = afwImage.ExposureSummaryStats(
            psfSigma=float(psfSigma),
            psfArea=float(psfArea),
            psfIxx=float(psfIxx),
            psfIyy=float(psfIyy),
            psfIxy=float(psfIxy),
            ra=float(ra),
            decl=float(decl),
            zenithDistance=float(zenithDistance),
            zeroPoint=float(zeroPoint),
            skyBg=float(skyBg),
            skyNoise=float(skyNoise),
            meanVar=float(meanVar),
            raCorners=raCorners,
            decCorners=decCorners,
            astromOffsetMean=astromOffsetMean,
            astromOffsetStd=astromOffsetStd,
            nPsfStar=psfStats.nPsfStar,
            psfStarDeltaE1Median=psfStats.psfStarDeltaE1Median,
            psfStarDeltaE2Median=psfStats.psfStarDeltaE2Median,
            psfStarDeltaE1Scatter=psfStats.psfStarDeltaE1Scatter,
            psfStarDeltaE2Scatter=psfStats.psfStarDeltaE2Scatter,
            psfStarDeltaSizeMedian=psfStats.psfStarDeltaSizeMedian,
            psfStarDeltaSizeScatter=psfStats.psfStarDeltaSizeScatter,
            psfStarScaledDeltaSizeScatter=psfStats.psfStarScaledDeltaSizeScatter
        )
 
        return summary
 

Member Data Documentation

ConfigClass

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.ConfigClass = ComputeExposureSummaryStatsConfig

static

Definition at line 105 of file computeExposureSummaryStats.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/computeExposureSummaryStats.py