lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask Class Reference

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

Public Member Functions
	__init__ (self, **kwargs)
	run (self, exposure, sources, background)
	update_psf_stats (self, summary, psf, bbox, sources=None, image_mask=None, image_ap_corr_map=None, sources_is_astropy=False)
	update_wcs_stats (self, summary, wcs, bbox, visitInfo)
	update_photo_calib_stats (self, summary, photo_calib)
	update_background_stats (self, summary, background)
	update_masked_image_stats (self, summary, masked_image)
	update_effective_time_stats (self, summary, exposure)
	update_magnitude_limit_stats (self, summary, exposure)

Static Public Attributes
	ConfigClass = ComputeExposureSummaryStatsConfig

Static Protected Attributes
str	_DefaultName = "computeExposureSummaryStats"

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:
- expTime
- psfSigma
- psfArea
- psfIxx
- psfIyy
- psfIxy
- ra
- dec
- pixelScale (arcsec/pixel)
- 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

These quantities are computed based on the PSF model and image mask
to assess the robustness of the PSF model across a given detector
(against, e.g., extrapolation instability):
- maxDistToNearestPsf
- psfTraceRadiusDelta
- psfApFluxDelta

This quantity is computed based on the aperture correction map, the
psfSigma, and the image mask to assess the robustness of the aperture
corrections across a given detector:
- psfApCorrSigmaScaledDelta

These quantities are computed to assess depth:
- effTime
- effTimePsfSigmaScale
- effTimeSkyBgScale
- effTimeZeroPointScale
- magLim

Definition at line 163 of file computeExposureSummaryStats.py.

Constructor & Destructor Documentation

__init__()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.__init__	(		self,
		**	kwargs )

Definition at line 218 of file computeExposureSummaryStats.py.

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
 
        self.makeSubtask("starSelector")
 

Member Function Documentation

run()

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 224 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")
 
        summary = afwImage.ExposureSummaryStats()
 
        # Set exposure time.
        exposureTime = exposure.getInfo().getVisitInfo().getExposureTime()
        summary.expTime = exposureTime
 
        bbox = exposure.getBBox()
 
        psf = exposure.getPsf()
        self.update_psf_stats(
            summary, psf, bbox, sources, image_mask=exposure.mask, image_ap_corr_map=exposure.apCorrMap
        )
 
        wcs = exposure.getWcs()
        visitInfo = exposure.getInfo().getVisitInfo()
        self.update_wcs_stats(summary, wcs, bbox, visitInfo)
 
        photoCalib = exposure.getPhotoCalib()
        self.update_photo_calib_stats(summary, photoCalib)
 
        self.update_background_stats(summary, background)
 
        self.update_masked_image_stats(summary, exposure.getMaskedImage())
 
        self.update_magnitude_limit_stats(summary, exposure)
 
        self.update_effective_time_stats(summary, exposure)
 
        md = exposure.getMetadata()
        if 'SFM_ASTROM_OFFSET_MEAN' in md:
            summary.astromOffsetMean = md['SFM_ASTROM_OFFSET_MEAN']
            summary.astromOffsetStd = md['SFM_ASTROM_OFFSET_STD']
 
        return summary
 

update_background_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_background_stats	(		self,
			summary,
			background )

Compute summary-statistic fields that depend only on the
background model.

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
background : `lsst.afw.math.BackgroundList` or `None`
    Background model.  If `None`, all fields that depend on the
    background will be reset (generally to NaN).

Notes
-----
This does not include fields that depend on the background-subtracted
masked image; when the background changes, it should generally be
applied to the image and `update_masked_image_stats` should be called
as well.

Definition at line 516 of file computeExposureSummaryStats.py.

    def update_background_stats(self, summary, background):
        """Compute summary-statistic fields that depend only on the
        background model.
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        background : `lsst.afw.math.BackgroundList` or `None`
            Background model.  If `None`, all fields that depend on the
            background will be reset (generally to NaN).
 
        Notes
        -----
        This does not include fields that depend on the background-subtracted
        masked image; when the background changes, it should generally be
        applied to the image and `update_masked_image_stats` should be called
        as well.
        """
        if background is not None:
            bgStats = (bg[0].getStatsImage().getImage().array
                       for bg in background)
            summary.skyBg = float(sum(np.median(bg[np.isfinite(bg)]) for bg in bgStats))
        else:
            summary.skyBg = float("nan")
 

update_effective_time_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_effective_time_stats	(		self,
			summary,
			exposure )

Compute effective exposure time statistics to estimate depth.

The effective exposure time is the equivalent shutter open
time that would be needed under nominal conditions to give the
same signal-to-noise for a point source as what is achieved by
the observation of interest. This metric combines measurements
of the point-spread function, the sky brightness, and the
transparency. It assumes that the observation is
sky-background dominated.

.. _teff_definitions:

The effective exposure time and its subcomponents are defined in [1]_.

References
----------

.. [1] Neilsen, E.H., Bernstein, G., Gruendl, R., and Kent, S. (2016).
       Limiting Magnitude, \tau, teff, and Image Quality in DES Year 1
       https://www.osti.gov/biblio/1250877/

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
exposure : `lsst.afw.image.ExposureF`
    Exposure to grab band and exposure time metadata

Definition at line 574 of file computeExposureSummaryStats.py.

    def update_effective_time_stats(self, summary, exposure):
        """Compute effective exposure time statistics to estimate depth.
 
        The effective exposure time is the equivalent shutter open
        time that would be needed under nominal conditions to give the
        same signal-to-noise for a point source as what is achieved by
        the observation of interest. This metric combines measurements
        of the point-spread function, the sky brightness, and the
        transparency. It assumes that the observation is
        sky-background dominated.
 
        .. _teff_definitions:
 
        The effective exposure time and its subcomponents are defined in [1]_.
 
        References
        ----------
 
        .. [1] Neilsen, E.H., Bernstein, G., Gruendl, R., and Kent, S. (2016).
               Limiting Magnitude, \tau, teff, and Image Quality in DES Year 1
               https://www.osti.gov/biblio/1250877/
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        exposure : `lsst.afw.image.ExposureF`
            Exposure to grab band and exposure time metadata
 
        """
        nan = float("nan")
        summary.effTime = nan
        summary.effTimePsfSigmaScale = nan
        summary.effTimeSkyBgScale = nan
        summary.effTimeZeroPointScale = nan
 
        exposureTime = exposure.getInfo().getVisitInfo().getExposureTime()
        filterLabel = exposure.getFilter()
        if (filterLabel is None) or (not filterLabel.hasBandLabel):
            band = None
        else:
            band = filterLabel.bandLabel
 
        if band is None:
            self.log.warning("No band associated with exposure; effTime not calculated.")
            return
 
        # PSF component
        if np.isnan(summary.psfSigma):
            self.log.debug("PSF sigma is NaN")
            f_eff = nan
        elif band not in self.config.fiducialPsfSigma:
            self.log.debug(f"Fiducial PSF value not found for {band}")
            f_eff = nan
        else:
            fiducialPsfSigma = self.config.fiducialPsfSigma[band]
            f_eff = (summary.psfSigma / fiducialPsfSigma)**-2
 
        # Transparency component
        # Note: Assumes that the zeropoint includes the exposure time
        if np.isnan(summary.zeroPoint):
            self.log.debug("Zero point is NaN")
            c_eff = nan
        elif band not in self.config.fiducialZeroPoint:
            self.log.debug(f"Fiducial zero point value not found for {band}")
            c_eff = nan
        else:
            fiducialZeroPoint = self.config.fiducialZeroPoint[band]
            zeroPointDiff = fiducialZeroPoint - (summary.zeroPoint - 2.5*np.log10(exposureTime))
            c_eff = min(10**(-2.0*(zeroPointDiff)/2.5), self.config.maxEffectiveTransparency)
 
        # Sky brightness component (convert to cts/s)
        if np.isnan(summary.skyBg):
            self.log.debug("Sky background is NaN")
            b_eff = nan
        elif band not in self.config.fiducialSkyBackground:
            self.log.debug(f"Fiducial sky background value not found for {band}")
            b_eff = nan
        else:
            fiducialSkyBackground = self.config.fiducialSkyBackground[band]
            b_eff = fiducialSkyBackground/(summary.skyBg/exposureTime)
 
        # Effective exposure time scale factor
        t_eff = f_eff * c_eff * b_eff
 
        # Effective exposure time (seconds)
        effectiveTime = t_eff * exposureTime
 
        # Output quantities
        summary.effTime = float(effectiveTime)
        summary.effTimePsfSigmaScale = float(f_eff)
        summary.effTimeSkyBgScale = float(b_eff)
        summary.effTimeZeroPointScale = float(c_eff)
 

update_magnitude_limit_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_magnitude_limit_stats	(		self,
			summary,
			exposure )

Compute a summary statistic for the point-source magnitude limit at
a given signal-to-noise ratio using exposure-level metadata.

The magnitude limit is calculated at a given SNR from the PSF,
sky, zeropoint, and readnoise in accordance with SMTN-002 [1]_,
LSE-40 [2]_, and DMTN-296 [3]_.

References
----------

.. [1] "Calculating LSST limiting magnitudes and SNR" (SMTN-002)
.. [2] "Photon Rates and SNR Calculations" (LSE-40)
.. [3] "Calculations of Image and Catalog Depth" (DMTN-296)


Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
exposure : `lsst.afw.image.ExposureF`
    Exposure to grab band and exposure time metadata

Definition at line 668 of file computeExposureSummaryStats.py.

    def update_magnitude_limit_stats(self, summary, exposure):
        """Compute a summary statistic for the point-source magnitude limit at
        a given signal-to-noise ratio using exposure-level metadata.
 
        The magnitude limit is calculated at a given SNR from the PSF,
        sky, zeropoint, and readnoise in accordance with SMTN-002 [1]_,
        LSE-40 [2]_, and DMTN-296 [3]_.
 
        References
        ----------
 
        .. [1] "Calculating LSST limiting magnitudes and SNR" (SMTN-002)
        .. [2] "Photon Rates and SNR Calculations" (LSE-40)
        .. [3] "Calculations of Image and Catalog Depth" (DMTN-296)
 
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        exposure : `lsst.afw.image.ExposureF`
            Exposure to grab band and exposure time metadata
        """
        if exposure.getDetector() is None:
            summary.magLim = float("nan")
            return
 
        # Calculate the average readnoise [e-]
        readNoiseList = list(ipIsr.getExposureReadNoises(exposure).values())
        readNoise = np.nanmean(readNoiseList)
        if np.isnan(readNoise):
            readNoise = 0.0
            self.log.warning("Read noise set to NaN! Setting readNoise to 0.0 to proceed.")
 
        # Calculate the average gain [e-/ADU]
        gainList = list(ipIsr.getExposureGains(exposure).values())
        gain = np.nanmean(gainList)
        if np.isnan(gain):
            self.log.warning("Gain set to NaN! Setting magLim to NaN.")
            summary.magLim = float("nan")
            return
 
        # Get the image units (default to 'adu' if metadata key absent)
        md = exposure.getMetadata()
        if md.get("LSST ISR UNITS", "adu") == "electron":
            gain = 1.0
 
        # Convert readNoise to image units
        readNoise /= gain
 
        # Calculate the limiting magnitude.
        # Note 1: Assumes that the image and readnoise have the same units
        # Note 2: Assumes that the zeropoint includes the exposure time
        magLim = compute_magnitude_limit(summary.psfArea, summary.skyBg,
                                         summary.zeroPoint, readNoise,
                                         gain, self.config.magLimSnr)
 
        summary.magLim = float(magLim)
 
 

update_masked_image_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_masked_image_stats	(		self,
			summary,
			masked_image )

Compute summary-statistic fields that depend on the masked image
itself.

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
masked_image : `lsst.afw.image.MaskedImage` or `None`
    Masked image.  If `None`, all fields that depend
    on the masked image will be reset (generally to NaN).

Definition at line 542 of file computeExposureSummaryStats.py.

    def update_masked_image_stats(self, summary, masked_image):
        """Compute summary-statistic fields that depend on the masked image
        itself.
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        masked_image : `lsst.afw.image.MaskedImage` or `None`
            Masked image.  If `None`, all fields that depend
            on the masked image will be reset (generally to NaN).
        """
        nan = float("nan")
        if masked_image is None:
            summary.skyNoise = nan
            summary.meanVar = nan
            return
        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(masked_image, afwMath.STDEVCLIP, statsCtrl)
        skyNoise, _ = statObj.getResult(afwMath.STDEVCLIP)
        summary.skyNoise = skyNoise
 
        statObj = afwMath.makeStatistics(masked_image.variance, masked_image.mask, afwMath.MEANCLIP,
                                         statsCtrl)
        meanVar, _ = statObj.getResult(afwMath.MEANCLIP)
        summary.meanVar = meanVar
 

update_photo_calib_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_photo_calib_stats	(		self,
			summary,
			photo_calib )

Compute all summary-statistic fields that depend on the photometric
calibration model.

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
photo_calib : `lsst.afw.image.PhotoCalib` or `None`
    Photometric calibration model.  If `None`, all fields that depend
    on the photometric calibration will be reset (generally to NaN).

Definition at line 499 of file computeExposureSummaryStats.py.

    def update_photo_calib_stats(self, summary, photo_calib):
        """Compute all summary-statistic fields that depend on the photometric
        calibration model.
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        photo_calib : `lsst.afw.image.PhotoCalib` or `None`
            Photometric calibration model.  If `None`, all fields that depend
            on the photometric calibration will be reset (generally to NaN).
        """
        if photo_calib is not None:
            summary.zeroPoint = float(2.5*np.log10(photo_calib.getInstFluxAtZeroMagnitude()))
        else:
            summary.zeroPoint = float("nan")
 

update_psf_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_psf_stats	(		self,
			summary,
			psf,
			bbox,
			sources = None,
			image_mask = None,
			image_ap_corr_map = None,
			sources_is_astropy = False )

Compute all summary-statistic fields that depend on the PSF model.

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
psf : `lsst.afw.detection.Psf` or `None`
    Point spread function model.  If `None`, all fields that depend on
    the PSF will be reset (generally to NaN).
bbox : `lsst.geom.Box2I`
    Bounding box of the image for which summary stats are being
    computed.
sources : `lsst.afw.table.SourceCatalog` or `astropy.table.Table`
    Catalog for quantities that are computed from source table columns.
    If `None`, these quantities will be reset (generally to NaN).
    The type of this table must correspond to the
    ``sources_is_astropy`` argument.
image_mask : `lsst.afw.image.Mask`, optional
    Mask image that may be used to compute distance-to-nearest-star
    metrics.
sources_is_astropy : `bool`, optional
    Whether ``sources`` is an `astropy.table.Table` instance instead
    of an `lsst.afw.table.Catalog` instance.  Default is `False` (the
    latter).

Definition at line 275 of file computeExposureSummaryStats.py.

    ):
        """Compute all summary-statistic fields that depend on the PSF model.
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        psf : `lsst.afw.detection.Psf` or `None`
            Point spread function model.  If `None`, all fields that depend on
            the PSF will be reset (generally to NaN).
        bbox : `lsst.geom.Box2I`
            Bounding box of the image for which summary stats are being
            computed.
        sources : `lsst.afw.table.SourceCatalog` or `astropy.table.Table`
            Catalog for quantities that are computed from source table columns.
            If `None`, these quantities will be reset (generally to NaN).
            The type of this table must correspond to the
            ``sources_is_astropy`` argument.
        image_mask : `lsst.afw.image.Mask`, optional
            Mask image that may be used to compute distance-to-nearest-star
            metrics.
        sources_is_astropy : `bool`, optional
            Whether ``sources`` is an `astropy.table.Table` instance instead
            of an `lsst.afw.table.Catalog` instance.  Default is `False` (the
            latter).
        """
        nan = float("nan")
        summary.psfSigma = nan
        summary.psfIxx = nan
        summary.psfIyy = nan
        summary.psfIxy = nan
        summary.psfArea = nan
        summary.nPsfStar = 0
        summary.psfStarDeltaE1Median = nan
        summary.psfStarDeltaE2Median = nan
        summary.psfStarDeltaE1Scatter = nan
        summary.psfStarDeltaE2Scatter = nan
        summary.psfStarDeltaSizeMedian = nan
        summary.psfStarDeltaSizeScatter = nan
        summary.psfStarScaledDeltaSizeScatter = nan
        summary.maxDistToNearestPsf = nan
        summary.psfTraceRadiusDelta = nan
        summary.psfApFluxDelta = nan
        summary.psfApCorrSigmaScaledDelta = nan
 
        if psf is None:
            return
        shape = psf.computeShape(bbox.getCenter())
        summary.psfSigma = shape.getDeterminantRadius()
        summary.psfIxx = shape.getIxx()
        summary.psfIyy = shape.getIyy()
        summary.psfIxy = shape.getIxy()
        im = psf.computeKernelImage(bbox.getCenter())
        # The calculation of effective psf area is taken from
        # ls.st/srd Equation 1.
        summary.psfArea = float(np.sum(im.array)**2./np.sum(im.array**2.))
 
        if image_mask is not None:
            psfApRadius = max(self.config.minPsfApRadiusPix, 3.0*summary.psfSigma)
            self.log.debug("Using radius of %.3f (pixels) for psfApFluxDelta metric", psfApRadius)
            psfTraceRadiusDelta, psfApFluxDelta = compute_psf_image_deltas(
                image_mask,
                psf,
                sampling=self.config.psfGridSampling,
                ap_radius_pix=psfApRadius,
                bad_mask_bits=self.config.psfBadMaskPlanes
            )
            summary.psfTraceRadiusDelta = float(psfTraceRadiusDelta)
            summary.psfApFluxDelta = float(psfApFluxDelta)
            if image_ap_corr_map is not None:
                if self.config.psfApCorrFieldName not in image_ap_corr_map.keys():
                    self.log.warning(f"{self.config.psfApCorrFieldName} not found in "
                                     "image_ap_corr_map.  Setting psfApCorrSigmaScaledDelta to NaN.")
                    psfApCorrSigmaScaledDelta = nan
                else:
                    image_ap_corr_field = image_ap_corr_map[self.config.psfApCorrFieldName]
                    psfApCorrSigmaScaledDelta = compute_ap_corr_sigma_scaled_delta(
                        image_mask,
                        image_ap_corr_field,
                        summary.psfSigma,
                        sampling=self.config.psfGridSampling,
                        bad_mask_bits=self.config.psfBadMaskPlanes,
                    )
                summary.psfApCorrSigmaScaledDelta = float(psfApCorrSigmaScaledDelta)
 
        if sources is None:
            # No sources are available (as in some tests and rare cases where
            # the selection criteria in finalizeCharacterization lead to no
            # good sources).
            return
 
        # Count the total number of psf stars used (prior to stats selection).
        nPsfStar = sources[self.config.starSelection].sum()
        summary.nPsfStar = int(nPsfStar)
 
        psf_mask = self.starSelector.run(sources).selected
        nPsfStarsUsedInStats = psf_mask.sum()
 
        if nPsfStarsUsedInStats == 0:
            # No stars to measure statistics, so we must return the defaults
            # of 0 stars and NaN values.
            return
 
        if sources_is_astropy:
            psf_cat = sources[psf_mask]
        else:
            psf_cat = sources[psf_mask].copy(deep=True)
 
        starXX = psf_cat[self.config.starShape + '_xx']
        starYY = psf_cat[self.config.starShape + '_yy']
        starXY = psf_cat[self.config.starShape + '_xy']
        psfXX = psf_cat[self.config.psfShape + '_xx']
        psfYY = psf_cat[self.config.psfShape + '_yy']
        psfXY = psf_cat[self.config.psfShape + '_xy']
 
        # Use the trace radius for the star size.
        starSize = np.sqrt(starXX/2. + starYY/2.)
 
        starE1 = (starXX - starYY)/(starXX + starYY)
        starE2 = 2*starXY/(starXX + starYY)
        starSizeMedian = np.median(starSize)
 
        # Use the trace radius for the psf size.
        psfSize = np.sqrt(psfXX/2. + psfYY/2.)
        psfE1 = (psfXX - psfYY)/(psfXX + psfYY)
        psfE2 = 2*psfXY/(psfXX + psfYY)
 
        psfStarDeltaE1Median = np.median(starE1 - psfE1)
        psfStarDeltaE1Scatter = sigmaMad(starE1 - psfE1, scale='normal')
        psfStarDeltaE2Median = np.median(starE2 - psfE2)
        psfStarDeltaE2Scatter = sigmaMad(starE2 - psfE2, scale='normal')
 
        psfStarDeltaSizeMedian = np.median(starSize - psfSize)
        psfStarDeltaSizeScatter = sigmaMad(starSize - psfSize, scale='normal')
        psfStarScaledDeltaSizeScatter = psfStarDeltaSizeScatter/starSizeMedian
 
        summary.psfStarDeltaE1Median = float(psfStarDeltaE1Median)
        summary.psfStarDeltaE2Median = float(psfStarDeltaE2Median)
        summary.psfStarDeltaE1Scatter = float(psfStarDeltaE1Scatter)
        summary.psfStarDeltaE2Scatter = float(psfStarDeltaE2Scatter)
        summary.psfStarDeltaSizeMedian = float(psfStarDeltaSizeMedian)
        summary.psfStarDeltaSizeScatter = float(psfStarDeltaSizeScatter)
        summary.psfStarScaledDeltaSizeScatter = float(psfStarScaledDeltaSizeScatter)
 
        if image_mask is not None:
            maxDistToNearestPsf = maximum_nearest_psf_distance(
                image_mask,
                psf_cat,
                sampling=self.config.psfSampling,
                bad_mask_bits=self.config.psfBadMaskPlanes
            )
            summary.maxDistToNearestPsf = float(maxDistToNearestPsf)
 

update_wcs_stats()

lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask.update_wcs_stats	(		self,
			summary,
			wcs,
			bbox,
			visitInfo )

Compute all summary-statistic fields that depend on the WCS model.

Parameters
----------
summary : `lsst.afw.image.ExposureSummaryStats`
    Summary object to update in-place.
wcs : `lsst.afw.geom.SkyWcs` or `None`
    Astrometric calibration model.  If `None`, all fields that depend
    on the WCS will be reset (generally to NaN).
bbox : `lsst.geom.Box2I`
    Bounding box of the image for which summary stats are being
    computed.
visitInfo : `lsst.afw.image.VisitInfo`
    Observation information used in together with ``wcs`` to compute
    the zenith distance.

Definition at line 437 of file computeExposureSummaryStats.py.

    def update_wcs_stats(self, summary, wcs, bbox, visitInfo):
        """Compute all summary-statistic fields that depend on the WCS model.
 
        Parameters
        ----------
        summary : `lsst.afw.image.ExposureSummaryStats`
            Summary object to update in-place.
        wcs : `lsst.afw.geom.SkyWcs` or `None`
            Astrometric calibration model.  If `None`, all fields that depend
            on the WCS will be reset (generally to NaN).
        bbox : `lsst.geom.Box2I`
            Bounding box of the image for which summary stats are being
            computed.
        visitInfo : `lsst.afw.image.VisitInfo`
            Observation information used in together with ``wcs`` to compute
            the zenith distance.
        """
        nan = float("nan")
        summary.raCorners = [nan]*4
        summary.decCorners = [nan]*4
        summary.ra = nan
        summary.dec = nan
        summary.pixelScale = nan
        summary.zenithDistance = nan
 
        if wcs is None:
            return
 
        sph_pts = wcs.pixelToSky(geom.Box2D(bbox).getCorners())
        summary.raCorners = [float(sph.getRa().asDegrees()) for sph in sph_pts]
        summary.decCorners = [float(sph.getDec().asDegrees()) for sph in sph_pts]
 
        sph_pt = wcs.pixelToSky(bbox.getCenter())
        summary.ra = sph_pt.getRa().asDegrees()
        summary.dec = sph_pt.getDec().asDegrees()
        summary.pixelScale = wcs.getPixelScale(bbox.getCenter()).asArcseconds()
 
        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(
                summary.ra*units.degree,
                summary.dec*units.degree,
                obstime=obstime,
                location=loc,
            )
            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                altaz = coord.transform_to(AltAz)
 
            summary.zenithDistance = float(90.0 - altaz.alt.degree)
 

Member Data Documentation

_DefaultName

str lsst.pipe.tasks.computeExposureSummaryStats.ComputeExposureSummaryStatsTask._DefaultName = "computeExposureSummaryStats"

staticprotected

Definition at line 216 of file computeExposureSummaryStats.py.

ConfigClass

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

static

Definition at line 215 of file computeExposureSummaryStats.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/pipe_tasks/g99af87f6a8+b0f4ad7b8d/python/lsst/pipe/tasks/computeExposureSummaryStats.py