class WarpAndPsfMatchConfig(pexConfig.Config):
"""Config for WarpAndPsfMatchTask
"""
psfMatch = pexConfig.ConfigurableField(
target=ModelPsfMatchTask,
doc="PSF matching model to model task",
)
warp = pexConfig.ConfigField(
dtype=afwMath.Warper.ConfigClass,
doc="warper configuration",
)
class DebugFakesConfig(pexConfig.Config):
coaddName = pexConfig.ChoiceField(dtype=str,
doc="Type of data to use",
default="deep",
allowed={"deep": "deepCoadd"})
fakes = pexConfig.ConfigurableField(
target=DummyFakeSourcesTask,
doc="Injection of fake sources for test purposes (retarget to enable)")
display = pexConfig.Field(dtype=bool,
doc='display exposure',
default=False)
class GenerateDonutCatalogWcsTaskConfig(
pipeBase.PipelineTaskConfig,
pipelineConnections=GenerateDonutCatalogWcsTaskConnections,
):
"""
Configuration settings for GenerateDonutCatalogWcsTask.
Specifies filter and camera details as well as subtasks
that run to do the source selection.
"""
filterName = pexConfig.Field(doc="Reference filter",
dtype=str,
default="g")
referenceSelector = pexConfig.ConfigurableField(
target=ReferenceSourceSelectorTask,
doc="How to select reference objects.")
donutSelector = pexConfig.ConfigurableField(
target=DonutSourceSelectorTask, doc="How to select donut targets.")
doDonutSelection = pexConfig.Field(
doc="Whether or not to run donut selector.", dtype=bool, default=True)
class AnotherSatelliteConfig(pexConfig.Config):
dummy = pexConfig.ConfigurableField(
target=SatelliteFinderTask,
doc="Search for PSF-width satellite trails")
doDummy = pexConfig.Field(dtype=bool, default=True, doc="")
def setDefaults(self):
# satellites
self.dummy.widths = [
1.0,
],
self.dummy.houghThresh = 40
class ReportImagesInPatchConfig(pexConfig.Config):
"""Config for ReportImagesInPatchTask
"""
coaddName = pexConfig.Field(
doc="coadd name: one of deep or goodSeeing",
dtype=str,
default="deep",
)
select = pexConfig.ConfigurableField(
doc="image selection subtask",
target=WcsSelectImagesTask,
)
class CalcZernikesTaskConfig(
pipeBase.PipelineTaskConfig, pipelineConnections=CalcZernikesTaskConnections
):
# Config setting for pipeline task with defaults
combineZernikes = pexConfig.ConfigurableField(
target=CombineZernikesSigmaClipTask,
doc=str(
"Choice of task to combine the Zernikes from pairs of "
+ "donuts into a single value for the detector. (The default "
+ "is CombineZernikesSigmaClipTask.)"
),
)
class ProcessCcdConfig(pexConfig.Config):
"""Config for ProcessCcd"""
isr = pexConfig.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 = pexConfig.ConfigurableField(
target=CharacterizeImageTask,
doc="""Task to characterize a science exposure:
- 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
""",
)
doCalibrate = pexConfig.Field(
dtype=bool,
default=True,
doc="Perform calibration?",
)
calibrate = pexConfig.ConfigurableField(
target=CalibrateTask,
doc="""Task to perform astrometric and photometric calibration:
- refine the WCS in the exposure
- refine the PhotoCalib object in the exposure
- detect sources, usually at low S/N
""",
)
def setDefaults(self):
self.isr.doWrite = False
self.charImage.doWriteExposure = False
self.charImage.detection.doTempLocalBackground = False
self.calibrate.detection.doTempLocalBackground = False
self.calibrate.deblend.maxFootprintSize = 2000
class MakeCoaddTempExpConfig(CoaddBaseTask.ConfigClass):
"""Config for MakeCoaddTempExpTask
"""
warpAndPsfMatch = pexConfig.ConfigurableField(
target=WarpAndPsfMatchTask,
doc="Task to warp and PSF-match calexp",
)
doWrite = pexConfig.Field(
doc="persist <coaddName>Coadd_<warpType>Warp",
dtype=bool,
default=True,
)
bgSubtracted = pexConfig.Field(
doc="Work with a background subtracted calexp?",
dtype=bool,
default=True,
)
coaddPsf = pexConfig.ConfigField(
doc="Configuration for CoaddPsf",
dtype=CoaddPsfConfig,
)
makeDirect = pexConfig.Field(
doc="Make direct Warp/Coadds",
dtype=bool,
default=True,
)
makePsfMatched = pexConfig.Field(
doc="Make Psf-Matched Warp/Coadd?",
dtype=bool,
default=False,
)
doApplySkyCorr = pexConfig.Field(dtype=bool,
default=False,
doc="Apply sky correction?")
def validate(self):
CoaddBaseTask.ConfigClass.validate(self)
if not self.makePsfMatched and not self.makeDirect:
raise RuntimeError(
"At least one of config.makePsfMatched and config.makeDirect must be True"
)
if self.doPsfMatch:
# Backwards compatibility.
log.warn(
"Config doPsfMatch deprecated. Setting makePsfMatched=True and makeDirect=False"
)
self.makePsfMatched = True
self.makeDirect = False
def setDefaults(self):
CoaddBaseTask.ConfigClass.setDefaults(self)
self.warpAndPsfMatch.psfMatch.kernel.active.kernelSize = self.matchingKernelSize
class CpFringeTaskConfig(pipeBase.PipelineTaskConfig,
pipelineConnections=CpFringeConnections):
stats = pexConfig.ConfigurableField(
target=cpCombine.CalibStatsTask,
doc="Statistics task to use.",
)
subtractBackground = pexConfig.ConfigurableField(
target=measAlg.SubtractBackgroundTask,
doc="Background configuration",
)
detection = pexConfig.ConfigurableField(
target=measAlg.SourceDetectionTask,
doc="Detection configuration",
)
detectSigma = pexConfig.Field(
dtype=float,
default=1.0,
doc="Detection psf gaussian sigma.",
)
def setDefaults(self):
self.detection.reEstimateBackground = False
class RefMatchConfig(pexConfig.Config):
matcher = pexConfig.ConfigurableField(
target=MatchOptimisticBTask,
doc="reference object/source matcher",
)
matchDistanceSigma = pexConfig.RangeField(
doc="the maximum match distance is set to "
" mean_match_distance + matchDistanceSigma*std_dev_match_distance; " +
"ignored if not fitting a WCS",
dtype=float,
default=2,
min=0,
)
class ExampleCmdLineConfig(pexConfig.Config):
"""!Configuration for ExampleCmdLineTask
"""
stats = pexConfig.ConfigurableField(
doc="Subtask to compute statistics of an image",
target=ExampleSigmaClippedStatsTask,
)
doFail = pexConfig.Field(
doc = "Raise an lsst.base.TaskError exception when processing each image? " \
+ "This allows one to see the effects of the --doraise command line flag",
dtype = bool,
default = False,
)
class SingleStarCentroidTaskConfig(
pipeBase.PipelineTaskConfig,
pipelineConnections=SingleStarCentroidTaskConnections):
"""Configuration parameters for ProcessStarTask."""
astromRefObjLoader = pexConfig.ConfigurableField(
target=LoadIndexedReferenceObjectsTask,
doc="Reference object loader for astrometric calibration",
)
astrometry = pexConfig.ConfigurableField(
target=AstrometryTask,
doc="Task to perform astrometric calibration to refine the WCS",
)
qfmTask = pexConfig.ConfigurableField(
target=QuickFrameMeasurementTask,
doc="XXX",
)
referenceFilterOverride = pexConfig.Field(
dtype=str,
doc="Which filter in the reference catalog to match to?",
default="phot_g_mean")
def setDefaults(self):
super().setDefaults()
# this is a null option now in Gen3 - do not set it here
# self.astromRefObjLoader.ref_dataset_name
self.astromRefObjLoader.pixelMargin = 1000
self.astrometry.wcsFitter.retarget(FitAffineWcsTask)
self.astrometry.referenceSelector.doMagLimit = True
magLimit = MagnitudeLimit()
magLimit.minimum = 1
magLimit.maximum = 15
self.astrometry.referenceSelector.magLimit = magLimit
self.astrometry.referenceSelector.magLimit.fluxField = "phot_g_mean_flux"
self.astrometry.matcher.maxRotationDeg = 5.99
self.astrometry.matcher.maxOffsetPix = 3000
self.astrometry.sourceSelector['matcher'].minSnr = 10
class FgcmLoadReferenceCatalogConfig(pexConfig.Config):
"""Config for FgcmLoadReferenceCatalogTask"""
refObjLoader = pexConfig.ConfigurableField(
target=LoadIndexedReferenceObjectsTask,
doc="Reference object loader for photometry",
deprecated="refObjLoader is deprecated, and will be removed after v24.",
)
filterMap = pexConfig.DictField(
doc="Mapping from physicalFilter label to reference filter name.",
keytype=str,
itemtype=str,
default={},
)
applyColorTerms = pexConfig.Field(
doc=("Apply photometric color terms to reference stars?"
"Requires that colorterms be set to a ColorTermLibrary"),
dtype=bool,
default=True)
colorterms = pexConfig.ConfigField(
doc="Library of photometric reference catalog name to color term dict.",
dtype=ColortermLibrary,
)
referenceSelector = pexConfig.ConfigurableField(
target=ReferenceSourceSelectorTask,
doc="Selection of reference sources",
)
def validate(self):
super().validate()
if not self.filterMap:
msg = 'Must set filterMap'
raise pexConfig.FieldValidationError(
FgcmLoadReferenceCatalogConfig.filterMap, self, msg)
if self.applyColorTerms and len(self.colorterms.data) == 0:
msg = "applyColorTerms=True requires the `colorterms` field be set to a ColortermLibrary."
raise pexConfig.FieldValidationError(
FgcmLoadReferenceCatalogConfig.colorterms, self, msg)
class GenerateDonutCatalogOnlineTaskConfig(pexConfig.Config):
"""Configuration for GenerateDonutCatalogOnlineTask."""
refObjLoader = pexConfig.ConfigurableField(
target=LoadIndexedReferenceObjectsTask,
doc="Reference object loader for photometry",
)
referenceSelector = pexConfig.ConfigurableField(
target=ReferenceSourceSelectorTask,
doc="Selection of reference sources",
)
doReferenceSelection = pexConfig.Field(
doc="Run the reference selector on the reference catalog?",
dtype=bool,
default=True,
)
filterName = pexConfig.Field(doc="Reference filter",
dtype=str,
default="g")
donutSelector = pexConfig.ConfigurableField(
target=DonutSourceSelectorTask, doc="How to select donut targets.")
doDonutSelection = pexConfig.Field(
doc="Whether or not to run donut selector.", dtype=bool, default=True)
class MeasurePsfConfig(pexConfig.Config):
starSelector = measAlg.sourceSelectorRegistry.makeField(
"Star selection algorithm", default="objectSize")
makePsfCandidates = pexConfig.ConfigurableField(
target=measAlg.MakePsfCandidatesTask,
doc="Task to make psf candidates from selected stars.",
)
psfDeterminer = measAlg.psfDeterminerRegistry.makeField(
"PSF Determination algorithm", default="piff")
reserve = pexConfig.ConfigurableField(target=measAlg.ReserveSourcesTask,
doc="Reserve sources from fitting")
def validate(self):
super().validate()
if (self.psfDeterminer.name == "piff"
and self.psfDeterminer["piff"].kernelSize >
self.makePsfCandidates.kernelSize):
msg = (
f"PIFF kernelSize={self.psfDeterminer['piff'].kernelSize}"
f" must be >= psf candidate kernelSize={self.makePsfCandidates.kernelSize}."
)
raise pexConfig.FieldValidationError(
MeasurePsfConfig.makePsfCandidates, self, msg)
class FindCosmicRaysConfig(pexConfig.Config):
"""Config for the findCosmicRays function
"""
nCrPixelMax = pexConfig.Field(
dtype=int,
doc="maximum number of contaminated pixels",
default=10000,
)
minSigma = pexConfig.Field(
dtype=float,
doc="CRs must be > this many sky-sig above sky",
default=6.0,
)
min_DN = pexConfig.Field(
dtype=float,
doc=
"CRs must have > this many DN (== electrons/gain) in initial detection",
default=150.0,
)
cond3_fac = pexConfig.Field(
dtype=float,
doc="used in condition 3 for CR; see CR.cc code",
default=2.5,
)
cond3_fac2 = pexConfig.Field(
dtype=float,
doc="used in condition 3 for CR; see CR.cc code",
default=0.6,
)
niteration = pexConfig.Field(
dtype=int,
doc=
"number of times to look for contaminated pixels near known CR pixels",
default=3,
)
keepCRs = pexConfig.Field(
dtype=bool,
doc="Don't interpolate over CR pixels",
default=False,
)
background = pexConfig.ConfigurableField(
target=SubtractBackgroundTask,
doc="Background estimation configuration")
def setDefaults(self):
self.background.useApprox = False
self.background.binSize = 100000
self.background.statisticsProperty = "MEDIAN"
self.background.undersampleStyle = "REDUCE_INTERP_ORDER"
self.background.algorithm = "AKIMA_SPLINE"
class CharacterizeImageConfig(pexConfig.Config):
"""In this config class we define only fields that are relevant to
this example, the rest should be "copied" without change from
pipe.tasks.CharacterizeImageConfig.
"""
obsDateDig = pexConfig.ConfigurableField(
target=ObsDateDIG,
doc="DataIdGenerator for observation data-based visit selection",
)
ccdDig = pexConfig.ConfigurableField(
target=CcdDIG,
doc="DataIdGenerator for per-CCD splitting",
default=CcdDIGConfig(dataset="postISRCCD"))
bckgDig = pexConfig.ConfigurableField(
target=BackgroundDIG,
doc="DataIdGenerator for background images",
default=BackgroundDIGConfig(ccdDataset="postISRCCD",
dataset="background"))
expIdDig = pexConfig.ConfigurableField(
target=ExposureIdDIG,
doc="DataIdGenerator for exposure ID",
default=ExposureIdDIGConfig(dataset="expIdInfo"))
class MeasurePhotonTransferCurveTaskConfig(pexConfig.Config):
extract = pexConfig.ConfigurableField(
target=PhotonTransferCurveExtractTask,
doc="Task to measure covariances from flats.",
)
solve = pexConfig.ConfigurableField(
target=PhotonTransferCurveSolveTask,
doc="Task to fit models to the measured covariances.",
)
ccdKey = pexConfig.Field(
dtype=str,
doc="The key by which to pull a detector from a dataId, e.g. 'ccd' or 'detector'.",
default='ccd',
)
doPhotodiode = pexConfig.Field(
dtype=bool,
doc="Apply a correction based on the photodiode readings if available?",
default=False,
)
photodiodeDataPath = pexConfig.Field(
dtype=str,
doc="Gen2 only: path to locate the data photodiode data files.",
default=""
)
class SpatialScaleZeroPointConfig(ScaleZeroPointConfig):
selectFluxMag0 = pexConfig.ConfigurableField(
doc=
"Task to select data to compute spatially varying photometric zeropoint",
target=BaseSelectImagesTask,
)
interpStyle = pexConfig.ChoiceField(
dtype=str,
doc="Algorithm to interpolate the flux scalings;"
"Currently only one choice implemented",
default="CONSTANT",
allowed={
"CONSTANT": "Use a single constant value",
})
class CoaddBaseConfig(pexConfig.Config):
"""!Configuration parameters for CoaddBaseTask
\anchor CoaddBaseConfig_
\brief Configuration parameters shared between MakeCoaddTempExp and AssembleCoadd
"""
coaddName = pexConfig.Field(
doc="Coadd name: typically one of deep or goodSeeing.",
dtype=str,
default="deep",
)
select = pexConfig.ConfigurableField(
doc="Image selection subtask.",
target=WcsSelectImagesTask,
)
badMaskPlanes = pexConfig.ListField(
dtype=str,
doc=
"Mask planes that, if set, the associated pixel should not be included in the coaddTempExp.",
default=("NO_DATA", ),
)
inputRecorder = pexConfig.ConfigurableField(
doc=
"Subtask that helps fill CoaddInputs catalogs added to the final Exposure",
target=CoaddInputRecorderTask)
doPsfMatch = pexConfig.Field(
dtype=bool,
doc=
"Match to modelPsf? Deprecated. Sets makePsfMatched=True, makeDirect=False",
default=False)
modelPsf = measAlg.GaussianPsfFactory.makeField(doc="Model Psf factory")
doApplyUberCal = pexConfig.Field(
dtype=bool,
doc="Apply meas_mosaic ubercal results to input calexps?",
default=False)
def task_param(task_class):
"""Build parameter from for a particular Task
Parameters
----------
task_class : `class`
Class of task of build parameter for
Returns
-------
ret_val : `pexConfig.ConfigurableField`
Parameter connect to the task class
"""
param = pexConfig.ConfigurableField(target=task_class,
doc=task_class.__doc__)
return param
class MeasureExtendedPsfConfig(
pipeBase.PipelineTaskConfig,
pipelineConnections=MeasureExtendedPsfConnections):
"""Configuration parameters for MeasureExtendedPsfTask.
"""
stack_bright_stars = pexConfig.ConfigurableField(
target=StackBrightStarsTask,
doc="Stack selected bright stars",
)
detectors_focal_plane_regions = pexConfig.DictField(
keytype=int,
itemtype=str,
doc=
"Mapping from detector IDs to focal plane region names. If empty, a constant "
"extended PSF model is built from all selected bright stars.",
default={})
class DrawRandomsConfig(CoaddBaseTask.ConfigClass):
"""configuration for drawRandoms
"""
N = pexConfig.Field("Number of random points per patch (supersedes Nden)", int, -1)
Nden = pexConfig.Field("Random number density per sq arcmin", float, 100)
clobber = pexConfig.Field("To overwrite existing file [default: True]", bool, True)
dirOutName = pexConfig.Field("Name of output directory (will write output files as dirOutName/FILTER/TRACT/PATCH/ran-FILTER-TRACT-PATCH.fits)", str, "")
fileOutName = pexConfig.Field("Name of output file (supersedes dirOutName)", str, "")
test = pexConfig.Field("To write a test table", bool, False)
seed = pexConfig.Field("Seed for random generator (default: based on patch id)", int, -1)
setPrimaryFlags = pexConfig.ConfigurableField(target=SetPrimaryFlagsTask, doc="Set flags for primary source in tract/patch")
depthMapFileName = pexConfig.Field("Name of healpix file that records full depth", str, "")
def setDefaults(self):
pexConfig.Config.setDefaults(self)
class MakeCoaddTempExpConfig(CoaddBaseTask.ConfigClass):
"""Config for MakeCoaddTempExpTask
"""
warpAndPsfMatch = pexConfig.ConfigurableField(
target=WarpAndPsfMatchTask,
doc="Task to warp and PSF-match calexp",
)
doWrite = pexConfig.Field(
doc="persist <coaddName>Coadd_<warpType>Warp",
dtype=bool,
default=True,
)
doOverwrite = pexConfig.Field(
doc="overwrite <coaddName>Coadd_<warpType>Warp; If False, continue if the file exists on disk",
dtype=bool,
default=True,
)
bgSubtracted = pexConfig.Field(
doc="Work with a background subtracted calexp?",
dtype=bool,
default=True,
)
coaddPsf = pexConfig.ConfigField(
doc="Configuration for CoaddPsf",
dtype=CoaddPsfConfig,
)
makeDirect = pexConfig.Field(
doc="Make direct Warp/Coadds",
dtype=bool,
default=True,
)
makePsfMatched = pexConfig.Field(
doc="Make Psf-Matched Warp/Coadd?",
dtype=bool,
default=False,
)
def validate(self):
CoaddBaseTask.ConfigClass.validate(self)
if not self.makePsfMatched and not self.makeDirect:
raise RuntimeError("At least one of config.makePsfMatched and config.makeDirect must be True")
if self.doPsfMatch:
# Backwards compatibility.
log.warn("Config doPsfMatch deprecated. Setting makePsfMatched=True and makeDirect=False")
self.makePsfMatched = True
self.makeDirect = False
class DrpAssociationPipeConfig(
pipeBase.PipelineTaskConfig,
pipelineConnections=DrpAssociationPipeConnections):
associator = pexConfig.ConfigurableField(
target=SimpleAssociationTask,
doc="Task used to associate DiaSources with DiaObjects.",
)
doAddDiaObjectCoords = pexConfig.Field(
dtype=bool,
default=True,
doc="Do pull diaObject's average coordinate as coord_ra and coord_dec"
"Duplicates information, but needed for bulk ingest into qserv."
)
doWriteEmptyTables = pexConfig.Field(
dtype=bool,
default=False,
doc="If True, construct and write out empty diaSource and diaObject "
"tables. If False, raise NoWorkFound"
)
class ANetAstrometryConfig(pexConfig.Config):
solver = pexConfig.ConfigurableField(
target=ANetBasicAstrometryTask,
doc="Basic astrometry solver",
)
forceKnownWcs = pexConfig.Field(dtype=bool, doc=(
"Assume that the input image's WCS is correct, without comparing it to any external reality."
" (In contrast to using Astrometry.net). NOTE, if you set this, you probably also want to"
" un-set 'solver.calculateSip'; otherwise we'll still try to find a TAN-SIP WCS starting "
" from the existing WCS"), default=False)
rejectThresh = pexConfig.RangeField(dtype=float, default=3.0, doc="Rejection threshold for Wcs fitting",
min=0.0, inclusiveMin=False)
rejectIter = pexConfig.RangeField(dtype=int, default=3, doc="Rejection iterations for Wcs fitting",
min=0)
@property
def refObjLoader(self):
"""An alias, for a uniform interface with the standard AstrometryTask"""
return self.solver
class processBasicDriverConfig(pexConfig.Config):
doHSM = pexConfig.Field(
dtype=bool,
default=False,
doc="Whether run HSM",
)
doFPFS = pexConfig.Field(
dtype=bool,
default=True,
doc="Whether run FPFS",
)
readDataSim = pexConfig.ConfigurableField(
target=readDataSimTask, doc="Subtask to run measurement hsm")
galDir = pexConfig.Field(dtype=str,
default="small2_psf60",
doc="Input galaxy directory")
noiName = pexConfig.Field(dtype=str,
default="var7em3",
doc="noise variance name")
outDir = pexConfig.Field(dtype=str, default="", doc="output directory")
def setDefaults(self):
pexConfig.Config.setDefaults(self)
self.readDataSim.doWrite = False
self.readDataSim.doDeblend = True
self.readDataSim.doAddFP = False
psfFWHM = self.galDir.split('_psf')[-1]
if 'small' in self.galDir:
irr = eval(self.galDir.split('_psf')[0].split('small')[-1])
gnm = 'Small%d' % irr
elif 'star' in self.galDir:
gnm = 'Star'
else:
gnm = 'Basic'
self.outDir = os.path.join('out%s-%s' % (gnm, self.noiName),
'psf%s' % (psfFWHM))
def validate(self):
assert os.path.exists('noise')
assert os.path.exists(self.galDir)
if not os.path.isdir(self.outDir):
os.mkdir(self.outDir)
class ProcessCcdWithFakesConfig(
PipelineTaskConfig,
pipelineConnections=ProcessCcdWithFakesConnections):
"""Config for inserting fake sources
Notes
-----
The default column names are those from the UW sims database.
"""
useUpdatedCalibs = pexConfig.Field(
doc="Use updated calibs and wcs from jointcal?",
dtype=bool,
default=False,
)
coaddName = pexConfig.Field(
doc="The name of the type of coadd used",
dtype=str,
default="deep",
)
insertFakes = pexConfig.ConfigurableField(
target=InsertFakesTask, doc="Configuration for the fake sources")
detection = pexConfig.ConfigurableField(target=SourceDetectionTask,
doc="The detection task to use.")
deblend = pexConfig.ConfigurableField(target=SourceDeblendTask,
doc="The deblending task to use.")
measurement = pexConfig.ConfigurableField(
target=SingleFrameMeasurementTask, doc="The measurement task to use")
applyApCorr = pexConfig.ConfigurableField(
target=ApplyApCorrTask,
doc="The apply aperture correction task to use.")
catalogCalculation = pexConfig.ConfigurableField(
target=CatalogCalculationTask,
doc="The catalog calculation ask to use.")
def setDefaults(self):
self.detection.reEstimateBackground = False
super().setDefaults()
self.measurement.plugins["base_PixelFlags"].masksFpAnywhere.append(
"FAKE")
self.measurement.plugins["base_PixelFlags"].masksFpCenter.append(
"FAKE")
class DrpDiaCalculationPipeConfig(
pipeBase.PipelineTaskConfig,
pipelineConnections=DrpDiaCalculationPipeConnections):
filterNames = pexConfig.ListField(
dtype=str,
default=['u', 'g', 'r', 'i', 'z', 'y'],
doc="List of filters to attempt to calculate DiaObject summary "
"values.")
diaCalculation = pexConfig.ConfigurableField(
target=DiaObjectCalculationTask,
doc="Task to compute summary statistics for DiaObjects.",
)
def setDefaults(self):
self.diaCalculation.plugins = [
"ap_meanPosition", "ap_diaObjectFlag", "ap_meanFlux",
"ap_percentileFlux", "ap_sigmaFlux", "ap_chi2Flux", "ap_madFlux",
"ap_skewFlux", "ap_minMaxFlux", "ap_maxSlopeFlux",
"ap_meanErrFlux", "ap_linearFit", "ap_stetsonJ", "ap_meanTotFlux",
"ap_sigmaTotFlux"
]
class SpatialDecorrelateALKernelMapReduceConfig(ImageMapReduceConfig):
"""Configuration parameters for the ImageMapReduceTask to direct it to use
SpatialDecorrelateALKernelMapperSubtask as its mapperSubtask for A&L decorrelation.
"""
mapperSubtask = pexConfig.ConfigurableField(
doc='A&L decorrelation subtask to run on each sub-image',
target=SpatialDecorrelateALKernelMapperSubtask)
reduceOperation = pexConfig.ChoiceField(
dtype=str,
doc="""Operation to use for reducing subimages into new image.""",
default="coaddPsf",
allowed={
"none":
"""simply return a list of values and don't re-map results into
a new image (noop operation)""",
"coaddPsf":
"""Instead of constructing an Exposure, take a list of returned
PSFs and use CoaddPsf to construct a single PSF that covers the
entire input exposure""",
})
