def testScalar(self):
apl = dafBase.PropertyList()
apl.setBool("bool", True)
apl.setShort("short", 42)
apl.setInt("int", 2008)
apl.setLongLong("int64_t", 0xfeeddeadbeef)
apl.setFloat("float", 3.14159)
apl.setDouble("double", 2.718281828459045)
apl.set("char*", "foo")
apl.setString("string", "bar")
apl.set("int2", 2009)
apl.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
apl.set("subclass", FloatSubClass(1.23456789))
apl.set("undef", None)
self.assertTrue(apl.isUndefined("undef"))
self.assertFalse(apl.isUndefined("string"))
self.assertEqual(apl.typeOf("bool"), dafBase.PropertyList.TYPE_Bool)
self.assertEqual(apl.getBool("bool"), True)
self.assertEqual(apl.typeOf("short"), dafBase.PropertyList.TYPE_Short)
self.assertEqual(apl.getShort("short"), 42)
self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int)
self.assertEqual(apl.getInt("int"), 2008)
self.assertEqual(apl.typeOf("int64_t"),
dafBase.PropertyList.TYPE_LongLong)
self.assertEqual(apl.getLongLong("int64_t"), 0xfeeddeadbeef)
self.assertEqual(apl.typeOf("float"), dafBase.PropertyList.TYPE_Float)
self.assertAlmostEqual(apl.getFloat("float"), 3.14159, 6)
self.assertEqual(apl.typeOf("double"),
dafBase.PropertyList.TYPE_Double)
self.assertEqual(apl.getDouble("double"), 2.718281828459045)
self.assertEqual(apl.typeOf("char*"), dafBase.PropertyList.TYPE_String)
self.assertEqual(apl.getString("char*"), "foo")
self.assertEqual(apl.typeOf("string"),
dafBase.PropertyList.TYPE_String)
self.assertEqual(apl.getString("string"), "bar")
self.assertEqual(apl.typeOf("int2"), dafBase.PropertyList.TYPE_Int)
self.assertEqual(apl.getInt("int2"), 2009)
self.assertEqual(apl.get("int2"), 2009)
self.assertEqual(apl.getArray("int2"), [2009])
self.assertEqual(apl.getScalar("int2"), 2009)
self.assertEqual(apl.typeOf("dt"), dafBase.PropertyList.TYPE_DateTime)
self.assertEqual(apl.getDateTime("dt").nsecs(), 1238657233314159265)
self.assertEqual(apl.getDouble("subclass"), 1.23456789)
self.assertEqual(apl["int2"], 2009)
self.assertIsNone(apl.getScalar("undef"))
self.assertEqual(apl.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
self.assertIsNone(apl.get("undef"))
self.assertIsNone(apl["undef"])
self.checkPickle(apl)
# Now replace the undef value with a defined value
apl.set("undef", "not undefined")
self.assertEqual(apl.getScalar("undef"), "not undefined")
self.assertFalse(apl.isUndefined("undef"))
self.assertEqual(apl.typeOf("undef"), dafBase.PropertyList.TYPE_String)
def testTopocentric(self):
"""Verify Altitude/Azimuth coordinate transforms"""
# try converting the RA,Dec of Sedna (on the specified date) to Alt/Az
# sedna (from jpl) for 2010-03-03 00:00 UT
ra, dec = "03:26:42.61", "+06:32:07.1"
az, alt = 231.5947, 44.3375
obs = afwCoord.Observatory(-74.659 * afwGeom.degrees, 40.384 * afwGeom.degrees, 100.0) # peyton
obsDate = dafBase.DateTime(2010, 3, 3, 0, 0, 0, dafBase.DateTime.TAI)
epoch = obsDate.get(dafBase.DateTime.EPOCH)
sedna = afwCoord.Fk5Coord(ra, dec, epoch)
altaz = sedna.toTopocentric(obs, obsDate)
print("Topocentric (Sedna): ",
altaz.getAltitude().asDegrees(), altaz.getAzimuth().asDegrees(), alt, az)
self.assertEqual(altaz.getCoordSystem(), afwCoord.TOPOCENTRIC)
# precision is low as we don't account for as much as jpl (abberation, nutation, etc)
self.assertAlmostEqual(altaz.getAltitude().asDegrees(), alt, 1)
self.assertAlmostEqual(altaz.getAzimuth().asDegrees(), az, 1)
# convert back to RA,Dec to check the roundtrip
sedna2 = altaz.toFk5(epoch)
ra2, dec2 = sedna2.getRa().asDegrees(), sedna2.getDec().asDegrees()
print("Topocentric roundtrip (Sedna): ",
sedna.getRa().asDegrees(), ra2, sedna.getDec().asDegrees(), dec2)
self.assertAlmostEqual(sedna.getRa().asDegrees(), ra2)
self.assertAlmostEqual(sedna.getDec().asDegrees(), dec2)
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 processRawDir(rawDir, conn, done):
print(rawDir, "... started")
nProcessed = 0
nSkipped = 0
nUnrecognized = 0
for fitsPath in glob.glob(os.path.join(rawDir, "*.fits*")):
m = re.search(r'raw_v(\d*)_f(.+)\.fits', fitsPath)
if not m:
sys.stderr.write("Warning: Unrecognized file: %r\n" % (fitsPath,))
nUnrecognized += 1
continue
visit, filterName = m.groups()
key = "%s_f%s" % (visit, filterName)
if key in done:
nSkipped += 1
continue
md = readMetadata(fitsPath)
expTime = md.getScalar("EXPTIME")
mjdObs = md.getScalar("MJD-OBS")
taiObs = dafBase.DateTime(mjdObs, dafBase.DateTime.MJD,
dafBase.DateTime.TAI).toString(dafBase.DateTime.UTC)[:-1]
conn.execute("""INSERT INTO raw VALUES
(NULL, ?, ?, ?, ?)""",
(visit, filterName, taiObs, expTime))
conn.commit()
nProcessed += 1
print("%s... %d processed, %d skipped, %d unrecognized" %
(rawDir, nProcessed, nSkipped, nUnrecognized))
def testCalibFromCalibs(self):
"""Test creating a Calib from an array of Calibs"""
exptime = 20
mag0, mag0Sigma = 1.0, 0.01
time0 = dafBase.DateTime.now().get()
calibs = afwImage.vectorCalib()
ncalib = 3
for i in range(ncalib):
calib = afwImage.Calib()
calib.setMidTime(dafBase.DateTime(time0 + i))
calib.setExptime(exptime)
calib.setFluxMag0(mag0, mag0Sigma)
calibs.append(calib)
ocalib = afwImage.Calib(calibs)
self.assertEqual(ocalib.getExptime(), ncalib * exptime)
self.assertAlmostEqual(calibs[ncalib // 2].getMidTime().get(),
ocalib.getMidTime().get())
#
# Check that we can only merge Calibs with the same fluxMag0 values
#
calibs[0].setFluxMag0(1.001 * mag0, mag0Sigma)
self.assertRaises(pexExcept.InvalidParameterError,
lambda: afwImage.Calib(calibs))
def processRaft(raftDir, conn, done, qsp):
nProcessed = 0
nSkipped = 0
nUnrecognized = 0
for fits in glob.glob(
os.path.join(
raftDir, "S[0-2][0-2]",
"imsim_*_R[0-4][0-4]_S[0-2][0-2]_C[01][0-7]_E00[01].fits*")):
m = re.search(
r'v(\d+)-f(\w)/E00(\d)/R(\d)(\d)/S(\d)(\d)/' +
r'imsim_\1_R\4\5_S\6\7_C(\d)(\d)_E00\3\.fits', fits)
if not m:
print >> sys.stderr, "Warning: Unrecognized file:", fits
nUnrecognized += 1
continue
(visit, filter, snap, raft1, raft2, sensor1, sensor2, channel1,
channel2) = m.groups()
key = "%s_F%s_E%s_R%s,%s_S%s,%s_C%s,%s" % (visit, filter, snap, raft1,
raft2, sensor1, sensor2,
channel1, channel2)
if key in done:
nSkipped += 1
continue
md = afwImage.readMetadata(fits)
expTime = md.get("EXPTIME")
mjdObs = md.get("MJD-OBS")
taiObs = dafBase.DateTime(mjdObs, dafBase.DateTime.MJD,
dafBase.DateTime.TAI).toString(
dafBase.DateTime.UTC)[:-1]
conn.execute(
"""INSERT INTO raw VALUES
(NULL, ?, ?, ?, ?, ?, ?, ?, ?)""",
(visit, filter, snap, "%s,%s" % (raft1, raft2), "%s,%s" %
(sensor1, sensor2), "%s,%s" %
(channel1, channel2), taiObs, expTime))
for row in conn.execute("SELECT last_insert_rowid()"):
id = row[0]
break
wcs = afwImage.makeWcs(md)
poly = skypix.imageToPolygon(wcs,
md.get("NAXIS1"),
md.get("NAXIS2"),
padRad=0.000075) # about 15 arcsec
pix = qsp.intersect(poly)
for skyTileId in pix:
conn.execute("INSERT INTO raw_skyTile VALUES(?, ?)",
(id, skyTileId))
conn.commit()
nProcessed += 1
print >>sys.stderr, raftDir, \
"... %d processed, %d skipped, %d unrecognized" % \
(nProcessed, nSkipped, nUnrecognized)
def testDateTimeToString(self):
ps = dafBase.PropertySet(flat=True)
ps.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
self.assertEqual(ps.toString(),
"dt = 2009-04-02T07:26:39.314159265Z\n")
def std_raw(self, item, dataId):
exp = super(PfsMapper, self).std_raw(item, dataId)
md = exp.getMetadata()
if md.exists("MJD-STR"):
calib = exp.getCalib()
expTime = calib.getExptime()
obsStart = dafBase.DateTime(md.get("MJD-STR"),
dafBase.DateTime.MJD,
dafBase.DateTime.UTC)
obsMidpoint = obsStart.nsecs() + long(expTime * 1000000000L / 2)
calib.setMidTime(dafBase.DateTime(obsMidpoint))
print "pfsMapper::std_raw: exp.getCalib().getExptime() = ", exp.getCalib(
).getExptime()
return exp
def testDateTimeToString(self):
apl = dafBase.PropertyList()
apl.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
self.assertEqual(apl.toString(),
"dt = 2009-04-02T07:26:39.314159265Z\n")
def testReadWriteFits(self):
"""Test readFits and writeFits.
"""
# This should pass without an exception
mainExposure = afwImage.ExposureF(inFilePathSmall)
mainExposure.setDetector(self.detector)
subBBox = afwGeom.Box2I(afwGeom.Point2I(10, 10),
afwGeom.Extent2I(40, 50))
subExposure = mainExposure.Factory(mainExposure, subBBox,
afwImage.LOCAL)
self.checkWcs(mainExposure, subExposure)
det = subExposure.getDetector()
self.assertTrue(det)
subExposure = afwImage.ExposureF(inFilePathSmall, subBBox,
afwImage.LOCAL)
self.checkWcs(mainExposure, subExposure)
# This should throw an exception
def getExposure():
afwImage.ExposureF(inFilePathSmallImage)
self.assertRaises(lsst.afw.fits.FitsError, getExposure)
mainExposure.setPsf(self.psf)
# Make sure we can write without an exception
mainExposure.getCalib().setExptime(10)
mainExposure.getCalib().setMidTime(dafBase.DateTime())
midMjd = mainExposure.getCalib().getMidTime().get()
fluxMag0, fluxMag0Err = 1e12, 1e10
mainExposure.getCalib().setFluxMag0(fluxMag0, fluxMag0Err)
with utilsTests.getTempFilePath(".fits") as tmpFile:
mainExposure.writeFits(tmpFile)
readExposure = type(mainExposure)(tmpFile)
#
# Check the round-tripping
#
self.assertEqual(mainExposure.getFilter().getName(),
readExposure.getFilter().getName())
self.assertEqual(mainExposure.getCalib().getExptime(),
readExposure.getCalib().getExptime())
self.assertEqual(midMjd,
readExposure.getCalib().getMidTime().get())
self.assertEqual((fluxMag0, fluxMag0Err),
readExposure.getCalib().getFluxMag0())
psf = readExposure.getPsf()
self.assert_(psf is not None)
dummyPsf = DummyPsf.swigConvert(psf)
self.assert_(dummyPsf is not None)
self.assertEqual(dummyPsf.getValue(), self.psf.getValue())
def testScalar(self):
ps = dafBase.PropertySet()
ps.setBool("bool", True)
ps.setShort("short", 42)
ps.setInt("int", 2008)
ps.setLongLong("int64_t", 0xfeeddeadbeef)
ps.setFloat("float", 3.14159)
ps.setDouble("double", 2.718281828459045)
ps.set("char*", "foo")
ps.setString("string", "bar")
ps.set("char*", u"foo")
ps.setString("string", u"bar")
ps.set("int2", 2009)
ps.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
ps.set("blank", "")
ps.set("undef", None)
self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
self.assertEqual(ps.getBool("bool"), True)
self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
self.assertEqual(ps.getShort("short"), 42)
self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int"), 2008)
self.assertEqual(ps.typeOf("int64_t"),
dafBase.PropertySet.TYPE_LongLong)
self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
self.assertEqual(ps.getDouble("double"), 2.718281828459045)
self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("char*"), "foo")
self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("string"), "bar")
self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int2"), 2009)
self.assertEqual(ps.get("int2"), 2009)
self.assertEqual(ps["int2"], 2009)
self.assertEqual(ps.getArray("int2"), [2009])
self.assertEqual(ps.getScalar("int2"), 2009)
self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
self.assertEqual(ps.getString("blank"), "")
self.assertIsNone(ps.getScalar("undef"))
self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
self.assertIsNone(ps.get("undef"))
self.checkPickle(ps)
# Now replace the undef value with a defined value
ps.set("undef", "not undefined")
self.assertEqual(ps.getScalar("undef"), "not undefined")
self.assertFalse(ps.isUndefined("undef"))
self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_String)
def mjdToVisit(date_obs):
"""Generate a visit number given a DATE-OBS
@param[in] date_obs a dafBase.DateTime.MJD compliant string
@return visit_num visit number generated from date_obs
"""
dt = dafBase.DateTime(date_obs, dafBase.DateTime.TAI)
mjd = dt.get(dafBase.DateTime.MJD) # MJD is actually the default
mmjd = mjd - 55197 # relative to 2010-01-01, just to make the visits a tiny bit smaller
return int(1e5 * mmjd) # 86400s per day, so we need this resolution
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 testTime(self):
"""Test the exposure time information"""
isoDate = "1995-01-26T07:32:00.000000000Z"
self.calib.setMidTime(dafBase.DateTime(isoDate))
self.assertEqual(isoDate, self.calib.getMidTime().toString())
self.assertAlmostEqual(self.calib.getMidTime().get(), 49743.3142245)
dt = 123.4
self.calib.setExptime(dt)
self.assertEqual(self.calib.getExptime(), dt)
def test_count_objects(self):
n_created = 5
sources = createTestObjects(n_created, {'nDiaSources': 'I'})
sources[-1]['nDiaSources'] = 2
# nsecs must be an integer, not 1.4e18
dateTime = dafBase.DateTime(nsecs=1400000000 * 10**9)
self.ppdb.storeDiaObjects(sources, dateTime.toPython())
value = self.ppdb.countUnassociatedObjects()
self.assertEqual(n_created - 1, value)
def testToDict(self):
ps = dafBase.PropertySet()
ps.setBool("bool", True)
ps.setShort("short", 42)
ps.setInt("int", 2008)
ps.setLongLong("int64_t", 0xfeeddeadbeef)
ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
ps.setInt("ints", [10, 9, 8])
ps2 = dafBase.PropertySet()
ps2.set("ps", ps)
ps2.setFloat("float", 3.14159)
ps2.setDouble("double", 2.718281828459045)
ps2.set("char*", "foo")
ps2.setString("string", "bar")
ps2.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
ps2.set("undef", None)
d = ps2.toDict()
self.assertIsInstance(d, dict)
self.assertIsInstance(d["float"], float)
self.assertAlmostEqual(d["float"], 3.14159, 6)
self.assertIsInstance(d["double"], float)
self.assertEqual(d["double"], 2.718281828459045)
self.assertIsNone(d["undef"])
self.assertIsInstance(d["char*"], str)
self.assertEqual(d["char*"], "foo")
self.assertIsInstance(d["string"], str)
self.assertEqual(d["string"], "bar")
self.assertIsInstance(d["dt"], dafBase.DateTime)
self.assertEqual(d["dt"].nsecs(), 1238657233314159265)
d2 = d["ps"]
self.assertIsInstance(d2, dict)
self.assertIsInstance(d2["bool"], bool)
self.assertEqual(d2["bool"], True)
self.assertIsInstance(d2["short"], (int, int))
self.assertEqual(d2["short"], 42)
self.assertIsInstance(d2["int"], (int, int))
self.assertEqual(d2["int"], 2008)
self.assertIsInstance(d2["int64_t"], (int, int))
self.assertEqual(d2["int64_t"], 0xfeeddeadbeef)
self.assertIsInstance(d2["uint64_t"], (int, int))
self.assertEqual(d2["uint64_t"], 0xFFFFFFFFFFFFFFFF)
self.assertIsInstance(d2["ints"], list)
self.assertIsInstance(d2["ints"][0], (int, int))
self.assertEqual(d2["ints"], [10, 9, 8])
def testScalar(self):
ps = dafBase.PropertySet(flat=True)
ps.setBool("bool", True)
ps.setShort("short", 42)
ps.setInt("int", 2008)
ps.setLongLong("int64_t", 0xfeeddeadbeef)
ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
ps.setFloat("float", 3.14159)
ps.setDouble("double", 2.718281828459045)
ps.set("char*", "foo")
ps.setString("string", "bar")
ps.set("int2", 2009)
ps.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
ps.set("autobool", True)
self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
self.assertIs(ps.getBool("bool"), True)
self.assertIs(ps.get("bool"), True)
self.assertEqual(ps.getArray("bool"), [True])
self.assertIs(ps.getScalar("bool"), True)
self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
self.assertEqual(ps.getShort("short"), 42)
self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int"), 2008)
self.assertEqual(ps.typeOf("int64_t"),
dafBase.PropertySet.TYPE_LongLong)
self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
self.assertEqual(ps.typeOf("uint64_t"),
dafBase.PropertySet.TYPE_UnsignedLongLong)
self.assertEqual(ps.getUnsignedLongLong("uint64_t"),
0xFFFFFFFFFFFFFFFF)
self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
self.assertEqual(ps.getDouble("double"), 2.718281828459045)
self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("char*"), "foo")
self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("string"), "bar")
self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int2"), 2009)
self.assertEqual(ps.get("int2"), 2009)
self.assertEqual(ps.getArray("int2"), [2009])
self.assertEqual(ps.getScalar("int2"), 2009)
self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool)
self.assertIs(ps.get("autobool"), True)
self.assertEqual(ps.getArray("autobool"), [True])
self.assertIs(ps.getScalar("autobool"), True)
def _setTimes(self, mapping, item, dataId):
"""Set the exposure time and exposure midpoint in the calib object in
an Exposure. Use the EXPTIME and MJD keywords (and strip out
EXPTIME).
@param mapping (lsst.daf.butlerUtils.Mapping)
@param[in,out] item (lsst.afw.image.Exposure)
@param dataId (dict) Dataset identifier"""
md = item.getMetadata()
calib = item.getCalib()
if md.exists("EXPTIME"):
expTime = md.get("EXPTIME")
calib.setExptime(expTime)
md.remove("EXPTIME")
else:
expTime = calib.getExptime()
if md.exists("MJD"):
obsStart = dafBase.DateTime(md.get("MJD"), dafBase.DateTime.MJD,
dafBase.DateTime.UTC)
obsMidpoint = obsStart.nsecs() + long(expTime * 1000000000L / 2)
calib.setMidTime(dafBase.DateTime(obsMidpoint))
def getMjd(self, butler, dataId, timescale=dafBase.DateTime.UTC):
"""Determine the Modified Julian Date (MJD; in TAI) from a data identifier"""
if self.config.dateObs in dataId:
dateObs = dataId[self.config.dateObs]
else:
dateObs = butler.queryMetadata('raw', [self.config.dateObs],
dataId)[0]
if "T" not in dateObs:
dateObs = dateObs + "T12:00:00.0Z"
elif not dateObs.endswith("Z"):
dateObs += "Z"
return dafBase.DateTime(dateObs, timescale).get(dafBase.DateTime.MJD)
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 std_raw(self, item, dataId):
md = item.getMetadata()
if md.exists("VERSION") and md.getInt("VERSION") < 16952:
# CRVAL is FK5 at date of observation
dateObsTaiMjd = md.getScalar("TAI")
dateObs = dafBase.DateTime(dateObsTaiMjd,
system=dafBase.DateTime.MJD,
scale=dafBase.DateTime.TAI)
correctedEquinox = dateObs.get(system=dafBase.DateTime.EPOCH,
scale=dafBase.DateTime.TAI)
md.set("EQUINOX", correctedEquinox)
md.set("RADESYS", "FK5")
print("****** changing equinox to", correctedEquinox)
return super(LsstSimMapper, self).std_raw(item, dataId)
def setUp(self):
super().setUp()
# Explicit date calculation to avoid errors from misuse of time libraries.
mjd = 57071.0
self.utc_jd = mjd + 2_400_000.5 - 35.0 / (24.0 * 60.0 * 60.0)
self.visitId = 42
self.visitInfo = afwImage.VisitInfo(
# Incomplete VisitInfo; Python constructor allows any value to
# be defaulted.
exposureTime=30.0,
darkTime=3.0,
date=dafBase.DateTime(mjd, system=dafBase.DateTime.MJD),
boresightRaDec=geom.SpherePoint(0.0, 0.0, geom.degrees),
)
def makeVisitInfo():
"""Return a non-NaN visitInfo."""
return afwImage.VisitInfo(exposureId=10313423,
exposureTime=10.01,
darkTime=11.02,
date=dafBase.DateTime(65321.1, dafBase.DateTime.MJD, dafBase.DateTime.TAI),
ut1=12345.1,
era=45.1*afwGeom.degrees,
boresightRaDec=afwGeom.SpherePoint(23.1, 73.2, afwGeom.degrees),
boresightAzAlt=afwGeom.SpherePoint(134.5, 33.3, afwGeom.degrees),
boresightAirmass=1.73,
boresightRotAngle=73.2*afwGeom.degrees,
rotType=afwImage.RotType.SKY,
observatory=Observatory(11.1*afwGeom.degrees, 22.2*afwGeom.degrees, 0.333),
weather=Weather(1.1, 2.2, 34.5),
)
def converttsField(infile, filt, exptime=53.907456):
"""Extract data from a tsField table
@param[in] infile path to tsField FITS file
@param[in] filt index of filter in tsField FILTERS metadata entry
@param[in] exptime exposure time (sec)
@return a dict with the following entries:
- calib: an lsst.afw.Calib
- gain: gain as a float
- dateAvg: date of exposure at middle of exposure, as an lsst.daf.base.DateTime
- exptime: exposure time (sec)
- airmass: airmass
"""
ptr = pyfits.open(infile)
if ptr[0].header['NFIELDS'] != 1:
print("INVALID TSFIELD FILE")
sys.exit(1)
filts = ptr[0].header['FILTERS'].split()
idx = filts.index(filt)
mjdTaiStart = ptr[1].data.field('mjd')[0][
idx] # MJD(TAI) when row 0 was read
airmass = ptr[1].data.field("airmass")[0][idx]
gain = float(
ptr[1].data.field('gain')[0][idx]) # comes out as numpy.float32
aa = ptr[1].data.field('aa')[0][idx] # f0 = 10**(-0.4*aa) counts/second
aaErr = ptr[1].data.field('aaErr')[0][idx]
# Conversions
dateAvg = dafBase.DateTime(mjdTaiStart + 0.5 * exptime / 3600 / 24)
fluxMag0 = 10**(-0.4 * aa) * exptime
dfluxMag0 = fluxMag0 * 0.4 * np.log(10.0) * aaErr
calib = afwImage.Calib()
calib.setFluxMag0(fluxMag0, dfluxMag0)
ptr.close()
return TsField(
calib=calib,
gain=gain,
dateAvg=dateAvg,
exptime=exptime,
airmass=airmass,
)
def processRaft(raftDir, conn, done):
nProcessed = 0
nSkipped = 0
nUnrecognized = 0
for fits in glob.glob(
os.path.join(
raftDir, "S[0-2][0-2]",
"imsim_*_R[0-4][0-4]_S[0-2][0-2]_C[01][0-7]_E00[01].fits*")):
m = re.search(
r'v(\d+)-f(\w)/E00(\d)/R(\d)(\d)/S(\d)(\d)/'
r'imsim_\1_R\4\5_S\6\7_C(\d)(\d)_E00\3\.fits', fits)
if not m:
print("Warning: Unrecognized file:", fits, file=sys.stderr)
nUnrecognized += 1
continue
(visit, filter, snap, raft1, raft2, sensor1, sensor2, channel1,
channel2) = m.groups()
key = "%s_F%s_E%s_R%s,%s_S%s,%s_C%s,%s" % (visit, filter, snap, raft1,
raft2, sensor1, sensor2,
channel1, channel2)
if key in done:
nSkipped += 1
continue
md = readMetadata(fits)
expTime = md.getScalar("EXPTIME")
mjdObs = md.getScalar("MJD-OBS")
taiObs = dafBase.DateTime(mjdObs, dafBase.DateTime.MJD,
dafBase.DateTime.TAI).toString(
dafBase.DateTime.UTC)[:-1]
conn.execute(
"""INSERT INTO raw VALUES
(NULL, ?, ?, ?, ?, ?, ?, ?, ?)""",
(visit, filter, snap, "%s,%s" % (raft1, raft2), "%s,%s" %
(sensor1, sensor2), "%s,%s" %
(channel1, channel2), taiObs, expTime))
conn.commit()
nProcessed += 1
print(raftDir,
"... %d processed, %d skipped, %d unrecognized" %
(nProcessed, nSkipped, nUnrecognized),
file=sys.stderr)
def testCheckProxy(self):
"""Attempt to cycle a DateTime object through the butler
"""
dt = dafBase.DateTime.now()
self.butler.put(dt, "dt", ccd=1)
# The next two types should not be castable to a DateTime object
# when the proxy is passed to a function
p1 = TypeWithoutProxy()
self.butler.put(p1, "p1", ccd=1)
p2 = TypeWithProxy()
self.butler.put(p2, "p2", ccd=1)
# First try with immediate read, this should obviously work
dt = self.butler.get("dt", ccd=1, immediate=True)
self.assertIsInstance(dt, dafBase.DateTime)
self.assertTrue(isValidDateTime(dt))
# Now try again with lazy read
dt = self.butler.get("dt", ccd=1, immediate=False)
self.assertIsInstance(dt, dafPersist.readProxy.ReadProxy)
self.assertTrue(isValidDateTime(dt))
# Now try with a type for which a proxy is not registered
p1 = self.butler.get("p1", ccd=1, immediate=True)
self.assertIsInstance(p1, TypeWithoutProxy)
with self.assertRaises(TypeError):
isValidDateTime(p1)
# Now try with a type for which a proxy was registered but
# that cannot convert to a DateTime
p2 = self.butler.get("p2", ccd=1, immediate=True)
self.assertIsInstance(p2, TypeWithProxy)
with self.assertRaises(TypeError):
isValidDateTime(p2)
# Finally try with an invalid DateTime
dt = dafBase.DateTime()
self.butler.put(dt, "dt", ccd=1)
dt = self.butler.get("dt", ccd=1, immediate=False)
self.assertIsInstance(dt, dafPersist.readProxy.ReadProxy)
self.assertFalse(isValidDateTime(dt))
def testScalar(self):
apl = dafBase.PropertyList()
apl.setBool("bool", True)
apl.setShort("short", 42)
apl.setInt("int", 2008)
apl.setLongLong("int64_t", long(0xfeeddeadbeef))
apl.setFloat("float", 3.14159)
apl.setDouble("double", 2.718281828459045)
apl.set("char*", "foo")
apl.setString("string", "bar")
apl.set("int2", 2009)
apl.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
apl.set("subclass", FloatSubClass(1.23456789))
self.assertEqual(apl.typeOf("bool"), dafBase.PropertyList.TYPE_Bool)
self.assertEqual(apl.getBool("bool"), True)
self.assertEqual(apl.typeOf("short"), dafBase.PropertyList.TYPE_Short)
self.assertEqual(apl.getShort("short"), 42)
self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int)
self.assertEqual(apl.getInt("int"), 2008)
self.assertEqual(apl.typeOf("int64_t"),
dafBase.PropertyList.TYPE_LongLong)
self.assertEqual(apl.getLongLong("int64_t"), long(0xfeeddeadbeef))
self.assertEqual(apl.typeOf("float"), dafBase.PropertyList.TYPE_Float)
self.assertAlmostEqual(apl.getFloat("float"), 3.14159, 6)
self.assertEqual(apl.typeOf("double"),
dafBase.PropertyList.TYPE_Double)
self.assertEqual(apl.getDouble("double"), 2.718281828459045)
self.assertEqual(apl.typeOf("char*"), dafBase.PropertyList.TYPE_String)
self.assertEqual(apl.getString("char*"), "foo")
self.assertEqual(apl.typeOf("string"),
dafBase.PropertyList.TYPE_String)
self.assertEqual(apl.getString("string"), "bar")
self.assertEqual(apl.typeOf("int2"), dafBase.PropertyList.TYPE_Int)
self.assertEqual(apl.getInt("int2"), 2009)
self.assertEqual(apl.get("int2"), 2009)
self.assertEqual(apl.typeOf("dt"), dafBase.PropertyList.TYPE_DateTime)
self.assertEqual(
apl.getDateTime("dt").nsecs(), long(1238657233314159265))
self.assertEqual(apl.getDouble("subclass"), 1.23456789)
self.checkPickle(apl)
def testScalar(self):
ps = dafBase.PropertySet()
ps.setBool("bool", True)
ps.setShort("short", 42)
ps.setInt("int", 2008)
ps.setLongLong("int64_t", long(0xfeeddeadbeef))
ps.setFloat("float", 3.14159)
ps.setDouble("double", 2.718281828459045)
ps.set("char*", "foo")
ps.setString("string", "bar")
ps.set("char*", u"foo")
ps.setString("string", u"bar")
ps.set("int2", 2009)
ps.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
ps.set("blank", "")
self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
self.assertEqual(ps.getBool("bool"), True)
self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
self.assertEqual(ps.getShort("short"), 42)
self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int"), 2008)
self.assertEqual(ps.typeOf("int64_t"),
dafBase.PropertySet.TYPE_LongLong)
self.assertEqual(ps.getLongLong("int64_t"), long(0xfeeddeadbeef))
self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
self.assertEqual(ps.getDouble("double"), 2.718281828459045)
self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("char*"), "foo")
self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("string"), "bar")
self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int2"), 2009)
self.assertEqual(ps.get("int2"), 2009)
self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
self.assertEqual(
ps.getDateTime("dt").nsecs(), long(1238657233314159265))
self.assertEqual(ps.getString("blank"), "")
def _setTimes(self, mapping, item, dataId):
"""Set the exposure time and exposure midpoint in the calib object in an Exposure.
@param mapping (lsst.daf.butlerUtils.Mapping)
@param[in,out] item (lsst.afw.image.Exposure)
@param dataId (dict) Dataset identifier
"""
year = dataId['year']
mon = dataId['month']
day = dataId['day']
mjd = dataId['mjd']
exptime = dataId['exptime']
calib = item.getCalib()
calib.setExptime(exptime)
obsMidpoint = dafBase.DateTime(mjd, dafBase.DateTime.MJD, dafBase.DateTime.UTC) + exptime / 2
calib.setMidTime(obsMidpoint)
def coordIter(self, includeCoord=True):
"""Return a collection of coords, one per class
@param[in] includeCoord if True then include lsst.afw.coord.Coord (the base class)
in the list of classes instantiated
"""
if includeCoord:
yield afwCoord.Coord(self.l * afwGeom.degrees, self.b * afwGeom.degrees)
for coordClass, enum, cast, stringName in self.coordList:
yield coordClass(self.l * afwGeom.degrees, self.b * afwGeom.degrees)
obs = afwCoord.Observatory(-74.659 * afwGeom.degrees, 40.384 * afwGeom.degrees, 100.0) # peyton
obsDate = dafBase.DateTime(2010, 3, 3, 0, 0, 0, dafBase.DateTime.TAI)
epoch = obsDate.get(dafBase.DateTime.EPOCH)
yield afwCoord.TopocentricCoord(
23.4 * afwGeom.degrees,
45.6 * afwGeom.degrees,
epoch,
obs,
)
