def phosim_obs_metadata(phosim_commands): """ Factory function to create an ObservationMetaData object based on the PhoSim commands extracted from an instance catalog. Parameters ---------- phosim_commands : dict Dictionary of PhoSim physics commands. Returns ------- lsst.sims.utils.ObservationMetaData """ bandpass = phosim_commands['bandpass'] fwhm_eff = FWHMeff(phosim_commands['seeing'], bandpass, phosim_commands['altitude']) fwhm_geom = FWHMgeom(phosim_commands['seeing'], bandpass, phosim_commands['altitude']) obs_md = ObservationMetaData(pointingRA=phosim_commands['rightascension'], pointingDec=phosim_commands['declination'], mjd=phosim_commands['mjd'], rotSkyPos=phosim_commands['rotskypos'], bandpassName=bandpass, m5=LSSTdefaults().m5(bandpass), seeing=fwhm_eff) # Set the OpsimMetaData attribute with the obshistID info. obs_md.OpsimMetaData = {'obshistID': phosim_commands['obshistid']} obs_md.OpsimMetaData['FWHMgeom'] = fwhm_geom obs_md.OpsimMetaData['FWHMeff'] = fwhm_eff obs_md.OpsimMetaData['rawSeeing'] = phosim_commands['seeing'] obs_md.OpsimMetaData['altitude'] = phosim_commands['altitude'] obs_md.OpsimMetaData['airmass'] = airmass(phosim_commands['altitude']) obs_md.OpsimMetaData['seed'] = phosim_commands['seed'] return obs_md
def phosim_obs_metadata(phosim_commands): """ Factory function to create an ObservationMetaData object based on the PhoSim commands extracted from an instance catalog. Parameters ---------- phosim_commands : dict Dictionary of PhoSim physics commands. Returns ------- lsst.sims.utils.ObservationMetaData Notes ----- The seeing from the instance catalog is the value at 500nm at zenith. Do we need to do a band-specific calculation? """ bandpass = phosim_commands['bandpass'] obs_md = ObservationMetaData(pointingRA=phosim_commands['rightascension'], pointingDec=phosim_commands['declination'], mjd=phosim_commands['mjd'], rotSkyPos=phosim_commands['rotskypos'], bandpassName=bandpass, m5=LSSTdefaults().m5(bandpass), seeing=phosim_commands['FWHMeff']) # Set the OpsimMetaData attribute with the obshistID info. obs_md.OpsimMetaData = {'obshistID': phosim_commands['obshistid']} obs_md.OpsimMetaData['FWHMgeom'] = phosim_commands['FWHMgeom'] obs_md.OpsimMetaData['FWHMeff'] = phosim_commands['FWHMeff'] obs_md.OpsimMetaData['rawSeeing'] = phosim_commands['rawSeeing'] obs_md.OpsimMetaData['altitude'] = phosim_commands['altitude'] return obs_md
def createTestSNDB(): """ Create a CatalogDBObject-like database that contains everything needed to create a supernova catalog. Return the CatalogDBObject and an ObservationMetaData pointing to its center. Note: the OpsimMetaData for the returned ObservationMetaData will be inconsistent. It is just there so that PhoSim InstanceCatalog classes can write out a header. """ raCenter = 23.0 decCenter = -19.0 radius = 0.1 obs = ObservationMetaData(pointingRA=raCenter, pointingDec=decCenter, boundType='circle', boundLength=radius, rotSkyPos=33.0, mjd=59580.0, bandpassName='r') # these will be totally inconsistent; just need something to put in the header obs.OpsimMetaData = {'dist2Moon': 0.1, 'moonalt': -0.2, 'moonra': 1.1, 'moondec': 0.5, 'rottelpos': 0.4, 'sunalt': -1.1} rng = np.random.RandomState(88) n_obj = 10 rr = rng.random_sample(n_obj)*radius theta = rng.random_sample(n_obj)*2.0*np.pi ra_list = raCenter + rr*np.cos(theta) dec_list = decCenter + rr*np.sin(theta) t0_list = 0.5*rng.random_sample(n_obj) x0_list = rng.random_sample(n_obj)*1.0e-4 x1_list = rng.random_sample(n_obj) c_list = rng.random_sample(n_obj)*2.0 z_list = rng.random_sample(n_obj)*1.1 + 0.1 txt_file_name = tempfile.mktemp(dir=ROOT, prefix='test_phosim_sn_source', suffix='.txt') dtype = np.dtype([('id', int), ('snra', float), ('sndec', float), ('t0', float), ('x0', float), ('x1', float), ('c', float), ('redshift', float), ('galtileid', int)]) with open(txt_file_name, 'w') as output_file: for ix, (ra, dec, t0, x0, x1, c, z) in enumerate(zip(ra_list, dec_list, t0_list, x0_list, x1_list, c_list, z_list)): output_file.write('%d %e %e %e %e %e %e %e %d\n' % (ix, ra, dec, t0, x0, x1, c, z, ix)) class testSNDBObj(SNDBObj, fileDBObject): tableid = 'test' def query_columns(self, *args, **kwargs): return fileDBObject.query_columns(self, *args, **kwargs) dbobj = testSNDBObj(txt_file_name, runtable='test', dtype=dtype) if os.path.exists(txt_file_name): os.unlink(txt_file_name) return dbobj, obs
def test_raw_file_writing(self): """ Test the writing of raw files directly from a galsim.Image. This is mostly an operational test that the raw files can be written from a galsim image. """ camera_wrapper = sims_gsi.LSSTCameraWrapper() phot_params = PhotometricParameters() obs_md = ObservationMetaData(pointingRA=31.1133844, pointingDec=-10.0970060, rotSkyPos=69.0922930, mjd=59797.2854090, bandpassName='r') obs_md.OpsimMetaData = { 'obshistID': 161899, 'airmass': desc.imsim.airmass(43.6990272) } detname = "R:2,2 S:1,1" chipid = 'R{}_S{}'.format(detname[2:5:2], detname[8:11:2]) detector = sims_gsi.make_galsim_detector(camera_wrapper, detname, phot_params, obs_md) gs_interpreter = sims_gsi.GalSimInterpreter(detectors=[detector]) gs_image = gs_interpreter.blankImage(detector) raw_image = desc.imsim.ImageSource.create_from_galsim_image(gs_image) self.outfile = 'lsst_a_{}_r.fits'.format(chipid) # Add keyword values via an optional dict. added_keywords = {'GAUSFWHM': 0.4, 'FOOBAR': 'hello, world'} raw_image.write_fits_file(self.outfile, overwrite=True, added_keywords=added_keywords) # Test some keywords. with fits.open(self.outfile) as raw_file: hdr = raw_file[0].header self.assertAlmostEqual(hdr['RATEL'], obs_md.pointingRA) self.assertAlmostEqual(hdr['DECTEL'], obs_md.pointingDec) self.assertAlmostEqual(hdr['ROTANGLE'], obs_md.rotSkyPos) self.assertEqual(hdr['CHIPID'], chipid) # Ensure the following keywords are set. self.assertNotEqual(hdr['AMSTART'], hdr['AMEND']) self.assertNotEqual(hdr['HASTART'], hdr['HAEND']) self.assertEqual(hdr['DATE-OBS'], '2022-08-06T06:50:59.338') self.assertEqual(hdr['DATE-END'], '2022-08-06T06:51:29.338') self.assertEqual(hdr['TIMESYS'], 'TAI') self.assertEqual(hdr['OBSTYPE'], 'SKYEXP') # Test the added_keywords. for key, value in added_keywords.items(): self.assertEqual(hdr[key], value)
def testOpsimMetaData(self): """ Make sure that an exception is raised if you pass a non-dict object in as OpsimMetaData """ obs = ObservationMetaData(pointingRA=23.0, pointingDec=-11.0) with self.assertRaises(RuntimeError) as ee: obs.OpsimMetaData = 5.0 self.assertIn("must be a dict", ee.exception.args[0]) with self.assertRaises(RuntimeError) as ee: obs.OpsimMetaData = 5 self.assertIn("must be a dict", ee.exception.args[0]) with self.assertRaises(RuntimeError) as ee: obs.OpsimMetaData = [5.0, 3.0] self.assertIn("must be a dict", ee.exception.args[0]) with self.assertRaises(RuntimeError) as ee: obs.OpsimMetaData = (5.0, 3.0) self.assertIn("must be a dict", ee.exception.args[0]) obs.OpsimMetaData = {'a': 1, 'b': 2}
def get_obs_md(instcat): with open(instcat, 'r') as fd: params = dict() for line in fd: if line.startswith('object'): break tokens = line.strip().split() try: params[tokens[0]] = float(tokens[1]) except ValueError: pass obs_md = ObservationMetaData(pointingRA=params['rightascension'], pointingDec=params['declination'], mjd=params['mjd'], rotSkyPos=params['rotskypos']) obs_md.OpsimMetaData = dict(obshistid=params['obshistid']) return obs_md
def get_obs_md_from_raw(raw_file): """ Get the ObservationMetaData object from the raw file header info. Parameters ---------- raw_file: str The path to the raw file. Results ------- lsst.sims.utils.ObservationMetaData """ with fits.open(raw_file) as fd: hdr = fd[0].header obs_md = ObservationMetaData(pointingRA=hdr['RATEL'], pointingDec=hdr['DECTEL'], mjd=hdr['MJD-OBS'], rotSkyPos=hdr['ROTANGLE']) obs_md.OpsimMetaData = dict(obshistid=hdr['OBSID']) return obs_md
def ObservationMetaDataFromPointing(self, OpSimPointingRecord, OpSimColumns=None, boundLength=1.75, boundType='circle'): """ Return instance of ObservationMetaData for an OpSim Pointing record from OpSim. Parameters ---------- OpSimPointingRecord : Dictionary, mandatory Dictionary of values with keys corresponding to certain columns of the Summary table in the OpSim database. The minimal list of keys required for catsim to work is 'fiveSigmaDepth', 'filtSkyBrightness', and at least one of ('finSeeing', 'FWHMeff'). More keys defined in columnMap may be necessary for PhoSim to work. OpSimColumns : tuple of strings, optional, defaults to None The columns corresponding to the OpSim records. If None, attempts to obtain these from the OpSimRecord as OpSimRecord.dtype.names boundType : {'circle', 'box'}, optional, defaults to 'circle' Shape of the observation boundLength : scalar float, optional, defaults to 1.75 'characteristic size' of observation field, in units of degrees. For boundType='circle', this is a radius, for boundType='box', this is a size of the box """ pointing = OpSimPointingRecord pointing_column_names = pointing.dtype.names # Decide what is the name of the column in the OpSim database # corresponding to the Seeing. For older OpSim outputs, this is # 'finSeeing'. For later OpSim outputs this is 'FWHMeff' if OpSimColumns is None: OpSimColumns = pointing_column_names self._set_seeing_column(OpSimColumns) # check to make sure the OpSim pointings being supplied contain # the minimum required information for required_column in ('fieldRA', 'fieldDec', 'expMJD', 'filter'): if required_column not in OpSimColumns: raise RuntimeError("ObservationMetaDataGenerator requires that the database of " "pointings include the coluns:\nfieldRA (in radians)" "\nfieldDec (in radians)\nexpMJD\nfilter") # construct a raw dict of all of the OpSim columns associated with this pointing raw_dict = dict([(col, pointing[col]) for col in pointing_column_names]) obs = ObservationMetaData(pointingRA=np.degrees(pointing['fieldRA']), pointingDec=np.degrees(pointing['fieldDec']), mjd=pointing['expMJD'], bandpassName=pointing['filter'], boundType=boundType, boundLength=boundLength) if 'fiveSigmaDepth' in pointing_column_names: obs.m5 = pointing['fiveSigmaDepth'] if 'filtSkyBrightness' in pointing_column_names: obs.skyBrightness = pointing['filtSkyBrightness'] if self._seeing_column in pointing_column_names: obs.seeing = pointing[self._seeing_column] if 'rotSkyPos' in pointing_column_names: obs.rotSkyPos = np.degrees(pointing['rotSkyPos']) obs.OpsimMetaData = raw_dict return obs
def makePhoSimTestDB(filename='PhoSimTestDatabase.db', size=1000, seedVal=32, radius=0.1, deltaRA=None, deltaDec=None, bandpass='******', m5=None, seeing=None, magnorm_min=17.0, delta_magnorm=4.0, **kwargs): """ Make a test database to storing cartoon information for the test phoSim input catalog to use. The method will return an ObservationMetaData object guaranteed to encompass the objects in this database. @param [in] filename is a string indicating the name of the DB file to be created @param [in] size is the number of objects int he database @param [in] seedVal is the seed passed to the random number generator @param [in] radius is the radius (in degrees) of the field of view to be returned @param [in] bandpass is the bandpas(es) of the observation to be passed to ObservationMetaData (optional) @param [in] m5 is the m5 value(s) to be passed to ObservationMetaData (optional) @param [in] seeing is the seeing value(s) in arcseconds to be passed to ObservationMetaData (optional) @param [in] deltaRA/Dec are numpy arrays that indicate where (in relation to the center of the field of view) objects should be placed. These coordinates are in degrees. Specifying either of these paramters will overwrite size. If you only specify one of these parameters, the other will be set randomly. These parameters are optional. @param [in] magnorm_min is the min magnorm (magNorms for sources in the database will be distributed according to a random deviate drawn from magnorm_min + random*delta_magnorm) @param [in] delta_magnorm (see documentation for magnorm_min) """ if os.path.exists(filename): os.unlink(filename) # just an example of some valid SED file names galaxy_seds = ['Const.80E07.02Z.spec', 'Inst.80E07.002Z.spec', 'Burst.19E07.0005Z.spec'] agn_sed = 'agn.spec' star_seds = ['km20_5750.fits_g40_5790', 'm2.0Full.dat', 'bergeron_6500_85.dat_6700'] rng = np.random.RandomState(seedVal) if deltaRA is not None and deltaDec is not None: if len(deltaRA) != len(deltaDec): raise RuntimeError("WARNING in makePhoSimTestDB deltaRA and " "deltaDec have different lengths") if deltaRA is not None: size = len(deltaRA) elif deltaDec is not None: size = len(deltaDec) # create the ObservationMetaData object mjd = 52000.0 alt = np.pi/2.0 az = 0.0 testSite = Site(name='LSST') obsTemp = ObservationMetaData(mjd=mjd, site=testSite) centerRA, centerDec = _raDecFromAltAz(alt, az, obsTemp) rotTel = _getRotTelPos(centerRA, centerDec, obsTemp, 0.0) rotSkyPos = _getRotSkyPos(centerRA, centerDec, obsTemp, rotTel) obs_metadata = ObservationMetaData(pointingRA=np.degrees(centerRA), pointingDec=np.degrees(centerDec), rotSkyPos=np.degrees(rotSkyPos), bandpassName=bandpass, mjd=mjd, boundType = 'circle', boundLength = 2.0*radius, site=testSite, m5=m5, seeing=seeing) moon_alt = -90.0 sun_alt = -90.0 moon_ra, moon_dec = raDecFromAltAz(moon_alt, 0.0, obs_metadata) dist2moon = haversine(np.radians(moon_ra), np.radians(moon_dec), obs_metadata._pointingRA, obs_metadata._pointingDec) obs_metadata.OpsimMetaData = {'moonra': moon_ra, 'moondec': moon_dec, 'moonalt': moon_alt, 'sunalt': sun_alt, 'dist2moon': dist2moon, 'rottelpos': np.degrees(rotTel)} # Now begin building the database. # First create the tables. conn = sqlite3.connect(filename) c = conn.cursor() try: c.execute('''CREATE TABLE galaxy_bulge (galtileid int, galid int, bra real, bdec real, ra real, dec real, magnorm_bulge real, sedname_bulge text, a_b real, b_b real, pa_bulge real, bulge_n int, ext_model_b text, av_b real, rv_b real, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real)''') conn.commit() except: raise RuntimeError("Error creating galaxy_bulge table.") try: c.execute('''CREATE TABLE galaxy (galtileid int, galid int, ra real, dec real, bra real, bdec real, dra real, ddec real, agnra real, agndec real, magnorm_bulge, magnorm_disk, magnorm_agn, sedname_bulge text, sedname_disk text, sedname_agn text, varParamStr text, a_b real, b_b real, pa_bulge real, bulge_n int, a_d real, b_d real, pa_disk real, disk_n int, ext_model_b text, av_b real, rv_b real, ext_model_d text, av_d real, rv_d real, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real, DiskHalfLightRadius real)''') conn.commit() except: raise RuntimeError("Error creating galaxy table.") try: c.execute('''CREATE TABLE galaxy_agn (galtileid int, galid int, agnra real, agndec real, ra real, dec real, magnorm_agn real, sedname_agn text, varParamStr text, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real)''') except: raise RuntimeError("Error creating galaxy_agn table.") try: c.execute('''CREATE TABLE StarAllForceseek (simobjid int, ra real, decl real, magNorm real, mudecl real, mura real, galacticAv real, vrad real, varParamStr text, sedFilename text, parallax real, ebv real)''') except: raise RuntimeError("Error creating StarAllForceseek table.") # Now generate the data to be stored in the tables. rr = rng.random_sample(size)*np.radians(radius) theta = rng.random_sample(size)*2.0*np.pi if deltaRA is None: ra = np.degrees(centerRA + rr*np.cos(theta)) else: ra = np.degrees(centerRA) + deltaRA if deltaDec is None: dec = np.degrees(centerDec + rr*np.sin(theta)) else: dec = np.degrees(centerDec) + deltaDec bra = np.radians(ra+rng.random_sample(size)*0.01*radius) bdec = np.radians(dec+rng.random_sample(size)*0.01*radius) dra = np.radians(ra + rng.random_sample(size)*0.01*radius) ddec = np.radians(dec + rng.random_sample(size)*0.01*radius) agnra = np.radians(ra + rng.random_sample(size)*0.01*radius) agndec = np.radians(dec + rng.random_sample(size)*0.01*radius) magnorm_bulge = rng.random_sample(size)*delta_magnorm + magnorm_min magnorm_disk = rng.random_sample(size)*delta_magnorm + magnorm_min magnorm_agn = rng.random_sample(size)*delta_magnorm + magnorm_min b_b = rng.random_sample(size)*0.2 a_b = b_b+rng.random_sample(size)*0.05 b_d = rng.random_sample(size)*0.5 a_d = b_d+rng.random_sample(size)*0.1 BulgeHalfLightRadius = rng.random_sample(size)*0.2 DiskHalfLightRadius = rng.random_sample(size)*0.5 pa_bulge = rng.random_sample(size)*360.0 pa_disk = rng.random_sample(size)*360.0 av_b = rng.random_sample(size)*0.3 av_d = rng.random_sample(size)*0.3 rv_b = rng.random_sample(size)*0.1 + 2.0 rv_d = rng.random_sample(size)*0.1 + 2.0 u_ab = rng.random_sample(size)*4.0 + 17.0 g_ab = rng.random_sample(size)*4.0 + 17.0 r_ab = rng.random_sample(size)*4.0 + 17.0 i_ab = rng.random_sample(size)*4.0 + 17.0 z_ab = rng.random_sample(size)*4.0 + 17.0 y_ab = rng.random_sample(size)*4.0 + 17.0 redshift = rng.random_sample(size)*2.0 t0_mjd = mjd - rng.random_sample(size)*1000.0 agn_tau = rng.random_sample(size)*1000.0 + 1000.0 agnSeed = rng.randint(2, 4001, size=size) agn_sfu = rng.random_sample(size) agn_sfg = rng.random_sample(size) agn_sfr = rng.random_sample(size) agn_sfi = rng.random_sample(size) agn_sfz = rng.random_sample(size) agn_sfy = rng.random_sample(size) rrStar = rng.random_sample(size)*np.radians(radius) thetaStar = rng.random_sample(size)*2.0*np.pi if deltaRA is None: raStar = centerRA + rrStar*np.cos(thetaStar) else: raStar = centerRA + np.radians(deltaRA) if deltaDec is None: decStar = centerDec + rrStar*np.sin(thetaStar) else: decStar = centerDec + np.radians(deltaDec) raStar = np.degrees(raStar) decStar = np.degrees(decStar) magnormStar = rng.random_sample(size)*delta_magnorm + magnorm_min mudecl = rng.random_sample(size)*0.0001 mura = rng.random_sample(size)*0.0001 galacticAv = rng.random_sample(size)*0.05*3.1 vrad = rng.random_sample(size)*1.0 parallax = 0.00045+rng.random_sample(size)*0.00001 period = rng.random_sample(size)*20.0 amp = rng.random_sample(size)*5.0 # write the data to the tables. for i in range(size): cmd = '''INSERT INTO galaxy_bulge VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', %f, %f, %f, %i, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, bra[i], bdec[i], ra[i], dec[i], magnorm_bulge[i], galaxy_seds[i%len(galaxy_seds)], a_b[i], b_b[i], pa_bulge[i], 4, 'CCM', av_b[i], rv_b[i], u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i]) c.execute(cmd) varParam = {'varMethodName': 'applyAgn', 'pars': {'agn_tau': round(agn_tau[i], 4), 't0_mjd': round(t0_mjd[i], 4), 'agn_sfu': round(agn_sfu[i], 4), 'agn_sfg': round(agn_sfg[i], 4), 'agn_sfr': round(agn_sfr[i], 4), 'agn_sfi': round(agn_sfi[i], 4), 'agn_sfz': round(agn_sfz[i], 4), 'agn_sfy': round(agn_sfy[i], 4), 'seed': int(agnSeed[i])}} paramStr = json.dumps(varParam) cmd = '''INSERT INTO galaxy VALUES (%i, %i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', '%s', '%s', %f, %f, %f, %i, %f, %f, %f, %i, '%s', %f, %f, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, ra[i], dec[i], bra[i], bdec[i], dra[i], ddec[i], agnra[i], agndec[i], magnorm_bulge[i], magnorm_disk[i], magnorm_agn[i], galaxy_seds[i%len(galaxy_seds)], galaxy_seds[i%len(galaxy_seds)], agn_sed, paramStr, a_b[i], b_b[i], pa_bulge[i], 4, a_d[i], b_d[i], pa_disk[i], 1, 'CCM', av_b[i], rv_b[i], 'CCM', av_d[i], rv_d[i], u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i], DiskHalfLightRadius[i]) c.execute(cmd) cmd = '''INSERT INTO galaxy_agn VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', '%s', %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, agnra[i], agndec[i], ra[i], dec[i], magnorm_agn[i], agn_sed, paramStr, u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i]) c.execute(cmd) varParam = {'varMethodName': 'testVar', 'pars': {'period': period[i], 'amplitude': amp[i]}} paramStr = json.dumps(varParam) cmd = '''INSERT INTO StarAllForceseek VALUES (%i, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', %f, %f)''' %\ (i, raStar[i], decStar[i], magnormStar[i], mudecl[i], mura[i], galacticAv[i], vrad[i], paramStr, star_seds[i%len(star_seds)], parallax[i], galacticAv[i]/3.1) c.execute(cmd) conn.commit() conn.close() return obs_metadata
def testFitsHeader(self): """ Create a test image with the LSST camera and with the cartoon camera. Verify that the image created with the LSST camera has the DM-required cards in its FITS header while the image created with the cartoon camera does not """ lsstCamera = LsstSimMapper().camera cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData') cartoonCamera = ReturnCamera(cameraDir) outputDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'scratchSpace') lsst_cat_name = os.path.join(outputDir, 'fits_test_lsst_cat.txt') lsst_cat_root = os.path.join(outputDir, 'fits_test_lsst_image') cartoon_cat_name = os.path.join(outputDir, 'fits_test_cartoon_cat.txt') cartoon_cat_root = os.path.join(outputDir, 'fits_test_cartoon_image') obs = ObservationMetaData(pointingRA=32.0, pointingDec=22.0, boundLength=0.1, boundType='circle', mjd=58000.0, rotSkyPos=14.0, bandpassName='u') obs.OpsimMetaData = {'obshistID': 112} dbFileName = os.path.join(outputDir, 'fits_test_db.dat') create_text_catalog(obs, dbFileName, np.array([30.0]), np.array([30.0]), [22.0]) db = fitsHeaderFileDBObj(dbFileName, runtable='test') # first test the lsst camera lsstCat = fitsHeaderCatalog(db, obs_metadata=obs) lsstCat.camera = lsstCamera lsstCat.PSF = SNRdocumentPSF() lsstCat.write_catalog(lsst_cat_name) lsstCat.write_images(nameRoot=lsst_cat_root) list_of_files = os.listdir(outputDir) ct = 0 for file_name in list_of_files: true_name = os.path.join(outputDir, file_name) if lsst_cat_root in true_name: ct += 1 fitsTest = fits.open(true_name) header = fitsTest[0].header self.assertIn('CHIPID', header) self.assertIn('OBSID', header) self.assertIn('OUTFILE', header) self.assertEqual(header['OBSID'], 112) self.assertEqual(header['CHIPID'], 'R22_S11') self.assertEqual(header['OUTFILE'], 'lsst_e_112_f0_R22_S11_E000') os.unlink(true_name) self.assertGreater(ct, 0) if os.path.exists(lsst_cat_name): os.unlink(lsst_cat_name) # now test with the cartoon camera cartoonCat = fitsHeaderCatalog(db, obs_metadata=obs) cartoonCat.camera = cartoonCamera cartoonCat.PSF = SNRdocumentPSF() cartoonCat.write_catalog(cartoon_cat_name) cartoonCat.write_images(nameRoot=cartoon_cat_root) list_of_files = os.listdir(outputDir) ct = 0 for file_name in list_of_files: true_name = os.path.join(outputDir, file_name) if cartoon_cat_root in true_name: ct += 1 fitsTest = fits.open(true_name) header = fitsTest[0].header self.assertNotIn('CHIPID', header) self.assertNotIn('OBSID', header) self.assertNotIn('OUTFILE', header) os.unlink(true_name) self.assertGreater(ct, 0) if os.path.exists(cartoon_cat_name): os.unlink(cartoon_cat_name) if os.path.exists(dbFileName): os.unlink(dbFileName)
out_dir = 'ratio_test/catalogs' sed_candidates = os.listdir(galaxy_dir) sed_names = rng.choice(sed_candidates, size=len(ra), replace=True) redshift_vals = rng.random_sample(len(sed_names))*2.0 for i_filter in range(6): obs = ObservationMetaData(pointingRA=obs_root.pointingRA, pointingDec=obs_root.pointingDec, rotSkyPos=obs_root.rotSkyPos, mjd=obs_root.mjd, site=obs_root.site, bandpassName='ugrizy'[i_filter]) obs.OpsimMetaData = obs_root.OpsimMetaData obs.OpsimMetaData['sunalt'] = -90.0 phosim_header['sunalt'] = -90.0 phosim_header['camconfig'] = 1 out_name = os.path.join(out_dir, 'instcat_ratio_grid_%d.txt' % (i_filter)) with open(out_name, 'w') as instcat_handle: phosim_header['obshistid'] = 100+i_filter write_phoSim_header(obs, instcat_handle, phosim_header) obj_ct = 0 redshift = 0.0 for ii, (rr, dd, zz, ss) in enumerate(zip(ra, dec, redshift_vals, sed_names)): magnorm = np.interp(zz, magnorm_interp[ss]['z'], magnorm_interp[ss]['mag']) unqid = ii+1 instcat_handle.write('object %d ' % unqid)
def getObservationMetaData(self, searchCenter, searchRadius, constraint=None, fovRadius=1.75, makeCircBounds=True, makeBoxBounds=False): """ This method will perform a query on the OpSim3_61 for pointings within a given region on the sky. It will then return a list of ObservationMetaData corresponding to the OpSim pointings returned by that query. param [in] searchCenter is a tuple (RA, Dec) indicating the center of the region of the sky wherein to search for OpSim pointings (in degrees). param [in] searchRadius is the radius of the region of the sky wherein to search for OpSim pointings (in degrees). param [in] constraint an optional constraint on another column. Should be a string of the form 'airmass=1.1' param [in] fovRadius is the radius (in degrees) of the resulting ObservationMetaDatas' fields of view. If you have specified a box bounds this will be half the length of each side of the box. param [in] makeCircBounds a boolean telling this method to construct an ObservationMetaData for a circular region of the sky centered on the specified OpSim pointing param [in] make BoxBounds a boolean telling this method to construct an ObservationMetaData for a square region of the sky centered on the specified OpSim pointing """ spatialBound = CircleBounds(numpy.radians(searchCenter[0]), numpy.radians(searchCenter[1]), numpy.radians(searchRadius)) # get the results of the query as a numpy recarray result = self.executeConstrainedQuery(spatialBound, constraint=constraint) obs_list = [] ra_list = numpy.degrees(result['pointingRA']) dec_list = numpy.degrees(result['pointingDec']) rotSkyPos_list = numpy.degrees(result['rotSkyPos']) for pointing, ra, dec, rotSkyPos in zip(result, ra_list, dec_list, rotSkyPos_list): mjd = pointing['expMJD'] #because makeCircBounds defaults to True, check whether the user is #requesting boxBounds before deciding to instantiate #circBounds boundType = None boundLength = None if makeBoxBounds: boundType = 'box' boundLength = numpy.array( [fovRadius / math.cos(numpy.radians(dec)), fovRadius]) elif makeCircBounds: boundType = 'circle' boundLength = fovRadius else: raise ValueErr("Need either makeBoxBounds or makeCircBounds") obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, rotSkyPos=rotSkyPos, mjd=mjd, bandpassName=result['filter'][0], boundType=boundType, boundLength=boundLength) raw_opsim_dict = dict([(k, pointing[k]) for k in result.dtype.names]) obs.OpsimMetaData = raw_opsim_dict obs_list.append(obs) return obs_list
def getObservationMetaData(self, searchCenter, searchRadius, constraint=None, fovRadius=1.75, makeCircBounds=True, makeBoxBounds=False): """ This method will perform a query on the OpSim3_61 for pointings within a given region on the sky. It will then return a list of ObservationMetaData corresponding to the OpSim pointings returned by that query. param [in] searchCenter is a tuple (RA, Dec) indicating the center of the region of the sky wherein to search for OpSim pointings (in degrees). param [in] searchRadius is the radius of the region of the sky wherein to search for OpSim pointings (in degrees). param [in] constraint an optional constraint on another column. Should be a string of the form 'airmass=1.1' param [in] fovRadius is the radius (in degrees) of the resulting ObservationMetaDatas' fields of view. If you have specified a box bounds this will be half the length of each side of the box. param [in] makeCircBounds a boolean telling this method to construct an ObservationMetaData for a circular region of the sky centered on the specified OpSim pointing param [in] make BoxBounds a boolean telling this method to construct an ObservationMetaData for a square region of the sky centered on the specified OpSim pointing """ spatialBound = CircleBounds(numpy.radians(searchCenter[0]), numpy.radians(searchCenter[1]), numpy.radians(searchRadius)) # get the results of the query as a numpy recarray result = self.executeConstrainedQuery(spatialBound, constraint=constraint) obs_list = [] ra_list = numpy.degrees(result['pointingRA']) dec_list = numpy.degrees(result['pointingDec']) rotSkyPos_list = numpy.degrees(result['rotSkyPos']) for pointing, ra, dec, rotSkyPos in zip(result, ra_list, dec_list, rotSkyPos_list): mjd = pointing['expMJD'] #because makeCircBounds defaults to True, check whether the user is #requesting boxBounds before deciding to instantiate #circBounds boundType = None boundLength = None if makeBoxBounds: boundType = 'box' boundLength = numpy.array([fovRadius/math.cos(numpy.radians(dec)), fovRadius]) elif makeCircBounds: boundType = 'circle' boundLength = fovRadius else: raise ValueErr("Need either makeBoxBounds or makeCircBounds") obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, rotSkyPos=rotSkyPos, mjd=mjd, bandpassName=result['filter'][0], boundType=boundType, boundLength=boundLength) raw_opsim_dict = dict([(k, pointing[k]) for k in result.dtype.names]) obs.OpsimMetaData = raw_opsim_dict obs_list.append(obs) return obs_list
def makePhoSimTestDB(filename='PhoSimTestDatabase.db', size=1000, seedVal=32, radius=0.1, deltaRA=None, deltaDec=None, bandpass='******', m5=None, seeing=None, magnorm_min=17.0, delta_magnorm=4.0, **kwargs): """ Make a test database to storing cartoon information for the test phoSim input catalog to use. The method will return an ObservationMetaData object guaranteed to encompass the objects in this database. @param [in] filename is a string indicating the name of the DB file to be created @param [in] size is the number of objects int he database @param [in] seedVal is the seed passed to the random number generator @param [in] radius is the radius (in degrees) of the field of view to be returned @param [in] bandpass is the bandpas(es) of the observation to be passed to ObservationMetaData (optional) @param [in] m5 is the m5 value(s) to be passed to ObservationMetaData (optional) @param [in] seeing is the seeing value(s) in arcseconds to be passed to ObservationMetaData (optional) @param [in] deltaRA/Dec are numpy arrays that indicate where (in relation to the center of the field of view) objects should be placed. These coordinates are in degrees. Specifying either of these paramters will overwrite size. If you only specify one of these parameters, the other will be set randomly. These parameters are optional. @param [in] magnorm_min is the min magnorm (magNorms for sources in the database will be distributed according to a random deviate drawn from magnorm_min + random*delta_magnorm) @param [in] delta_magnorm (see documentation for magnorm_min) """ if os.path.exists(filename): os.unlink(filename) # just an example of some valid SED file names galaxy_seds = [ 'Const.80E07.02Z.spec', 'Inst.80E07.002Z.spec', 'Burst.19E07.0005Z.spec' ] agn_sed = 'agn.spec' star_seds = [ 'km20_5750.fits_g40_5790', 'm2.0Full.dat', 'bergeron_6500_85.dat_6700' ] rng = np.random.RandomState(seedVal) if deltaRA is not None and deltaDec is not None: if len(deltaRA) != len(deltaDec): raise RuntimeError("WARNING in makePhoSimTestDB deltaRA and " "deltaDec have different lengths") if deltaRA is not None: size = len(deltaRA) elif deltaDec is not None: size = len(deltaDec) # create the ObservationMetaData object mjd = 52000.0 alt = np.pi / 2.0 az = 0.0 testSite = Site(name='LSST') obsTemp = ObservationMetaData(mjd=mjd, site=testSite) centerRA, centerDec = _raDecFromAltAz(alt, az, obsTemp) rotTel = _getRotTelPos(centerRA, centerDec, obsTemp, 0.0) rotSkyPos = _getRotSkyPos(centerRA, centerDec, obsTemp, rotTel) obs_metadata = ObservationMetaData(pointingRA=np.degrees(centerRA), pointingDec=np.degrees(centerDec), rotSkyPos=np.degrees(rotSkyPos), bandpassName=bandpass, mjd=mjd, boundType='circle', boundLength=2.0 * radius, site=testSite, m5=m5, seeing=seeing) moon_alt = -90.0 sun_alt = -90.0 moon_ra, moon_dec = raDecFromAltAz(moon_alt, 0.0, obs_metadata) dist2moon = haversine(np.radians(moon_ra), np.radians(moon_dec), obs_metadata._pointingRA, obs_metadata._pointingDec) obs_metadata.OpsimMetaData = { 'moonra': moon_ra, 'moondec': moon_dec, 'moonalt': moon_alt, 'sunalt': sun_alt, 'dist2moon': dist2moon, 'rottelpos': np.degrees(rotTel) } # Now begin building the database. # First create the tables. conn = sqlite3.connect(filename) c = conn.cursor() try: c.execute('''CREATE TABLE galaxy_bulge (galtileid int, galid int, bra real, bdec real, ra real, dec real, magnorm_bulge real, sedname_bulge text, a_b real, b_b real, pa_bulge real, bulge_n int, ext_model_b text, av_b real, rv_b real, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real)''' ) conn.commit() except: raise RuntimeError("Error creating galaxy_bulge table.") try: c.execute('''CREATE TABLE galaxy (galtileid int, galid int, ra real, dec real, bra real, bdec real, dra real, ddec real, agnra real, agndec real, magnorm_bulge, magnorm_disk, magnorm_agn, sedname_bulge text, sedname_disk text, sedname_agn text, varParamStr text, a_b real, b_b real, pa_bulge real, bulge_n int, a_d real, b_d real, pa_disk real, disk_n int, ext_model_b text, av_b real, rv_b real, ext_model_d text, av_d real, rv_d real, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real, BulgeHalfLightRadius real, DiskHalfLightRadius real)''' ) conn.commit() except: raise RuntimeError("Error creating galaxy table.") try: c.execute('''CREATE TABLE galaxy_agn (galtileid int, galid int, agnra real, agndec real, ra real, dec real, magnorm_agn real, sedname_agn text, varParamStr text, u_ab real, g_ab real, r_ab real, i_ab real, z_ab real, y_ab real, redshift real)''' ) except: raise RuntimeError("Error creating galaxy_agn table.") try: c.execute('''CREATE TABLE StarAllForceseek (simobjid int, ra real, decl real, magNorm real, mudecl real, mura real, galacticAv real, vrad real, varParamStr text, sedFilename text, parallax real, ebv real)''') except: raise RuntimeError("Error creating StarAllForceseek table.") # Now generate the data to be stored in the tables. rr = rng.random_sample(size) * np.radians(radius) theta = rng.random_sample(size) * 2.0 * np.pi if deltaRA is None: ra = np.degrees(centerRA + rr * np.cos(theta)) else: ra = np.degrees(centerRA) + deltaRA if deltaDec is None: dec = np.degrees(centerDec + rr * np.sin(theta)) else: dec = np.degrees(centerDec) + deltaDec bra = np.radians(ra + rng.random_sample(size) * 0.01 * radius) bdec = np.radians(dec + rng.random_sample(size) * 0.01 * radius) dra = np.radians(ra + rng.random_sample(size) * 0.01 * radius) ddec = np.radians(dec + rng.random_sample(size) * 0.01 * radius) agnra = np.radians(ra + rng.random_sample(size) * 0.01 * radius) agndec = np.radians(dec + rng.random_sample(size) * 0.01 * radius) magnorm_bulge = rng.random_sample(size) * delta_magnorm + magnorm_min magnorm_disk = rng.random_sample(size) * delta_magnorm + magnorm_min magnorm_agn = rng.random_sample(size) * delta_magnorm + magnorm_min b_b = rng.random_sample(size) * 0.2 a_b = b_b + rng.random_sample(size) * 0.05 b_d = rng.random_sample(size) * 0.5 a_d = b_d + rng.random_sample(size) * 0.1 BulgeHalfLightRadius = rng.random_sample(size) * 0.2 DiskHalfLightRadius = rng.random_sample(size) * 0.5 pa_bulge = rng.random_sample(size) * 360.0 pa_disk = rng.random_sample(size) * 360.0 av_b = rng.random_sample(size) * 0.3 av_d = rng.random_sample(size) * 0.3 rv_b = rng.random_sample(size) * 0.1 + 2.0 rv_d = rng.random_sample(size) * 0.1 + 2.0 u_ab = rng.random_sample(size) * 4.0 + 17.0 g_ab = rng.random_sample(size) * 4.0 + 17.0 r_ab = rng.random_sample(size) * 4.0 + 17.0 i_ab = rng.random_sample(size) * 4.0 + 17.0 z_ab = rng.random_sample(size) * 4.0 + 17.0 y_ab = rng.random_sample(size) * 4.0 + 17.0 redshift = rng.random_sample(size) * 2.0 t0_mjd = mjd - rng.random_sample(size) * 1000.0 agn_tau = rng.random_sample(size) * 1000.0 + 1000.0 agnSeed = rng.randint(2, 4001, size=size) agn_sfu = rng.random_sample(size) agn_sfg = rng.random_sample(size) agn_sfr = rng.random_sample(size) agn_sfi = rng.random_sample(size) agn_sfz = rng.random_sample(size) agn_sfy = rng.random_sample(size) rrStar = rng.random_sample(size) * np.radians(radius) thetaStar = rng.random_sample(size) * 2.0 * np.pi if deltaRA is None: raStar = centerRA + rrStar * np.cos(thetaStar) else: raStar = centerRA + np.radians(deltaRA) if deltaDec is None: decStar = centerDec + rrStar * np.sin(thetaStar) else: decStar = centerDec + np.radians(deltaDec) raStar = np.degrees(raStar) decStar = np.degrees(decStar) magnormStar = rng.random_sample(size) * delta_magnorm + magnorm_min mudecl = rng.random_sample(size) * 0.0001 mura = rng.random_sample(size) * 0.0001 galacticAv = rng.random_sample(size) * 0.05 * 3.1 vrad = rng.random_sample(size) * 1.0 parallax = 0.00045 + rng.random_sample(size) * 0.00001 period = rng.random_sample(size) * 20.0 amp = rng.random_sample(size) * 5.0 # write the data to the tables. for i in range(size): cmd = '''INSERT INTO galaxy_bulge VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', %f, %f, %f, %i, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, bra[i], bdec[i], ra[i], dec[i], magnorm_bulge[i], galaxy_seds[i%len(galaxy_seds)], a_b[i], b_b[i], pa_bulge[i], 4, 'CCM', av_b[i], rv_b[i], u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i]) c.execute(cmd) varParam = { 'varMethodName': 'applyAgn', 'pars': { 'agn_tau': round(agn_tau[i], 4), 't0_mjd': round(t0_mjd[i], 4), 'agn_sfu': round(agn_sfu[i], 4), 'agn_sfg': round(agn_sfg[i], 4), 'agn_sfr': round(agn_sfr[i], 4), 'agn_sfi': round(agn_sfi[i], 4), 'agn_sfz': round(agn_sfz[i], 4), 'agn_sfy': round(agn_sfy[i], 4), 'seed': int(agnSeed[i]) } } paramStr = json.dumps(varParam) cmd = '''INSERT INTO galaxy VALUES (%i, %i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', '%s', '%s', %f, %f, %f, %i, %f, %f, %f, %i, '%s', %f, %f, '%s', %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, ra[i], dec[i], bra[i], bdec[i], dra[i], ddec[i], agnra[i], agndec[i], magnorm_bulge[i], magnorm_disk[i], magnorm_agn[i], galaxy_seds[i%len(galaxy_seds)], galaxy_seds[i%len(galaxy_seds)], agn_sed, paramStr, a_b[i], b_b[i], pa_bulge[i], 4, a_d[i], b_d[i], pa_disk[i], 1, 'CCM', av_b[i], rv_b[i], 'CCM', av_d[i], rv_d[i], u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i], BulgeHalfLightRadius[i], DiskHalfLightRadius[i]) c.execute(cmd) cmd = '''INSERT INTO galaxy_agn VALUES (%i, %i, %f, %f, %f, %f, %f, '%s', '%s', %f, %f, %f, %f, %f, %f, %f)''' % \ (i, i, agnra[i], agndec[i], ra[i], dec[i], magnorm_agn[i], agn_sed, paramStr, u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i]) c.execute(cmd) varParam = { 'varMethodName': 'testVar', 'pars': { 'period': period[i], 'amplitude': amp[i] } } paramStr = json.dumps(varParam) cmd = '''INSERT INTO StarAllForceseek VALUES (%i, %f, %f, %f, %f, %f, %f, %f, '%s', '%s', %f, %f)''' %\ (i, raStar[i], decStar[i], magnormStar[i], mudecl[i], mura[i], galacticAv[i], vrad[i], paramStr, star_seds[i%len(star_seds)], parallax[i], galacticAv[i]/3.1) c.execute(cmd) conn.commit() conn.close() return obs_metadata
def createTestSNDB(): """ Create a CatalogDBObject-like database that contains everything needed to create a supernova catalog. Return the CatalogDBObject and an ObservationMetaData pointing to its center. Note: the OpsimMetaData for the returned ObservationMetaData will be inconsistent. It is just there so that PhoSim InstanceCatalog classes can write out a header. """ raCenter = 23.0 decCenter = -19.0 radius = 0.1 obs = ObservationMetaData(pointingRA=raCenter, pointingDec=decCenter, boundType='circle', boundLength=radius, rotSkyPos=33.0, mjd=59580.0, bandpassName='r') # these will be totally inconsistent; just need something to put in the header obs.OpsimMetaData = { 'dist2Moon': 0.1, 'moonalt': -0.2, 'moonra': 1.1, 'moondec': 0.5, 'rottelpos': 0.4, 'sunalt': -1.1 } rng = np.random.RandomState(88) n_obj = 10 rr = rng.random_sample(n_obj) * radius theta = rng.random_sample(n_obj) * 2.0 * np.pi ra_list = raCenter + rr * np.cos(theta) dec_list = decCenter + rr * np.sin(theta) t0_list = 0.5 * rng.random_sample(n_obj) x0_list = rng.random_sample(n_obj) * 1.0e-4 x1_list = rng.random_sample(n_obj) c_list = rng.random_sample(n_obj) * 2.0 z_list = rng.random_sample(n_obj) * 1.1 + 0.1 txt_file_name = tempfile.mktemp(dir=ROOT, prefix='test_phosim_sn_source', suffix='.txt') dtype = np.dtype([('id', int), ('snra', float), ('sndec', float), ('t0', float), ('x0', float), ('x1', float), ('c', float), ('redshift', float), ('galtileid', int)]) with open(txt_file_name, 'w') as output_file: for ix, (ra, dec, t0, x0, x1, c, z) in enumerate( zip(ra_list, dec_list, t0_list, x0_list, x1_list, c_list, z_list)): output_file.write('%d %e %e %e %e %e %e %e %d\n' % (ix, ra, dec, t0, x0, x1, c, z, ix)) class testSNDBObj(SNDBObj, fileDBObject): tableid = 'test' def query_columns(self, *args, **kwargs): return fileDBObject.query_columns(self, *args, **kwargs) dbobj = testSNDBObj(txt_file_name, runtable='test', dtype=dtype) if os.path.exists(txt_file_name): os.unlink(txt_file_name) return dbobj, obs
def ObservationMetaDataFromPointing(self, OpSimPointingRecord, OpSimColumns=None, boundLength=1.75, boundType='circle'): """ Return instance of ObservationMetaData for an OpSim Pointing record from OpSim. Parameters ---------- OpSimPointingRecord : Dictionary, mandatory Dictionary of values with keys corresponding to certain columns of the Summary table in the OpSim database. The minimal list of keys required for catsim to work is 'fiveSigmaDepth', 'filtSkyBrightness', and at least one of ('finSeeing', 'FWHMeff'). More keys defined in columnMap may be necessary for PhoSim to work. OpSimColumns : tuple of strings, optional, defaults to None The columns corresponding to the OpSim records. If None, attempts to obtain these from the OpSimRecord as OpSimRecord.dtype.names boundType : {'circle', 'box'}, optional, defaults to 'circle' Shape of the observation boundLength : scalar float, optional, defaults to 1.75 'characteristic size' of observation field, in units of degrees. For boundType='circle', this is a radius, for boundType='box', this is a size of the box """ pointing = OpSimPointingRecord pointing_column_names = pointing.dtype.names # Decide what is the name of the column in the OpSim database # corresponding to the Seeing. For older OpSim outputs, this is # 'finSeeing'. For later OpSim outputs this is 'FWHMeff' if OpSimColumns is None: OpSimColumns = pointing_column_names self._set_seeing_column(OpSimColumns) # get the names of the columns that contain the minimal schema # for an ObservationMetaData mjd_name = self.user_interface_to_opsim['expMJD'][0] ra_name = self.user_interface_to_opsim['fieldRA'][0] dec_name = self.user_interface_to_opsim['fieldDec'][0] filter_name = self.user_interface_to_opsim['telescopeFilter'][0] # check to see if angles are in degrees or radians if self.user_interface_to_opsim['fieldRA'][1] is None: in_degrees = True else: in_degrees = False # check to make sure the OpSim pointings being supplied contain # the minimum required information for required_column in (ra_name, dec_name, mjd_name, filter_name): if required_column not in OpSimColumns: raise RuntimeError( "ObservationMetaDataGenerator requires that the database of " "pointings include data for:\nfieldRA" "\nfieldDec\nexpMJD\nfilter") # construct a raw dict of all of the OpSim columns associated with this pointing raw_dict = dict([(col, pointing[col]) for col in pointing_column_names]) raw_dict['opsim_version'] = self.opsim_version if in_degrees: ra_val = pointing[ra_name] dec_val = pointing[dec_name] else: ra_val = np.degrees(pointing[ra_name]) dec_val = np.degrees(pointing[dec_name]) mjd_val = pointing[mjd_name] filter_val = pointing[filter_name] obs = ObservationMetaData(pointingRA=ra_val, pointingDec=dec_val, mjd=mjd_val, bandpassName=filter_val, boundType=boundType, boundLength=boundLength) m5_name = self.user_interface_to_opsim['m5'][0] rotSky_name = self.user_interface_to_opsim['rotSkyPos'][0] if m5_name in pointing_column_names: obs.m5 = pointing[m5_name] if 'filtSkyBrightness' in pointing_column_names: obs.skyBrightness = pointing['filtSkyBrightness'] if self._seeing_column in pointing_column_names: obs.seeing = pointing[self._seeing_column] if rotSky_name in pointing_column_names: if in_degrees: obs.rotSkyPos = pointing[rotSky_name] else: obs.rotSkyPos = np.degrees(pointing[rotSky_name]) obs.OpsimMetaData = raw_dict return obs
def ObservationMetaDataFromPointing(self, OpSimPointingRecord, OpSimColumns=None, boundLength=1.75, boundType='circle'): """ Return instance of ObservationMetaData for an OpSim Pointing record from OpSim. Parameters ---------- OpSimPointingRecord : Dictionary, mandatory Dictionary of values with keys corresponding to certain columns of the Summary table in the OpSim database. The minimal list of keys required for catsim to work is 'fiveSigmaDepth', 'filtSkyBrightness', and at least one of ('finSeeing', 'FWHMeff'). More keys defined in columnMap may be necessary for PhoSim to work. OpSimColumns : tuple of strings, optional, defaults to None The columns corresponding to the OpSim records. If None, attempts to obtain these from the OpSimRecord as OpSimRecord.dtype.names boundType : {'circle', 'box'}, optional, defaults to 'circle' Shape of the observation boundLength : scalar float, optional, defaults to 1.75 'characteristic size' of observation field, in units of degrees. For boundType='circle', this is a radius, for boundType='box', this is a size of the box """ pointing = OpSimPointingRecord pointing_column_names = pointing.dtype.names # Decide what is the name of the column in the OpSim database # corresponding to the Seeing. For older OpSim outputs, this is # 'finSeeing'. For later OpSim outputs this is 'FWHMeff' if OpSimColumns is None: OpSimColumns = pointing_column_names self._set_seeing_column(OpSimColumns) # get the names of the columns that contain the minimal schema # for an ObservationMetaData mjd_name = self.user_interface_to_opsim['expMJD'][0] ra_name = self.user_interface_to_opsim['fieldRA'][0] dec_name = self.user_interface_to_opsim['fieldDec'][0] filter_name = self.user_interface_to_opsim['telescopeFilter'][0] # check to see if angles are in degrees or radians if self.user_interface_to_opsim['fieldRA'][1] is None: in_degrees = True else: in_degrees = False # check to make sure the OpSim pointings being supplied contain # the minimum required information for required_column in (ra_name, dec_name, mjd_name, filter_name): if required_column not in OpSimColumns: raise RuntimeError("ObservationMetaDataGenerator requires that the database of " "pointings include data for:\nfieldRA" "\nfieldDec\nexpMJD\nfilter") # construct a raw dict of all of the OpSim columns associated with this pointing raw_dict = dict([(col, pointing[col]) for col in pointing_column_names]) raw_dict['opsim_version'] = self.opsim_version if in_degrees: ra_val = pointing[ra_name] dec_val = pointing[dec_name] else: ra_val = np.degrees(pointing[ra_name]) dec_val = np.degrees(pointing[dec_name]) mjd_val = pointing[mjd_name] filter_val = pointing[filter_name] obs = ObservationMetaData(pointingRA=ra_val, pointingDec=dec_val, mjd=mjd_val, bandpassName=filter_val, boundType=boundType, boundLength=boundLength) m5_name = self.user_interface_to_opsim['m5'][0] rotSky_name = self.user_interface_to_opsim['rotSkyPos'][0] if m5_name in pointing_column_names: obs.m5 = pointing[m5_name] if 'filtSkyBrightness' in pointing_column_names: obs.skyBrightness = pointing['filtSkyBrightness'] if self._seeing_column in pointing_column_names: obs.seeing = pointing[self._seeing_column] if rotSky_name in pointing_column_names: if in_degrees: obs.rotSkyPos = pointing[rotSky_name] else: obs.rotSkyPos = np.degrees(pointing[rotSky_name]) obs.OpsimMetaData = raw_dict return obs
mjd_good.append(mjd) if len(mjd_good) > 20: break rot_sky_pos = rng.random_sample(len(mjd_good)) * 360.0 for i_mjd, mjd in enumerate(mjd_good): for i_filter in range(6): for all_same in (True, False): obs = ObservationMetaData(pointingRA=obs_root.pointingRA, pointingDec=obs_root.pointingDec, rotSkyPos=rot_sky_pos[i_mjd], mjd=mjd_good[i_mjd], site=obs_root.site, bandpassName='ugrizy'[i_filter]) obs.OpsimMetaData = opsim_meta_data obs.OpsimMetaData['rawSeeing'] = rng.random_sample() * 0.15 + 0.6 if all_same: out_name = os.path.join( out_dir, 'instcat_%d_%d_same_sed.txt' % (i_mjd, i_filter)) else: out_name = os.path.join( out_dir, 'instcat_%d_%d_diff_sed.txt' % (i_mjd, i_filter)) ref_name = os.path.join(out_dir, 'phosim_ref_cat.txt') if not ref_made: ref_handle = open(ref_name, 'w') if all_same:
def testFitsHeader(self): """ Create a test image with the LSST camera and with the cartoon camera. Verify that the image created with the LSST camera has the DM-required cards in its FITS header while the image created with the cartoon camera does not """ cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData') cartoonCamera = ReturnCamera(cameraDir) outputDir = tempfile.mkdtemp(dir=ROOT, prefix='testFitsHeader-') lsst_cat_name = os.path.join(outputDir, 'fits_test_lsst_cat.txt') lsst_cat_root = os.path.join(outputDir, 'fits_test_lsst_image') cartoon_cat_name = os.path.join(outputDir, 'fits_test_cartoon_cat.txt') cartoon_cat_root = os.path.join(outputDir, 'fits_test_cartoon_image') obs = ObservationMetaData(pointingRA=32.0, pointingDec=22.0, boundLength=0.1, boundType='circle', mjd=58000.0, rotSkyPos=14.0, bandpassName='u') obs.OpsimMetaData = {'obshistID': 112} dbFileName = os.path.join(outputDir, 'fits_test_db.dat') create_text_catalog(obs, dbFileName, np.array([30.0]), np.array([30.0]), [22.0]) db = fitsHeaderFileDBObj(dbFileName, runtable='test') # first test the lsst camera lsstCat = fitsHeaderCatalog(db, obs_metadata=obs) lsstCat.camera_wrapper = LSSTCameraWrapper() lsstCat.PSF = SNRdocumentPSF() lsstCat.write_catalog(lsst_cat_name) lsstCat.write_images(nameRoot=lsst_cat_root) list_of_files = os.listdir(outputDir) ct = 0 for file_name in list_of_files: true_name = os.path.join(outputDir, file_name) if lsst_cat_root in true_name: ct += 1 with fits.open(true_name) as fitsTest: header = fitsTest[0].header self.assertIn('CHIPID', header) self.assertIn('OBSID', header) self.assertIn('OUTFILE', header) self.assertEqual(header['OBSID'], 112) self.assertEqual(header['CHIPID'], 'R22_S11') self.assertEqual(header['OUTFILE'], 'lsst_e_112_f0_R22_S11_E000') os.unlink(true_name) self.assertGreater(ct, 0) if os.path.exists(lsst_cat_name): os.unlink(lsst_cat_name) # now test with the cartoon camera cartoonCat = fitsHeaderCatalog(db, obs_metadata=obs) cartoonCat.camera_wrapper = GalSimCameraWrapper(cartoonCamera) cartoonCat.PSF = SNRdocumentPSF() cartoonCat.write_catalog(cartoon_cat_name) cartoonCat.write_images(nameRoot=cartoon_cat_root) list_of_files = os.listdir(outputDir) ct = 0 for file_name in list_of_files: true_name = os.path.join(outputDir, file_name) if cartoon_cat_root in true_name: ct += 1 with fits.open(true_name) as fitsTest: header = fitsTest[0].header self.assertNotIn('CHIPID', header) self.assertNotIn('OBSID', header) self.assertNotIn('OUTFILE', header) os.unlink(true_name) self.assertGreater(ct, 0) if os.path.exists(cartoon_cat_name): os.unlink(cartoon_cat_name) if os.path.exists(dbFileName): os.unlink(dbFileName) if os.path.exists(outputDir): shutil.rmtree(outputDir)