def test_one_by_one(self): """ test that running RA, Dec pairs in one at a time gives the same results as running them in in batches """ ra = 145.0 dec = -25.0 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, mjd=59580.0, rotSkyPos=113.0) rng = np.random.RandomState(100) theta = rng.random_sample(100) * 2.0 * np.pi rr = rng.random_sample(len(theta)) * 2.0 ra_list = ra + rr * np.cos(theta) dec_list = dec + rr * np.sin(theta) name_control = chipNameFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera) is_none = 0 for ra, dec, name in zip(ra_list, dec_list, name_control): test_name = chipNameFromRaDec(ra, dec, obs_metadata=obs, camera=self.camera) self.assertEqual(test_name, name) if test_name is None: is_none += 1 self.assertGreater(is_none, 0) self.assertLess(is_none, (3 * len(ra_list)) // 4)
def test_outside_radius(self): """ Test that methods can gracefully handle points outside of the focal plane """ rng = np.random.RandomState(7123) ra = 145.0 dec = -25.0 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, mjd=59580.0, rotSkyPos=113.0) rr = rng.random_sample(100) * 5.0 self.assertGreater(rr.max(), 4.5) theta = rng.random_sample(100) * 2.0 * np.pi ra_vec = ra + rr * np.cos(theta) dec_vec = dec + rr * np.sin(theta) chip_name_list = chipNameFromRaDec(ra_vec, dec_vec, obs_metadata=obs, camera=self.camera) rr = angularSeparation(ra, dec, ra_vec, dec_vec) ct_none = 0 for rr, name in zip(rr, chip_name_list): if rr > 2.0: self.assertIsNone(name) ct_none += 1 self.assertGreater(ct_none, 0)
def ssoInCameraFov(self, ephems, obsData): """Determine which observations are within the actual camera footprint for a series of observations. Note that ephems and obsData must be the same length. Parameters ---------- ephems : np.recarray Ephemerides for the objects. obsData : np.recarray Observation pointings. Returns ------- np.ndarray Returns the indexes of the numpy array of the object observations which are inside the fov. """ if not hasattr(self, 'camera'): self._setupCamera() epoch = 2000.0 # See if the object is within 'rFov' of the center of the boresight. idxObsRough = self._ssoInCircleFov(ephems, obsData, rFov=2.1) # Then test for the camera footprint exactly. idxObs = [] for idx in idxObsRough: mjd_date = obsData[idx][self.obsTimeCol] if self.obsTimeScale == 'TAI': mjd = ModifiedJulianDate(TAI=mjd_date) elif self.obsTimeScale == 'UTC': mjd = ModifiedJulianDate(UTC=mjd_date) else: warnings.warn( 'Expected timescale of TAI or UTC, but did not match. Using TAI.' ) mjd = ModifiedJulianDate(TAI=mjd_date) if not self.obsDegrees: obs_metadata = ObservationMetaData( pointingRA=np.degrees(obsData[idx][self.obsRA]), pointingDec=np.degrees(obsData[idx][self.obsDec]), rotSkyPos=np.degrees(obsData[idx][self.obsRotSkyPos]), mjd=mjd) else: obs_metadata = ObservationMetaData( pointingRA=obsData[idx][self.obsRA], pointingDec=obsData[idx][self.obsDec], rotSkyPos=obsData[idx][self.obsRotSkyPos], mjd=mjd) # Catch the warnings from astropy about the time being in the future. with warnings.catch_warnings(record=False): warnings.simplefilter('ignore') chipName = chipNameFromRaDec(ra=ephems['ra'][idx], dec=ephems['dec'][idx], epoch=epoch, obs_metadata=obs_metadata, camera=self.camera) if chipName is not None: tt = self.ccd_type_dict[self.camera[chipName].getType()] if tt == 'science': idxObs.append(idx) idxObs = np.array(idxObs, int) return idxObs
def test_chip_name_from_ra_dec_degrees(self): """ test that chipNameFromRaDecLSST agrees with chipNameFromRaDec """ n_obj = 1000 raP = 112.1 decP = -34.1 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=45.0, mjd=43000.0) rng = np.random.RandomState(8731) rr = rng.random_sample(n_obj)*1.75 theta = rng.random_sample(n_obj)*2.0*np.pi ra_list = raP + rr*np.cos(theta) dec_list = decP + rr*np.sin(theta) control_name_list = chipNameFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera) test_name_list = chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) try: np.testing.assert_array_equal(control_name_list.astype(str), test_name_list.astype(str)) except AssertionError: n_problematic = 0 for ii, (c_n, t_n) in enumerate(zip(control_name_list.astype(str), test_name_list.astype(str))): if c_n != t_n: x_pix, y_pix = pixelCoordsFromRaDecLSST(ra_list[ii], dec_list[ii], obs_metadata=obs) if c_n != 'None': n_problematic += 1 if n_problematic > 0: raise self.assertLessEqual(len(np.where(np.char.rfind(test_name_list.astype(str), 'None') >= 0)[0]), n_obj/10) # test that exceptions are raised when incomplete ObservationMetaData are used obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) self.assertIn("rotSkyPos", context.exception.args[0]) obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) self.assertIn("mjd", context.exception.args[0]) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list) self.assertIn("ObservationMetaData", context.exception.args[0]) # check that exceptions are raised when ra_list, dec_list are of the wrong shape obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs) self.assertIn("chipNameFromRaDecLSST", context.exception.args[0])
def test_chipName(self): """ Verify that chipNameFromRaDecLSST has not changed. """ chip_name_arr = chipNameFromRaDec(self.pix_data['ra'], self.pix_data['dec'], obs_metadata=self.obs, camera=self.camera) np.testing.assert_array_equal(chip_name_arr, self.pix_data['name'])
def test_chip_center(self): """ Test that, if we ask for the chip at the bore site, we get back 'R:2,2 S:1,1' """ ra = 145.0 dec = -25.0 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, mjd=59580.0, rotSkyPos=113.0) name = chipNameFromRaDec(ra, dec, obs_metadata=obs, camera=self.camera) self.assertEqual(name, 'R22_S11')
def inCameraFov(self, ephems, obsData, epoch=2000.0, timeCol='observationStartMJD'): """Determine which observations are within the actual camera footprint for a series of observations. Parameters ---------- ephems : np.recarray Ephemerides for the objects, with RA and Dec as 'ra' and 'dec' columns (in degrees). obsData : np.recarray Observation pointings, with RA and Dec as 'ra' and 'dec' columns (in degrees). The telescope rotation angle should be in 'rotSkyPos' (in degrees), and the time of each pointing should be in the 'expMJD' column. epoch: float, opt The epoch of the ephemerides and pointing data. Default 2000.0. Returns ------- np.ndarray Returns the indexes of the numpy array of the object observations which are inside the fov. """ # See if the object is within 'rFov' of the center of the boresight. sep = angularSeparation(ephems['ra'], ephems['dec'], obsData['ra'], obsData['dec']) idxObsRough = np.where(sep <= 2.1)[0] # Or go on and use the camera footprint. idxObs = [] for idx in idxObsRough: mjd_date = obsData[idx][timeCol] mjd = ModifiedJulianDate(TAI=mjd_date) obs_metadata = ObservationMetaData(pointingRA=obsData[idx]['ra'], pointingDec=obsData[idx]['dec'], rotSkyPos=obsData[idx]['rotSkyPos'], mjd=mjd) # Catch the warnings from astropy about the time being in the future. with warnings.catch_warnings(record=False): warnings.simplefilter('ignore') chipName = chipNameFromRaDec(ra=ephems['ra'][idx],dec=ephems['dec'][idx], epoch=epoch, obs_metadata=obs_metadata, camera=self.camera) if chipName != None: tt = self.ccd_type_dict[self.camera[chipName].getType()] if tt == 'science': idxObs.append(idx) idxObs = np.array(idxObs, int) return idxObs
def select_by_chip_name(objs, chip_name, obs_md, camera, logger=default_logger): """ Select only objects that are on the specified chip. Parameters ---------- objs : pandas.DataFrame DataFrame of phosim objects. obs_md : lsst.sims.utils.ObservationMetaData Obsevation metadata extracted from the phosim commands. camera : lsst.afw.cameraGeom.camera.Camera The camera instance from lsst.obs.lsstSim.LsstSimMapper(). logger : logging.Logger, optional The logger to use. Returns ------- pandas.DataFrame The DataFrame containing down-selected objects. """ t0 = time.time() my_objs = objs.copy(deep=True) my_objs['chip_name'] = coordUtils.chipNameFromRaDec(my_objs['ra'].values, my_objs['dec'].values, camera=camera, obs_metadata=obs_md) my_objs = my_objs.query('chip_name=="%s"' % chip_name) del my_objs['chip_name'] logger.debug('select_by_chip_name:\n elapsed time: %f s', time.time() - t0) logger.debug(' # objects remaining: %i', len(my_objs)) logger.debug(mem_use_message()) return my_objs
def test_chip_name_from_ra_dec_degrees(self): """ test that chipNameFromRaDecLSST agrees with chipNameFromRaDec """ n_obj = 1000 raP = 112.1 decP = -34.1 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=45.0, mjd=43000.0) rng = np.random.RandomState(8731) rr = rng.random_sample(n_obj) * 1.75 theta = rng.random_sample(n_obj) * 2.0 * np.pi ra_list = raP + rr * np.cos(theta) dec_list = decP + rr * np.sin(theta) control_name_list = chipNameFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera) test_name_list = chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) np.testing.assert_array_equal(control_name_list.astype(str), test_name_list.astype(str)) self.assertLessEqual( len( np.where( np.char.rfind(test_name_list.astype(str), 'None') >= 0) [0]), n_obj / 10) # test that exceptions are raised when incomplete ObservationMetaData are used obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) self.assertIn("rotSkyPos", context.exception.args[0]) obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) self.assertIn("mjd", context.exception.args[0]) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list) self.assertIn("ObservationMetaData", context.exception.args[0]) # check that exceptions are raised when ra_list, dec_list are of the wrong shape obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0) with self.assertRaises(RuntimeError) as context: chipNameFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs) self.assertIn("chipNameFromRaDecLSST", context.exception.args[0])
def test_alert_data_generation(self): dmag_cutoff = 0.005 mag_name_to_int = {'u': 0, 'g': 1, 'r': 2, 'i': 3, 'z' : 4, 'y': 5} _max_var_param_str = self.max_str_len class StarAlertTestDBObj(StellarAlertDBObjMixin, CatalogDBObject): objid = 'star_alert' tableid = 'stars' idColKey = 'simobjid' raColName = 'ra' decColName = 'dec' objectTypeId = 0 columns = [('raJ2000', 'ra*0.01745329252'), ('decJ2000', 'dec*0.01745329252'), ('parallax', 'px*0.01745329252/3600.0'), ('properMotionRa', 'pmra*0.01745329252/3600.0'), ('properMotionDec', 'pmdec*0.01745329252/3600.0'), ('radialVelocity', 'vrad'), ('variabilityParameters', 'varParamStr', str, _max_var_param_str)] class TestAlertsVarCatMixin(object): @register_method('alert_test') def applyAlertTest(self, valid_dexes, params, expmjd, variability_cache=None): if len(params) == 0: return np.array([[], [], [], [], [], []]) if isinstance(expmjd, numbers.Number): dmags_out = np.zeros((6, self.num_variable_obj(params))) else: dmags_out = np.zeros((6, self.num_variable_obj(params), len(expmjd))) for i_star in range(self.num_variable_obj(params)): if params['amp'][i_star] is not None: dmags = params['amp'][i_star]*np.cos(params['per'][i_star]*expmjd) for i_filter in range(6): dmags_out[i_filter][i_star] = dmags return dmags_out class TestAlertsVarCat(TestAlertsVarCatMixin, AlertStellarVariabilityCatalog): pass class TestAlertsTruthCat(TestAlertsVarCatMixin, CameraCoords, AstrometryStars, Variability, InstanceCatalog): column_outputs = ['uniqueId', 'chipName', 'dmagAlert', 'magAlert'] camera = obs_lsst_phosim.PhosimMapper().camera @compound('delta_umag', 'delta_gmag', 'delta_rmag', 'delta_imag', 'delta_zmag', 'delta_ymag') def get_TruthVariability(self): return self.applyVariability(self.column_by_name('varParamStr')) @cached def get_dmagAlert(self): return self.column_by_name('delta_%smag' % self.obs_metadata.bandpass) @cached def get_magAlert(self): return self.column_by_name('%smag' % self.obs_metadata.bandpass) + \ self.column_by_name('dmagAlert') star_db = StarAlertTestDBObj(database=self.star_db_name, driver='sqlite') # assemble the true light curves for each object; we need to figure out # if their np.max(dMag) ever goes over dmag_cutoff; then we will know if # we are supposed to simulate them true_lc_dict = {} true_lc_obshistid_dict = {} is_visible_dict = {} obs_dict = {} max_obshistid = -1 n_total_observations = 0 for obs in self.obs_list: obs_dict[obs.OpsimMetaData['obsHistID']] = obs obshistid = obs.OpsimMetaData['obsHistID'] if obshistid > max_obshistid: max_obshistid = obshistid cat = TestAlertsTruthCat(star_db, obs_metadata=obs) for line in cat.iter_catalog(): if line[1] is None: continue n_total_observations += 1 if line[0] not in true_lc_dict: true_lc_dict[line[0]] = {} true_lc_obshistid_dict[line[0]] = [] true_lc_dict[line[0]][obshistid] = line[2] true_lc_obshistid_dict[line[0]].append(obshistid) if line[0] not in is_visible_dict: is_visible_dict[line[0]] = False if line[3] <= self.obs_mag_cutoff[mag_name_to_int[obs.bandpass]]: is_visible_dict[line[0]] = True obshistid_bits = int(np.ceil(np.log(max_obshistid)/np.log(2))) skipped_due_to_mag = 0 objects_to_simulate = [] obshistid_unqid_set = set() for obj_id in true_lc_dict: dmag_max = -1.0 for obshistid in true_lc_dict[obj_id]: if np.abs(true_lc_dict[obj_id][obshistid]) > dmag_max: dmag_max = np.abs(true_lc_dict[obj_id][obshistid]) if dmag_max >= dmag_cutoff: if not is_visible_dict[obj_id]: skipped_due_to_mag += 1 continue objects_to_simulate.append(obj_id) for obshistid in true_lc_obshistid_dict[obj_id]: obshistid_unqid_set.add((obj_id << obshistid_bits) + obshistid) self.assertGreater(len(objects_to_simulate), 10) self.assertGreater(skipped_due_to_mag, 0) log_file_name = tempfile.mktemp(dir=self.output_dir, suffix='log.txt') alert_gen = AlertDataGenerator(testing=True) alert_gen.subdivide_obs(self.obs_list, htmid_level=6) for htmid in alert_gen.htmid_list: alert_gen.alert_data_from_htmid(htmid, star_db, photometry_class=TestAlertsVarCat, output_prefix='alert_test', output_dir=self.output_dir, dmag_cutoff=dmag_cutoff, log_file_name=log_file_name) dummy_sed = Sed() bp_dict = BandpassDict.loadTotalBandpassesFromFiles() phot_params = PhotometricParameters() # First, verify that the contents of the sqlite files are all correct n_tot_simulated = 0 alert_query = 'SELECT alert.uniqueId, alert.obshistId, meta.TAI, ' alert_query += 'meta.band, quiescent.flux, alert.dflux, ' alert_query += 'quiescent.snr, alert.snr, ' alert_query += 'alert.ra, alert.dec, alert.chipNum, ' alert_query += 'alert.xPix, alert.yPix, ast.pmRA, ast.pmDec, ' alert_query += 'ast.parallax ' alert_query += 'FROM alert_data AS alert ' alert_query += 'INNER JOIN metadata AS meta ON meta.obshistId=alert.obshistId ' alert_query += 'INNER JOIN quiescent_flux AS quiescent ' alert_query += 'ON quiescent.uniqueId=alert.uniqueId ' alert_query += 'AND quiescent.band=meta.band ' alert_query += 'INNER JOIN baseline_astrometry AS ast ' alert_query += 'ON ast.uniqueId=alert.uniqueId' alert_dtype = np.dtype([('uniqueId', int), ('obshistId', int), ('TAI', float), ('band', int), ('q_flux', float), ('dflux', float), ('q_snr', float), ('tot_snr', float), ('ra', float), ('dec', float), ('chipNum', int), ('xPix', float), ('yPix', float), ('pmRA', float), ('pmDec', float), ('parallax', float)]) sqlite_file_list = os.listdir(self.output_dir) n_tot_simulated = 0 obshistid_unqid_simulated_set = set() for file_name in sqlite_file_list: if not file_name.endswith('db'): continue full_name = os.path.join(self.output_dir, file_name) self.assertTrue(os.path.exists(full_name)) alert_db = DBObject(full_name, driver='sqlite') alert_data = alert_db.execute_arbitrary(alert_query, dtype=alert_dtype) if len(alert_data) == 0: continue mjd_list = ModifiedJulianDate.get_list(TAI=alert_data['TAI']) for i_obj in range(len(alert_data)): n_tot_simulated += 1 obshistid_unqid_simulated_set.add((alert_data['uniqueId'][i_obj] << obshistid_bits) + alert_data['obshistId'][i_obj]) unq = alert_data['uniqueId'][i_obj] obj_dex = (unq//1024)-1 self.assertAlmostEqual(self.pmra_truth[obj_dex], 0.001*alert_data['pmRA'][i_obj], 4) self.assertAlmostEqual(self.pmdec_truth[obj_dex], 0.001*alert_data['pmDec'][i_obj], 4) self.assertAlmostEqual(self.px_truth[obj_dex], 0.001*alert_data['parallax'][i_obj], 4) ra_truth, dec_truth = applyProperMotion(self.ra_truth[obj_dex], self.dec_truth[obj_dex], self.pmra_truth[obj_dex], self.pmdec_truth[obj_dex], self.px_truth[obj_dex], self.vrad_truth[obj_dex], mjd=mjd_list[i_obj]) distance = angularSeparation(ra_truth, dec_truth, alert_data['ra'][i_obj], alert_data['dec'][i_obj]) distance_arcsec = 3600.0*distance msg = '\ntruth: %e %e\nalert: %e %e\n' % (ra_truth, dec_truth, alert_data['ra'][i_obj], alert_data['dec'][i_obj]) self.assertLess(distance_arcsec, 0.0005, msg=msg) obs = obs_dict[alert_data['obshistId'][i_obj]] chipname = chipNameFromRaDec(self.ra_truth[obj_dex], self.dec_truth[obj_dex], pm_ra=self.pmra_truth[obj_dex], pm_dec=self.pmdec_truth[obj_dex], parallax=self.px_truth[obj_dex], v_rad=self.vrad_truth[obj_dex], obs_metadata=obs, camera=self.camera) chipnum = int(chipname.replace('R', '').replace('S', ''). replace(' ', '').replace(';', '').replace(',', ''). replace(':', '')) self.assertEqual(chipnum, alert_data['chipNum'][i_obj]) xpix, ypix = pixelCoordsFromRaDec(self.ra_truth[obj_dex], self.dec_truth[obj_dex], pm_ra=self.pmra_truth[obj_dex], pm_dec=self.pmdec_truth[obj_dex], parallax=self.px_truth[obj_dex], v_rad=self.vrad_truth[obj_dex], obs_metadata=obs, camera=self.camera) self.assertAlmostEqual(alert_data['xPix'][i_obj], xpix, 4) self.assertAlmostEqual(alert_data['yPix'][i_obj], ypix, 4) dmag_sim = -2.5*np.log10(1.0+alert_data['dflux'][i_obj]/alert_data['q_flux'][i_obj]) self.assertAlmostEqual(true_lc_dict[alert_data['uniqueId'][i_obj]][alert_data['obshistId'][i_obj]], dmag_sim, 3) mag_name = ('u', 'g', 'r', 'i', 'z', 'y')[alert_data['band'][i_obj]] m5 = obs.m5[mag_name] q_mag = dummy_sed.magFromFlux(alert_data['q_flux'][i_obj]) self.assertAlmostEqual(self.mag0_truth_dict[alert_data['band'][i_obj]][obj_dex], q_mag, 4) snr, gamma = calcSNR_m5(self.mag0_truth_dict[alert_data['band'][i_obj]][obj_dex], bp_dict[mag_name], self.obs_mag_cutoff[alert_data['band'][i_obj]], phot_params) self.assertAlmostEqual(snr/alert_data['q_snr'][i_obj], 1.0, 4) tot_mag = self.mag0_truth_dict[alert_data['band'][i_obj]][obj_dex] + \ true_lc_dict[alert_data['uniqueId'][i_obj]][alert_data['obshistId'][i_obj]] snr, gamma = calcSNR_m5(tot_mag, bp_dict[mag_name], m5, phot_params) self.assertAlmostEqual(snr/alert_data['tot_snr'][i_obj], 1.0, 4) for val in obshistid_unqid_set: self.assertIn(val, obshistid_unqid_simulated_set) self.assertEqual(len(obshistid_unqid_set), len(obshistid_unqid_simulated_set)) astrometry_query = 'SELECT uniqueId, ra, dec, TAI ' astrometry_query += 'FROM baseline_astrometry' astrometry_dtype = np.dtype([('uniqueId', int), ('ra', float), ('dec', float), ('TAI', float)]) tai_list = [] for obs in self.obs_list: tai_list.append(obs.mjd.TAI) tai_list = np.array(tai_list) n_tot_ast_simulated = 0 for file_name in sqlite_file_list: if not file_name.endswith('db'): continue full_name = os.path.join(self.output_dir, file_name) self.assertTrue(os.path.exists(full_name)) alert_db = DBObject(full_name, driver='sqlite') astrometry_data = alert_db.execute_arbitrary(astrometry_query, dtype=astrometry_dtype) if len(astrometry_data) == 0: continue mjd_list = ModifiedJulianDate.get_list(TAI=astrometry_data['TAI']) for i_obj in range(len(astrometry_data)): n_tot_ast_simulated += 1 obj_dex = (astrometry_data['uniqueId'][i_obj]//1024) - 1 ra_truth, dec_truth = applyProperMotion(self.ra_truth[obj_dex], self.dec_truth[obj_dex], self.pmra_truth[obj_dex], self.pmdec_truth[obj_dex], self.px_truth[obj_dex], self.vrad_truth[obj_dex], mjd=mjd_list[i_obj]) distance = angularSeparation(ra_truth, dec_truth, astrometry_data['ra'][i_obj], astrometry_data['dec'][i_obj]) self.assertLess(3600.0*distance, 0.0005) del alert_gen gc.collect() self.assertGreater(n_tot_simulated, 10) self.assertGreater(len(obshistid_unqid_simulated_set), 10) self.assertLess(len(obshistid_unqid_simulated_set), n_total_observations) self.assertGreater(n_tot_ast_simulated, 0)
obs_metadata_list = OpSimDB.getObservationMetaData((88.0, -40.0), 5.0, fovRadius=radiusDegrees, makeCircBounds=True) obs_metadata = obs_metadata_list[0] #generate some random RA and Dec to find chips for nsamples = 10 numpy.random.seed(32) rr = numpy.radians(2.0) * numpy.random.sample(nsamples) theta = 2.0 * numpy.pi * numpy.random.sample(nsamples) ra = numpy.degrees( numpy.radians(obs_metadata.pointingRA) + rr * numpy.cos(theta)) dec = numpy.degrees( numpy.radians(obs_metadata.pointingDec) + rr * numpy.sin(theta)) #need to correct coordinates for precession, nutation, and aberration ra, dec = observedFromICRS(ra, dec, obs_metadata=obs_metadata, epoch=epoch) xx, yy = pupilCoordsFromRaDec(ra, dec, obs_metadata=obs_metadata, epoch=epoch) chipNames = chipNameFromRaDec(ra, dec, epoch=epoch, camera=camera, obs_metadata=obs_metadata) for (rr, dd, x, y, nn) in zip(ra, dec, xx, yy, chipNames): print(rr, dd, arcsecFromRadians(x), arcsecFromRadians(y), nn)
def main(file, psf, outdir): """ Drive GalSim to simulate the LSST. """ # Setup a parser to take command line arguments config = desc.imsim.read_config(None) logger = desc.imsim.get_logger("INFO") # Get the number of rows to read from the instance file. Use # default if not specified. numRows = None sensor = None # The PhoSim instance file contains both pointing commands and # objects. The parser will split them and return a both phosim # command dictionary and a dataframe of objects. commands, phosim_objects = \ desc.imsim.parsePhoSimInstanceFile(file, numRows) phosim_objects = \ desc.imsim.validate_phosim_object_list(phosim_objects).accepted # Build the ObservationMetaData with values taken from the # PhoSim commands at the top of the instance file. obs_md = desc.imsim.phosim_obs_metadata(commands) #print (commands) #obs_md.OpsimMetaData['altitude' ] = 20 camera = LsstSimMapper().camera # Sub-divide the source dataframe into stars and galaxies. if sensor is not None: # Trim the input catalog to a single chip. phosim_objects['chipName'] = \ chipNameFromRaDec(phosim_objects['raICRS'].values, phosim_objects['decICRS'].values, parallax=phosim_objects['parallax'].values, camera=camera, obs_metadata=obs_md, epoch=2000.0) starDataBase = \ phosim_objects.query("galSimType=='pointSource' and chipName=='%s'" % sensor) galaxyDataBase = \ phosim_objects.query("galSimType=='sersic' and chipName=='%s'" % sensor) else: starDataBase = \ phosim_objects.query("galSimType=='pointSource'") galaxyDataBase = \ phosim_objects.query("galSimType=='sersic'") # Simulate the objects in the Pandas Dataframes. # First simulate stars phoSimStarCatalog = desc.imsim.ImSimStars(starDataBase, obs_md) phoSimStarCatalog.photParams = desc.imsim.photometricParameters(commands) # Add noise and sky background # The simple code using the default lsst-GalSim interface would be: # # PhoSimStarCatalog.noise_and_background = ExampleCCDNoise(addNoise=True, # addBackground=True) # # But, we need a more realistic sky model and we need to pass more than # this basic info to use Peter Y's ESO sky model. # We must pass obs_metadata, chip information etc... phoSimStarCatalog.noise_and_background = ESOSkyModel(obs_md, addNoise=True, addBackground=True) # Add a PSF. if psf.lower() == "doublegaussian": # This one is taken from equation 30 of # www.astro.washington.edu/users/ivezic/Astr511/LSST_SNRdoc.pdf . # # Set seeing from self.obs_metadata. phoSimStarCatalog.PSF = \ SNRdocumentPSF(obs_md.OpsimMetaData['FWHMgeom']) elif psf.lower() == "kolmogorov": # This PSF was presented by David Kirkby at the 23 March 2017 # Survey Simulations Working Group telecon # # https://confluence.slac.stanford.edu/pages/viewpage.action?spaceKey=LSSTDESC&title=SSim+2017-03-23 # equation 3 of Krisciunas and Schaefer 1991 airmass = 1.0 / np.sqrt( 1.0 - 0.96 * (np.sin(0.5 * np.pi - obs_md.OpsimMetaData['altitude']))**2) phoSimStarCatalog.PSF = \ Kolmogorov_and_Gaussian_PSF(airmass=airmass, rawSeeing=obs_md.OpsimMetaData['rawSeeing'], band=obs_md.bandpass) else: raise RuntimeError("Do not know what to do with psf model: " "%s" % psf) phoSimStarCatalog.camera = camera phoSimStarCatalog.get_fitsFiles() # Now galaxies phoSimGalaxyCatalog = desc.imsim.ImSimGalaxies(galaxyDataBase, obs_md) phoSimGalaxyCatalog.copyGalSimInterpreter(phoSimStarCatalog) phoSimGalaxyCatalog.PSF = phoSimStarCatalog.PSF phoSimGalaxyCatalog.noise_and_background = phoSimStarCatalog.noise_and_background phoSimGalaxyCatalog.get_fitsFiles() # Write out the fits files outdir = outdir if not os.path.isdir(outdir): os.makedirs(outdir) prefix = config['persistence']['eimage_prefix'] phoSimGalaxyCatalog.write_images(nameRoot=os.path.join(outdir, prefix) + str(commands['obshistid']))
from lsst.obs.lsstSim import LsstSimMapper mapper = LsstSimMapper() camera = mapper.camera epoch = 2000.0 #generate an ObservationMetaData object based on an actual OpSim pointing obshistid = 88625744 radiusDegrees = 3.0 OpSimDB = OpSim3_61DBObject() obs_metadata = OpSimDB.getObservationMetaData(obshistid, radiusDegrees, makeCircBounds=True) #generate some random RA and Dec to find chips for nsamples = 10 numpy.random.seed(32) rr = numpy.radians(2.0)*numpy.random.sample(nsamples) theta = 2.0*numpy.pi*numpy.random.sample(nsamples) ra = numpy.degrees(numpy.radians(obs_metadata.pointingRA) + rr*numpy.cos(theta)) dec = numpy.degrees(numpy.radians(obs_metadata.pointingDec) + rr*numpy.sin(theta)) #need to correct coordinates for precession, nutation, and aberration ra, dec = observedFromICRS(ra, dec, obs_metadata=obs_metadata, epoch=epoch) xx, yy = pupilCoordsFromRaDec(ra, dec, obs_metadata=obs_metadata, epoch=epoch) chipNames = chipNameFromRaDec(ra, dec, epoch=epoch, camera=camera, obs_metadata=obs_metadata) for (rr,dd,x,y,nn) in zip(ra,dec,xx,yy,chipNames): print rr,dd,arcsecFromRadians(x),arcsecFromRadians(y),nn
header_msg += '# regenerated.\n#\n' camera = lsst_camera() ra = 25.0 dec = -62.0 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, rotSkyPos=57.2, mjd=59586.2) ra_range = np.arange(ra-4.0, ra+4.0, 0.1) dec_range = np.arange(dec-4.0, dec+4.0, 0.1) ra_grid, dec_grid = np.meshgrid(ra_range, dec_range) ra_grid = ra_grid.flatten() dec_grid = dec_grid.flatten() chip_name_grid = chipNameFromRaDec(ra_grid, dec_grid, obs_metadata=obs, camera=camera) valid = np.where(np.char.find(chip_name_grid.astype(str), 'None')<0) ra_grid = ra_grid[valid] dec_grid = dec_grid[valid] chip_name_grid = chip_name_grid[valid] focal_x, focal_y = focalPlaneCoordsFromRaDec(ra_grid, dec_grid, obs_metadata=obs, camera=camera) pix_x, pix_y = pixelCoordsFromRaDec(ra_grid, dec_grid, chipName=chip_name_grid, obs_metadata=obs, camera=camera)
ra = 25.0 dec = -62.0 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, rotSkyPos=57.2, mjd=59586.2) ra_range = np.arange(ra - 4.0, ra + 4.0, 0.1) dec_range = np.arange(dec - 4.0, dec + 4.0, 0.1) ra_grid, dec_grid = np.meshgrid(ra_range, dec_range) ra_grid = ra_grid.flatten() dec_grid = dec_grid.flatten() chip_name_grid = chipNameFromRaDec(ra_grid, dec_grid, obs_metadata=obs, camera=camera) valid = np.where(np.char.find(chip_name_grid.astype(str), 'None') < 0) ra_grid = ra_grid[valid] dec_grid = dec_grid[valid] chip_name_grid = chip_name_grid[valid] focal_x, focal_y = focalPlaneCoordsFromRaDec(ra_grid, dec_grid, obs_metadata=obs, camera=camera) pix_x, pix_y = pixelCoordsFromRaDec(ra_grid, dec_grid,