class CalibsRegisterConfig(RegisterConfig):
"""Configuration for the CalibsRegisterTask"""
tables = ListField(dtype=str,
default=[
"bias", "dark", "flat", "fringe", "sky", "defects",
"qe_curve"
],
doc="Names of tables")
calibDate = Field(dtype=str,
default="calibDate",
doc="Name of column for calibration date")
validStart = Field(dtype=str,
default="validStart",
doc="Name of column for validity start")
validEnd = Field(dtype=str,
default="validEnd",
doc="Name of column for validity stop")
detector = ListField(dtype=str,
default=["filter", "ccd"],
doc="Columns that identify individual detectors")
validityUntilSuperseded = ListField(
dtype=str,
default=["defects", "qe_curve"],
doc="Tables for which to set validity for a calib from when it is "
"taken until it is superseded by the next; validity in other tables "
"is calculated by applying the validity range.")
class VignetteConfig(Config):
"""Settings to define vignetting pattern.
"""
xCenter = Field(
dtype=float,
doc="Center of vignetting pattern, in focal plane x coordinates.",
default=0.0,
)
yCenter = Field(
dtype=float,
doc="Center of vignetting pattern, in focal plane y coordinates.",
default=0.0,
)
radius = Field(
dtype=float,
doc="Radius of vignetting pattern, in focal plane coordinates.",
default=100.0,
check=lambda x: x >= 0)
numPolygonPoints = Field(
dtype=int,
doc="Number of points used to define the vignette polygon.",
default=100,
)
doWriteVignettePolygon = Field(
dtype=bool,
doc="Persist polygon used to define vignetted region?",
default=False,
deprecated=(
"Vignetted polygon is added to the exposure by default."
" This option is no longer used, and will be removed after v24."))
class CalibsRegisterConfig(RegisterConfig):
"""Configuration for the CalibsRegisterTask"""
tables = ListField(dtype=str,
default=[
"bias", "dark", "flat", "fringe", "sky", "defects",
"qe_curve", "linearizer", "crosstalk"
],
doc="Names of tables")
calibDate = Field(dtype=str,
default="calibDate",
doc="Name of column for calibration date")
validStart = Field(dtype=str,
default="validStart",
doc="Name of column for validity start")
validEnd = Field(dtype=str,
default="validEnd",
doc="Name of column for validity stop")
detector = ListField(dtype=str,
default=["filter", "ccd"],
doc="Columns that identify individual detectors")
validityUntilSuperseded = ListField(
dtype=str,
default=["defects", "qe_curve", "linearizer", "crosstalk"],
doc="Tables for which to set validity for a calib from when it is "
"taken until it is superseded by the next; validity in other tables "
"is calculated by applying the validity range.")
incrementValidEnd = Field(
dtype=bool,
default=True,
doc="Fix the off-by-one error by incrementing validEnd. See "
"fixSubsetValidity for more details.",
)
class ReserveSourcesConfig(Config):
"""Configuration for reserving sources"""
fraction = Field(dtype=float, default=0.0,
doc="Fraction of candidates to reserve from fitting; none if <= 0")
seed = Field(dtype=int, default=1,
doc=("This number will be added to the exposure ID to set the random seed for "
"reserving candidates"))
class VignetteConfig(Config):
"""
Settings to define vignetteing pattern
"""
xCenter = Field(
dtype=float,
doc="Center of vignetting pattern, in focal plane x coordinates.",
default=0.0,
)
yCenter = Field(
dtype=float,
doc="Center of vignetting pattern, in focal plane y coordinates.",
default=0.0,
)
radius = Field(
dtype=float,
doc="Radius of vignetting pattern, in focal plane coordinates.",
default=100.0,
check=lambda x: x >= 0)
numPolygonPoints = Field(
dtype=int,
doc="Number of points used to define the vignette polygon.",
default=100,
)
doWriteVignettePolygon = Field(
dtype=bool,
doc="Persist polygon used to define vignetted region?",
default=False,
)
class MaskObjectsConfig(Config):
"""Configuration for MaskObjectsTask"""
nIter = Field(dtype=int, default=3, doc="Number of iterations")
subtractBackground = ConfigurableField(target=measAlg.SubtractBackgroundTask,
doc="Background subtraction")
detection = ConfigurableField(target=measAlg.SourceDetectionTask, doc="Source detection")
detectSigma = Field(dtype=float, default=5.0, doc="Detection threshold (standard deviations)")
doInterpolate = Field(dtype=bool, default=True, doc="Interpolate when removing objects?")
interpolate = ConfigurableField(target=measAlg.SubtractBackgroundTask, doc="Interpolation")
def setDefaults(self):
self.detection.reEstimateBackground = False
self.detection.doTempLocalBackground = False
self.detection.doTempWideBackground = False
self.detection.thresholdValue = 2.5
self.subtractBackground.binSize = 1024
self.subtractBackground.useApprox = False
self.interpolate.binSize = 256
self.interpolate.useApprox = False
def validate(self):
if (self.detection.reEstimateBackground or
self.detection.doTempLocalBackground or
self.detection.doTempWideBackground):
raise RuntimeError("Incorrect settings for object masking: reEstimateBackground, "
"doTempLocalBackground and doTempWideBackground must be False")
class CoaddDriverConfig(Config):
coaddName = Field(dtype=str, default="deep", doc="Name for coadd")
select = ConfigurableField(target=WcsSelectImagesTask,
doc="Select images to process")
makeCoaddTempExp = ConfigurableField(target=MakeCoaddTempExpTask,
doc="Warp images to sky")
doBackgroundReference = Field(dtype=bool,
default=False,
doc="Build background reference?")
backgroundReference = ConfigurableField(target=NullSelectImagesTask,
doc="Build background reference")
assembleCoadd = ConfigurableField(target=SafeClipAssembleCoaddTask,
doc="Assemble warps into coadd")
detectCoaddSources = ConfigurableField(target=DetectCoaddSourcesTask,
doc="Detect sources on coadd")
doOverwriteCoadd = Field(dtype=bool, default=False, doc="Overwrite coadd?")
def setDefaults(self):
self.makeCoaddTempExp.select.retarget(NullSelectImagesTask)
self.assembleCoadd.select.retarget(NullSelectImagesTask)
self.makeCoaddTempExp.doOverwrite = False
self.assembleCoadd.doWrite = False
self.assembleCoadd.doMatchBackgrounds = False
self.makeCoaddTempExp.bgSubtracted = True
self.assembleCoadd.badMaskPlanes = [
'BAD', 'EDGE', 'SAT', 'INTRP', 'NO_DATA'
]
def validate(self):
if self.makeCoaddTempExp.coaddName != self.coaddName:
raise RuntimeError(
"makeCoaddTempExp.coaddName and coaddName don't match")
if self.assembleCoadd.coaddName != self.coaddName:
raise RuntimeError(
"assembleCoadd.coaddName and coaddName don't match")
class RegisterConfig(Config):
"""Configuration for RegisterTask"""
matchRadius = Field(dtype=float, default=1.0, doc="Matching radius (arcsec)", check=lambda x: x > 0)
sipOrder = Field(dtype=int, default=4, doc="Order for SIP WCS", check=lambda x: x > 1)
sipIter = Field(dtype=int, default=3, doc="Rejection iterations for SIP WCS", check=lambda x: x > 0)
sipRej = Field(dtype=float, default=3.0, doc="Rejection threshold for SIP WCS", check=lambda x: x > 0)
warper = ConfigField(dtype=Warper.ConfigClass, doc="Configuration for warping")
class SkyCorrectionConfig(Config):
"""Configuration for SkyCorrectionTask"""
bgModel = ConfigField(dtype=FocalPlaneBackgroundConfig,
doc="Background model")
sky = ConfigurableField(target=SkyMeasurementTask, doc="Sky measurement")
detection = ConfigurableField(target=measAlg.SourceDetectionTask,
doc="Detection configuration")
doDetection = Field(dtype=bool,
default=True,
doc="Detect sources (to find good sky)?")
detectSigma = Field(dtype=float,
default=5.0,
doc="Detection PSF gaussian sigma")
doBgModel = Field(dtype=bool,
default=True,
doc="Do background model subtraction?")
doSky = Field(dtype=bool, default=True, doc="Do sky frame subtraction?")
binning = Field(dtype=int,
default=8,
doc="Binning factor for constructing focal-plane images")
def setDefaults(self):
Config.setDefaults(self)
self.detection.reEstimateBackground = False
self.detection.thresholdPolarity = "both"
self.detection.doTempLocalBackground = False
self.detection.thresholdType = "pixel_stdev"
self.detection.thresholdValue = 3.0
class RegisterConfig(Config):
"""Configuration for the RegisterTask"""
table = Field(dtype=str, default="raw", doc="Name of table")
columns = DictField(
keytype=str,
itemtype=str,
doc="List of columns for raw table, with their types",
itemCheck=lambda x: x in ("text", "int", "double"),
default={
'object': 'text',
'visit': 'int',
'ccd': 'int',
'filter': 'text',
'date': 'text',
'taiObs': 'text',
'expTime': 'double',
},
)
unique = ListField(
dtype=str,
doc="List of columns to be declared unique for the table",
default=["visit", "ccd"])
visit = ListField(dtype=str,
default=["visit", "object", "date", "filter"],
doc="List of columns for raw_visit table")
ignore = Field(dtype=bool,
default=False,
doc="Ignore duplicates in the table?")
permissions = Field(dtype=int,
default=0o664,
doc="Permissions mode for registry; 0o664 = rw-rw-r--")
class RingsSkyMapConfig(CachingSkyMap.ConfigClass):
"""Configuration for the RingsSkyMap"""
numRings = Field(dtype=int, doc="Number of rings", check=lambda x: x > 0)
raStart = Field(dtype=float,
default=0.0,
doc="Starting center RA for each ring (degrees)",
check=lambda x: x >= 0.0 and x < 360.0)
class CoaddDriverConfig(Config):
coaddName = Field(dtype=str, default="deep", doc="Name for coadd")
select = ConfigurableField(
target=WcsSelectImagesTask, doc="Select images to process")
makeCoaddTempExp = ConfigurableField(
target=MakeCoaddTempExpTask, doc="Warp images to sky")
doBackgroundReference = Field(
dtype=bool, default=False, doc="Build background reference?")
backgroundReference = ConfigurableField(
target=NullSelectImagesTask, doc="Build background reference")
assembleCoadd = ConfigurableField(
target=SafeClipAssembleCoaddTask, doc="Assemble warps into coadd")
doDetection = Field(dtype=bool, default=True,
doc="Run detection on the coaddition product")
detectCoaddSources = ConfigurableField(
target=DetectCoaddSourcesTask, doc="Detect sources on coadd")
def setDefaults(self):
self.makeCoaddTempExp.select.retarget(NullSelectImagesTask)
self.assembleCoadd.select.retarget(NullSelectImagesTask)
self.assembleCoadd.doWrite = False
def validate(self):
if self.makeCoaddTempExp.coaddName != self.coaddName:
raise RuntimeError(
"makeCoaddTempExp.coaddName and coaddName don't match")
if self.assembleCoadd.coaddName != self.coaddName:
raise RuntimeError(
"assembleCoadd.coaddName and coaddName don't match")
if self.assembleCoadd.matchingKernelSize != self.makeCoaddTempExp.matchingKernelSize:
message = ("assembleCoadd.matchingKernelSize (%s) and makeCoaddTempExp.matchingKernelSize (%s)"
" don't match" % (self.assembleCoadd.matchingKernelSize,
self.makeCoaddTempExp.matchingKernelSize))
raise RuntimeError(message)
class AB1TaskConfig(Config):
bright_mag_cut = Field(doc="Bright limit of catalog entries to include",
dtype=float, default=17.0)
faint_mag_cut = Field(doc="Faint limit of catalog entries to include",
dtype=float, default=21.5)
ref_filter = Field(doc="String representing the filter to use as reference",
dtype=str, default="r")
class HealpixSkyMapConfig(CachingSkyMap.ConfigClass):
"""Configuration for the HealpixSkyMap"""
log2NSide = Field(dtype=int, default=0, doc="Number of sides, expressed in powers of 2")
nest = Field(dtype=bool, default=False, doc="Use NEST ordering instead of RING?")
def setDefaults(self):
self.rotation = 45 # HEALPixels are oriented at 45 degrees
class MergeDetectionsConfig(PipelineTaskConfig, pipelineConnections=MergeDetectionsConnections):
"""!
@anchor MergeDetectionsConfig_
@brief Configuration parameters for the MergeDetectionsTask.
"""
minNewPeak = Field(dtype=float, default=1,
doc="Minimum distance from closest peak to create a new one (in arcsec).")
maxSamePeak = Field(dtype=float, default=0.3,
doc="When adding new catalogs to the merge, all peaks less than this distance "
" (in arcsec) to an existing peak will be flagged as detected in that catalog.")
cullPeaks = ConfigField(dtype=CullPeaksConfig, doc="Configuration for how to cull peaks.")
skyFilterName = Field(dtype=str, default="sky",
doc="Name of `filter' used to label sky objects (e.g. flag merge_peak_sky is set)\n"
"(N.b. should be in MergeMeasurementsConfig.pseudoFilterList)")
skyObjects = ConfigurableField(target=SkyObjectsTask, doc="Generate sky objects")
priorityList = ListField(dtype=str, default=[],
doc="Priority-ordered list of bands for the merge.")
coaddName = Field(dtype=str, default="deep", doc="Name of coadd")
def setDefaults(self):
Config.setDefaults(self)
self.skyObjects.avoidMask = ["DETECTED"] # Nothing else is available in our custom mask
def validate(self):
super().validate()
if len(self.priorityList) == 0:
raise RuntimeError("No priority list provided")
class DynamicDetectionConfig(SourceDetectionConfig):
"""Configuration for DynamicDetectionTask
"""
prelimThresholdFactor = Field(
dtype=float,
default=0.5,
doc=
"Fraction of the threshold to use for first pass (to find sky objects)"
)
skyObjects = ConfigurableField(target=SkyObjectsTask,
doc="Generate sky objects")
doBackgroundTweak = Field(
dtype=bool,
default=True,
doc="Tweak background level so median PSF flux of sky objects is zero?"
)
minNumSources = Field(
dtype=int,
default=10,
doc="Minimum number of sky sources in statistical sample; "
"if below this number, we refuse to modify the threshold.")
def setDefaults(self):
SourceDetectionConfig.setDefaults(self)
self.skyObjects.nSources = 1000 # For good statistics
class CalibConfig(Config):
"""Configuration for constructing calibs"""
clobber = Field(dtype=bool,
default=True,
doc="Clobber existing processed images?")
isr = ConfigurableField(target=IsrTask, doc="ISR configuration")
dateObs = Field(dtype=str,
default="dateObs",
doc="Key for observation date in exposure registry")
dateCalib = Field(dtype=str,
default="calibDate",
doc="Key for calib date in calib registry")
filter = Field(dtype=str,
default="filter",
doc="Key for filter name in exposure/calib registries")
combination = ConfigurableField(target=CalibCombineTask,
doc="Calib combination configuration")
ccdKeys = ListField(dtype=str,
default=["ccd"],
doc="DataId keywords specifying a CCD")
visitKeys = ListField(dtype=str,
default=["visit"],
doc="DataId keywords specifying a visit")
calibKeys = ListField(dtype=str,
default=[],
doc="DataId keywords specifying a calibration")
def setDefaults(self):
self.isr.doWrite = False
class FocalPlaneBackgroundConfig(Config):
"""Configuration for FocalPlaneBackground
Note that `xSize` and `ySize` are floating-point values, as
the focal plane frame is usually defined in units of microns
or millimetres rather than pixels. As such, their values will
need to be revised according to each particular camera. For
this reason, no defaults are set for those.
"""
xSize = Field(dtype=float, doc="Bin size in x")
ySize = Field(dtype=float, doc="Bin size in y")
minFrac = Field(dtype=float, default=0.1, doc="Minimum fraction of bin size for good measurement")
mask = ListField(dtype=str, doc="Mask planes to treat as bad",
default=["BAD", "SAT", "INTRP", "DETECTED", "DETECTED_NEGATIVE", "EDGE", "NO_DATA"])
interpolation = ChoiceField(
doc="how to interpolate the background values. This maps to an enum; see afw::math::Background",
dtype=str, default="AKIMA_SPLINE", optional=True,
allowed={
"CONSTANT": "Use a single constant value",
"LINEAR": "Use linear interpolation",
"NATURAL_SPLINE": "cubic spline with zero second derivative at endpoints",
"AKIMA_SPLINE": "higher-level nonlinear spline that is more robust to outliers",
"NONE": "No background estimation is to be attempted",
},
)
binning = Field(dtype=int, default=64, doc="Binning to use for CCD background model (pixels)")
class ProcessCoaddsTogetherConfig(Config):
images = Field(
doc="Coadd image DatasetType used as input (one for each band)",
default="deepCoadd_calexp",
dtype=str,
)
ref = Field(
doc="Coadd catalog DatasetType reference input (one instance across all bands).",
default="deepCoadd_ref",
dtype=str,
)
output = Field(
doc="Output catalog DatasetType (one instance across all bands)",
default=None, # Must be overridden by derived classes to a DatasetType known to obs_base
dtype=str,
)
deblendReplacer = ConfigField(
dtype=NoiseReplacerConfig,
doc=("Details for how to replace neighbors with noise when applying deblender outputs. "
"Ignored if `useDeblending == False`.")
)
deblendCatalog = Field(
doc=("Catalog DatasetType from which to extract deblended [Heavy]Footprints (one for each band). "
"Ignored if 'useDeblending == False'."),
default="deepCoadd_meas",
dtype=str,
)
class SkyObjectsConfig(Config):
"""Configuration for generating sky objects"""
avoidMask = ListField(
dtype=str,
default=["DETECTED", "DETECTED_NEGATIVE", "BAD", "NO_DATA"],
doc="Avoid pixels masked with these mask planes")
growMask = Field(
dtype=int,
default=0,
doc="Number of pixels to grow the masked pixels when adding sky objects"
)
sourceRadius = Field(dtype=float,
default=8,
doc="Radius, in pixels, of sky objects")
nSources = Field(dtype=int,
default=100,
doc="Try to add this many sky objects")
nTrialSources = Field(dtype=int,
default=None,
optional=True,
doc="Maximum number of trial sky object positions\n"
"(default: nSkySources*nTrialSkySourcesMultiplier)")
nTrialSourcesMultiplier = Field(
dtype=int,
default=5,
doc="Set nTrialSkySources to\n"
" nSkySources*nTrialSkySourcesMultiplier\n"
"if nTrialSkySources is None")
class SkyMeasurementConfig(Config):
"""Configuration for SkyMeasurementTask"""
skyIter = Field(dtype=int, default=3, doc="k-sigma rejection iterations for sky scale")
skyRej = Field(dtype=float, default=3.0, doc="k-sigma rejection threshold for sky scale")
background = ConfigField(dtype=BackgroundConfig, doc="Background measurement")
xNumSamples = Field(dtype=int, default=4, doc="Number of samples in x for scaling sky frame")
yNumSamples = Field(dtype=int, default=4, doc="Number of samples in y for scaling sky frame")
stats = ConfigField(dtype=SkyStatsConfig, doc="Measurement of sky statistics in the samples")
class IngestConfig(Config):
"""Configuration for IngestTask"""
parse = ConfigurableField(target=ParseTask, doc="File parsing")
register = ConfigurableField(target=RegisterTask, doc="Registry entry")
allowError = Field(dtype=bool,
default=False,
doc="Allow error in ingestion?")
clobber = Field(dtype=bool, default=False, doc="Clobber existing file?")
class FringeStatisticsConfig(Config):
"""Options for measuring fringes on an exposure"""
badMaskPlanes = ListField(dtype=str, default=["SAT"], doc="Ignore pixels with these masks")
stat = Field(dtype=int, default=int(afwMath.MEDIAN), doc="Statistic to use")
clip = Field(dtype=float, default=3.0, doc="Sigma clip threshold")
iterations = Field(dtype=int, default=3, doc="Number of fitting iterations")
rngSeedOffset = Field(dtype=int, default=0,
doc="Offset to the random number generator seed (full seed includes exposure ID)")
class WPerpTaskConfig(Config):
# These are cuts to apply to the r-band only:
bright_rmag_cut = Field(doc="Bright limit of catalog entries to include",
dtype=float,
default=17.0)
faint_rmag_cut = Field(doc="Faint limit of catalog entries to include",
dtype=float,
default=23.0)
class CrosstalkConfig(Config):
"""Configuration for intra-CCD crosstalk removal"""
minPixelToMask = Field(
dtype=float,
default=45000,
doc="Set crosstalk mask plane for pixels over this value")
crosstalkMaskPlane = Field(dtype=str,
default="CROSSTALK",
doc="Name for crosstalk mask plane")
class PA1TaskConfig(Config):
brightSnrMin = Field(doc="Minimum median SNR for a source to be considered bright.",
dtype=float, default=50)
brightSnrMax = Field(doc="Maximum median SNR for a source to be considered bright.",
dtype=float, default=np.Inf)
numRandomShuffles = Field(doc="Number of trials used for random sampling of observation pairs.",
dtype=int, default=50)
randomSeed = Field(doc="Random seed for sampling.",
dtype=int, default=12345)
class SkyStatsConfig(Config):
"""Parameters controlling the measurement of sky statistics"""
statistic = ChoiceField(dtype=str, default="MEANCLIP", doc="type of statistic to use for grid points",
allowed={"MEANCLIP": "clipped mean",
"MEAN": "unclipped mean",
"MEDIAN": "median"})
clip = Field(doc="Clipping threshold for background", dtype=float, default=3.0)
nIter = Field(doc="Clipping iterations for background", dtype=int, default=3)
mask = ListField(doc="Mask planes to reject", dtype=str,
default=["SAT", "DETECTED", "DETECTED_NEGATIVE", "BAD", "NO_DATA"])
class PropagateVisitFlagsConfig(Config):
"""!Configuration for propagating flags to coadd"""
flags = DictField(keytype=str, itemtype=float,
default={"calib_psf_candidate": 0.2, "calib_psf_used": 0.2, "calib_psf_reserved": 0.2,
"calib_astrometry_used": 0.2, "calib_photometry_used": 0.2,
"calib_photometry_reserved": 0.2, },
doc=("Source catalog flags to propagate, with the threshold of relative occurrence "
"(valid range: [0-1], default is 0.2). Coadd object will have flag set if the "
"fraction of input visits in which it is flagged is greater than the threshold."))
matchRadius = Field(dtype=float, default=0.2, doc="Source matching radius (arcsec)")
ccdName = Field(dtype=str, default='ccd', doc="Name of ccd to give to butler")
class SingleVisitDriverConfig(Config):
doWrite = Field(
dtype=bool,
default=True,
doc="Save calibration results?")
doWriteWarps = Field(
dtype=bool,
default=True,
doc="""Save the individual warps?
Ignored if doWrite false.""")
isr = ConfigurableField(
target=IsrTask,
doc="""Task to perform instrumental signature removal or load a post-ISR image; ISR consists of:
- assemble raw amplifier images into an exposure with image, variance and mask planes
- perform bias subtraction, flat fielding, etc.
- mask known bad pixels
- provide a preliminary WCS
""")
charImage = ConfigurableField(
target=GotoCharacterizeImageTask,
doc="""Task to characterize a coadded visit frame:
- detect sources, usually at high S/N
- estimate the background, which is subtracted from the image and returned as field "background"
- estimate a PSF model, which is added to the exposure
- interpolate over defects and cosmic rays, updating the image, variance and mask planes
""")
warp = ConfigurableField(
target = WarpAndPsfMatchTask,
doc = """Warps and optionally PSF matches (the latter set to False by default)""")
snapCombine = ConfigurableField(
target=SnapCombineTask,
doc="""Sums two exposures""")
calibrate = ConfigurableField(
target=CalibrateTask,
doc="""Task to perform astrometric and photometric calibration:
- refine the WCS in the exposure
- refine the Calib photometric calibration object in the exposure
- detect sources, usually at low S/N
""")
forcedPhot = ConfigurableField(
target=ForcedPhotVisitTask,
doc="""Task to peform forced photometry""")
def setDefaults(self):
self.snapCombine.doRepair = False
self.snapCombine.badMaskPlanes = ()
class NoDimensionsTestConfig(PipelineTaskConfig,
pipelineConnections=NoDimensionsTestConnections):
key = Field(dtype=str,
doc="String key for the dict entry the task sets.",
default="one")
value = Field(dtype=int,
doc="Integer value for the dict entry the task sets.",
default=1)
outputSC = Field(dtype=str,
doc="Output storage class requested",
default="dict")