def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile(self.packageName,
"ctio0m9Mapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
CameraMapper.__init__(self, policy, policyFile.getRepositoryPath(),
**kwargs)
filter_pairings = [
'NONE+SEMROCK', # list of all filter pairings found in data
'NONE+RONCHI200',
'RONCHI200+SEMROCK',
'NONE+NONE',
'NONE+g',
'NONE+r',
'NONE+i',
'NONE+z',
'RONCHI200+z',
'RONCHI200+g',
'FGB37+RONCHI200',
'NONE+RONCHI400',
'FGC715S+RONCHI400',
'FGC715S+RONCHI200'
]
# default no-filter name used for biases and darks - must appear
afwImageUtils.defineFilter('NONE', 0.0, alias=[])
for pairing in filter_pairings:
afwImageUtils.defineFilter(pairing, 0.0, alias=[])
def testMultiPlaneFitsReaders(self):
"""Run tests for MaskedImageFitsReader and ExposureFitsReader.
"""
metadata = PropertyList()
metadata.add("FIVE", 5)
metadata.add("SIX", 6.0)
wcs = makeSkyWcs(Point2D(2.5, 3.75),
SpherePoint(40.0 * degrees, 50.0 * degrees),
np.array([[1E-5, 0.0], [0.0, -1E-5]]))
defineFilter("test_readers_filter", lambdaEff=470.0)
calib = PhotoCalib(2.5E4)
psf = GaussianPsf(21, 21, 8.0)
polygon = Polygon(Box2D(self.bbox))
apCorrMap = ApCorrMap()
visitInfo = VisitInfo(exposureTime=5.0)
transmissionCurve = TransmissionCurve.makeIdentity()
coaddInputs = CoaddInputs(ExposureTable.makeMinimalSchema(),
ExposureTable.makeMinimalSchema())
detector = DetectorWrapper().detector
record = coaddInputs.ccds.addNew()
record.setWcs(wcs)
record.setPhotoCalib(calib)
record.setPsf(psf)
record.setValidPolygon(polygon)
record.setApCorrMap(apCorrMap)
record.setVisitInfo(visitInfo)
record.setTransmissionCurve(transmissionCurve)
record.setDetector(detector)
for n, dtypeIn in enumerate(self.dtypes):
with self.subTest(dtypeIn=dtypeIn):
exposureIn = Exposure(self.bbox, dtype=dtypeIn)
shape = exposureIn.image.array.shape
exposureIn.image.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.mask.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.variance.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.setMetadata(metadata)
exposureIn.setWcs(wcs)
exposureIn.setFilter(Filter("test_readers_filter"))
exposureIn.setFilterLabel(
FilterLabel(physical="test_readers_filter"))
exposureIn.setPhotoCalib(calib)
exposureIn.setPsf(psf)
exposureIn.getInfo().setValidPolygon(polygon)
exposureIn.getInfo().setApCorrMap(apCorrMap)
exposureIn.getInfo().setVisitInfo(visitInfo)
exposureIn.getInfo().setTransmissionCurve(transmissionCurve)
exposureIn.getInfo().setCoaddInputs(coaddInputs)
exposureIn.setDetector(detector)
with lsst.utils.tests.getTempFilePath(".fits") as fileName:
exposureIn.writeFits(fileName)
self.checkMaskedImageFitsReader(exposureIn, fileName,
self.dtypes[n:])
self.checkExposureFitsReader(exposureIn, fileName,
self.dtypes[n:])
def __init__(self, root, **kwargs):
self.storage = lsst.daf.persistence.Storage.makeFromURI(root)
super(SimpleMapper, self).__init__(**kwargs)
self.root = root
self.camera = makeSimpleCamera(nX=1, nY=2, sizeX=400, sizeY=200, gapX=2, gapY=2)
afwImageUtils.defineFilter('r', 619.42)
self.update()
def testCoordinateTransformDcrCalculation(self):
"""Check the DCR calculation using astropy coordinate transformations.
Astmospheric refraction causes sources to appear closer to zenith than
they really are. An alternate calculation of the shift due to DCR is to
transform the pixel coordinates to altitude and azimuth, add the DCR
amplitude to the altitude, and transform back to pixel coordinates.
"""
afwImageUtils.defineFilter("gTest", self.lambdaEff,
lambdaMin=self.lambdaMin, lambdaMax=self.lambdaMax)
filterInfo = afwImage.Filter("gTest")
pixelScale = 0.2*arcseconds
doFlip = [False, True]
for testIter in range(self.nRandIter):
rotAngle = 360.*self.rng.rand()*degrees
azimuth = 360.*self.rng.rand()*degrees
elevation = (45. + self.rng.rand()*40.)*degrees # Restrict to 45 < elevation < 85 degrees
visitInfo = self.makeDummyVisitInfo(azimuth, elevation)
for flip in doFlip:
# Repeat the calculation for both WCS orientations
wcs = self.makeDummyWcs(rotAngle, pixelScale, crval=visitInfo.getBoresightRaDec(), flipX=flip)
dcrShifts = calculateDcr(visitInfo, wcs, filterInfo, self.dcrNumSubfilters)
refShifts = calculateAstropyDcr(visitInfo, wcs, filterInfo, self.dcrNumSubfilters)
for refShift, dcrShift in zip(refShifts, dcrShifts):
# Use a fairly loose tolerance, since 1% of a pixel is good enough agreement.
self.assertFloatsAlmostEqual(refShift[1], dcrShift[1], rtol=1e-2, atol=1e-2)
self.assertFloatsAlmostEqual(refShift[0], dcrShift[0], rtol=1e-2, atol=1e-2)
def defineFilter(self,
lambdaEff=476.31,
lambdaMin=405.,
lambdaMax=552.,
filterName="gTest"):
"""Construct a `Filter` with sufficient information to calculate DCR.
Parameters
----------
lambdaEff : `float`, optional
The effective wavelength of the filter, defaults to LSST g-band value.
lambdaMin : float, optional
The minimum wavelength of the filter with greater than 1% transmission,
defaults to LSST g-band value.
lambdaMax : `float`, optional
The maximum wavelength of the filter with greater than 1% transmission,
defaults to LSST g-band value.
filterName : `str`, optional
The simplified name of the filter.
Returns
-------
filterInfo : `lsst.afw.image.Filter`
The filter definition.
"""
afwImageUtils.defineFilter(filterName,
lambdaEff,
lambdaMin=lambdaMin,
lambdaMax=lambdaMax)
return afwImage.Filter(filterName)
def setUp(self):
nSources = 10
# CFHT Filters from the camera mapper.
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('u', lambdaEff=374, alias="u.MP9301")
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
afwImageUtils.defineFilter('r', lambdaEff=628, alias="r.MP9601")
afwImageUtils.defineFilter('i', lambdaEff=778, alias="i.MP9701")
afwImageUtils.defineFilter('z', lambdaEff=1170, alias="z.MP9801")
self.bbox = geom.Box2I(geom.Point2I(0, 0), geom.Extent2I(1024, 1153))
dataset = measTests.TestDataset(self.bbox)
for srcIdx in range(nSources):
dataset.addSource(100000.0, geom.Point2D(100, 100))
self.inputCatalogNoFlags, _ = make_input_source_catalog(dataset, False)
self.inputCatalog, self.exposure = \
make_input_source_catalog(dataset, True)
detector = DetectorWrapper(id=23,
bbox=self.exposure.getBBox()).detector
visit = afwImage.VisitInfo(exposureId=4321,
exposureTime=200.,
date=dafBase.DateTime(nsecs=1400000000 *
10**9))
self.exposure.setDetector(detector)
self.exposure.getInfo().setVisitInfo(visit)
self.exposure.setFilter(afwImage.Filter('g.MP9401'))
scale = 2
scaleErr = 1
self.photoCalib = afwImage.PhotoCalib(scale, scaleErr)
self.exposure.setPhotoCalib(self.photoCalib)
def __init__(self, root, **kwargs):
self.storage = lsst.daf.persistence.Storage.makeFromURI(root)
super(SimpleMapper, self).__init__(**kwargs)
self.root = root
self.camera = makeSimpleCamera(nX=1, nY=2, sizeX=400, sizeY=200, gapX=2, gapY=2)
afwImageUtils.defineFilter('r', 619.42)
self.update()
def setUp(self):
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
maskedImageMD = readMetadata(inFilePathSmall)
self.smallExposure = afwImage.ExposureF(inFilePathSmall)
self.width = maskedImage.getWidth()
self.height = maskedImage.getHeight()
self.wcs = afwGeom.makeSkyWcs(maskedImageMD, False)
self.md = maskedImageMD
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.extras = {"misc": DummyPsf(3.5)}
self.exposureBlank = afwImage.ExposureF()
self.exposureMiOnly = afwImage.makeExposure(maskedImage)
self.exposureMiWcs = afwImage.makeExposure(maskedImage, self.wcs)
# n.b. the (100, 100, ...) form
self.exposureCrWcs = afwImage.ExposureF(100, 100, self.wcs)
# test with ExtentI(100, 100) too
self.exposureCrOnly = afwImage.ExposureF(lsst.geom.ExtentI(100, 100))
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
defineFilter("g", 470.0)
def setUp(self):
super().setUp()
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
defineFilter("g", 470.0)
self.wcs = afwGeom.makeSkyWcs(
lsst.geom.Point2D(0.0, 0.0),
lsst.geom.SpherePoint(2.0, 34.0, lsst.geom.degrees),
np.identity(2),
)
self.photoCalib = afwImage.PhotoCalib(1.5)
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.summaryStats = afwImage.ExposureSummaryStats(ra=100.0)
self.polygon = afwGeom.Polygon(
lsst.geom.Box2D(lsst.geom.Point2D(0.0, 0.0),
lsst.geom.Point2D(25.0, 20.0)))
self.coaddInputs = afwImage.CoaddInputs()
self.apCorrMap = afwImage.ApCorrMap()
self.transmissionCurve = afwImage.TransmissionCurve.makeIdentity()
self.exposureInfo = afwImage.ExposureInfo()
gFilter = afwImage.Filter("g")
gFilterLabel = afwImage.FilterLabel(band="g")
self.exposureInfo.setFilter(gFilter)
self.exposureInfo.setFilterLabel(gFilterLabel)
def __init__(self, outputRoot=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_sst", "SstMapper.paf",
"policy")
policy = pexPolicy.Policy(policyFile)
super(SstMapper, self).__init__(policy, policyFile.getRepositoryPath(),
**kwargs)
afwImageUtils.defineFilter('OPEN', lambdaEff=650)
def testNullWarpExposure(self, interpLength=10):
"""Test that warpExposure maps an image onto itself.
Note:
- NO_DATA and off-CCD pixels must be ignored
- bad mask pixels get smeared out so we have to excluded all bad mask pixels
from the output image when comparing masks.
"""
imageUtils.defineFilter("i", 748.1)
originalExposure = afwImage.ExposureF(originalExposurePath)
originalExposure.getInfo().setVisitInfo(makeVisitInfo())
originalFilter = afwImage.Filter("i")
originalCalib = afwImage.Calib()
originalCalib.setFluxMag0(1.0e5, 1.0e3)
originalExposure.setFilter(originalFilter)
originalExposure.setCalib(originalCalib)
afwWarpedExposure = afwImage.ExposureF(originalExposure.getBBox(),
originalExposure.getWcs())
warpingControl = afwMath.WarpingControl("lanczos4", "", 0,
interpLength)
afwMath.warpExposure(afwWarpedExposure, originalExposure,
warpingControl)
if SAVE_FITS_FILES:
afwWarpedExposure.writeFits("afwWarpedExposureNull.fits")
self.assertEqual(afwWarpedExposure.getFilter().getName(),
originalFilter.getName())
self.assertEqual(afwWarpedExposure.getCalib().getFluxMag0(),
originalCalib.getFluxMag0())
self.assertEqual(afwWarpedExposure.getInfo().getVisitInfo(),
originalExposure.getInfo().getVisitInfo())
afwWarpedMaskedImage = afwWarpedExposure.getMaskedImage()
afwWarpedMask = afwWarpedMaskedImage.getMask()
noDataBitMask = afwWarpedMask.getPlaneBitMask("NO_DATA")
afwWarpedMaskedImageArrSet = afwWarpedMaskedImage.getArrays()
afwWarpedMaskArr = afwWarpedMaskedImageArrSet[1]
# compare all non-DATA pixels of image and variance, but relax specs a bit
# because of minor noise introduced by bad pixels
noDataMaskArr = afwWarpedMaskArr & noDataBitMask
msg = "afw null-warped MaskedImage (all pixels, relaxed tolerance)"
self.assertMaskedImagesAlmostEqual(afwWarpedMaskedImage,
originalExposure.getMaskedImage(),
doMask=False,
skipMask=noDataMaskArr,
atol=1e-5,
msg=msg)
# compare good pixels (mask=0) of image, mask and variance using full
# tolerance
msg = "afw null-warped MaskedImage (good pixels, max tolerance)"
self.assertMaskedImagesAlmostEqual(afwWarpedMaskedImage,
originalExposure.getMaskedImage(),
skipMask=afwWarpedMask,
msg=msg)
def setUp(self):
self.size = 512
self.config = FringeTask.ConfigClass()
self.config.filters = ['FILTER']
self.config.num = 5000
self.config.small = 1
self.config.large = 128
self.config.pedestal = False
afwImageUtils.defineFilter('FILTER', lambdaEff=0)
def setUp(self):
self.size = 512
self.config = FringeTask.ConfigClass()
self.config.filters = ['FILTER']
self.config.num = 5000
self.config.small = 1
self.config.large = 128
self.config.pedestal = False
afwImageUtils.defineFilter('FILTER', lambdaEff=0)
def defineSdssFilters(testCase):
"""Initialise filters as used for our tests"""
imageUtils.resetFilters()
wavelengths = dict()
testCase.aliases = dict(u=[], g=[], r=[], i=[], z=['zprime', "z'"])
for name, lambdaEff in (('u', 355.1), ('g', 468.6), ('r', 616.5),
('i', 748.1), ('z', 893.1)):
wavelengths[name] = lambdaEff
imageUtils.defineFilter(name, lambdaEff, alias=testCase.aliases[name])
return wavelengths
def setUp(self):
np.random.seed(1234)
self.cutoutSize = 35
self.center = lsst.geom.Point2D(50.1, 49.8)
self.bbox = lsst.geom.Box2I(lsst.geom.Point2I(-20, -30),
lsst.geom.Extent2I(140, 160))
self.dataset = lsst.meas.base.tests.TestDataset(self.bbox)
self.dataset.addSource(100000.0, self.center)
exposure, catalog = self.dataset.realize(
10.0, self.dataset.makeMinimalSchema(), randomSeed=0)
self.exposure = exposure
detector = DetectorWrapper(id=23, bbox=exposure.getBBox()).detector
self.exposure.setDetector(detector)
visit = afwImage.VisitInfo(exposureId=1234,
exposureTime=200.,
date=dafBase.DateTime(
"2014-05-13T17:00:00.000000000",
dafBase.DateTime.Timescale.TAI))
self.exposure.getInfo().setVisitInfo(visit)
self.filter_names = ["g"]
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
self.exposure.setFilter(afwImage.Filter('g'))
diaObjects = makeDiaObjects(2, self.exposure)
diaSourceHistory = makeDiaSources(10, diaObjects["diaObjectId"],
self.exposure)
diaForcedSources = makeDiaForcedSources(10, diaObjects["diaObjectId"],
self.exposure)
self.diaObjects, diaSourceHistory, self.diaForcedSources = _roundTripThroughApdb(
diaObjects, diaSourceHistory, diaForcedSources,
self.exposure.getInfo().getVisitInfo().getDate().toPython())
self.diaObjects.replace(to_replace=[None], value=np.nan, inplace=True)
diaSourceHistory.replace(to_replace=[None], value=np.nan, inplace=True)
self.diaForcedSources.replace(to_replace=[None],
value=np.nan,
inplace=True)
diaSourceHistory["programId"] = 0
self.diaSources = diaSourceHistory.loc[[(0, "g", 8), (1, "g", 9)], :]
self.diaSources["bboxSize"] = self.cutoutSize
self.diaSourceHistory = diaSourceHistory.drop(labels=[(0, "g",
8), (1, "g",
9)])
self.cutoutWcs = wcs.WCS(naxis=2)
self.cutoutWcs.wcs.crpix = [self.center[0], self.center[1]]
self.cutoutWcs.wcs.crval = [
self.exposure.getWcs().getSkyOrigin().getRa().asDegrees(),
self.exposure.getWcs().getSkyOrigin().getDec().asDegrees()
]
self.cutoutWcs.wcs.cd = self.exposure.getWcs().getCdMatrix()
self.cutoutWcs.wcs.ctype = ["RA---TAN", "DEC--TAN"]
def __init__(self, root):
super(SimpleMapper, self).__init__()
self.root = root
self.camera = makeSimpleCamera(nX=1,
nY=2,
sizeX=400,
sizeY=200,
gapX=2,
gapY=2)
afwImageUtils.defineFilter('r', 619.42)
self.update()
def __init__(self, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_ukirt", "CasuWfcamMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
CameraMapper.__init__(self, policy, policyFile.getRepositoryPath(), **kwargs)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = {
'project': str,
'object': str,
'obsType': str,
'visit': int,
'grp': int,
'dateObs': str,
'expTime': float,
'filter': str,
'date': str,
}
for name in ("raw",
# processCcd outputs
"calexp", "src", "icMatch", "icMatchFull",
"srcMatch", "srcMatchFull",
# Warp
"deepCoadd_tempExp",
):
self.mappings[name].keyDict.update(keys)
# The order of these defineFilter commands matters as their IDs are used to generate at least some
# object IDs (e.g. on coadds) and changing the order will invalidate old objIDs
afwImageUtils.resetFilters()
afwImageUtils.defineFilter(name='Z', lambdaEff=950, alias=[])
afwImageUtils.defineFilter(name='Y', lambdaEff=1100, alias=[])
afwImageUtils.defineFilter(name='J', lambdaEff=1300, alias=[])
afwImageUtils.defineFilter(name='H', lambdaEff=1600, alias=[])
afwImageUtils.defineFilter(name='K', lambdaEff=2000, alias=[])
self.filters = {}
for f in "ZYJHK":
self.filters[f] = f
#
# The number of bits allocated for fields in object IDs, appropriate for
# the default-configured Rings skymap.
#
CasuWfcamMapper._nbit_tract = 16
CasuWfcamMapper._nbit_patch = 5
CasuWfcamMapper._nbit_filter = 6
CasuWfcamMapper._nbit_id = 64 - (CasuWfcamMapper._nbit_tract + 2*CasuWfcamMapper._nbit_patch +
CasuWfcamMapper._nbit_filter)
if len(afwImage.Filter.getNames()) >= 2**CasuWfcamMapper._nbit_filter:
raise RuntimeError("You have more filters defined than fit into the %d bits allocated" %
CasuWfcamMapper._nbit_filter)
def defineSdssFilters(testCase):
"""Initialise filters as used for our tests"""
imageUtils.resetFilters()
wavelengths = dict()
testCase.aliases = dict(u=[], g=[], r=[], i=[], z=['zprime', "z'"])
for name, lambdaEff in (('u', 355.1),
('g', 468.6),
('r', 616.5),
('i', 748.1),
('z', 893.1)):
wavelengths[name] = lambdaEff
imageUtils.defineFilter(name, lambdaEff, alias=testCase.aliases[name])
return wavelengths
def defineSdssFilters():
# Initialise filters as used for our tests
imageUtils.resetFilters()
wavelengths = dict()
for name, lambdaEff, aliases in (('u', 355.1, []),
('g', 468.6, []),
('r', 616.5, []),
('i', 748.1, []),
('z', 893.1, ['zprime', "z'"]),
):
wavelengths[name] = lambdaEff
imageUtils.defineFilter(name, lambdaEff, alias=aliases)
return wavelengths
def defineSdssFilters():
# Initialise filters as used for our tests
imageUtils.resetFilters()
wavelengths = dict()
for name, lambdaEff, aliases in (('u', 355.1, []),
('g', 468.6, []),
('r', 616.5, []),
('i', 748.1, []),
('z', 893.1, ['zprime', "z'"]),
):
wavelengths[name] = lambdaEff
imageUtils.defineFilter(name, lambdaEff, alias=aliases)
return wavelengths
def testLambdaMinMax(self):
"""Test additional properties for minimum and maximum wavelength for a filter."""
filt = afwImage.Filter("g")
# LambdaMin and LambdaMax are undefined for the test SDSS filter, and should return nan
self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMin()))
self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMax()))
lambdaEff = 476.31
lambdaMin = 405
lambdaMax = 552
imageUtils.defineFilter("gNew", lambdaEff, lambdaMin=lambdaMin, lambdaMax=lambdaMax)
filtNew = afwImage.Filter("gNew")
self.assertEqual(lambdaMin, filtNew.getFilterProperty().getLambdaMin())
self.assertEqual(lambdaMax, filtNew.getFilterProperty().getLambdaMax())
def setUp(self):
# CFHT Filters from the camera mapper.
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('u', lambdaEff=374, alias="u.MP9301")
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
afwImageUtils.defineFilter('r', lambdaEff=628, alias="r.MP9601")
afwImageUtils.defineFilter('i', lambdaEff=778, alias="i.MP9701")
afwImageUtils.defineFilter('z', lambdaEff=1170, alias="z.MP9801")
self.metadata = dafBase.PropertySet()
self.metadata.set("SIMPLE", "T")
self.metadata.set("BITPIX", -32)
self.metadata.set("NAXIS", 2)
self.metadata.set("NAXIS1", 1024)
self.metadata.set("NAXIS2", 1153)
self.metadata.set("RADECSYS", 'FK5')
self.metadata.set("EQUINOX", 2000.)
self.metadata.setDouble("CRVAL1", 215.604025685476)
self.metadata.setDouble("CRVAL2", 53.1595451514076)
self.metadata.setDouble("CRPIX1", 1109.99981456774)
self.metadata.setDouble("CRPIX2", 560.018167811613)
self.metadata.set("CTYPE1", 'RA---SIN')
self.metadata.set("CTYPE2", 'DEC--SIN')
self.metadata.setDouble("CD1_1", 5.10808596133527E-05)
self.metadata.setDouble("CD1_2", 1.85579539217196E-07)
self.metadata.setDouble("CD2_2", -5.10281493481982E-05)
self.metadata.setDouble("CD2_1", -8.27440751733828E-07)
self.wcs = afwGeom.makeSkyWcs(self.metadata)
self.exposure = afwImage.makeExposure(
afwImage.makeMaskedImageFromArrays(np.ones((1024, 1153))),
self.wcs)
detector = DetectorWrapper(id=23,
bbox=self.exposure.getBBox()).detector
visit = afwImage.VisitInfo(exposureId=4321,
exposureTime=200.,
date=dafBase.DateTime(nsecs=1400000000 *
10**9))
self.exposure.setDetector(detector)
self.exposure.getInfo().setVisitInfo(visit)
self.exposure.setFilter(afwImage.Filter('g'))
scale = 2
scaleErr = 1
self.photoCalib = afwImage.PhotoCalib(scale, scaleErr)
self.exposure.setPhotoCalib(self.photoCalib)
self.inputCatalogNoFlags = make_input_source_catalog(10, False)
self.inputCatalog = make_input_source_catalog(10, True)
def __init__(self, **kwargs):
#Define the policy file:
policyFile = Policy.defaultPolicyFile(self.packageName, "GotoMapper.yaml", "policy")
policy =Policy(policyFile)
#Change the policy to point to the sim camera description:
policy["camera"] = "../sim/camera"
#This creates the camera class by calling CameraMapper (i.e., the parent class):
super(GotoMapper, self).__init__(policy, os.path.dirname(policyFile), **kwargs)
#Set the filters:
self.filterIdMap = dict(v=0)
afwImageUtils.defineFilter(name='R', lambdaEff=635.9, alias=['R'])
afwImageUtils.defineFilter(name='G', lambdaEff=534.9, alias=['G'])
afwImageUtils.defineFilter(name='B', lambdaEff=446.6, alias=['B'])
afwImageUtils.defineFilter(name='L', lambdaEff=535.5, alias=['L'])
self.filters = {}
self.filters['R'] = afwImage.Filter('R').getCanonicalName()
self.filters['G'] = afwImage.Filter('G').getCanonicalName()
self.filters['B'] = afwImage.Filter('B').getCanonicalName()
self.filters['L'] = afwImage.Filter('L').getCanonicalName()
self.defaultFilterName = 'L'
def testNullWarpExposure(self, interpLength=10):
"""Test that warpExposure maps an image onto itself.
Note:
- NO_DATA and off-CCD pixels must be ignored
- bad mask pixels get smeared out so we have to excluded all bad mask pixels
from the output image when comparing masks.
"""
imageUtils.defineFilter("i", 748.1)
originalExposure = afwImage.ExposureF(originalExposurePath)
originalExposure.getInfo().setVisitInfo(makeVisitInfo())
originalFilter = afwImage.Filter("i")
originalPhotoCalib = afwImage.PhotoCalib(1.0e5, 1.0e3)
originalExposure.setFilter(originalFilter)
originalExposure.setCalib(originalPhotoCalib)
afwWarpedExposure = afwImage.ExposureF(
originalExposure.getBBox(),
originalExposure.getWcs())
warpingControl = afwMath.WarpingControl(
"lanczos4", "", 0, interpLength)
afwMath.warpExposure(
afwWarpedExposure, originalExposure, warpingControl)
if SAVE_FITS_FILES:
afwWarpedExposure.writeFits("afwWarpedExposureNull.fits")
self.assertEqual(afwWarpedExposure.getFilter().getName(),
originalFilter.getName())
self.assertEqual(afwWarpedExposure.getPhotoCalib(), originalPhotoCalib)
self.assertEqual(afwWarpedExposure.getInfo().getVisitInfo(),
originalExposure.getInfo().getVisitInfo())
afwWarpedMaskedImage = afwWarpedExposure.getMaskedImage()
afwWarpedMask = afwWarpedMaskedImage.getMask()
noDataBitMask = afwWarpedMask.getPlaneBitMask("NO_DATA")
afwWarpedMaskedImageArrSet = afwWarpedMaskedImage.getArrays()
afwWarpedMaskArr = afwWarpedMaskedImageArrSet[1]
# compare all non-DATA pixels of image and variance, but relax specs a bit
# because of minor noise introduced by bad pixels
noDataMaskArr = afwWarpedMaskArr & noDataBitMask
msg = "afw null-warped MaskedImage (all pixels, relaxed tolerance)"
self.assertMaskedImagesAlmostEqual(afwWarpedMaskedImage, originalExposure.getMaskedImage(),
doMask=False, skipMask=noDataMaskArr, atol=1e-5, msg=msg)
# compare good pixels (mask=0) of image, mask and variance using full
# tolerance
msg = "afw null-warped MaskedImage (good pixels, max tolerance)"
self.assertMaskedImagesAlmostEqual(afwWarpedMaskedImage, originalExposure.getMaskedImage(),
skipMask=afwWarpedMask, msg=msg)
def testMultiPlaneFitsReaders(self):
"""Run tests for MaskedImageFitsReader and ExposureFitsReader.
"""
metadata = PropertyList()
metadata.add("FIVE", 5)
metadata.add("SIX", 6.0)
wcs = makeSkyWcs(Point2D(2.5, 3.75), SpherePoint(40.0*degrees, 50.0*degrees),
np.array([[1E-5, 0.0], [0.0, -1E-5]]))
defineFilter("test_readers_filter", lambdaEff=470.0)
calib = PhotoCalib(2.5E4)
psf = GaussianPsf(21, 21, 8.0)
polygon = Polygon(Box2D(self.bbox))
apCorrMap = ApCorrMap()
visitInfo = VisitInfo(exposureTime=5.0)
transmissionCurve = TransmissionCurve.makeIdentity()
coaddInputs = CoaddInputs(ExposureTable.makeMinimalSchema(), ExposureTable.makeMinimalSchema())
detector = DetectorWrapper().detector
record = coaddInputs.ccds.addNew()
record.setWcs(wcs)
record.setCalib(calib)
record.setPsf(psf)
record.setValidPolygon(polygon)
record.setApCorrMap(apCorrMap)
record.setVisitInfo(visitInfo)
record.setTransmissionCurve(transmissionCurve)
record.setDetector(detector)
for n, dtypeIn in enumerate(self.dtypes):
with self.subTest(dtypeIn=dtypeIn):
exposureIn = Exposure(self.bbox, dtype=dtypeIn)
shape = exposureIn.image.array.shape
exposureIn.image.array[:, :] = np.random.randint(low=1, high=5, size=shape)
exposureIn.mask.array[:, :] = np.random.randint(low=1, high=5, size=shape)
exposureIn.variance.array[:, :] = np.random.randint(low=1, high=5, size=shape)
exposureIn.setMetadata(metadata)
exposureIn.setWcs(wcs)
exposureIn.setFilter(Filter("test_readers_filter"))
exposureIn.setCalib(calib)
exposureIn.setPsf(psf)
exposureIn.getInfo().setValidPolygon(polygon)
exposureIn.getInfo().setApCorrMap(apCorrMap)
exposureIn.getInfo().setVisitInfo(visitInfo)
exposureIn.getInfo().setTransmissionCurve(transmissionCurve)
exposureIn.getInfo().setCoaddInputs(coaddInputs)
exposureIn.setDetector(detector)
with lsst.utils.tests.getTempFilePath(".fits") as fileName:
exposureIn.writeFits(fileName)
self.checkMaskedImageFitsReader(exposureIn, fileName, self.dtypes[n:])
self.checkExposureFitsReader(exposureIn, fileName, self.dtypes[n:])
def testLambdaMinMax(self):
"""Test additional properties for minimum and maximum wavelength for a filter."""
filt = afwImage.Filter("g")
# LambdaMin and LambdaMax are undefined for the test SDSS filter, and should return nan
self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMin()))
self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMax()))
lambdaEff = 476.31
lambdaMin = 405
lambdaMax = 552
imageUtils.defineFilter("gNew",
lambdaEff,
lambdaMin=lambdaMin,
lambdaMax=lambdaMax)
filtNew = afwImage.Filter("gNew")
self.assertEqual(lambdaMin, filtNew.getFilterProperty().getLambdaMin())
self.assertEqual(lambdaMax, filtNew.getFilterProperty().getLambdaMax())
def __init__(self, inputPolicy=None, **kwargs):
"""Initialization for the AuxTel Mapper."""
policyFile = dafPersist.Policy.defaultPolicyFile(self.packageName, "auxTelMapper.yaml", "policy")
policy = dafPersist.Policy(policyFile)
CameraMapper.__init__(self, policy, os.path.dirname(policyFile), **kwargs)
#
# The composite objects don't seem to set these
#
for d in (self.mappings, self.exposures):
d['raw'] = d['_raw']
afwImageUtils.defineFilter('NONE', 0.0, alias=['no_filter', 'OPEN', 'empty'])
afwImageUtils.defineFilter('275CutOn', 0.0, alias=[])
afwImageUtils.defineFilter('550CutOn', 0.0, alias=[])
afwImageUtils.defineFilter('green', 0.0, alias=[])
afwImageUtils.defineFilter('blue', 0.0, alias=[])
def __init__(self, outputRoot=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_wiyn", "WhircMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
# print policyFile.getRepositoryPath()
super(WhircMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
afwImageUtils.defineFilter('OPEN', lambdaEff=1750) # nm
afwImageUtils.defineFilter('J' , lambdaEff=1250)
afwImageUtils.defineFilter('H' , lambdaEff=1650)
afwImageUtils.defineFilter('KS', lambdaEff=2175, alias=['Ks'])
def testBBox(self):
"""Test that the default bounding box includes all warped pixels
"""
kernelName = "lanczos2"
warper = afwMath.Warper(kernelName)
originalExposure, swarpedImage, swarpedWcs = self.getSwarpedImage(
kernelName=kernelName, useSubregion=True, useDeepCopy=False)
imageUtils.defineFilter("i", 748.1)
originalFilter = afwImage.Filter("i")
originalCalib = afwImage.Calib()
originalCalib.setFluxMag0(1.0e5, 1.0e3)
originalExposure.setFilter(originalFilter)
originalExposure.setCalib(originalCalib)
warpedExposure1 = warper.warpExposure(destWcs=swarpedWcs,
srcExposure=originalExposure)
# the default size must include all good pixels, so growing the bbox
# should not add any
warpedExposure2 = warper.warpExposure(destWcs=swarpedWcs,
srcExposure=originalExposure,
border=1)
# a bit of excess border is allowed, but surely not as much as 10 (in
# fact it is approx. 5)
warpedExposure3 = warper.warpExposure(destWcs=swarpedWcs,
srcExposure=originalExposure,
border=-10)
# assert that warpedExposure and warpedExposure2 have the same number of non-no_data pixels
# and that warpedExposure3 has fewer
noDataBitMask = afwImage.Mask.getPlaneBitMask("NO_DATA")
mask1Arr = warpedExposure1.getMaskedImage().getMask().getArray()
mask2Arr = warpedExposure2.getMaskedImage().getMask().getArray()
mask3Arr = warpedExposure3.getMaskedImage().getMask().getArray()
nGood1 = (mask1Arr & noDataBitMask == 0).sum()
nGood2 = (mask2Arr & noDataBitMask == 0).sum()
nGood3 = (mask3Arr & noDataBitMask == 0).sum()
self.assertEqual(nGood1, nGood2)
self.assertLess(nGood3, nGood1)
self.assertEqual(warpedExposure1.getFilter().getName(),
originalFilter.getName())
self.assertEqual(warpedExposure1.getCalib().getFluxMag0(),
originalCalib.getFluxMag0())
def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile(self.packageName,
"ts3Mapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
CameraMapper.__init__(self, policy, policyFile.getRepositoryPath(),
**kwargs)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = {
'visit': int,
'ccd': int,
'filter': str,
'date': str,
'expTime': float,
'object': str,
'imageType': str,
}
for name in (
"raw",
"raw_amp",
# processCcd outputs
"postISRCCD",
"calexp",
"postISRCCD",
"src",
"icSrc",
"srcMatch",
):
self.mappings[name].keyDict.update(keys)
# @merlin, you should swap these out for the filters you actually intend to use.
self.filterIdMap = {'u': 0, 'g': 1, 'r': 2, 'i': 3, 'z': 4, 'y': 5}
# The LSST Filters from L. Jones 04/07/10
# afwImageUtils.defineFilter('u', 364.59)
# afwImageUtils.defineFilter('g', 476.31, alias=["SDSSG"])
# afwImageUtils.defineFilter('r', 619.42, alias=["SDSSR"])
# afwImageUtils.defineFilter('i', 752.06, alias=["SDSSI"])
# afwImageUtils.defineFilter('z', 866.85, alias=["SDSSZ"])
# afwImageUtils.defineFilter('y', 971.68, alias=['y4']) # official y filter
afwImageUtils.defineFilter('550CutOn', 550.0)
afwImageUtils.defineFilter('NONE', 0.0, alias=['no_filter', "OPEN"])
def __init__(self, outputRoot=None, **kwargs):
policyFile = dafPersist.Policy.defaultPolicyFile(
self.packageName, "WhircMapper.yaml", "policy")
policy = dafPersist.Policy(policyFile)
CameraMapper.__init__(self, policy, os.path.dirname(policyFile),
**kwargs)
afwImageUtils.defineFilter('OPAQUE', lambdaEff=0) # nm
afwImageUtils.defineFilter('OPEN', lambdaEff=1750) # nm
afwImageUtils.defineFilter('J', lambdaEff=1250)
afwImageUtils.defineFilter('H', lambdaEff=1650)
afwImageUtils.defineFilter('KS', lambdaEff=2175, alias=['Ks'])
self._nbit_tract = 8
self._nbit_patch = 8
self._nbit_filter = 8
self._nbit_id = 64 - (self._nbit_tract + 2*self._nbit_patch + self._nbit_filter)
def __init__(self, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_file", "FileMapper.paf",
"policy")
policy = pexPolicy.Policy(policyFile)
if False:
if not kwargs.get('root', None):
raise RuntimeError("Please specify a root")
if not kwargs.get('calibRoot', None):
kwargs['calibRoot'] = os.path.join(kwargs['root'], 'CALIB')
super(FileMapper,
self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = dict(calexp=str, )
for name in ("calexp", "src"):
self.mappings[name].keyDict = keys
# SDSS g': http://www.naoj.org/Observing/Instruments/SCam/txt/g.txt
# SDSS r': http://www.naoj.org/Observing/Instruments/SCam/txt/r.txt
# SDSS i': http://www.naoj.org/Observing/Instruments/SCam/txt/i.txt
# SDSS z': http://www.naoj.org/Observing/Instruments/SCam/txt/z.txt
# y-band: Shimasaku et al., 2005, PASJ, 57, 447
afwImageUtils.resetFilters()
afwImageUtils.defineFilter(name='g', lambdaEff=477, alias=['W-S-G+'])
afwImageUtils.defineFilter(name='r', lambdaEff=623, alias=['W-S-R+'])
afwImageUtils.defineFilter(name='i', lambdaEff=775, alias=['W-S-I+'])
afwImageUtils.defineFilter(name='z', lambdaEff=925, alias=['W-S-Z+'])
afwImageUtils.defineFilter(name='y', lambdaEff=990, alias=['W-S-ZR'])
self.filters = {
"W-S-G+": "g",
"W-S-R+": "r",
"W-S-I+": "i",
"W-S-Z+": "z",
"W-S-ZR": "y",
}
# next line makes a dict that maps filter names to sequential integers (arbitrarily sorted),
# for use in generating unique IDs for sources.
self.filterIdMap = dict(zip(self.filters, range(len(self.filters))))
def __init__(self, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_file", "FileMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
if False:
if not kwargs.get('root', None):
raise RuntimeError("Please specify a root")
if not kwargs.get('calibRoot', None):
kwargs['calibRoot'] = os.path.join(kwargs['root'], 'CALIB')
super(FileMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = dict(calexp=str,
)
for name in ("calexp", "src"):
self.mappings[name].keyDict = keys
# SDSS g': http://www.naoj.org/Observing/Instruments/SCam/txt/g.txt
# SDSS r': http://www.naoj.org/Observing/Instruments/SCam/txt/r.txt
# SDSS i': http://www.naoj.org/Observing/Instruments/SCam/txt/i.txt
# SDSS z': http://www.naoj.org/Observing/Instruments/SCam/txt/z.txt
# y-band: Shimasaku et al., 2005, PASJ, 57, 447
afwImageUtils.resetFilters()
afwImageUtils.defineFilter(name='g', lambdaEff=477, alias=['W-S-G+'])
afwImageUtils.defineFilter(name='r', lambdaEff=623, alias=['W-S-R+'])
afwImageUtils.defineFilter(name='i', lambdaEff=775, alias=['W-S-I+'])
afwImageUtils.defineFilter(name='z', lambdaEff=925, alias=['W-S-Z+'])
afwImageUtils.defineFilter(name='y', lambdaEff=990, alias=['W-S-ZR'])
self.filters = {
"W-S-G+" : "g",
"W-S-R+" : "r",
"W-S-I+" : "i",
"W-S-Z+" : "z",
"W-S-ZR" : "y",
}
# next line makes a dict that maps filter names to sequential integers (arbitrarily sorted),
# for use in generating unique IDs for sources.
self.filterIdMap = dict(zip(self.filters, range(len(self.filters))))
def testFilters(self):
"""Test that the coadd filter is set correctly
"""
imageUtils.defineFilter("g", 468.6)
imageUtils.defineFilter("r", 616.5)
unkFilter = afwImage.Filter()
gFilter = afwImage.Filter("g")
rFilter = afwImage.Filter("r")
imShape = (150, 150)
imSigma = 1.0
imVariance = 1.0
badMaskPlanes = ["EDGE"]
np.random.seed(0)
coadd = None
maskedImage = afwTestUtils.makeGaussianNoiseMaskedImage(
dimensions=imShape, sigma=imSigma, variance=imVariance)
inExp = afwImage.ExposureF(maskedImage)
coadd = coaddChiSq.Coadd(
bbox=inExp.getBBox(),
wcs=inExp.getWcs(),
badMaskPlanes=badMaskPlanes,
)
inExp.setFilter(gFilter)
coadd.addExposure(inExp)
self.assertEqualFilters(coadd.getCoadd().getFilter(), gFilter)
self.assertEqualFilterSets(coadd.getFilters(), (gFilter, ))
coadd.addExposure(inExp)
self.assertEqualFilters(coadd.getCoadd().getFilter(), gFilter)
self.assertEqualFilterSets(coadd.getFilters(), (gFilter, ))
inExp.setFilter(rFilter)
coadd.addExposure(inExp)
self.assertEqualFilters(coadd.getCoadd().getFilter(), unkFilter)
self.assertEqualFilterSets(coadd.getFilters(), (gFilter, rFilter))
def __init__(self, inputPolicy=None, **kwargs):
policyFile = dafPersist.Policy.defaultPolicyFile(self.packageName, "SdssMapper.yaml", "policy")
policy = dafPersist.Policy(policyFile)
self.doFootprints = False
if inputPolicy is not None:
for kw in inputPolicy.paramNames(True):
if kw == "doFootprints":
self.doFootprints = True
else:
kwargs[kw] = inputPolicy.get(kw)
super(SdssMapper, self).__init__(policy, os.path.dirname(policyFile), **kwargs)
# define filters?
self.filterIdMap = dict(u=0, g=1, r=2, i=3, z=4)
afwImageUtils.defineFilter('u', lambdaEff=380)
afwImageUtils.defineFilter('g', lambdaEff=450)
afwImageUtils.defineFilter('r', lambdaEff=600)
afwImageUtils.defineFilter('i', lambdaEff=770)
afwImageUtils.defineFilter('z', lambdaEff=900)
def __init__(self, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_sofi", "SOFIMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(SofiMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
# The "ccd" provided by the user is translated through the registry into an extension name for the "raw"
# template. The template therefore doesn't include "ccd", so we need to ensure it's explicitly included
# so the ArgumentParser can recognise and accept it.
self.exposures['raw'].keyDict['ccd'] = int
afwImageUtils.defineFilter('Ks', lambdaEff=2175, alias=['KS'])
self.filterIdMap = dict(Ks=0)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = {'pointing': str,
'dateObs': str,
'expTime': float,
}
for name in ("raw", "calexp", "postISRCCD", "src", "icSrc", "icMatch"):
self.mappings[name].keyDict.update(keys)
def testBBox(self):
"""Test that the default bounding box includes all warped pixels
"""
kernelName = "lanczos2"
warper = afwMath.Warper(kernelName)
originalExposure, swarpedImage, swarpedWcs = self.getSwarpedImage(
kernelName=kernelName, useSubregion=True, useDeepCopy=False)
imageUtils.defineFilter("i", 748.1)
originalFilter = afwImage.Filter("i")
originalPhotoCalib = afwImage.PhotoCalib(1.0e5, 1.0e3)
originalExposure.setFilter(originalFilter)
originalExposure.setCalib(originalPhotoCalib)
warpedExposure1 = warper.warpExposure(
destWcs=swarpedWcs, srcExposure=originalExposure)
# the default size must include all good pixels, so growing the bbox
# should not add any
warpedExposure2 = warper.warpExposure(
destWcs=swarpedWcs, srcExposure=originalExposure, border=1)
# a bit of excess border is allowed, but surely not as much as 10 (in
# fact it is approx. 5)
warpedExposure3 = warper.warpExposure(
destWcs=swarpedWcs, srcExposure=originalExposure, border=-10)
# assert that warpedExposure and warpedExposure2 have the same number of non-no_data pixels
# and that warpedExposure3 has fewer
noDataBitMask = afwImage.Mask.getPlaneBitMask("NO_DATA")
mask1Arr = warpedExposure1.getMaskedImage().getMask().getArray()
mask2Arr = warpedExposure2.getMaskedImage().getMask().getArray()
mask3Arr = warpedExposure3.getMaskedImage().getMask().getArray()
nGood1 = (mask1Arr & noDataBitMask == 0).sum()
nGood2 = (mask2Arr & noDataBitMask == 0).sum()
nGood3 = (mask3Arr & noDataBitMask == 0).sum()
self.assertEqual(nGood1, nGood2)
self.assertLess(nGood3, nGood1)
self.assertEqual(warpedExposure1.getFilter().getName(),
originalFilter.getName())
self.assertEqual(warpedExposure1.getPhotoCalib(), originalPhotoCalib)
def __init__(self, inputPolicy=None, **kwargs):
policyFile = Policy.defaultPolicyFile(self.packageName,
"CtmoMapper.yaml", "policy")
policy = Policy(policyFile)
# ...and add it to the mapper:
super(CtmoCamMapper,
self).__init__(policy, os.path.dirname(policyFile), **kwargs)
# Define your filter set
# Create a dict of filters:
self.filters = {}
# Define your set of filters; you can have as many filters as you like...
afwImageUtils.defineFilter(name="Clear",
lambdaEff=535.5,
alias=["Clear"])
# ...add them to your filter dict...
self.filters["Clear"] = afwImage.Filter("Clear").getCanonicalName()
# ...and set your default filter.
self.defaultFilterName = "Clear"
def testDcrCalculation(self):
"""Test that the shift in pixels due to DCR is consistently computed.
The shift is compared to pre-computed values.
"""
dcrNumSubfilters = 3
afwImageUtils.defineFilter("gTest", self.lambdaEff,
lambdaMin=self.lambdaMin, lambdaMax=self.lambdaMax)
filterInfo = afwImage.Filter("gTest")
rotAngle = 0.*degrees
azimuth = 30.*degrees
elevation = 65.*degrees
pixelScale = 0.2*arcseconds
visitInfo = self.makeDummyVisitInfo(azimuth, elevation)
wcs = self.makeDummyWcs(rotAngle, pixelScale, crval=visitInfo.getBoresightRaDec())
dcrShift = calculateDcr(visitInfo, wcs, filterInfo, dcrNumSubfilters)
# Compare to precomputed values.
refShift = [(-0.5575567724366292, -0.2704095599533037),
(0.001961910992342903, 0.000951507567181944),
(0.40402552599550073, 0.19594841296051665)]
for shiftOld, shiftNew in zip(refShift, dcrShift):
self.assertFloatsAlmostEqual(shiftOld[1], shiftNew[1], rtol=1e-6, atol=1e-8)
self.assertFloatsAlmostEqual(shiftOld[0], shiftNew[0], rtol=1e-6, atol=1e-8)
def testDcrSubfilterOrder(self):
"""Test that the bluest subfilter always has the largest DCR amplitude.
"""
dcrNumSubfilters = 3
afwImageUtils.defineFilter("gTest", self.lambdaEff,
lambdaMin=self.lambdaMin, lambdaMax=self.lambdaMax)
filterInfo = afwImage.Filter("gTest")
pixelScale = 0.2*arcseconds
for testIter in range(self.nRandIter):
rotAngle = 360.*self.rng.rand()*degrees
azimuth = 360.*self.rng.rand()*degrees
elevation = (45. + self.rng.rand()*40.)*degrees # Restrict to 45 < elevation < 85 degrees
visitInfo = self.makeDummyVisitInfo(azimuth, elevation)
wcs = self.makeDummyWcs(rotAngle, pixelScale, crval=visitInfo.getBoresightRaDec())
dcrShift = calculateDcr(visitInfo, wcs, filterInfo, dcrNumSubfilters)
# First check that the blue subfilter amplitude is greater than the red subfilter
rotation = calculateImageParallacticAngle(visitInfo, wcs).asRadians()
ampShift = [dcr[1]*np.sin(rotation) + dcr[0]*np.cos(rotation) for dcr in dcrShift]
self.assertGreater(ampShift[0], 0.) # The blue subfilter should be shifted towards zenith
self.assertLess(ampShift[2], 0.) # The red subfilter should be shifted away from zenith
# The absolute amplitude of the blue subfilter should also
# be greater than that of the red subfilter
self.assertGreater(np.abs(ampShift[0]), np.abs(ampShift[2]))
def testDcrCalculation(self):
"""Test that the shift in pixels due to DCR is consistently computed.
The shift is compared to pre-computed values.
"""
dcrNumSubfilters = 3
afwImageUtils.defineFilter("gTest", self.lambdaEff,
lambdaMin=self.lambdaMin, lambdaMax=self.lambdaMax)
filterInfo = afwImage.Filter("gTest")
rotAngle = 0.*degrees
azimuth = 30.*degrees
elevation = 65.*degrees
pixelScale = 0.2*arcseconds
visitInfo = self.makeDummyVisitInfo(azimuth, elevation)
wcs = self.makeDummyWcs(rotAngle, pixelScale, crval=visitInfo.getBoresightRaDec())
dcrShift = calculateDcr(visitInfo, wcs, filterInfo, dcrNumSubfilters)
# Compare to precomputed values.
refShift = [(-0.5363512808, -0.3103517169),
(0.001887293861, 0.001092054612),
(0.3886592703, 0.2248919247)]
for shiftOld, shiftNew in zip(refShift, dcrShift):
self.assertFloatsAlmostEqual(shiftOld[1], shiftNew[1], rtol=1e-6, atol=1e-8)
self.assertFloatsAlmostEqual(shiftOld[0], shiftNew[0], rtol=1e-6, atol=1e-8)
def testDcrSubfilterOrder(self):
"""Test that the bluest subfilter always has the largest DCR amplitude.
"""
dcrNumSubfilters = 3
afwImageUtils.defineFilter("gTest", self.lambdaEff,
lambdaMin=self.lambdaMin, lambdaMax=self.lambdaMax)
filterInfo = afwImage.Filter("gTest")
pixelScale = 0.2*arcseconds
for testIter in range(self.nRandIter):
rotAngle = 360.*self.rng.rand()*degrees
azimuth = 360.*self.rng.rand()*degrees
elevation = (45. + self.rng.rand()*40.)*degrees # Restrict to 45 < elevation < 85 degrees
visitInfo = self.makeDummyVisitInfo(azimuth, elevation)
wcs = self.makeDummyWcs(rotAngle, pixelScale, crval=visitInfo.getBoresightRaDec())
dcrShift = calculateDcr(visitInfo, wcs, filterInfo, dcrNumSubfilters)
# First check that the blue subfilter amplitude is greater than the red subfilter
rotation = calculateImageParallacticAngle(visitInfo, wcs).asRadians()
ampShift = [dcr[1]*np.sin(rotation) + dcr[0]*np.cos(rotation) for dcr in dcrShift]
self.assertGreater(ampShift[0], 0.) # The blue subfilter should be shifted towards zenith
self.assertLess(ampShift[2], 0.) # The red subfilter should be shifted away from zenith
# The absolute amplitude of the blue subfilter should also
# be greater than that of the red subfilter
self.assertGreater(np.abs(ampShift[0]), np.abs(ampShift[2]))
def __init__(self, inputPolicy=None, **kwargs):
#Define the policy file:
policyFile = Policy.defaultPolicyFile(self.packageName,
"GotoMapper.yaml", "policy")
policy = Policy(policyFile)
#This creates the camera class by calling CameraMapper (i.e., the parent class):
super(GotoMapper, self).__init__(policy, os.path.dirname(policyFile),
**kwargs)
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = {
'visit': int,
'ccd': int,
'filter': str,
'dataType': str,
'expTime': float,
'dateObs': str,
'taiObs': str,
'mjd': int,
'field': str,
'survey': str
}
for name in (
"raw",
"postISRCCD",
"calexp",
"src",
"icSrc",
"srcMatch",
):
self.mappings[name].keyDict.update(keys)
#Set the filters:
self.filterIdMap = dict(v=0)
afwImageUtils.defineFilter(name='R', lambdaEff=635.9, alias=['R'])
afwImageUtils.defineFilter(name='G', lambdaEff=534.9, alias=['G'])
afwImageUtils.defineFilter(name='B', lambdaEff=446.6, alias=['B'])
afwImageUtils.defineFilter(name='L', lambdaEff=535.5, alias=['L'])
self.filters = {}
self.filters['R'] = afwImage.Filter('R').getCanonicalName()
self.filters['G'] = afwImage.Filter('G').getCanonicalName()
self.filters['B'] = afwImage.Filter('B').getCanonicalName()
self.filters['L'] = afwImage.Filter('L').getCanonicalName()
self.defaultFilterName = 'L'
def setUp(self):
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
maskedImageMD = readMetadata(inFilePathSmall)
self.smallExposure = afwImage.ExposureF(inFilePathSmall)
self.width = maskedImage.getWidth()
self.height = maskedImage.getHeight()
self.wcs = afwGeom.makeSkyWcs(maskedImageMD, False)
self.md = maskedImageMD
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.exposureBlank = afwImage.ExposureF()
self.exposureMiOnly = afwImage.makeExposure(maskedImage)
self.exposureMiWcs = afwImage.makeExposure(maskedImage, self.wcs)
# n.b. the (100, 100, ...) form
self.exposureCrWcs = afwImage.ExposureF(100, 100, self.wcs)
# test with ExtentI(100, 100) too
self.exposureCrOnly = afwImage.ExposureF(lsst.geom.ExtentI(100, 100))
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
defineFilter("g", 470.0)
def defineFilters(self):
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('NONE', lambdaEff=0)
# Johnson filters
afwImageUtils.defineFilter('U', lambdaEff=300, alias=['W-J-U'])
afwImageUtils.defineFilter('B', lambdaEff=400, alias=['W-J-B'])
afwImageUtils.defineFilter('V', lambdaEff=550, alias=['W-J-V'])
afwImageUtils.defineFilter('VR', lambdaEff=600, alias=['W-J-VR'])
# Cousins filters
afwImageUtils.defineFilter('R', lambdaEff=650, alias=['W-C-RC'])
afwImageUtils.defineFilter('I', lambdaEff=800, alias=['W-C-IC'])
# Sloan filters
afwImageUtils.defineFilter('g', lambdaEff=450, alias=['W-S-G+'])
afwImageUtils.defineFilter('r', lambdaEff=600, alias=['W-S-R+'])
afwImageUtils.defineFilter('i', lambdaEff=770, alias=['W-S-I+'])
afwImageUtils.defineFilter('z', lambdaEff=900, alias=['W-S-Z+'])
afwImageUtils.defineFilter('y', lambdaEff=1000, alias=['W-S-ZR'])
# Narrow-band filters
afwImageUtils.defineFilter("NA503", lambdaEff=503, alias=['N-A-L503'])
afwImageUtils.defineFilter("NA651", lambdaEff=651, alias=['N-A-L651'])
afwImageUtils.defineFilter("NA656", lambdaEff=656, alias=['N-A-L656'])
afwImageUtils.defineFilter("NA659", lambdaEff=659, alias=['N-A-L659'])
afwImageUtils.defineFilter("NA671", lambdaEff=671, alias=['N-A-L671'])
afwImageUtils.defineFilter('NB1006', lambdaEff=1006, alias=['N-B-1006'])
afwImageUtils.defineFilter('NB1010', lambdaEff=1010, alias=['N-B-1010'])
afwImageUtils.defineFilter('NB100', lambdaEff=100, alias=['N-B-L100'])
afwImageUtils.defineFilter('NB359', lambdaEff=359, alias=['N-B-L359'])
afwImageUtils.defineFilter('NB387', lambdaEff=387, alias=['N-B-L387'])
afwImageUtils.defineFilter('NB413', lambdaEff=413, alias=['N-B-L413'])
afwImageUtils.defineFilter('NB497', lambdaEff=497, alias=['N-B-L497'])
afwImageUtils.defineFilter('NB515', lambdaEff=515, alias=['N-B-L515'])
afwImageUtils.defineFilter('NB570', lambdaEff=570, alias=['N-B-L570'])
afwImageUtils.defineFilter('NB704', lambdaEff=704, alias=['N-B-L704'])
afwImageUtils.defineFilter('NB711', lambdaEff=711, alias=['N-B-L711'])
afwImageUtils.defineFilter('NB816', lambdaEff=816, alias=['N-B-L816'])
afwImageUtils.defineFilter('NB818', lambdaEff=818, alias=['N-B-L818'])
afwImageUtils.defineFilter('NB912', lambdaEff=912, alias=['N-B-L912'])
afwImageUtils.defineFilter('NB921', lambdaEff=921, alias=['N-B-L921'])
afwImageUtils.defineFilter('NB973', lambdaEff=973, alias=['N-B-L973'])
# Intermediate-band filters
afwImageUtils.defineFilter("L427", lambdaEff=427, alias=['I-A-L427'])
afwImageUtils.defineFilter("L445", lambdaEff=445, alias=['I-A-L445'])
afwImageUtils.defineFilter("L464", lambdaEff=464, alias=['I-A-L464'])
afwImageUtils.defineFilter("L484", lambdaEff=484, alias=['I-A-L484'])
afwImageUtils.defineFilter("L505", lambdaEff=505, alias=['I-A-L505'])
afwImageUtils.defineFilter("L527", lambdaEff=527, alias=['I-A-L527'])
afwImageUtils.defineFilter("L550", lambdaEff=550, alias=['I-A-L550'])
afwImageUtils.defineFilter("L574", lambdaEff=574, alias=['I-A-L574'])
afwImageUtils.defineFilter("L598", lambdaEff=598, alias=['I-A-L598'])
afwImageUtils.defineFilter("L624", lambdaEff=624, alias=['I-A-L624'])
afwImageUtils.defineFilter("L651", lambdaEff=651, alias=['I-A-L651'])
afwImageUtils.defineFilter("L679", lambdaEff=679, alias=['I-A-L679'])
afwImageUtils.defineFilter("L709", lambdaEff=709, alias=['I-A-L709'])
afwImageUtils.defineFilter("L738", lambdaEff=738, alias=['I-A-L738'])
afwImageUtils.defineFilter("L767", lambdaEff=767, alias=['I-A-L767'])
afwImageUtils.defineFilter("L797", lambdaEff=797, alias=['I-A-L797'])
afwImageUtils.defineFilter("L827", lambdaEff=827, alias=['I-A-L827'])
afwImageUtils.defineFilter("L856", lambdaEff=856, alias=['I-A-L856'])
afwImageUtils.defineFilter("L856", lambdaEff=856, alias=['I-A-L856'])
# Unknown/custom filters
afwImageUtils.defineFilter("B030", lambdaEff=0, alias=['G-A-B030'])
afwImageUtils.defineFilter("R030", lambdaEff=0, alias=['G-A-R030'])
afwImageUtils.defineFilter("P550", lambdaEff=0, alias=['P-A-L550'])
afwImageUtils.defineFilter("SN01", lambdaEff=0, alias=['S-A-SN01'])
afwImageUtils.defineFilter("SN02", lambdaEff=0, alias=['S-A-SN02'])
afwImageUtils.defineFilter("Y", lambdaEff=0, alias=['W-A-Y'])
afwImageUtils.defineFilter("ZB", lambdaEff=0, alias=['W-S-ZB'])
self.filters = {
"W-J-U" : "U",
"W-J-B" : "B",
"W-J-V" : "V",
"W-J-VR" : "VR",
"W-C-RC" : "R",
"W-C-IC" : "I",
"W-S-G+" : "g",
"W-S-R+" : "r",
"W-S-I+" : "i",
"W-S-Z+" : "z",
"W-S-ZR" : "y",
'N-A-L503': "NA503",
'N-A-L651': "NA651",
'N-A-L656': "NA656",
'N-A-L659': "NA659",
'N-A-L671': "NA671",
'N-B-1006': 'NB1006',
'N-B-1010': 'NB1010',
'N-B-L100': 'NB100',
'N-B-L359': 'NB359',
'N-B-L387': 'NB387',
'N-B-L413': 'NB413',
'N-B-L497': 'NB497',
'N-B-L515': 'NB515',
'N-B-L570': 'NB570',
'N-B-L704': 'NB704',
'N-B-L711': 'NB711',
'N-B-L816': 'NB816',
'N-B-L818': 'NB818',
'N-B-L912': 'NB912',
'N-B-L921': 'NB921',
'N-B-L973': 'NB973',
"I-A-L427": "L427",
"I-A-L445": "L445",
"I-A-L464": "L464",
"I-A-L484": "L484",
"I-A-L505": "L505",
"I-A-L527": "L527",
"I-A-L550": "L550",
"I-A-L574": "L574",
"I-A-L598": "L598",
"I-A-L624": "L624",
"I-A-L651": "L651",
"I-A-L679": "L679",
"I-A-L709": "L709",
"I-A-L738": "L738",
"I-A-L767": "L767",
"I-A-L797": "L797",
"I-A-L827": "L827",
"I-A-L856": "L856",
'G-A-B030': "B030",
'G-A-R030': "R030",
'P-A-L550': "P550",
'S-A-SN01': "SN01",
'S-A-SN02': "SN02",
'W-A-Y' : "Y",
'W-S-ZB' : "ZB",
}
# next line makes a dict that maps filter names to sequential integers (arbitrarily sorted),
# for use in generating unique IDs for sources.
self.filterIdMap = dict(zip(self.filters, range(len(self.filters))))
def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile(self.packageName, "DecamMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(DecamMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
afwImageUtils.defineFilter('u', lambdaEff=350, alias=['u DECam c0006 3500.0 1000.0'])
afwImageUtils.defineFilter('g', lambdaEff=450, alias=['g DECam SDSS c0001 4720.0 1520.0'])
afwImageUtils.defineFilter('r', lambdaEff=600, alias=['r DECam SDSS c0002 6415.0 1480.0'])
afwImageUtils.defineFilter('i', lambdaEff=750, alias=['i DECam SDSS c0003 7835.0 1470.0'])
afwImageUtils.defineFilter('z', lambdaEff=900, alias=['z DECam SDSS c0004 9260.0 1520.0'])
afwImageUtils.defineFilter('y', lambdaEff=1000, alias=['Y DECam c0005 10095.0 1130.0'])
# The data ID key ccdnum is not directly used in the current policy
# template of the raw dataset, so is not in its keyDict automatically.
# Add it so raw dataset know about the data ID key ccdnum.
self.mappings["raw"].keyDict.update({'ccdnum': int})
# The number of bits allocated for fields in object IDs
# TODO: This needs to be updated; also see Trac #2797
DecamMapper._nbit_tract = 10
DecamMapper._nbit_patch = 10
DecamMapper._nbit_filter = 4
DecamMapper._nbit_id = 64 - (DecamMapper._nbit_tract +
2*DecamMapper._nbit_patch +
DecamMapper._nbit_filter)
def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile(self.packageName, "DecamMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(DecamMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
afwImageUtils.defineFilter('u', lambdaEff=350, alias=['u DECam c0006 3500.0 1000.0'])
afwImageUtils.defineFilter('g', lambdaEff=450, alias=['g DECam SDSS c0001 4720.0 1520.0'])
afwImageUtils.defineFilter('r', lambdaEff=600, alias=['r DECam SDSS c0002 6415.0 1480.0'])
afwImageUtils.defineFilter('i', lambdaEff=750, alias=['i DECam SDSS c0003 7835.0 1470.0'])
afwImageUtils.defineFilter('z', lambdaEff=900, alias=['z DECam SDSS c0004 9260.0 1520.0'])
afwImageUtils.defineFilter('y', lambdaEff=1000, alias=['Y DECam c0005 10095.0 1130.0'])
import pdb
import unittest
import lsst.utils.tests as utilsTests
import lsst.daf.base as dafBase
import lsst.afw.image as afwImage
import lsst.afw.image.utils as afwImageUtils
import lsst.afw.geom as afwGeom
import lsst.afw.geom.ellipses as afwGeomEllipses
import lsst.afw.table as afwTable
import lsst.ap.cluster as apCluster
import lsst.ap.match as apMatch
# Usually defined by lsst.obs.lsstSim.LsstSimMapper
afwImageUtils.defineFilter('u', 364.59)
afwImageUtils.defineFilter('g', 476.31)
afwImageUtils.defineFilter('r', 619.42)
afwImageUtils.defineFilter('i', 752.06)
afwImageUtils.defineFilter('z', 866.85)
afwImageUtils.defineFilter('y', 971.68)
class SourceClusterAttributesTestCase(unittest.TestCase):
"""Test case for source cluster attribute computation.
"""
def setUp(self):
# Setup bogus exposure information
self.exposures = apMatch.ExposureInfoMap()
for filter in "ugrizy":
filterId = afwImage.Filter(filter).getId()
ps = dafBase.PropertySet()
def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_decam", "DecamMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(DecamMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
afwImageUtils.defineFilter('u', lambdaEff=350)
afwImageUtils.defineFilter('g', lambdaEff=450)
afwImageUtils.defineFilter('r', lambdaEff=600)
afwImageUtils.defineFilter('i', lambdaEff=750)
afwImageUtils.defineFilter('z', lambdaEff=900)
afwImageUtils.defineFilter('y', lambdaEff=1000, alias='Y') # Urgh!
nx = 10
ny = 10
exp = lsst.afw.image.ExposureF(nx, ny)
# Fill the maskedImage
exp.maskedImage.image.array = np.arange(nx*ny, dtype='f').reshape(nx, ny)
exp.maskedImage.variance.array = np.ones((nx, ny), dtype='f')
exp.maskedImage.mask.array[5, 5] = 5 # make one pixel non-zero
# Fill the detector
detectorWrapper = DetectorWrapper(bbox=exp.getBBox())
exp.setDetector(detectorWrapper.detector)
# Fill the filter
resetFilters()
defineFilter('ha', 656.28)
filt = lsst.afw.image.Filter('ha')
exp.setFilter(filt)
# Fill the PhotoCalib
photoCalib = lsst.afw.image.PhotoCalib(1e6, 2e4)
exp.setPhotoCalib(photoCalib)
# Fill the SkyWcs
ra = 30.0 * lsst.geom.degrees
dec = 40.0 * lsst.geom.degrees
cdMatrix = lsst.afw.geom.makeCdMatrix(scale=0.2*lsst.geom.arcseconds, orientation=45*lsst.geom.degrees)
crpix = lsst.geom.Point2D(4, 4)
crval = lsst.geom.SpherePoint(ra, dec)
skyWcs = lsst.afw.geom.makeSkyWcs(crpix=crpix, crval=crval, cdMatrix=cdMatrix)
exp.setWcs(skyWcs)
def addFilters(cls):
afwImageUtils.resetFilters()
for kwds in HSC_FILTER_DEFINITIONS:
afwImageUtils.defineFilter(**kwds)
#!/usr/bin/env python
from lsst.afw.image.utils import defineFilter
# Effective wavelengths from Fukugita et al., 1996AJ....111.1748F
# Table 2a (1.2 airmass, first row)
defineFilter("u'", 355.7)
defineFilter("g'", 482.5)
defineFilter("r'", 626.1)
defineFilter("i'", 767.2)
defineFilter("z'", 909.7)
def __init__(self, root, parentRegistry=None, repositoryCfg=None):
policyFilePath = dafPersist.Policy.defaultPolicyFile(
self.packageName, "testCalexpMetadataObjects.yaml", "policy")
policy = dafPersist.Policy(policyFilePath)
super(MapperForTestCalexpMetadataObjects, self).__init__(
policy, repositoryDir=root, root=root, parentRegistry=None, repositoryCfg=None)
self.filterIdMap = {
'u': 0, 'g': 1, 'r': 2, 'i': 3, 'z': 4, 'y': 5, 'i2': 5}
# The LSST Filters from L. Jones 04/07/10
afwImageUtils.defineFilter('u', 364.59)
afwImageUtils.defineFilter('g', 476.31)
afwImageUtils.defineFilter('r', 619.42)
afwImageUtils.defineFilter('i', 752.06)
afwImageUtils.defineFilter('z', 866.85)
afwImageUtils.defineFilter('y', 971.68, alias=['y4']) # official y filter
def __init__(self, outputRoot=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_sst", "SstMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(SstMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
afwImageUtils.defineFilter('OPEN', lambdaEff=650)
def __init__(self, root):
super(SimpleMapper, self).__init__()
self.root = root
self.camera = makeSimpleCamera(nX=1, nY=2, sizeX=400, sizeY=200, gapX=2, gapY=2)
afwImageUtils.defineFilter('r', 619.42)
self.update()
def __init__(self, **kwargs):
policyFile = Policy.defaultPolicyFile("obs_cfht", "MegacamMapper.yaml", "policy")
policy = Policy(policyFile)
super(MegacamMapper, self).__init__(policy, os.path.dirname(policyFile), **kwargs)
# The "ccd" provided by the user is translated through the registry
# into an extension name for the "raw" template. The template
# therefore doesn't include "ccd", so we need to ensure it's
# explicitly included so the ArgumentParser can recognise and accept
# it.
self.exposures['raw'].keyDict['ccd'] = int
afwImageUtils.defineFilter('u', lambdaEff=374, alias="u.MP9301")
afwImageUtils.defineFilter('u2', lambdaEff=354, alias="u.MP9302")
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
afwImageUtils.defineFilter('g2', lambdaEff=472, alias="g.MP9402")
afwImageUtils.defineFilter('r', lambdaEff=628, alias="r.MP9601")
afwImageUtils.defineFilter('r2', lambdaEff=640, alias="r.MP9602")
afwImageUtils.defineFilter('i', lambdaEff=778, alias="i.MP9701")
afwImageUtils.defineFilter('i2', lambdaEff=764, alias="i.MP9702")
afwImageUtils.defineFilter('i3', lambdaEff=776, alias="i.MP9703")
afwImageUtils.defineFilter('z', lambdaEff=1170, alias="z.MP9801")
afwImageUtils.defineFilter('z2', lambdaEff=926, alias="z.MP9901")
# define filters?
self.filterIdMap = dict(u=0, g=1, r=2, i=3, z=4, i2=5, u2=6, g2=7, r2=8, i3=9, z2=10)
# Ensure each dataset type of interest knows about the full range of
# keys available from the registry
keys = {'runId': str,
'object': str,
'visit': int,
'ccd': int,
'extension': int,
'state': str,
'filter': str,
'date': str,
'taiObs': str,
'expTime': float,
}
for name in ("raw", "calexp", "postISRCCD", "src", "icSrc", "icMatch"):
self.mappings[name].keyDict.update(keys)
def __init__(self, inputPolicy=None, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile(self.packageName, "testMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
self.doFootprints = False
if inputPolicy is not None:
for kw in inputPolicy.paramNames(True):
if kw == "doFootprints":
self.doFootprints = True
else:
kwargs[kw] = inputPolicy.get(kw)
CameraMapper.__init__(self, policy, policyFile.getRepositoryPath(), **kwargs)
self.filterIdMap = {
'u': 0, 'g': 1, 'r': 2, 'i': 3, 'z': 4, 'y': 5, 'i2': 5}
# The LSST Filters from L. Jones 04/07/10
afwImageUtils.defineFilter('u', 364.59)
afwImageUtils.defineFilter('g', 476.31)
afwImageUtils.defineFilter('r', 619.42)
afwImageUtils.defineFilter('i', 752.06)
afwImageUtils.defineFilter('z', 866.85)
afwImageUtils.defineFilter('y', 971.68, alias=['y4']) # official y filter
def __init__(self, **kwargs):
policyFile = pexPolicy.DefaultPolicyFile("obs_cfht", "MegacamMapper.paf", "policy")
policy = pexPolicy.Policy(policyFile)
super(MegacamMapper, self).__init__(policy, policyFile.getRepositoryPath(), **kwargs)
# The "ccd" provided by the user is translated through the registry into an extension name for the "raw"
# template. The template therefore doesn't include "ccd", so we need to ensure it's explicitly included
# so the ArgumentParser can recognise and accept it.
for mapping in self.exposures.values():
if 'visit' in mapping.keyDict:
mapping.keyDict['ccd'] = int
afwImageUtils.defineFilter('u', lambdaEff=350, alias="u.MP9301")
afwImageUtils.defineFilter('g', lambdaEff=450, alias="g.MP9401")
afwImageUtils.defineFilter('r', lambdaEff=600, alias="r.MP9601")
afwImageUtils.defineFilter('i', lambdaEff=750, alias="i.MP9701")
afwImageUtils.defineFilter('i2', lambdaEff=750, alias="i.MP9702")
afwImageUtils.defineFilter('z', lambdaEff=900, alias="z.MP9801")
# Ensure each dataset type of interest knows about the full range of keys available from the registry
keys = {'runId': str,
'object': str,
'visit': int,
'ccd': int,
'extension': int,
'state': str,
'filter': str,
'date': str,
'taiObs': str,
'expTime': float,
}
for name in ("raw", "calexp", "postISRCCD", "src"):
self.mappings[name].keyDict.update(keys)
