lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask Class Reference

Inheritance diagram for lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask:

Public Member Functions
	__init__ (self, schema, peakSchema=None, **kwargs)
	addSchemaKeys (self, schema)
	run (self, exposure, sources)
	deblend (self, exposure, srcs, psf)
	preSingleDeblendHook (self, exposure, srcs, i, fp, psf, psf_fwhm, sigma1)
	postSingleDeblendHook (self, exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res)
	isLargeFootprint (self, footprint)
	isMasked (self, footprint, mask)
	skipParent (self, source, mask)

Public Attributes
	schema
	toCopyFromParent
	peakSchemaMapper
	nChildKey
	psfKey
	psfCenterKey
	psfFluxKey
	tooManyPeaksKey
	tooBigKey
	maskedKey
	deblendFailedKey
	deblendSkippedKey
	deblendRampedTemplateKey
	deblendPatchedTemplateKey
	hasStrayFluxKey
	peakCenter
	peakIdKey
	nPeaksKey
	parentNPeaksKey

Static Public Attributes
	ConfigClass = SourceDeblendConfig

Protected Member Functions
	_getPsfFwhm (self, psf, position)

Static Protected Attributes
str	_DefaultName = "sourceDeblend"

Detailed Description

Split blended sources into individual sources.

This task has no return value; it only modifies the SourceCatalog in-place.

Definition at line 164 of file sourceDeblendTask.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.__init__	(		self,
			schema,
			peakSchema = None,
		**	kwargs )

Create the task, adding necessary fields to the given schema.

Parameters
----------
schema : `lsst.afw.table.Schema`
    Schema object for measurement fields; will be modified in-place.
peakSchema : `lsst.afw.table.peakSchema`
    Schema of Footprint Peaks that will be passed to the deblender.
    Any fields beyond the PeakTable minimal schema will be transferred
    to the main source Schema. If None, no fields will be transferred
    from the Peaks
**kwargs
    Additional keyword arguments passed to ~lsst.pipe.base.task

Definition at line 172 of file sourceDeblendTask.py.

    def __init__(self, schema, peakSchema=None, **kwargs):
        """Create the task, adding necessary fields to the given schema.
 
        Parameters
        ----------
        schema : `lsst.afw.table.Schema`
            Schema object for measurement fields; will be modified in-place.
        peakSchema : `lsst.afw.table.peakSchema`
            Schema of Footprint Peaks that will be passed to the deblender.
            Any fields beyond the PeakTable minimal schema will be transferred
            to the main source Schema. If None, no fields will be transferred
            from the Peaks
        **kwargs
            Additional keyword arguments passed to ~lsst.pipe.base.task
        """
        pipeBase.Task.__init__(self, **kwargs)
        self.schema = schema
        self.toCopyFromParent = [item.key for item in self.schema
                                 if item.field.getName().startswith("merge_footprint")]
        peakMinimalSchema = afwDet.PeakTable.makeMinimalSchema()
        if peakSchema is None:
            # In this case, the peakSchemaMapper will transfer nothing, but we'll still have one
            # to simplify downstream code
            self.peakSchemaMapper = afwTable.SchemaMapper(peakMinimalSchema, schema)
        else:
            self.peakSchemaMapper = afwTable.SchemaMapper(peakSchema, schema)
            for item in peakSchema:
                if item.key not in peakMinimalSchema:
                    self.peakSchemaMapper.addMapping(item.key, item.field)
                    # Because SchemaMapper makes a copy of the output schema you give its ctor, it isn't
                    # updating this Schema in place.  That's probably a design flaw, but in the meantime,
                    # we'll keep that schema in sync with the peakSchemaMapper.getOutputSchema() manually,
                    # by adding the same fields to both.
                    schema.addField(item.field)
            assert schema == self.peakSchemaMapper.getOutputSchema(), "Logic bug mapping schemas"
        self.addSchemaKeys(schema)
 

Member Function Documentation

_getPsfFwhm()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask._getPsfFwhm ( self, psf, position )

protected

Definition at line 281 of file sourceDeblendTask.py.

    def _getPsfFwhm(self, psf, position):
        return psf.computeShape(position).getDeterminantRadius() * 2.35
 

addSchemaKeys()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.addSchemaKeys	(		self,
			schema )

Definition at line 209 of file sourceDeblendTask.py.

    def addSchemaKeys(self, schema):
        self.nChildKey = schema.addField('deblend_nChild', type=np.int32,
                                         doc='Number of children this object has (defaults to 0)')
        self.psfKey = schema.addField('deblend_deblendedAsPsf', type='Flag',
                                      doc='Deblender thought this source looked like a PSF')
        self.psfCenterKey = afwTable.Point2DKey.addFields(schema, 'deblend_psfCenter',
                                                          'If deblended-as-psf, the PSF centroid', "pixel")
        self.psfFluxKey = schema.addField('deblend_psf_instFlux', type='D',
                                          doc='If deblended-as-psf, the instrumental PSF flux', units='count')
        self.tooManyPeaksKey = schema.addField('deblend_tooManyPeaks', type='Flag',
                                               doc='Source had too many peaks; '
                                               'only the brightest were included')
        self.tooBigKey = schema.addField('deblend_parentTooBig', type='Flag',
                                         doc='Parent footprint covered too many pixels')
        self.maskedKey = schema.addField('deblend_masked', type='Flag',
                                         doc='Parent footprint was predominantly masked')
 
        if self.config.catchFailures:
            self.deblendFailedKey = schema.addField('deblend_failed', type='Flag',
                                                    doc="Deblending failed on source")
 
        self.deblendSkippedKey = schema.addField('deblend_skipped', type='Flag',
                                                 doc="Deblender skipped this source")
 
        self.deblendRampedTemplateKey = schema.addField(
            'deblend_rampedTemplate', type='Flag',
            doc=('This source was near an image edge and the deblender used '
                 '"ramp" edge-handling.'))
 
        self.deblendPatchedTemplateKey = schema.addField(
            'deblend_patchedTemplate', type='Flag',
            doc=('This source was near an image edge and the deblender used '
                 '"patched" edge-handling.'))
 
        self.hasStrayFluxKey = schema.addField(
            'deblend_hasStrayFlux', type='Flag',
            doc=('This source was assigned some stray flux'))
 
        self.log.trace('Added keys to schema: %s', ", ".join(str(x) for x in (
                       self.nChildKey, self.psfKey, self.psfCenterKey, self.psfFluxKey,
                       self.tooManyPeaksKey, self.tooBigKey)))
        self.peakCenter = afwTable.Point2IKey.addFields(schema, name="deblend_peak_center",
                                                        doc="Center used to apply constraints in scarlet",
                                                        unit="pixel")
        self.peakIdKey = schema.addField("deblend_peakId", type=np.int32,
                                         doc="ID of the peak in the parent footprint. "
                                             "This is not unique, but the combination of 'parent'"
                                             "and 'peakId' should be for all child sources. "
                                             "Top level blends with no parents have 'peakId=0'")
        self.nPeaksKey = schema.addField("deblend_nPeaks", type=np.int32,
                                         doc="Number of initial peaks in the blend. "
                                             "This includes peaks that may have been culled "
                                             "during deblending or failed to deblend")
        self.parentNPeaksKey = schema.addField("deblend_parentNPeaks", type=np.int32,
                                               doc="Same as deblend_n_peaks, but the number of peaks "
                                                   "in the parent footprint")
 

deblend()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.deblend	(		self,
			exposure,
			srcs,
			psf )

Deblend.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to be processed
srcs : `lsst.afw.table.SourceCatalog`
    SourceCatalog containing sources detected on this exposure
psf : `lsst.afw.detection.Psf`
    Point source function

Returns
-------
None

Definition at line 285 of file sourceDeblendTask.py.

    def deblend(self, exposure, srcs, psf):
        """Deblend.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to be processed
        srcs : `lsst.afw.table.SourceCatalog`
            SourceCatalog containing sources detected on this exposure
        psf : `lsst.afw.detection.Psf`
            Point source function
 
        Returns
        -------
        None
        """
        # Cull footprints if required by ci
        if self.config.useCiLimits:
            self.log.info(f"Using CI catalog limits, "
                          f"the original number of sources to deblend was {len(srcs)}.")
            # Select parents with a number of children in the range
            # config.ciDeblendChildRange
            minChildren, maxChildren = self.config.ciDeblendChildRange
            nPeaks = np.array([len(src.getFootprint().peaks) for src in srcs])
            childrenInRange = np.where((nPeaks >= minChildren) & (nPeaks <= maxChildren))[0]
            if len(childrenInRange) < self.config.ciNumParentsToDeblend:
                raise ValueError("Fewer than ciNumParentsToDeblend children were contained in the range "
                                 "indicated by ciDeblendChildRange. Adjust this range to include more "
                                 "parents.")
            # Keep all of the isolated parents and the first
            # `ciNumParentsToDeblend` children
            parents = nPeaks == 1
            children = np.zeros((len(srcs),), dtype=bool)
            children[childrenInRange[:self.config.ciNumParentsToDeblend]] = True
            srcs = srcs[parents | children]
            # We need to update the IdFactory, otherwise the the source ids
            # will not be sequential
            idFactory = srcs.getIdFactory()
            maxId = np.max(srcs["id"])
            idFactory.notify(maxId)
 
        self.log.info("Deblending %d sources", len(srcs))
 
        from lsst.meas.deblender.baseline import deblend
 
        # find the median stdev in the image...
        mi = exposure.getMaskedImage()
        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setAndMask(mi.getMask().getPlaneBitMask(self.config.maskPlanes))
        stats = afwMath.makeStatistics(mi.getVariance(), mi.getMask(), afwMath.MEDIAN, statsCtrl)
        sigma1 = math.sqrt(stats.getValue(afwMath.MEDIAN))
        self.log.trace('sigma1: %g', sigma1)
 
        n0 = len(srcs)
        nparents = 0
        for i, src in enumerate(srcs):
            # t0 = time.clock()
 
            fp = src.getFootprint()
            pks = fp.getPeaks()
 
            # Since we use the first peak for the parent object, we should propagate its flags
            # to the parent source.
            src.assign(pks[0], self.peakSchemaMapper)
 
            if len(pks) < 2:
                continue
 
            if self.isLargeFootprint(fp):
                src.set(self.tooBigKey, True)
                self.skipParent(src, mi.getMask())
                self.log.debug('Parent %i: skipping large footprint (area: %i)',
                               int(src.getId()), int(fp.getArea()))
                continue
            if self.isMasked(fp, exposure.getMaskedImage().getMask()):
                src.set(self.maskedKey, True)
                self.skipParent(src, mi.getMask())
                self.log.debug('Parent %i: skipping masked footprint (area: %i)',
                               int(src.getId()), int(fp.getArea()))
                continue
 
            nparents += 1
            center = fp.getCentroid()
            psf_fwhm = self._getPsfFwhm(psf, center)
 
            if not (psf_fwhm > 0):
                if self.config.catchFailures:
                    self.log.warning("Unable to deblend source %d: because PSF FWHM=%f is invalid.",
                                     src.getId(), psf_fwhm)
                    src.set(self.deblendFailedKey, True)
                    continue
                else:
                    raise ValueError(f"PSF at {center} has an invalid FWHM value of {psf_fwhm}")
 
            self.log.trace('Parent %i: deblending %i peaks', int(src.getId()), len(pks))
 
            self.preSingleDeblendHook(exposure, srcs, i, fp, psf, psf_fwhm, sigma1)
            npre = len(srcs)
 
            # This should really be set in deblend, but deblend doesn't have access to the src
            src.set(self.tooManyPeaksKey, len(fp.getPeaks()) > self.config.maxNumberOfPeaks)
 
            try:
                res = deblend(
                    fp, mi, psf, psf_fwhm, sigma1=sigma1,
                    psfChisqCut1=self.config.psfChisq1,
                    psfChisqCut2=self.config.psfChisq2,
                    psfChisqCut2b=self.config.psfChisq2b,
                    maxNumberOfPeaks=self.config.maxNumberOfPeaks,
                    strayFluxToPointSources=self.config.strayFluxToPointSources,
                    assignStrayFlux=self.config.assignStrayFlux,
                    strayFluxAssignment=self.config.strayFluxRule,
                    rampFluxAtEdge=(self.config.edgeHandling == 'ramp'),
                    patchEdges=(self.config.edgeHandling == 'noclip'),
                    tinyFootprintSize=self.config.tinyFootprintSize,
                    clipStrayFluxFraction=self.config.clipStrayFluxFraction,
                    weightTemplates=self.config.weightTemplates,
                    removeDegenerateTemplates=self.config.removeDegenerateTemplates,
                    maxTempDotProd=self.config.maxTempDotProd,
                    medianSmoothTemplate=self.config.medianSmoothTemplate
                )
                if self.config.catchFailures:
                    src.set(self.deblendFailedKey, False)
            except Exception as e:
                if self.config.catchFailures:
                    self.log.warning("Unable to deblend source %d: %s", src.getId(), e)
                    src.set(self.deblendFailedKey, True)
                    import traceback
                    traceback.print_exc()
                    continue
                else:
                    raise
 
            kids = []
            nchild = 0
            for j, peak in enumerate(res.deblendedParents[0].peaks):
                heavy = peak.getFluxPortion()
                if heavy is None or peak.skip:
                    src.set(self.deblendSkippedKey, True)
                    if not self.config.propagateAllPeaks:
                        # Don't care
                        continue
                    # We need to preserve the peak: make sure we have enough info to create a minimal
                    # child src
                    self.log.trace("Peak at (%i,%i) failed.  Using minimal default info for child.",
                                   pks[j].getIx(), pks[j].getIy())
                    if heavy is None:
                        # copy the full footprint and strip out extra peaks
                        foot = afwDet.Footprint(src.getFootprint())
                        peakList = foot.getPeaks()
                        peakList.clear()
                        peakList.append(peak.peak)
                        zeroMimg = afwImage.MaskedImageF(foot.getBBox())
                        heavy = afwDet.makeHeavyFootprint(foot, zeroMimg)
                    if peak.deblendedAsPsf:
                        if peak.psfFitFlux is None:
                            peak.psfFitFlux = 0.0
                        if peak.psfFitCenter is None:
                            peak.psfFitCenter = (peak.peak.getIx(), peak.peak.getIy())
 
                assert len(heavy.getPeaks()) == 1
 
                src.set(self.deblendSkippedKey, False)
                child = srcs.addNew()
                nchild += 1
                for key in self.toCopyFromParent:
                    child.set(key, src.get(key))
                child.assign(heavy.getPeaks()[0], self.peakSchemaMapper)
                child.setParent(src.getId())
                child.setFootprint(heavy)
                child.set(self.psfKey, peak.deblendedAsPsf)
                child.set(self.hasStrayFluxKey, peak.strayFlux is not None)
                if peak.deblendedAsPsf:
                    (cx, cy) = peak.psfFitCenter
                    child.set(self.psfCenterKey, geom.Point2D(cx, cy))
                    child.set(self.psfFluxKey, peak.psfFitFlux)
                child.set(self.deblendRampedTemplateKey, peak.hasRampedTemplate)
                child.set(self.deblendPatchedTemplateKey, peak.patched)
 
                # Set the position of the peak from the parent footprint
                # This will make it easier to match the same source across
                # deblenders and across observations, where the peak
                # position is unlikely to change unless enough time passes
                # for a source to move on the sky.
                child.set(self.peakCenter, geom.Point2I(pks[j].getIx(), pks[j].getIy()))
                child.set(self.peakIdKey, pks[j].getId())
 
                # The children have a single peak
                child.set(self.nPeaksKey, 1)
                # Set the number of peaks in the parent
                child.set(self.parentNPeaksKey, len(pks))
 
                kids.append(child)
 
            # Child footprints may extend beyond the full extent of their parent's which
            # results in a failure of the replace-by-noise code to reinstate these pixels
            # to their original values.  The following updates the parent footprint
            # in-place to ensure it contains the full union of itself and all of its
            # children's footprints.
            spans = src.getFootprint().spans
            for child in kids:
                spans = spans.union(child.getFootprint().spans)
            src.getFootprint().setSpans(spans)
 
            src.set(self.nChildKey, nchild)
 
            self.postSingleDeblendHook(exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res)
            # print('Deblending parent id', src.getId(), 'took', time.clock() - t0)
 
        n1 = len(srcs)
        self.log.info('Deblended: of %i sources, %i were deblended, creating %i children, total %i sources',
                      n0, nparents, n1-n0, n1)
 

isLargeFootprint()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.isLargeFootprint	(		self,
			footprint )

Returns whether a Footprint is large

'Large' is defined by thresholds on the area, size and axis ratio.
These may be disabled independently by configuring them to be non-positive.

This is principally intended to get rid of satellite streaks, which the
deblender or other downstream processing can have trouble dealing with
(e.g., multiple large HeavyFootprints can chew up memory).

Definition at line 504 of file sourceDeblendTask.py.

    def isLargeFootprint(self, footprint):
        """Returns whether a Footprint is large
 
        'Large' is defined by thresholds on the area, size and axis ratio.
        These may be disabled independently by configuring them to be non-positive.
 
        This is principally intended to get rid of satellite streaks, which the
        deblender or other downstream processing can have trouble dealing with
        (e.g., multiple large HeavyFootprints can chew up memory).
        """
        if self.config.maxFootprintArea > 0 and footprint.getArea() > self.config.maxFootprintArea:
            return True
        if self.config.maxFootprintSize > 0:
            bbox = footprint.getBBox()
            if max(bbox.getWidth(), bbox.getHeight()) > self.config.maxFootprintSize:
                return True
        if self.config.minFootprintAxisRatio > 0:
            axes = afwEll.Axes(footprint.getShape())
            if axes.getB() < self.config.minFootprintAxisRatio*axes.getA():
                return True
        return False
 

isMasked()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.isMasked	(		self,
			footprint,
			mask )

Returns whether the footprint violates the mask limits

Definition at line 526 of file sourceDeblendTask.py.

    def isMasked(self, footprint, mask):
        """Returns whether the footprint violates the mask limits
        """
        size = float(footprint.getArea())
        for maskName, limit in self.config.maskLimits.items():
            maskVal = mask.getPlaneBitMask(maskName)
            unmaskedSpan = footprint.spans.intersectNot(mask, maskVal)  # spanset of unmasked pixels
            if (size - unmaskedSpan.getArea())/size > limit:
                return True
        return False
 

postSingleDeblendHook()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.postSingleDeblendHook	(		self,
			exposure,
			srcs,
			i,
			npre,
			kids,
			fp,
			psf,
			psf_fwhm,
			sigma1,
			res )

Definition at line 501 of file sourceDeblendTask.py.

    def postSingleDeblendHook(self, exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res):
        pass
 

preSingleDeblendHook()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.preSingleDeblendHook	(		self,
			exposure,
			srcs,
			i,
			fp,
			psf,
			psf_fwhm,
			sigma1 )

Definition at line 498 of file sourceDeblendTask.py.

    def preSingleDeblendHook(self, exposure, srcs, i, fp, psf, psf_fwhm, sigma1):
        pass
 

run()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.run	(		self,
			exposure,
			sources )

Get the PSF from the provided exposure and then run deblend.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to be processed
sources : `lsst.afw.table.SourceCatalog`
    SourceCatalog containing sources detected on this exposure.

Definition at line 267 of file sourceDeblendTask.py.

    def run(self, exposure, sources):
        """Get the PSF from the provided exposure and then run deblend.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to be processed
        sources : `lsst.afw.table.SourceCatalog`
            SourceCatalog containing sources detected on this exposure.
        """
        psf = exposure.getPsf()
        assert sources.getSchema() == self.schema
        self.deblend(exposure, sources, psf)
 

skipParent()

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.skipParent	(		self,
			source,
			mask )

Indicate that the parent source is not being deblended

We set the appropriate flags and mask.

Parameters
----------
source : `lsst.afw.table.SourceRecord`
    The source to flag as skipped
mask : `lsst.afw.image.Mask`
    The mask to update

Definition at line 537 of file sourceDeblendTask.py.

    def skipParent(self, source, mask):
        """Indicate that the parent source is not being deblended
 
        We set the appropriate flags and mask.
 
        Parameters
        ----------
        source : `lsst.afw.table.SourceRecord`
            The source to flag as skipped
        mask : `lsst.afw.image.Mask`
            The mask to update
        """
        fp = source.getFootprint()
        source.set(self.deblendSkippedKey, True)
        if self.config.notDeblendedMask:
            mask.addMaskPlane(self.config.notDeblendedMask)
            fp.spans.setMask(mask, mask.getPlaneBitMask(self.config.notDeblendedMask))
 
        # Set the center of the parent
        bbox = fp.getBBox()
        centerX = int(bbox.getMinX()+bbox.getWidth()/2)
        centerY = int(bbox.getMinY()+bbox.getHeight()/2)
        source.set(self.peakCenter, geom.Point2I(centerX, centerY))
        # There are no deblended children, so nChild = 0
        source.set(self.nChildKey, 0)
        # But we also want to know how many peaks that we would have
        # deblended if the parent wasn't skipped.
        source.set(self.nPeaksKey, len(fp.peaks))
        # Top level parents are not a detected peak, so they have no peakId
        source.set(self.peakIdKey, 0)
        # Top level parents also have no parentNPeaks
        source.set(self.parentNPeaksKey, 0)

Member Data Documentation

_DefaultName

str lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask._DefaultName = "sourceDeblend"

staticprotected

Definition at line 170 of file sourceDeblendTask.py.

ConfigClass

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.ConfigClass = SourceDeblendConfig

static

Definition at line 169 of file sourceDeblendTask.py.

deblendFailedKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.deblendFailedKey

Definition at line 227 of file sourceDeblendTask.py.

deblendPatchedTemplateKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.deblendPatchedTemplateKey

Definition at line 238 of file sourceDeblendTask.py.

deblendRampedTemplateKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.deblendRampedTemplateKey

Definition at line 233 of file sourceDeblendTask.py.

deblendSkippedKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.deblendSkippedKey

Definition at line 230 of file sourceDeblendTask.py.

hasStrayFluxKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.hasStrayFluxKey

Definition at line 243 of file sourceDeblendTask.py.

maskedKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.maskedKey

Definition at line 223 of file sourceDeblendTask.py.

nChildKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.nChildKey

Definition at line 210 of file sourceDeblendTask.py.

nPeaksKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.nPeaksKey

Definition at line 258 of file sourceDeblendTask.py.

parentNPeaksKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.parentNPeaksKey

Definition at line 262 of file sourceDeblendTask.py.

peakCenter

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.peakCenter

Definition at line 250 of file sourceDeblendTask.py.

peakIdKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.peakIdKey

Definition at line 253 of file sourceDeblendTask.py.

peakSchemaMapper

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.peakSchemaMapper

Definition at line 195 of file sourceDeblendTask.py.

psfCenterKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.psfCenterKey

Definition at line 214 of file sourceDeblendTask.py.

psfFluxKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.psfFluxKey

Definition at line 216 of file sourceDeblendTask.py.

psfKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.psfKey

Definition at line 212 of file sourceDeblendTask.py.

schema

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.schema

Definition at line 188 of file sourceDeblendTask.py.

toCopyFromParent

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.toCopyFromParent

Definition at line 189 of file sourceDeblendTask.py.

tooBigKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.tooBigKey

Definition at line 221 of file sourceDeblendTask.py.

tooManyPeaksKey

lsst.meas.deblender.sourceDeblendTask.SourceDeblendTask.tooManyPeaksKey

Definition at line 218 of file sourceDeblendTask.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_deblender/g99cad8db69+d39438377f/python/lsst/meas/deblender/sourceDeblendTask.py