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

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

Public Member Functions
	__init__ (self, config, schema=None, **kwds)
	determinePsf (self, exposure, psfCandidateList, metadata=None, flagKey=None)
	downsampleCandidates (self, inputCandidateList)

Public Attributes
	piffLogger = lsst.utils.logging.getLogger(f"{self.log.name}.piff")

Static Public Attributes
bool	usesMatches = False
	ConfigClass = BasePsfDeterminerConfig

Protected Attributes
	_piffConfig = piffConfig

Static Protected Attributes
str	_DefaultName = "psfDeterminer"

Detailed Description

A measurePsfTask PSF estimator using Piff as the implementation.

Definition at line 394 of file piffPsfDeterminer.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask.__init__	(		self,
			config,
			schema = None,
		**	kwds )

Definition at line 400 of file piffPsfDeterminer.py.

    def __init__(self, config, schema=None, **kwds):
        BasePsfDeterminerTask.__init__(self, config, schema=schema, **kwds)
 
        piffLoggingLevels = {
            0: logging.CRITICAL,
            1: logging.WARNING,
            2: logging.INFO,
            3: logging.DEBUG,
        }
        self.piffLogger = lsst.utils.logging.getLogger(f"{self.log.name}.piff")
        self.piffLogger.setLevel(piffLoggingLevels[self.config.piffLoggingLevel])
 

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 412 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(exposure.getBBox().getCenter()).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()
            starId = source.getId()
            image_pos = galsim.PositionD(source.getX(), source.getY())
 
            data = piff.StarData(
                gsImage,
                image_pos,
                weight=gsWeight,
                pointing=pointing
            )
            star = piff.Star(data, None)
            star.data.properties['starId'] = starId
            stars.append(star)
 
        if self.config.piffPsfConfigYaml is None:
            # The following is mostly accommodating unittests that don't have
            # the filter attribute set on the mock exposure.
            if hasattr(exposure.filter, "bandLabel"):
                band = exposure.filter.bandLabel
            else:
                band = None
            spatialOrder = self.config.spatialOrderPerBand.get(band, self.config.spatialOrder)
            piffConfig = {
                'type': 'Simple',
                'model': {
                    'type': 'PixelGrid',
                    'scale': scale * self.config.samplingSize,
                    'size': self.config.modelSize,
                    'interp': self.config.interpolant,
                    'centered': self.config.piffPixelGridFitCenter,
                },
                'interp': {
                    'type': 'BasisPolynomial',
                    'order': spatialOrder,
                    'solver': self.config.piffBasisPolynomialSolver,
                },
                'outliers': {
                    'type': 'Chisq',
                    'nsigma': self.config.outlierNSigma,
                    'max_remove': self.config.outlierMaxRemove,
                },
                'max_iter': self.config.piffMaxIter
            }
        else:
            piffConfig = yaml.safe_load(self.config.piffPsfConfigYaml)
 
        def _get_threshold(nth_order):
            # number of free parameter in the polynomial interpolation
            freeParameters = ((nth_order + 1) * (nth_order + 2)) // 2
            return freeParameters
 
        if piffConfig['interp']['type'] in ['BasisPolynomial', 'Polynomial']:
            threshold = _get_threshold(piffConfig['interp']['order'])
            if len(stars) < threshold:
                if self.config.zerothOrderInterpNotEnoughStars:
                    self.log.warning(
                        "Only %d stars found, "
                        "but %d required. Using zeroth order interpolation."%((len(stars), threshold))
                    )
                    piffConfig['interp']['order'] = 0
                    # No need to do any outlier rejection assume
                    # PSF to be average of few stars.
                    piffConfig['max_iter'] = 1
                else:
                    raise PiffTooFewGoodStarsError(
                        num_good_stars=len(stars),
                        minimum_dof=threshold,
                        poly_ndim=piffConfig['interp']['order'],
                    )
 
        self._piffConfig = piffConfig
        piffResult = piff.PSF.process(piffConfig)
        wcs = {0: gswcs}
 
        piffResult.fit(stars, wcs, pointing, logger=self.piffLogger)
 
        nUsedStars = len([s for s in piffResult.stars if not s.is_flagged and not s.is_reserve])
 
        if piffConfig['interp']['type'] in ['BasisPolynomial', 'Polynomial']:
            threshold = _get_threshold(piffConfig['interp']['order'])
            if nUsedStars < threshold:
                if self.config.zerothOrderInterpNotEnoughStars:
                    self.log.warning(
                        "Only %d after outlier rejection, "
                        "but %d required. Using zeroth order interpolation."%((nUsedStars, threshold))
                    )
                    piffConfig['interp']['order'] = 0
                    # No need to do any outlier rejection assume
                    # PSF to be average of few stars.
                    piffConfig['max_iter'] = 1
                    piffResult.fit(stars, wcs, pointing, logger=self.piffLogger)
                    nUsedStars = len(stars)
                else:
                    raise PiffTooFewGoodStarsError(
                        num_good_stars=nUsedStars,
                        minimum_dof=threshold,
                        poly_ndim=piffConfig['interp']['order'],
                    )
 
        drawSize = 2*np.floor(0.5*stampSize/self.config.samplingSize) + 1
 
        used_image_starId = {s.data.properties['starId'] for s in piffResult.stars
                             if not s.is_flagged and not s.is_reserve}
 
        assert len(used_image_starId) == nUsedStars, "Star IDs are not unique"
 
        if flagKey:
            for candidate in psfCandidateList:
                source = candidate.getSource()
                starId = source.getId()
                if starId in used_image_starId:
                    source.set(flagKey, True)
 
        if metadata is not None:
            metadata["spatialFitChi2"] = piffResult.chisq
            metadata["numAvailStars"] = len(stars)
            metadata["numGoodStars"] = nUsedStars
            metadata["avgX"] = np.mean([s.x for s in piffResult.stars
                                        if not s.is_flagged and not s.is_reserve])
            metadata["avgY"] = np.mean([s.y for s in piffResult.stars
                                        if not s.is_flagged and not s.is_reserve])
 
        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
 
 

downsampleCandidates()

lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask.downsampleCandidates ( self, inputCandidateList )

inherited

Down-sample candidates from the input candidate list.

Parameters
----------
inputCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
    Input candidate list.

Returns
-------
outputCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
    Down-selected candidate list.

Definition at line 75 of file psfDeterminer.py.

    def downsampleCandidates(self, inputCandidateList):
        """Down-sample candidates from the input candidate list.
 
        Parameters
        ----------
        inputCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
            Input candidate list.
 
        Returns
        -------
        outputCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
            Down-selected candidate list.
        """
        if len(inputCandidateList) <= self.config.maxCandidates:
            return inputCandidateList
 
        rng = np.random.RandomState(seed=self.config.downsampleRandomSeed)
 
        self.log.info(
            "Down-sampling from %d to %d psf candidates.",
            len(inputCandidateList),
            self.config.maxCandidates,
        )
 
        selection = rng.choice(len(inputCandidateList), size=self.config.maxCandidates, replace=False)
        selection = np.sort(selection)
 
        outputCandidateList = [inputCandidateList[index] for index in selection]
 
        return outputCandidateList
 

Member Data Documentation

_DefaultName

str lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask._DefaultName = "psfDeterminer"

staticprotectedinherited

Definition at line 70 of file psfDeterminer.py.

_piffConfig

lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask._piffConfig = piffConfig

protected

Definition at line 560 of file piffPsfDeterminer.py.

ConfigClass

lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask.ConfigClass = BasePsfDeterminerConfig

staticinherited

Definition at line 69 of file psfDeterminer.py.

piffLogger

lsst.meas.extensions.piff.piffPsfDeterminer.PiffPsfDeterminerTask.piffLogger = lsst.utils.logging.getLogger(f"{self.log.name}.piff")

Definition at line 409 of file piffPsfDeterminer.py.

usesMatches

bool lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask.usesMatches = False

staticinherited

Definition at line 68 of file psfDeterminer.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/meas_extensions_piff/g94187f82dc+d3ce33c3e0/python/lsst/meas/extensions/piff/piffPsfDeterminer.py