24from lsst.pipe.base import (Struct, PipelineTask, PipelineTaskConfig, PipelineTaskConnections)
25import lsst.pipe.base.connectionTypes
as cT
29from lsst.meas.extensions.scarlet
import ScarletDeblendTask
30from lsst.obs.base
import ExposureIdInfo
35from .makeCoaddTempExp
import reorderRefs
37__all__ = (
"DeblendCoaddSourcesSingleConfig",
"DeblendCoaddSourcesSingleTask",
38 "DeblendCoaddSourcesMultiConfig",
"DeblendCoaddSourcesMultiTask")
41deblendBaseTemplates = {
"inputCoaddName":
"deep",
"outputCoaddName":
"deep"}
45 dimensions=(
"tract",
"patch",
"band",
"skymap"),
46 defaultTemplates=deblendBaseTemplates):
47 inputSchema = cT.InitInput(
48 doc=
"Input schema to use in the deblend catalog",
49 name=
"{inputCoaddName}Coadd_mergeDet_schema",
50 storageClass=
"SourceCatalog"
52 peakSchema = cT.InitInput(
53 doc=
"Schema of the footprint peak catalogs",
54 name=
"{inputCoaddName}Coadd_peak_schema",
55 storageClass=
"PeakCatalog"
57 mergedDetections = cT.Input(
58 doc=
"Detection catalog merged across bands",
59 name=
"{inputCoaddName}Coadd_mergeDet",
60 storageClass=
"SourceCatalog",
61 dimensions=(
"tract",
"patch",
"skymap")
64 doc=
"Exposure on which to run deblending",
65 name=
"{inputCoaddName}Coadd_calexp",
66 storageClass=
"ExposureF",
67 dimensions=(
"tract",
"patch",
"band",
"skymap")
69 measureCatalog = cT.Output(
70 doc=
"The output measurement catalog of deblended sources",
71 name=
"{outputCoaddName}Coadd_deblendedFlux",
72 storageClass=
"SourceCatalog",
73 dimensions=(
"tract",
"patch",
"band",
"skymap")
75 outputSchema = cT.InitOutput(
76 doc=
"Output of the schema used in deblending task",
77 name=
"{outputCoaddName}Coadd_deblendedFlux_schema",
78 storageClass=
"SourceCatalog"
83 self.singleBandDeblend.propagateAllPeaks =
True
87 pipelineConnections=DeblendCoaddSourceSingleConnections):
88 singleBandDeblend = ConfigurableField(
89 target=SourceDeblendTask,
90 doc=
"Task to deblend an image in one band"
95 dimensions=(
"tract",
"patch",
"skymap"),
96 defaultTemplates=deblendBaseTemplates):
97 inputSchema = cT.InitInput(
98 doc=
"Input schema to use in the deblend catalog",
99 name=
"{inputCoaddName}Coadd_mergeDet_schema",
100 storageClass=
"SourceCatalog"
102 peakSchema = cT.InitInput(
103 doc=
"Schema of the footprint peak catalogs",
104 name=
"{inputCoaddName}Coadd_peak_schema",
105 storageClass=
"PeakCatalog"
107 mergedDetections = cT.Input(
108 doc=
"Detection catalog merged across bands",
109 name=
"{inputCoaddName}Coadd_mergeDet",
110 storageClass=
"SourceCatalog",
111 dimensions=(
"tract",
"patch",
"skymap")
114 doc=
"Exposure on which to run deblending",
115 name=
"{inputCoaddName}Coadd_calexp",
116 storageClass=
"ExposureF",
118 dimensions=(
"tract",
"patch",
"band",
"skymap")
120 outputSchema = cT.InitOutput(
121 doc=
"Output of the schema used in deblending task",
122 name=
"{outputCoaddName}Coadd_deblendedFlux_schema",
123 storageClass=
"SourceCatalog"
125 fluxCatalogs = cT.Output(
126 doc=
"Flux weighted catalogs produced by multiband deblending",
127 name=
"{outputCoaddName}Coadd_deblendedFlux",
128 storageClass=
"SourceCatalog",
129 dimensions=(
"tract",
"patch",
"band",
"skymap"),
132 templateCatalogs = cT.Output(
133 doc=
"Template catalogs produced by multiband deblending",
134 name=
"{outputCoaddName}Coadd_deblendedModel",
135 storageClass=
"SourceCatalog",
136 dimensions=(
"tract",
"patch",
"band",
"skymap"),
142 pipelineConnections=DeblendCoaddSourcesMultiConnections):
143 multibandDeblend = ConfigurableField(
144 target=ScarletDeblendTask,
145 doc=
"Task to deblend an images in multiple bands"
151 super().
__init__(initInputs=initInputs, **kwargs)
152 schema = initInputs[
"inputSchema"].schema
159 inputs = butlerQC.get(inputRefs)
160 inputs[
"idFactory"] = ExposureIdInfo.fromDataId(
161 butlerQC.quantum.dataId,
163 ).makeSourceIdFactory()
164 outputs = self.run(**inputs)
165 butlerQC.put(outputs, outputRefs)
167 def _makeSourceCatalog(self, mergedDetections, idFactory):
171 maxId = np.max(mergedDetections[
"id"])
172 idFactory.notify(maxId)
173 table = afwTable.SourceTable.make(self.
schemaschema, idFactory)
174 sources = afwTable.SourceCatalog(table)
175 sources.extend(mergedDetections, self.
schemaMapperschemaMapper)
180 ConfigClass = DeblendCoaddSourcesSingleConfig
181 _DefaultName =
"deblendCoaddSourcesSingle"
184 super().
__init__(initInputs=initInputs, **kwargs)
185 self.makeSubtask(
"singleBandDeblend", schema=self.
schemaschema, peakSchema=self.
peakSchemapeakSchema)
188 def run(self, coadd, mergedDetections, idFactory):
190 self.singleBandDeblend.
run(coadd, sources)
191 if not sources.isContiguous():
192 sources = sources.copy(deep=
True)
193 return Struct(measureCatalog=sources)
197 ConfigClass = DeblendCoaddSourcesMultiConfig
198 _DefaultName =
"deblendCoaddSourcesMulti"
201 super().
__init__(initInputs=initInputs, **kwargs)
202 self.makeSubtask(
"multibandDeblend", schema=self.
schemaschema, peakSchema=self.
peakSchemapeakSchema)
208 bandOrder = [dRef.dataId[
"band"]
for dRef
in inputRefs.coadds]
210 inputRefs = reorderRefs(inputRefs, bandOrder, dataIdKey=
"band")
211 inputs = butlerQC.get(inputRefs)
212 exposureIdInfo = ExposureIdInfo.fromDataId(butlerQC.quantum.dataId,
"tract_patch")
213 inputs[
"idFactory"] = exposureIdInfo.makeSourceIdFactory()
214 inputs[
"filters"] = [dRef.dataId[
"band"]
for dRef
in inputRefs.coadds]
215 outputs = self.
runrun(**inputs)
216 for outRef
in outputRefs.templateCatalogs:
217 band = outRef.dataId[
'band']
218 if (catalog := outputs.templateCatalogs.get(band))
is not None:
219 butlerQC.put(catalog, outRef)
221 for outRef
in outputRefs.fluxCatalogs:
222 band = outRef.dataId[
'band']
223 if (catalog := outputs.fluxCatalogs.get(band))
is not None:
224 butlerQC.put(catalog, outRef)
226 def run(self, coadds, filters, mergedDetections, idFactory):
228 multiExposure = afwImage.MultibandExposure.fromExposures(filters, coadds)
229 templateCatalogs, fluxCatalogs = self.multibandDeblend.
run(multiExposure, sources)
230 retStruct = Struct(templateCatalogs=templateCatalogs, fluxCatalogs=fluxCatalogs)
def __init__(self, initInputs, **kwargs)
def _makeSourceCatalog(self, mergedDetections, idFactory)
def runQuantum(self, butlerQC, inputRefs, outputRefs)
def runQuantum(self, butlerQC, inputRefs, outputRefs)
def run(self, coadds, filters, mergedDetections, idFactory)
def __init__(self, initInputs, **kwargs)
def __init__(self, initInputs, **kwargs)
def run(self, coadd, mergedDetections, idFactory)