lsst.ip.diffim.dipoleMeasurement.DipoleDeblender Class Reference

Inheritance diagram for lsst.ip.diffim.dipoleMeasurement.DipoleDeblender:

Public Member Functions
	__init__ (self)
	__call__ (self, source, exposure)

Public Attributes
	psfChisqCut1
	log
	sigma2fwhm
	psfChisqCut2
	psfChisqCut2b

Detailed Description

Functor to deblend a source as a dipole, and return a new source with deblended footprints.

   This necessarily overrides some of the functionality from
   meas_algorithms/python/lsst/meas/algorithms/deblend.py since we
   need a single source that contains the blended peaks, not
   multiple children sources.  This directly calls the core
   deblending code deblendBaseline.deblend (optionally _fitPsf for
   debugging).

   Not actively being used, but there is a unit test for it in
   dipoleAlgorithm.py.

Definition at line 289 of file dipoleMeasurement.py.

Constructor & Destructor Documentation

__init__()

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.__init__

(

self

)

Definition at line 303 of file dipoleMeasurement.py.

    def __init__(self):
        # Set up defaults to send to deblender
 
        # Always deblend as Psf
        self.psfChisqCut1 = self.psfChisqCut2 = self.psfChisqCut2b = np.inf
        self.log = getLogger('lsst.ip.diffim.DipoleDeblender')
        self.sigma2fwhm = 2. * np.sqrt(2. * np.log(2.))
 

Member Function Documentation

__call__()

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.__call__	(		self,
			source,
			exposure )

Definition at line 311 of file dipoleMeasurement.py.

    def __call__(self, source, exposure):
        fp = source.getFootprint()
        peaks = fp.getPeaks()
        peaksF = [pk.getF() for pk in peaks]
        fbb = fp.getBBox()
        fmask = afwImage.Mask(fbb)
        fmask.setXY0(fbb.getMinX(), fbb.getMinY())
        fp.spans.setMask(fmask, 1)
 
        psf = exposure.getPsf()
        psfSigPix = psf.computeShape(psf.getAveragePosition()).getDeterminantRadius()
        psfFwhmPix = psfSigPix * self.sigma2fwhm
        subimage = afwImage.ExposureF(exposure, bbox=fbb, deep=True)
        cpsf = deblendBaseline.CachingPsf(psf)
 
        # if fewer than 2 peaks, just return a copy of the source
        if len(peaks) < 2:
            return source.getTable().copyRecord(source)
 
        # make sure you only deblend 2 peaks; take the brighest and faintest
        speaks = [(p.getPeakValue(), p) for p in peaks]
        speaks.sort()
        dpeaks = [speaks[0][1], speaks[-1][1]]
 
        # and only set these peaks in the footprint (peaks is mutable)
        peaks.clear()
        for peak in dpeaks:
            peaks.append(peak)
 
        if True:
            # Call top-level deblend task
            fpres = deblendBaseline.deblend(fp, exposure.getMaskedImage(), psf, psfFwhmPix,
                                            log=self.log,
                                            psfChisqCut1=self.psfChisqCut1,
                                            psfChisqCut2=self.psfChisqCut2,
                                            psfChisqCut2b=self.psfChisqCut2b)
        else:
            # Call lower-level _fit_psf task
 
            # Prepare results structure
            fpres = deblendBaseline.DeblenderResult(fp, exposure.getMaskedImage(), psf, psfFwhmPix, self.log)
 
            for pki, (pk, pkres, pkF) in enumerate(zip(dpeaks, fpres.deblendedParents[0].peaks, peaksF)):
                self.log.debug('Peak %i', pki)
                deblendBaseline._fitPsf(fp, fmask, pk, pkF, pkres, fbb, dpeaks, peaksF, self.log,
                                        cpsf, psfFwhmPix,
                                        subimage.image,
                                        subimage.variance,
                                        self.psfChisqCut1, self.psfChisqCut2, self.psfChisqCut2b)
 
        deblendedSource = source.getTable().copyRecord(source)
        deblendedSource.setParent(source.getId())
        peakList = deblendedSource.getFootprint().getPeaks()
        peakList.clear()
 
        for i, peak in enumerate(fpres.deblendedParents[0].peaks):
            if peak.psfFitFlux > 0:
                suffix = "pos"
            else:
                suffix = "neg"
            c = peak.psfFitCenter
            self.log.info("deblended.centroid.dipole.psf.%s %f %f",
                          suffix, c[0], c[1])
            self.log.info("deblended.chi2dof.dipole.%s %f",
                          suffix, peak.psfFitChisq / peak.psfFitDof)
            self.log.info("deblended.flux.dipole.psf.%s %f",
                          suffix, peak.psfFitFlux * np.sum(peak.templateImage.array))
            peakList.append(peak.peak)
        return deblendedSource

Member Data Documentation

log

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.log

Definition at line 308 of file dipoleMeasurement.py.

psfChisqCut1

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.psfChisqCut1

Definition at line 307 of file dipoleMeasurement.py.

psfChisqCut2

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.psfChisqCut2

Definition at line 359 of file dipoleMeasurement.py.

psfChisqCut2b

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.psfChisqCut2b

Definition at line 359 of file dipoleMeasurement.py.

sigma2fwhm

lsst.ip.diffim.dipoleMeasurement.DipoleDeblender.sigma2fwhm

Definition at line 309 of file dipoleMeasurement.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g1470d8bcf6+3ea6592b6f/python/lsst/ip/diffim/dipoleMeasurement.py