lsst.ip.diffim gaa63f70f4e+5e034ae04a
Loading...
Searching...
No Matches
Classes | Variables
lsst.ip.diffim.detectAndMeasure Namespace Reference

Classes

class  DetectAndMeasureConnections
 

Variables

int expId : `int`
 
int expBits : `int`
 
lsst idFactory : `lsst.afw.table.IdFactory`
 
lsst science : `lsst.afw.image.ExposureF`
 
lsst template : `lsst.afw.image.ExposureF`
 
lsst difference : `lsst.afw.image.ExposureF`
 
lsst selectSources : `lsst.afw.table.SourceCatalog`, optional
 
lsst results : `lsst.pipe.base.Struct`
 
lsst diaSources : `lsst.afw.table.SourceCatalog`
 
lsst mask : `lsst.afw.image.Mask`
 
int seed : `int`
 
lsst matchedTemplate : `lsst.afw.image.ExposureF`
 
lsst wcs : `lsst.afw.geom.SkyWcs`
 

Variable Documentation

◆ diaSources

lsst lsst.ip.diffim.detectAndMeasure.diaSources : `lsst.afw.table.SourceCatalog`
# Ensure that we start with an empty detection mask.
mask = difference.mask
mask &= ~(mask.getPlaneBitMask("DETECTED") | mask.getPlaneBitMask("DETECTED_NEGATIVE"))

table = afwTable.SourceTable.make(self.schema, idFactory)
table.setMetadata(self.algMetadata)
results = self.detection.run(
    table=table,
    exposure=difference,
    doSmooth=True,
)

if self.config.doMerge:
    fpSet = results.fpSets.positive
    fpSet.merge(results.fpSets.negative, self.config.growFootprint,
                self.config.growFootprint, False)
    diaSources = afwTable.SourceCatalog(table)
    fpSet.makeSources(diaSources)
    self.log.info("Merging detections into %d sources", len(diaSources))
else:
    diaSources = results.sources

if self.config.doSkySources:
    self.addSkySources(diaSources, difference.mask, difference.info.id)

self.measureDiaSources(diaSources, science, difference, template)

if self.config.doForcedMeasurement:
    self.measureForcedSources(diaSources, science, difference.getWcs())

return pipeBase.Struct(
    subtractedMeasuredExposure=difference,
    diaSources=diaSources,
)

def addSkySources(self, diaSources, mask, seed):
skySourceFootprints = self.skySources.run(mask=mask, seed=seed)
if skySourceFootprints:
    for foot in skySourceFootprints:
        s = diaSources.addNew()
        s.setFootprint(foot)
        s.set(self.skySourceKey, True)

def measureDiaSources(self, diaSources, science, difference, matchedTemplate):
# Note that this may not be correct if we convolved the science image.
# In the future we may wish to persist the matchedScience image.
self.measurement.run(diaSources, difference, science, matchedTemplate)
if self.config.doApCorr:
    self.applyApCorr.run(
        catalog=diaSources,
        apCorrMap=difference.getInfo().getApCorrMap()
    )

def measureForcedSources(self, diaSources, science, wcs):

Definition at line 325 of file detectAndMeasure.py.

◆ difference

lsst lsst.ip.diffim.detectAndMeasure.difference : `lsst.afw.image.ExposureF`

Definition at line 268 of file detectAndMeasure.py.

◆ expBits

int lsst.ip.diffim.detectAndMeasure.expBits : `int`

Definition at line 226 of file detectAndMeasure.py.

◆ expId

int lsst.ip.diffim.detectAndMeasure.expId : `int`
doMerge = pexConfig.Field(
    dtype=bool,
    default=True,
    doc="Merge positive and negative diaSources with grow radius "
        "set by growFootprint"
)
doForcedMeasurement = pexConfig.Field(
    dtype=bool,
    default=True,
    doc="Force photometer diaSource locations on PVI?")
doAddMetrics = pexConfig.Field(
    dtype=bool,
    default=False,
    doc="Add columns to the source table to hold analysis metrics?"
)
detection = pexConfig.ConfigurableField(
    target=SourceDetectionTask,
    doc="Final source detection for diaSource measurement",
)
measurement = pexConfig.ConfigurableField(
    target=DipoleFitTask,
    doc="Task to measure sources on the difference image.",
)
doApCorr = lsst.pex.config.Field(
    dtype=bool,
    default=True,
    doc="Run subtask to apply aperture corrections"
)
applyApCorr = lsst.pex.config.ConfigurableField(
    target=ApplyApCorrTask,
    doc="Task to apply aperture corrections"
)
forcedMeasurement = pexConfig.ConfigurableField(
    target=ForcedMeasurementTask,
    doc="Task to force photometer science image at diaSource locations.",
)
growFootprint = pexConfig.Field(
    dtype=int,
    default=2,
    doc="Grow positive and negative footprints by this many pixels before merging"
)
diaSourceMatchRadius = pexConfig.Field(
    dtype=float,
    default=0.5,
    doc="Match radius (in arcseconds) for DiaSource to Source association"
)
doSkySources = pexConfig.Field(
    dtype=bool,
    default=False,
    doc="Generate sky sources?",
)
skySources = pexConfig.ConfigurableField(
    target=SkyObjectsTask,
    doc="Generate sky sources",
)

def setDefaults(self):
    # DiaSource Detection
    self.detection.thresholdPolarity = "both"
    self.detection.thresholdValue = 5.0
    self.detection.reEstimateBackground = False
    self.detection.thresholdType = "pixel_stdev"

    # Add filtered flux measurement, the correct measurement for pre-convolved images.
    self.measurement.algorithms.names.add('base_PeakLikelihoodFlux')
    self.measurement.plugins.names |= ['ext_trailedSources_Naive',
                                       'base_LocalPhotoCalib',
                                       'base_LocalWcs']

    self.forcedMeasurement.plugins = ["base_TransformedCentroid", "base_PsfFlux"]
    self.forcedMeasurement.copyColumns = {
        "id": "objectId", "parent": "parentObjectId", "coord_ra": "coord_ra", "coord_dec": "coord_dec"}
    self.forcedMeasurement.slots.centroid = "base_TransformedCentroid"
    self.forcedMeasurement.slots.shape = None


class DetectAndMeasureTask(lsst.pipe.base.PipelineTask):
ConfigClass = DetectAndMeasureConfig
_DefaultName = "detectAndMeasure"

def __init__(self, **kwargs):
    super().__init__(**kwargs)
    self.schema = afwTable.SourceTable.makeMinimalSchema()

    self.algMetadata = dafBase.PropertyList()
    self.makeSubtask("detection", schema=self.schema)
    self.makeSubtask("measurement", schema=self.schema,
                     algMetadata=self.algMetadata)
    if self.config.doApCorr:
        self.makeSubtask("applyApCorr", schema=self.measurement.schema)
    if self.config.doForcedMeasurement:
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_instFlux", "D",
            "Forced PSF flux measured on the direct image.",
            units="count")
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_instFluxErr", "D",
            "Forced PSF flux error measured on the direct image.",
            units="count")
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_area", "F",
            "Forced PSF flux effective area of PSF.",
            units="pixel")
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_flag", "Flag",
            "Forced PSF flux general failure flag.")
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_flag_noGoodPixels", "Flag",
            "Forced PSF flux not enough non-rejected pixels in data to attempt the fit.")
        self.schema.addField(
            "ip_diffim_forced_PsfFlux_flag_edge", "Flag",
            "Forced PSF flux object was too close to the edge of the image to use the full PSF model.")
        self.makeSubtask("forcedMeasurement", refSchema=self.schema)

    self.schema.addField("refMatchId", "L", "unique id of reference catalog match")
    self.schema.addField("srcMatchId", "L", "unique id of source match")
    if self.config.doSkySources:
        self.makeSubtask("skySources")
        self.skySourceKey = self.schema.addField("sky_source", type="Flag", doc="Sky objects.")

    # initialize InitOutputs
    self.outputSchema = afwTable.SourceCatalog(self.schema)
    self.outputSchema.getTable().setMetadata(self.algMetadata)

@staticmethod
def makeIdFactory(expId, expBits):

Definition at line 223 of file detectAndMeasure.py.

◆ idFactory

lsst lsst.ip.diffim.detectAndMeasure.idFactory : `lsst.afw.table.IdFactory`

Definition at line 237 of file detectAndMeasure.py.

◆ mask

lsst lsst.ip.diffim.detectAndMeasure.mask : `lsst.afw.image.Mask`

Definition at line 327 of file detectAndMeasure.py.

◆ matchedTemplate

lsst lsst.ip.diffim.detectAndMeasure.matchedTemplate : `lsst.afw.image.ExposureF`

Definition at line 350 of file detectAndMeasure.py.

◆ results

lsst lsst.ip.diffim.detectAndMeasure.results : `lsst.pipe.base.Struct`

Definition at line 277 of file detectAndMeasure.py.

◆ science

lsst lsst.ip.diffim.detectAndMeasure.science : `lsst.afw.image.ExposureF`
return ExposureIdInfo(expId, expBits).makeSourceIdFactory()

def runQuantum(self, butlerQC: pipeBase.ButlerQuantumContext,
           inputRefs: pipeBase.InputQuantizedConnection,
           outputRefs: pipeBase.OutputQuantizedConnection):
inputs = butlerQC.get(inputRefs)
expId, expBits = butlerQC.quantum.dataId.pack("visit_detector",
                                              returnMaxBits=True)
idFactory = self.makeIdFactory(expId=expId, expBits=expBits)

outputs = self.run(inputs['science'],
                   inputs['template'],
                   inputs['difference'],
                   inputs['selectSources'],
                   idFactory=idFactory)
butlerQC.put(outputs, outputRefs)

@timeMethod
def run(self, science, template, difference, selectSources,
    idFactory=None):

Definition at line 263 of file detectAndMeasure.py.

◆ seed

int lsst.ip.diffim.detectAndMeasure.seed : `int`

Definition at line 329 of file detectAndMeasure.py.

◆ selectSources

lsst lsst.ip.diffim.detectAndMeasure.selectSources : `lsst.afw.table.SourceCatalog`, optional

Definition at line 270 of file detectAndMeasure.py.

◆ template

lsst lsst.ip.diffim.detectAndMeasure.template : `lsst.afw.image.ExposureF`

Definition at line 265 of file detectAndMeasure.py.

◆ wcs

lsst lsst.ip.diffim.detectAndMeasure.wcs : `lsst.afw.geom.SkyWcs`

Definition at line 372 of file detectAndMeasure.py.