exposureIdInfo = dataRef.get("expIdInfo")
if self.config.insertFakes.fakeType == "snapshot":
fakeCat = dataRef.get("fakeSourceCat").toDataFrame()
elif self.config.insertFakes.fakeType == "static":
fakeCat = dataRef.get("deepCoadd_fakeSourceCat").toDataFrame()
else:
fakeCat = Table.read(self.config.insertFakes.fakeType).to_pandas()
calexp = dataRef.get("calexp")
if self.config.doApplyExternalGlobalSkyWcs or self.config.doApplyExternalTractSkyWcs:
self.log.info("Using external wcs from %s", self.config.externalSkyWcsName)
wcs = dataRef.get(self.config.externalSkyWcsName + "_wcs")
else:
wcs = calexp.getWcs()
if self.config.doApplyExternalGlobalPhotoCalib or self.config.doApplyExternalTractPhotoCalib:
self.log.info("Using external photocalib from %s", self.config.externalPhotoCalibName)
photoCalib = dataRef.get(self.config.externalPhotoCalibName + "_photoCalib")
else:
photoCalib = calexp.getPhotoCalib()
icSourceCat = dataRef.get("icSrc", immediate=True)
sfdSourceCat = dataRef.get("src", immediate=True)
resultStruct = self.run(fakeCat, calexp, wcs=wcs, photoCalib=photoCalib,
exposureIdInfo=exposureIdInfo, icSourceCat=icSourceCat,
sfdSourceCat=sfdSourceCat)
dataRef.put(resultStruct.outputExposure, "fakes_calexp")
dataRef.put(resultStruct.outputCat, "fakes_src")
return resultStruct
def runQuantum(self, butlerQC, inputRefs, outputRefs):
inputs = butlerQC.get(inputRefs)
detectorId = inputs["exposure"].getInfo().getDetector().getId()
if 'exposureIdInfo' not in inputs.keys():
expId, expBits = butlerQC.quantum.dataId.pack("visit_detector", returnMaxBits=True)
inputs['exposureIdInfo'] = ExposureIdInfo(expId, expBits)
expWcs = inputs["exposure"].getWcs()
tractId = inputs["skyMap"].findTract(
expWcs.pixelToSky(inputs["exposure"].getBBox().getCenter())).tract_id
if not self.config.doApplyExternalGlobalSkyWcs and not self.config.doApplyExternalTractSkyWcs:
inputs["wcs"] = expWcs
elif self.config.doApplyExternalGlobalSkyWcs:
externalSkyWcsCatalog = inputs["externalSkyWcsGlobalCatalog"]
row = externalSkyWcsCatalog.find(detectorId)
inputs["wcs"] = row.getWcs()
elif self.config.doApplyExternalTractSkyWcs:
externalSkyWcsCatalogList = inputs["externalSkyWcsTractCatalog"]
externalSkyWcsCatalog = None
for externalSkyWcsCatalogRef in externalSkyWcsCatalogList:
if externalSkyWcsCatalogRef.dataId["tract"] == tractId:
externalSkyWcsCatalog = externalSkyWcsCatalogRef.get(
datasetType=self.config.connections.externalSkyWcsTractCatalog)
break
if externalSkyWcsCatalog is None:
usedTract = externalSkyWcsCatalogList[-1].dataId["tract"]
self.log.warn(
f"Warning, external SkyWcs for tract {tractId} not found. Using tract {usedTract} "
"instead.")
externalSkyWcsCatalog = externalSkyWcsCatalogList[-1].get(
datasetType=self.config.connections.externalSkyWcsTractCatalog)
row = externalSkyWcsCatalog.find(detectorId)
inputs["wcs"] = row.getWcs()
if not self.config.doApplyExternalGlobalPhotoCalib and not self.config.doApplyExternalTractPhotoCalib:
inputs["photoCalib"] = inputs["exposure"].getPhotoCalib()
elif self.config.doApplyExternalGlobalPhotoCalib:
externalPhotoCalibCatalog = inputs["externalPhotoCalibGlobalCatalog"]
row = externalPhotoCalibCatalog.find(detectorId)
inputs["photoCalib"] = row.getPhotoCalib()
elif self.config.doApplyExternalTractPhotoCalib:
externalPhotoCalibCatalogList = inputs["externalPhotoCalibTractCatalog"]
externalPhotoCalibCatalog = None
for externalPhotoCalibCatalogRef in externalPhotoCalibCatalogList:
if externalPhotoCalibCatalogRef.dataId["tract"] == tractId:
externalPhotoCalibCatalog = externalPhotoCalibCatalogRef.get(
datasetType=self.config.connections.externalPhotoCalibTractCatalog)
break
if externalPhotoCalibCatalog is None:
usedTract = externalPhotoCalibCatalogList[-1].dataId["tract"]
self.log.warn(
f"Warning, external PhotoCalib for tract {tractId} not found. Using tract {usedTract} "
"instead.")
externalPhotoCalibCatalog = externalPhotoCalibCatalogList[-1].get(
datasetType=self.config.connections.externalPhotoCalibTractCatalog)
row = externalPhotoCalibCatalog.find(detectorId)
inputs["photoCalib"] = row.getPhotoCalib()
outputs = self.run(**inputs)
butlerQC.put(outputs, outputRefs)
@classmethod
def _makeArgumentParser(cls):
parser = pipeBase.ArgumentParser(name=cls._DefaultName)
parser.add_id_argument("--id", "fakes_calexp", help="data ID with raw CCD keys [+ tract optionally], "
"e.g. --id visit=12345 ccd=1,2 [tract=0]",
ContainerClass=PerTractCcdDataIdContainer)
return parser
def run(self, fakeCats, exposure, skyMap, wcs=None, photoCalib=None, exposureIdInfo=None,
icSourceCat=None, sfdSourceCat=None, externalSkyWcsGlobalCatalog=None,
externalSkyWcsTractCatalog=None, externalPhotoCalibGlobalCatalog=None,
externalPhotoCalibTractCatalog=None):
fakeCat = self.composeFakeCat(fakeCats, skyMap)
if wcs is None:
wcs = exposure.getWcs()
if photoCalib is None:
photoCalib = exposure.getPhotoCalib()
if self.config.doMatchVisit:
fakeCat = self.getVisitMatchedFakeCat(fakeCat, exposure)
self.insertFakes.run(fakeCat, exposure, wcs, photoCalib)
# detect, deblend and measure sources
if exposureIdInfo is None:
exposureIdInfo = ExposureIdInfo()
returnedStruct = self.calibrate.run(exposure, exposureIdInfo=exposureIdInfo)
sourceCat = returnedStruct.sourceCat
sourceCat = self.copyCalibrationFields(sfdSourceCat, sourceCat, self.config.srcFieldsToCopy)
resultStruct = pipeBase.Struct(outputExposure=exposure, outputCat=sourceCat)
return resultStruct
def composeFakeCat(self, fakeCats, skyMap):
if len(fakeCats) == 1:
return fakeCats[0].get(
datasetType=self.config.connections.fakeCats)
outputCat = []
for fakeCatRef in fakeCats:
cat = fakeCatRef.get(
datasetType=self.config.connections.fakeCats)
tractId = fakeCatRef.dataId["tract"]
# Make sure all data is within the inner part of the tract.
outputCat.append(cat[
skyMap.findTractIdArray(cat[self.config.insertFakes.ra_col],
cat[self.config.insertFakes.dec_col],
degrees=False)
== tractId])
return pd.concat(outputCat)
def getVisitMatchedFakeCat(self, fakeCat, exposure):
selected = exposure.getInfo().getVisitInfo().getId() == fakeCat["visit"]
return fakeCat[selected]
def copyCalibrationFields(self, calibCat, sourceCat, fieldsToCopy):
# Make a new SourceCatalog with the data from sourceCat so that we can add the new columns to it
sourceSchemaMapper = afwTable.SchemaMapper(sourceCat.schema)
sourceSchemaMapper.addMinimalSchema(sourceCat.schema, True)
calibSchemaMapper = afwTable.SchemaMapper(calibCat.schema, sourceCat.schema)
# Add the desired columns from the option fieldsToCopy
missingFieldNames = []
for fieldName in fieldsToCopy:
if fieldName in calibCat.schema:
schemaItem = calibCat.schema.find(fieldName)
calibSchemaMapper.editOutputSchema().addField(schemaItem.getField())
schema = calibSchemaMapper.editOutputSchema()
calibSchemaMapper.addMapping(schemaItem.getKey(), schema.find(fieldName).getField())
else:
missingFieldNames.append(fieldName)
if missingFieldNames:
raise RuntimeError(f"calibCat is missing fields {missingFieldNames} specified in "
"fieldsToCopy")
if "calib_detected" not in calibSchemaMapper.getOutputSchema():
self.calibSourceKey = calibSchemaMapper.addOutputField(afwTable.Field["Flag"]("calib_detected",
"Source was detected as an icSource"))
else:
self.calibSourceKey = None
schema = calibSchemaMapper.getOutputSchema()
newCat = afwTable.SourceCatalog(schema)
newCat.reserve(len(sourceCat))
newCat.extend(sourceCat, sourceSchemaMapper)
# Set the aliases so it doesn't complain.
for k, v in sourceCat.schema.getAliasMap().items():
newCat.schema.getAliasMap().set(k, v)
select = newCat["deblend_nChild"] == 0
matches = afwTable.matchXy(newCat[select], calibCat, self.config.matchRadiusPix)
# Check that no sourceCat sources are listed twice (we already know
# that each match has a unique calibCat source ID, due to using
# that ID as the key in bestMatches)
numMatches = len(matches)
numUniqueSources = len(set(m[1].getId() for m in matches))
if numUniqueSources != numMatches:
self.log.warning("%d calibCat sources matched only %d sourceCat sources", numMatches,
numUniqueSources)
self.log.info("Copying flags from calibCat to sourceCat for %s sources", numMatches)
# For each match: set the calibSourceKey flag and copy the desired
# fields
for src, calibSrc, d in matches:
if self.calibSourceKey:
src.setFlag(self.calibSourceKey, True)
# src.assign copies the footprint from calibSrc, which we don't want
# (DM-407)
# so set calibSrc's footprint to src's footprint before src.assign,
# then restore it
calibSrcFootprint = calibSrc.getFootprint()
try:
calibSrc.setFootprint(src.getFootprint())
src.assign(calibSrc, calibSchemaMapper)
finally:
calibSrc.setFootprint(calibSrcFootprint)
return newCat
class ProcessCcdWithVariableFakesConnections(ProcessCcdWithFakesConnections):
ccdVisitFakeMagnitudes = cT.Output(
doc="Catalog of fakes with magnitudes scattered for this ccdVisit.",
name="{fakesType}ccdVisitFakeMagnitudes",
storageClass="DataFrame",
dimensions=("instrument", "visit", "detector"),
)
class ProcessCcdWithVariableFakesConfig(ProcessCcdWithFakesConfig,
pipelineConnections=ProcessCcdWithVariableFakesConnections):
scatterSize = pexConfig.RangeField(
dtype=float,
default=0.4,
min=0,
max=100,
doc="Amount of scatter to add to the visit magnitude for variable "
"sources."
)
class ProcessCcdWithVariableFakesTask(ProcessCcdWithFakesTask):
_DefaultName = "processCcdWithVariableFakes"
ConfigClass = ProcessCcdWithVariableFakesConfig
def run(self, fakeCats, exposure, skyMap, wcs=None, photoCalib=None, exposureIdInfo=None,
icSourceCat=None, sfdSourceCat=None):
Definition at line 466 of file processCcdWithFakes.py.
