lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask Class Reference

Inheritance diagram for lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask:

Public Member Functions
	determinePsf (self, exposure, psfCandidateList, metadata=None, flagKey=None)

Static Public Attributes
	ConfigClass = PiffPsfDeterminerConfig

Static Protected Attributes
str	_DefaultName = "psfDeterminer.Piff"

Detailed Description

A measurePsfTask PSF estimator using Piff as the implementation.

Definition at line 269 of file piffPsfDeterminer.py.

Member Function Documentation

determinePsf()

lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask.determinePsf	(		self,
			exposure,
			psfCandidateList,
			metadata = None,
			flagKey = None )

Determine a Piff PSF model for an exposure given a list of PSF
candidates.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
   Exposure containing the PSF candidates.
psfCandidateList : `list` of `lsst.meas.algorithms.PsfCandidate`
   A sequence of PSF candidates typically obtained by detecting sources
   and then running them through a star selector.
metadata : `lsst.daf.base import PropertyList` or `None`, optional
   A home for interesting tidbits of information.
flagKey : `str` or `None`, optional
   Schema key used to mark sources actually used in PSF determination.

Returns
-------
psf : `lsst.meas.extensions.piff.PiffPsf`
   The measured PSF model.
psfCellSet : `None`
   Unused by this PsfDeterminer.

Reimplemented from lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask.

Definition at line 275 of file piffPsfDeterminer.py.

    ):
        """Determine a Piff PSF model for an exposure given a list of PSF
        candidates.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
           Exposure containing the PSF candidates.
        psfCandidateList : `list` of `lsst.meas.algorithms.PsfCandidate`
           A sequence of PSF candidates typically obtained by detecting sources
           and then running them through a star selector.
        metadata : `lsst.daf.base import PropertyList` or `None`, optional
           A home for interesting tidbits of information.
        flagKey : `str` or `None`, optional
           Schema key used to mark sources actually used in PSF determination.
 
        Returns
        -------
        psf : `lsst.meas.extensions.piff.PiffPsf`
           The measured PSF model.
        psfCellSet : `None`
           Unused by this PsfDeterminer.
        """
        psfCandidateList = self.downsampleCandidates(psfCandidateList)
 
        if self.config.stampSize:
            stampSize = self.config.stampSize
            if stampSize > psfCandidateList[0].getWidth():
                self.log.warning("stampSize is larger than the PSF candidate size.  Using candidate size.")
                stampSize = psfCandidateList[0].getWidth()
        else:  # TODO: Only the if block should stay after DM-36311
            self.log.debug("stampSize not set.  Using candidate size.")
            stampSize = psfCandidateList[0].getWidth()
 
        scale = exposure.getWcs().getPixelScale().asArcseconds()
        match self.config.useCoordinates:
            case 'field':
                detector = exposure.getDetector()
                pix_to_field = detector.getTransform(PIXELS, FIELD_ANGLE)
                gswcs = UVWcsWrapper(pix_to_field)
                pointing = None
            case 'sky':
                gswcs = CelestialWcsWrapper(exposure.getWcs())
                skyOrigin = exposure.getWcs().getSkyOrigin()
                ra = skyOrigin.getLongitude().asDegrees()
                dec = skyOrigin.getLatitude().asDegrees()
                pointing = galsim.CelestialCoord(
                    ra*galsim.degrees,
                    dec*galsim.degrees
                )
            case 'pixel':
                gswcs = galsim.PixelScale(scale)
                pointing = None
 
        stars = []
        for candidate in psfCandidateList:
            cmi = candidate.getMaskedImage(stampSize, stampSize)
            good = getGoodPixels(cmi, self.config.zeroWeightMaskBits)
            fracGood = np.sum(good)/good.size
            if fracGood < self.config.minimumUnmaskedFraction:
                continue
            weight = computeWeight(cmi, self.config.maxSNR, good)
 
            bbox = cmi.getBBox()
            bds = galsim.BoundsI(
                galsim.PositionI(*bbox.getMin()),
                galsim.PositionI(*bbox.getMax())
            )
            gsImage = galsim.Image(bds, wcs=gswcs, dtype=float)
            gsImage.array[:] = cmi.image.array
            gsWeight = galsim.Image(bds, wcs=gswcs, dtype=float)
            gsWeight.array[:] = weight
 
            source = candidate.getSource()
            image_pos = galsim.PositionD(source.getX(), source.getY())
 
            data = piff.StarData(
                gsImage,
                image_pos,
                weight=gsWeight,
                pointing=pointing
            )
            stars.append(piff.Star(data, None))
 
        piffConfig = {
            'type': "Simple",
            'model': {
                'type': 'PixelGrid',
                'scale': scale * self.config.samplingSize,
                'size': stampSize,
                'interp': self.config.interpolant
            },
            'interp': {
                'type': 'BasisPolynomial',
                'order': self.config.spatialOrder
            },
            'outliers': {
                'type': 'Chisq',
                'nsigma': self.config.outlierNSigma,
                'max_remove': self.config.outlierMaxRemove
            }
        }
 
        piffResult = piff.PSF.process(piffConfig)
        wcs = {0: gswcs}
 
        piffResult.fit(stars, wcs, pointing, logger=self.log)
        drawSize = 2*np.floor(0.5*stampSize/self.config.samplingSize) + 1
 
        used_image_pos = [s.image_pos for s in piffResult.stars]
        if flagKey:
            for candidate in psfCandidateList:
                source = candidate.getSource()
                posd = galsim.PositionD(source.getX(), source.getY())
                if posd in used_image_pos:
                    source.set(flagKey, True)
 
        if metadata is not None:
            metadata["spatialFitChi2"] = piffResult.chisq
            metadata["numAvailStars"] = len(stars)
            metadata["numGoodStars"] = len(piffResult.stars)
            metadata["avgX"] = np.mean([p.x for p in piffResult.stars])
            metadata["avgY"] = np.mean([p.y for p in piffResult.stars])
 
        if not self.config.debugStarData:
            for star in piffResult.stars:
                # Remove large data objects from the stars
                del star.fit.params
                del star.fit.params_var
                del star.fit.A
                del star.fit.b
                del star.data.image
                del star.data.weight
                del star.data.orig_weight
 
        return PiffPsf(drawSize, drawSize, piffResult), None
 
 

Member Data Documentation

_DefaultName

str lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask._DefaultName = "psfDeterminer.Piff"

staticprotected

Definition at line 273 of file piffPsfDeterminer.py.

ConfigClass

lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask.ConfigClass = PiffPsfDeterminerConfig

static

Definition at line 272 of file piffPsfDeterminer.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_extensions_piff/g64a986408d+0dd8ce4237/python/lsst/meas/extensions/piff/piffPsfDeterminer.py