LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
Classes | Variables
lsst.pipe.tasks.processCcdWithFakes Namespace Reference

Classes

class  ProcessCcdWithFakesConnections
 
class  docstring
 

Variables

 radius
 
 cleanCat
 

Variable Documentation

◆ cleanCat

lsst.pipe.tasks.processCcdWithFakes.cleanCat

Definition at line 350 of file processCcdWithFakes.py.

◆ radius

lsst.pipe.tasks.processCcdWithFakes.radius
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.doApplyExternalSkyWcs:
    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.doApplyExternalPhotoCalib:
    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)
if 'exposureIdInfo' not in inputs.keys():
    expId, expBits = butlerQC.quantum.dataId.pack("visit_detector", returnMaxBits=True)
    inputs['exposureIdInfo'] = ExposureIdInfo(expId, expBits)

if not self.config.doApplyExternalSkyWcs:
    inputs["wcs"] = inputs["exposure"].getWcs()

if not self.config.doApplyExternalPhotoCalib:
    inputs["photoCalib"] = inputs["exposure"].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, fakeCat, exposure, wcs=None, photoCalib=None, exposureIdInfo=None, icSourceCat=None,
    sfdSourceCat=None):
if wcs is None:
    wcs = exposure.getWcs()

if photoCalib is None:
    photoCalib = exposure.getPhotoCalib()

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 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, fakeCat, exposure, wcs=None, photoCalib=None, exposureIdInfo=None, icSourceCat=None,
        sfdSourceCat=None):

Definition at line 350 of file processCcdWithFakes.py.