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, )