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

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

def	determinePsf (self, exposure, psfCandidateList, metadata=None)

Static Public Attributes
	ConfigClass = PiffPsfDeterminerConfig

bool	usesMatches = False

Detailed Description

A measurePsfTask PSF estimator using Piff as the implementation.

Definition at line 171 of file piffPsfDeterminer.py.

Member Function Documentation

◆ determinePsf() [1/2]

def lsst.meas.algorithms.psfDeterminer.BasePsfDeterminerTask.determinePsf	(	self,
		exposure,
		psfCandidateList,
		metadata = `None`
	)

inherited

Determine a PSF model.

Parameters
----------
exposure : `lsst.afw.Exposure`
    Exposure containing the psf candidates.
psdCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
    A sequence of PSF candidates; typically obtained by
    detecting sources and then running them through a star
    selector.
metadata : `str`
    A place to save interesting items.

Returns
-------
psf : `lsst.afw.detection.Psf`
    The fit PSF.
cellSet : `lsst.afw.math.SpatialCellSet`
    The spatial cell set used to determine the PSF

Definition at line 78 of file psfDeterminer.py.

     def determinePsf(self, exposure, psfCandidateList, metadata=None):
         """Determine a PSF model.
  
         Parameters
         ----------
         exposure : `lsst.afw.Exposure`
             Exposure containing the psf candidates.
         psdCandidateList : `list` [`lsst.meas.algorithms.PsfCandidate`]
             A sequence of PSF candidates; typically obtained by
             detecting sources and then running them through a star
             selector.
         metadata : `str`
             A place to save interesting items.
  
         Returns
         -------
         psf : `lsst.afw.detection.Psf`
             The fit PSF.
         cellSet : `lsst.afw.math.SpatialCellSet`
             The spatial cell set used to determine the PSF
         """
         raise NotImplementedError("BasePsfDeterminerTask is abstract, subclasses must override this method")
  
  

◆ determinePsf() [2/2]

def 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.

Definition at line 177 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.
         """
         stars = []
         for candidate in psfCandidateList:
             cmi = candidate.getMaskedImage()
             weight = computeWeight(cmi, self.config.maxSNR)
  
             bbox = cmi.getBBox()
             bds = galsim.BoundsI(
                 galsim.PositionI(*bbox.getMin()),
                 galsim.PositionI(*bbox.getMax())
             )
             gsImage = galsim.Image(bds, scale=1.0, dtype=float)
             gsImage.array[:] = cmi.image.array
             gsWeight = galsim.Image(bds, scale=1.0, dtype=float)
             gsWeight.array[:] = weight
  
             source = candidate.getSource()
             image_pos = galsim.PositionD(source.getX(), source.getY())
  
             data = piff.StarData(
                 gsImage,
                 image_pos,
                 weight=gsWeight
             )
             stars.append(piff.Star(data, None))
  
         kernelSize = int(np.clip(
             self.config.kernelSize,
             self.config.kernelSizeMin,
             self.config.kernelSizeMax
         ))
  
         piffConfig = {
             'type': "Simple",
             'model': {
                 'type': 'PixelGrid',
                 'scale': self.config.samplingSize,
                 'size': kernelSize
             },
             'interp': {
                 'type': 'BasisPolynomial',
                 'order': self.config.spatialOrder
             },
             'outliers': {
                 'type': 'Chisq',
                 'nsigma': self.config.outlierNSigma,
                 'max_remove': self.config.outlierMaxRemove
             }
         }
  
         piffResult = piff.PSF.process(piffConfig)
         # Run on a single CCD, and in image coords rather than sky coords.
         wcs = {0: galsim.PixelScale(1.0)}
         pointing = None
  
         piffResult.fit(stars, wcs, pointing, logger=self.log)
         psf = PiffPsf(kernelSize, kernelSize, piffResult)
  
         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.set("spatialFitChi2", piffResult.chisq)
             metadata.set("numAvailStars", len(stars))
             metadata.set("numGoodStars", len(piffResult.stars))
             metadata.set("avgX", np.mean([p.x for p in piffResult.stars]))
             metadata.set("avgY", np.mean([p.y for p in piffResult.stars]))
  
         return psf, None
  
  
 measAlg.psfDeterminerRegistry.register("piff", PiffPsfDeterminerTask)

Member Data Documentation

◆ ConfigClass

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

static

Definition at line 174 of file piffPsfDeterminer.py.

◆ usesMatches

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

staticinherited

Definition at line 70 of file psfDeterminer.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_extensions_piff/22.0.1-2-g8ef0a89+b8044ec9de/python/lsst/meas/extensions/piff/piffPsfDeterminer.py

Public Member Functions