class CepheidStarObj(StarBase): objid = 'cepheidstars' tableid = 'StarCepheid' objectTypeId = 10 doRunTest = True testObservationMetaData = ObservationMetaData(mjd=52000., bandpassName='r', m5=22.0) #These types should be matched to the database. #: Default map is float. If the column mapping is the same as the column name, None can be specified columns = [('id','simobjid', int), ('raJ2000', 'ra*PI()/180.'), ('decJ2000', 'decl*PI()/180.'), ('glon', 'gal_l*PI()/180.'), ('glat', 'gal_b*PI()/180.'), ('magNorm', '(-2.5*log(flux_scale)/log(10.)) - 18.402732642'), ('properMotionRa', '(mura/(1000.*3600.))*PI()/180.'), ('properMotionDec', '(mudecl/(1000.*3600.))*PI()/180.'), ('parallax', 'parallax*PI()/648000000.'), ('galacticAv', 'CONVERT(float, ebv*3.1)'), ('radialVelocity', 'vrad'), ('variabilityParameters', 'varParamStr', str, 256), ('sedFilename', 'sedfilename', str, 40)]
def testDefault(self): """ Test that ObservationMetaData's default variables are properly set """ testObsMD = ObservationMetaData() self.assertEqual(testObsMD.pointingRA, None) self.assertEqual(testObsMD.pointingDec, None) self.assertEqual(testObsMD.rotSkyPos, None) self.assertEqual(testObsMD.bandpass, None) self.assertEqual(testObsMD.m5, None) self.assertEqual(testObsMD.seeing, None) self.assertAlmostEqual(testObsMD.site.longitude, -70.7494, 10) self.assertAlmostEqual(testObsMD.site.latitude, -30.2444, 10) self.assertAlmostEqual(testObsMD.site.height, 2650, 10) self.assertAlmostEqual(testObsMD.site.temperature_kelvin, 284.65, 10) self.assertAlmostEqual(testObsMD.site.temperature, 11.5, 10) self.assertAlmostEqual(testObsMD.site.pressure, 750.0, 10) self.assertAlmostEqual(testObsMD.site.humidity, 0.4, 10) self.assertAlmostEqual(testObsMD.site.lapseRate, 0.0065, 10)
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 test_chip_name_from_pupil_coords(self): """ Test that chipNameFromPupilCoordsLSST returns the same results as chipNameFromPupilCoords """ n_pointings = 3 n_obj = 1000 rng = np.random.RandomState(8831) ra_pointing_list = rng.random_sample(n_pointings) * 360.0 dec_pointing_list = rng.random_sample(n_pointings) * 180.0 - 90.0 rot_list = rng.random_sample(n_pointings) * 360.0 mjd_list = rng.random_sample(n_pointings) * 3653 + 59580.0 for ra, dec, rot, mjd in zip(ra_pointing_list, dec_pointing_list, rot_list, mjd_list): obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, rotSkyPos=rot, mjd=mjd) rr_list = rng.random_sample(n_obj) * 1.75 theta_list = rng.random_sample(n_obj) * 2.0 * np.pi ra_list = ra + rr_list * np.cos(theta_list) dec_list = dec + rr_list * np.sin(theta_list) x_pup, y_pup = pupilCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, epoch=2000.0) control_name_list = chipNameFromPupilCoords(x_pup, y_pup, camera=self.camera) test_name_list = chipNameFromPupilCoordsLSST(x_pup, y_pup) np.testing.assert_array_equal(control_name_list.astype(str), test_name_list.astype(str)) # make sure we didn't accidentally get a lot of positions that don't land on chips self.assertLessEqual( len( np.where( np.char.rfind(test_name_list.astype(str), 'None') >= 0) [0]), n_obj / 10)
def testObservedRaDec(self): """ Test that the mixins provided in Astrometry SSM really do convert ICRS RA, Dec into observed RA, Dec """ dtype = np.dtype([('id', np.int), ('raObserved', np.float), ('decObserved', np.float)]) controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) rng = np.random.RandomState(42) nTests = 5 raList = rng.random_sample(nTests) * 2.0 * np.pi decList = (rng.random_sample(nTests) - 0.5) * np.pi mjdList = rng.random_sample(nTests) * 5000.0 + 53850.0 for raPointing, decPointing, mjd in zip(raList, decList, mjdList): obs = ObservationMetaData(pointingRA=raPointing, pointingDec=decPointing, mjd=mjd) cat = SSM_astrometryCat(self.astDB, obs_metadata=obs) with lsst.utils.tests.getTempFilePath('.txt') as catName: cat.write_catalog(catName) testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') self.assertGreater(len(testData), 0) raObservedControl, decObservedControl = _observedFromICRS( controlData['raJ2000'], controlData['decJ2000'], obs_metadata=obs, epoch=2000.0, includeRefraction=True) np.testing.assert_array_almost_equal(raObservedControl, testData['raObserved'], 10) np.testing.assert_array_almost_equal(decObservedControl, testData['decObserved'], 10)
def testNaNs(self): """ Test how _pupilCoordsFromRaDec handles improper values """ obs = ObservationMetaData(pointingRA=42.0, pointingDec=-28.0, rotSkyPos=111.0, mjd=42356.0) nSamples = 100 rng = np.random.RandomState(42) raList = np.radians(rng.random_sample(nSamples) * 2.0 + 42.0) decList = np.radians(rng.random_sample(nSamples) * 2.0 - 28.0) xControl, yControl = _pupilCoordsFromRaDec(raList, decList, obs_metadata=obs, epoch=2000.0) raList[5] = np.NaN decList[5] = np.NaN raList[15] = np.NaN decList[20] = np.NaN raList[30] = np.radians(42.0) + np.pi xTest, yTest = _pupilCoordsFromRaDec(raList, decList, obs_metadata=obs, epoch=2000.0) for ix, (xc, yc, xt, yt) in \ enumerate(zip(xControl, yControl, xTest, yTest)): if ix != 5 and ix != 15 and ix != 20 and ix != 30: self.assertAlmostEqual(xc, xt, 10) self.assertAlmostEqual(yc, yt, 10) self.assertFalse(np.isnan(xt)) self.assertFalse(np.isnan(yt)) else: np.testing.assert_equal(xt, np.NaN) np.testing.assert_equal(yt, np.NaN)
def testNoHeaderMap(self): """ Test that the correct error is raised if no header map is specified """ testBulge = PhoSimCatalogSersic2D(self.bulgeDB, obs_metadata=self.obs_metadata) with self.assertRaises(RuntimeError) as context: with lsst.utils.tests.getTempFilePath('.txt') as catName: testBulge.write_catalog(catName) self.assertIn("without specifying a phoSimHeaderMap", context.exception.args[0]) if os.path.exists(catName): os.unlink(catName) # now make sure that the exception is raised, even if ObservationMetaData # does not have an OpsimMetaData obs = ObservationMetaData(pointingRA=35.0, pointingDec=-23.0, mjd=43900.0, rotSkyPos=22.0, boundType='circle', boundLength=1.75) testBulge = PhoSimCatalogSersic2D(self.bulgeDB, obs_metadata=obs) with self.assertRaises(RuntimeError) as context: with lsst.utils.tests.getTempFilePath('.txt') as catName: testBulge.write_catalog(catName) if os.path.exists(catName): os.unlink(catName) self.assertIn("without specifying a phoSimHeaderMap", context.exception.args[0]) self.assertIn( "you may wish to consider adding default PhoSim parameters", context.exception.args[0])
def test_against_catalog(self): """ Compare deprecession results to a catalog that was validated with PhoSim. """ obs = ObservationMetaData(pointingRA=53.00913847303155535, pointingDec=-27.43894880881512321, rotSkyPos=256.75075318193080420, mjd=59580.13955500000156462, site=Site(name="LSST", pressure=0.0, humidity=0.0)) dtype = np.dtype([('id', int), ('ra', float), ('dec', float), ('ra_deprecessed', float), ('dec_deprecessed', float), ('x_dm', float), ('y_dm', float), ('x_focal', float), ('y_focal', float), ('x_cam', float), ('y_cam', float)]) data = np.genfromtxt(os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData', 'pixel_prediction_catalog.txt'), dtype=dtype) ra_obs, dec_obs = observedFromICRS(data['ra'], data['dec'], obs_metadata=obs, includeRefraction=False, epoch=2000.0) phosim_mixin = PhoSimAstrometryBase() ra_dep, dec_dep = phosim_mixin._dePrecess(np.radians(ra_obs), np.radians(dec_obs), obs) dd = 3600.0 * angularSeparation( data['ra_deprecessed'], data['dec_deprecessed'], np.degrees(ra_dep), np.degrees(dec_dep)) self.assertLess(dd.max(), 1.0e-5)
def setUpClass(cls): """ """ cls.obsMetaDataforCat = ObservationMetaData(boundType='circle', boundLength=np.degrees( 0.25), pointingRA=np.degrees( 0.13), pointingDec=np.degrees(-1.2), bandpassName=['r'], mjd=49350.) ObsMetaData = cls.obsMetaDataforCat cls.samples = spatiallySample_obsmetadata(ObsMetaData, size=1000) cls.theta_c = -60. cls.phi_c = 30. cls.delta = 30. cls.size = 1000000 cls.dense_samples = samplePatchOnSphere(phi=cls.phi_c, theta=cls.theta_c, delta=cls.delta, size=cls.size, seed=42)
def testAgn(self): """ Just verify that the catalog generation code runs in this case """ cat_name = os.path.join(self.scratch_dir, 'agnTestCatalog.dat') makeAgnTable(database=self.variability_db) myDB = CatalogDBObject.from_objid('agnTest', database=self.variability_db) obs = ObservationMetaData(pointingRA=self.obs_metadata.pointingRA, pointingDec=self.obs_metadata.pointingDec, boundType=self.obs_metadata.boundType, boundLength=self.obs_metadata.boundLength, mjd=60000.0) myCatalog = GalaxyVariabilityCatalog(myDB, obs_metadata=obs) myCatalog.write_catalog(cat_name, chunk_size=1000) with open(cat_name,'r') as input_file: lines = input_file.readlines() self.assertGreater(len(lines), 10) if os.path.exists(cat_name): os.unlink(cat_name)
def testGetRotSkyPos(self): rotTelList = self.rng.random_sample(len(self.raList)) * 2.0 * np.pi mjd = 56321.8 obsTemp = ObservationMetaData(mjd=mjd, site=Site(longitude=self.lon, latitude=self.lat, name='LSST')) rotSkyRad = utils._getRotSkyPos(self.raList, self.decList, obsTemp, rotTelList) rotSkyDeg = utils.getRotSkyPos(np.degrees(self.raList), np.degrees(self.decList), obsTemp, np.degrees(rotTelList)) np.testing.assert_array_almost_equal(rotSkyRad, np.radians(rotSkyDeg), 10) rotSkyRad = utils._getRotSkyPos(self.raList, self.decList, obsTemp, rotTelList[0]) rotSkyDeg = utils.getRotSkyPos(np.degrees(self.raList), np.degrees(self.decList), obsTemp, np.degrees(rotTelList[0])) np.testing.assert_array_almost_equal(rotSkyRad, np.radians(rotSkyDeg), 10) for ra, dec, rotTel in \ zip(self.raList, self.decList, rotTelList): rotSkyRad = utils._getRotSkyPos(ra, dec, obsTemp, rotTel) rotSkyDeg = utils.getRotSkyPos(np.degrees(ra), np.degrees(dec), obsTemp, np.degrees(rotTel)) self.assertAlmostEqual(rotSkyRad, np.radians(rotSkyDeg), 10)
def setUpClass(cls): cls.obs = ObservationMetaData( bandpassName=['u', 'g', 'r', 'i', 'z', 'y'], m5=[24.0, 25.0, 26.0, 27.0, 28.0, 29.0]) dtype = np.dtype([('id', np.int), ('sedFilenameBulge', str, 100), ('magNormBulge', np.float), ('sedFilenameDisk', str, 100), ('magNormDisk', np.float), ('sedFilenameAgn', str, 100), ('magNormAgn', np.float), ('internalAvBulge', np.float), ('internalAvDisk', np.float), ('galacticAv', np.float), ('redshift', np.float)]) inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData') inputFile = os.path.join(inputDir, 'IndicesTestCatalogGalaxies.txt') cls.db = fileDBObject(inputFile, dtype=dtype, runtable='test', idColKey='id') cls.db.objectTypeId = 44 catName = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'scratchSpace', 'galaxyPhotIndicesBaseline.txt') cat = baselineGalaxyCatalog(cls.db, obs_metadata=cls.obs) cat.write_catalog(catName) dtype = np.dtype([(name, np.float) for name in cat.column_outputs]) cls.controlData = np.genfromtxt(catName, dtype=dtype, delimiter=',') if os.path.exists(catName): os.unlink(catName)
def testraDecFromPupilCoords(self): obs = ObservationMetaData(pointingRA=23.5, pointingDec=-115.0, mjd=42351.0, rotSkyPos=127.0) xpList = self.rng.random_sample(100) * 0.25 * np.pi ypList = self.rng.random_sample(100) * 0.25 * np.pi raRad, decRad = utils._raDecFromPupilCoords(xpList, ypList, obs_metadata=obs, epoch=2000.0) raDeg, decDeg = utils.raDecFromPupilCoords(xpList, ypList, obs_metadata=obs, epoch=2000.0) dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) np.testing.assert_array_almost_equal(dRa, np.zeros(len(xpList)), 9) dDec = utils.arcsecFromRadians(decRad - np.radians(decDeg)) np.testing.assert_array_almost_equal(dDec, np.zeros(len(xpList)), 9)
def testradec2altaz(self): np.random.seed(42) ra = np.random.rand(100) * np.pi * 2 dec = np.random.rand(100) * np.pi - np.pi / 2 site = Site('LSST') mjd = 55000 omd = ObservationMetaData(mjd=mjd, site=site) trueAlt, trueAz, pa = _altAzPaFromRaDec(ra, dec, omd) fastAlt, fastAz = sb.stupidFast_RaDec2AltAz(ra, dec, site.latitude_rad, site.longitude_rad, mjd) distanceDiff = haversine(trueAz, trueAlt, fastAz, fastAlt) degreeTol = 2. # 2-degree tolerance on the fast transform assert (np.degrees(distanceDiff.max()) < degreeTol) # make sure we don't have nans alt, az = sb.stupidFast_RaDec2AltAz(np.radians(np.array([0.])), np.radians(np.array([-90.])), np.radians(-30.2444), np.radians(-70.7494), 59582.05125) assert (~np.isnan(alt)) assert (~np.isnan(az))
def testGalaxyPhotometricIndices(self): baselineDtype = np.dtype([('galid', int), ('raObserved', float), ('decObserved', float), ('ctotal_u', float), ('ctotal_g', float), ('ctotal_r', float), ('ctotal_i', float), ('ctotal_z', float)]) obs_metadata_pointed = ObservationMetaData(mjd=50000.0, boundType='circle', pointingRA=0.0, pointingDec=0.0, boundLength=10.0) baseline_cat = cartoonGalaxies(self.galaxy, obs_metadata=obs_metadata_pointed) with lsst.utils.tests.getTempFilePath('.txt') as baselineCatName: baseline_cat.write_catalog(baselineCatName) baselineData = np.genfromtxt(baselineCatName, dtype=baselineDtype, delimiter=',') self.assertGreater(len(baselineData), 0) testDtype = np.dtype([('galid', int), ('raObserved', float), ('decObserved', float), ('ctotal_i', float), ('ctotal_g', float)]) test_cat = cartoonGalaxiesIG(self.galaxy, obs_metadata=obs_metadata_pointed) with lsst.utils.tests.getTempFilePath('.txt') as testCatName: test_cat.write_catalog(testCatName) testData = np.genfromtxt(testCatName, dtype=testDtype, delimiter=',') self.assertGreater(len(testData), 0) for b, t in zip(baselineData, testData): self.assertAlmostEqual(b['ctotal_i'], t['ctotal_i'], 10) self.assertAlmostEqual(b['ctotal_g'], t['ctotal_g'], 10)
def testAltAzPaFromRaDec(self): mjd = 57432.7 obs = ObservationMetaData(mjd=mjd, site=Site(longitude=self.lon, latitude=self.lat, name='LSST')) altRad, azRad, paRad = utils._altAzPaFromRaDec(self.raList, self.decList, obs) altDeg, azDeg, paDeg = utils.altAzPaFromRaDec(np.degrees(self.raList), np.degrees(self.decList), obs) np.testing.assert_array_almost_equal(altRad, np.radians(altDeg), 10) np.testing.assert_array_almost_equal(azRad, np.radians(azDeg), 10) np.testing.assert_array_almost_equal(paRad, np.radians(paDeg), 10) altRad, azRad, paRad = utils._altAzPaFromRaDec(self.raList, self.decList, obs) altDeg, azDeg, paDeg = utils.altAzPaFromRaDec(np.degrees(self.raList), np.degrees(self.decList), obs) np.testing.assert_array_almost_equal(altRad, np.radians(altDeg), 10) np.testing.assert_array_almost_equal(azRad, np.radians(azDeg), 10) np.testing.assert_array_almost_equal(paRad, np.radians(paDeg), 10) for ra, dec, in zip(self.raList, self.decList): altRad, azRad, paRad = utils._altAzPaFromRaDec(ra, dec, obs) altDeg, azDeg, paDeg = utils.altAzPaFromRaDec( np.degrees(ra), np.degrees(dec), obs) self.assertAlmostEqual(altRad, np.radians(altDeg), 10) self.assertAlmostEqual(azRad, np.radians(azDeg), 10) self.assertAlmostEqual(paRad, np.radians(paDeg), 10)
def testBoxBounds(self): """Test Sql Server rectangular search region (ra/dec cuts). exepectedFailure used despite expectation of success because test depends on a network connection. """ column_outputs = ['raJ2000', 'decJ2000'] for objname, objcls in CatalogDBObject.registry.items(): if (not objcls.doRunTest or (objcls.testObservationMetaData is None) or (objcls.testObservationMetaData.bounds is None) or (objcls.testObservationMetaData.bounds.boundType != 'circle')): continue print("Running tests for", objname) circ_bounds = objcls.testObservationMetaData.bounds length = numpy.degrees(circ_bounds.radius) raCenter = numpy.degrees(circ_bounds.RA)+length decCenter = numpy.degrees(circ_bounds.DEC)+length obs_metadata = ObservationMetaData(boundType='box', pointingRA=raCenter, pointingDec=decCenter, boundLength=length, mjd=51000., bandpassName='i') dbobj = objcls(verbose=False) result = dbobj.query_columns(column_outputs, obs_metadata=obs_metadata) # testObservationMetadata gives few enough results for one chunk try: result = next(result) except StopIteration: raise RuntimeError("No results for %s."%(objname)) self.assertLess(max(result['raJ2000']), numpy.radians(raCenter+length)) self.assertGreater(min(result['raJ2000']), numpy.radians(raCenter-length)) self.assertLess(max(result['decJ2000']), numpy.radians(decCenter+length)) self.assertGreater(max(result['decJ2000']), numpy.radians(decCenter-length))
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 testRaDecVector(self): """ Test that raDecFromNativeLonLat does invert nativeLonLatFromRaDec (make sure it works in a vectorized way) """ rng = np.random.RandomState(42) nSamples = 100 latList = rng.random_sample(nSamples) * 360.0 lonList = rng.random_sample(nSamples) * 180.0 - 90.0 raPoint = 95.0 decPoint = 75.0 obs = ObservationMetaData(pointingRA=raPoint, pointingDec=decPoint, mjd=53467.89) raList, decList = raDecFromNativeLonLat(lonList, latList, obs) for lon, lat, ra0, dec0 in zip(lonList, latList, raList, decList): ra1, dec1 = raDecFromNativeLonLat(lon, lat, obs) distance = arcsecFromRadians( haversine(np.radians(ra0), np.radians(dec0), np.radians(ra1), np.radians(dec1))) self.assertLess(distance, 0.1)
def __init__(self): """Initialization of sky simulator class.""" # Star ID self.starId = np.array([], dtype=int) # Star RA self.ra = np.array([]) # Star Decl self.decl = np.array([]) # Star magnitude self.mag = np.array([]) # DM camera object contains the information to do the coordinate # transformation self._camera = LsstSimMapper().camera # SIMS observation metadata object self._obs = ObservationMetaData() # Source processor in ts_wep self._sourProc = SourceProcessor()
wavelengthInNm = 500 mjdTime = 59580.0 # Generate the camera object camera = LsstSimMapper().camera # Set the ObservationMetaData RA = 0 Dec = 0 # The unit of camera rotation angle is in degree cameraRotation = 0 cameraMJD = 59580.0 obs = ObservationMetaData(pointingRA=RA, pointingDec=Dec, rotSkyPos=cameraRotation, mjd=mjdTime) # Instantiate the subsystems phoSimCommu = PhosimCommu() skySim = SkySim() # Instantiate the telescope tele = TeleFacade(phoSimCommu=phoSimCommu) # Set the subsystem directory tele.setSubSysConfigFile(phosimDir=phosimDir) # Update the telescope degree of freedom # dofInUm = np.zeros(50)
def testNonsenseCircularConstraints(self): """ Test that a query performed on a circle bound gets all of the objects (and only all of the objects) within that circle """ radius = 20.0 raCenter = 210.0 decCenter = -60.0 mycolumns = ['NonsenseId', 'NonsenseRaJ2000', 'NonsenseDecJ2000', 'NonsenseMag'] circObsMd = ObservationMetaData(boundType='circle', pointingRA=raCenter, pointingDec=decCenter, boundLength=radius, mjd=52000., bandpassName='r') circQuery = self.myNonsense.query_columns(colnames = mycolumns, obs_metadata=circObsMd, chunk_size=100) raCenter = numpy.radians(raCenter) decCenter = numpy.radians(decCenter) radius = numpy.radians(radius) goodPoints = [] ct = 0 for chunk in circQuery: for row in chunk: ct += 1 distance = haversine(raCenter, decCenter, row[1], row[2]) self.assertLess(distance, radius) dex = numpy.where(self.baselineData['id'] == row[0])[0][0] #store a list of which objects fell within our circle bound goodPoints.append(row[0]) self.assertAlmostEqual(numpy.radians(self.baselineData['ra'][dex]), row[1], 3) self.assertAlmostEqual(numpy.radians(self.baselineData['dec'][dex]), row[2], 3) self.assertAlmostEqual(self.baselineData['mag'][dex], row[3], 3) self.assertGreater(ct, 0) ct = 0 for entry in [xx for xx in self.baselineData if xx[0] not in goodPoints]: #make sure that all of the points not returned by the query were, in fact, outside of #the circle bound distance = haversine(raCenter, decCenter, numpy.radians(entry[1]), numpy.radians(entry[2])) self.assertGreater(distance, radius) ct += 1 self.assertGreater(ct, 0) #make sure that the CatalogDBObject which used a header gets the same result headerQuery = self.myNonsenseHeader.query_columns(colnames = mycolumns, obs_metadata=circObsMd, chunk_size=100) goodPointsHeader = [] for chunk in headerQuery: for row in chunk: distance = haversine(raCenter, decCenter, row[1], row[2]) dex = numpy.where(self.baselineData['id'] == row[0])[0][0] goodPointsHeader.append(row[0]) self.assertAlmostEqual(numpy.radians(self.baselineData['ra'][dex]), row[1], 3) self.assertAlmostEqual(numpy.radians(self.baselineData['dec'][dex]), row[2], 3) self.assertAlmostEqual(self.baselineData['mag'][dex], row[3], 3) self.assertEqual(len(goodPoints), len(goodPointsHeader)) for xx in goodPoints: self.assertIn(xx, goodPointsHeader)
def testNonsenseArbitraryConstraints_passConnection(self): """ Test a query with a user-specified constraint on the magnitude column Pass connection directly in to the constructor. """ myNonsense_base = CatalogDBObject.from_objid('Nonsense') myNonsense = myNonsenseDB_noConnection(connection=myNonsense_base.connection) raMin = 50.0 raMax = 150.0 decMax = 30.0 decMin = -20.0 raCenter=0.5*(raMin+raMax) decCenter=0.5*(decMin+decMax) mycolumns = ['NonsenseId', 'NonsenseRaJ2000', 'NonsenseDecJ2000', 'NonsenseMag'] boxObsMd = ObservationMetaData(boundType='box', pointingRA=raCenter, pointingDec=decCenter, boundLength=numpy.array([0.5*(raMax-raMin), 0.5*(decMax-decMin)]), mjd=52000., bandpassName='r') boxQuery = myNonsense.query_columns(colnames = mycolumns, obs_metadata=boxObsMd, chunk_size=100, constraint = 'mag > 11.0') raMin = numpy.radians(raMin) raMax = numpy.radians(raMax) decMin = numpy.radians(decMin) decMax = numpy.radians(decMax) goodPoints = [] ct = 0 for chunk in boxQuery: for row in chunk: ct += 1 self.assertLess(row[1], raMax) self.assertGreater(row[1], raMin) self.assertLess(row[2], decMax) self.assertGreater(row[2], decMin) self.assertGreater(row[3], 11.0) dex = numpy.where(self.baselineData['id'] == row[0])[0][0] #keep a list of the points returned by the query goodPoints.append(row[0]) self.assertAlmostEqual(numpy.radians(self.baselineData['ra'][dex]), row[1], 3) self.assertAlmostEqual(numpy.radians(self.baselineData['dec'][dex]), row[2], 3) self.assertAlmostEqual(self.baselineData['mag'][dex], row[3], 3) self.assertGreater(ct, 0) ct = 0 for entry in [xx for xx in self.baselineData if xx[0] not in goodPoints]: #make sure that the points not returned by the query did, in fact, violate one of the #constraints of the query (either the box bound or the magnitude cut off) switch = (entry[1] > raMax or entry[1] < raMin or entry[2] >decMax or entry[2] < decMin or entry[3]<11.0) self.assertTrue(switch) ct += 1 self.assertGreater(ct, 0)
def testNonsenseBoxConstraints_passConnection(self): """ Test that a query performed on a box bound gets all of the points (and only all of the points) inside that box bound. Pass connection directly in to the constructor. """ myNonsense_base = CatalogDBObject.from_objid('Nonsense') myNonsense = myNonsenseDB_noConnection(connection=myNonsense_base.connection) raMin = 50.0 raMax = 150.0 decMax = 30.0 decMin = -20.0 raCenter = 0.5*(raMin+raMax) decCenter = 0.5*(decMin+decMax) mycolumns = ['NonsenseId', 'NonsenseRaJ2000', 'NonsenseDecJ2000', 'NonsenseMag'] boxObsMd = ObservationMetaData(boundType='box', pointingDec=decCenter, pointingRA=raCenter, boundLength=numpy.array([0.5*(raMax-raMin), 0.5*(decMax-decMin)]), mjd=52000., bandpassName='r') boxQuery = myNonsense.query_columns(obs_metadata=boxObsMd, chunk_size=100, colnames=mycolumns) raMin = numpy.radians(raMin) raMax = numpy.radians(raMax) decMin = numpy.radians(decMin) decMax = numpy.radians(decMax) goodPoints = [] ct = 0 for chunk in boxQuery: for row in chunk: ct += 1 self.assertLess(row[1], raMax) self.assertGreater(row[1], raMin) self.assertLess(row[2], decMax) self.assertGreater(row[2], decMin) dex = numpy.where(self.baselineData['id'] == row[0])[0][0] #keep a list of which points were returned by teh query goodPoints.append(row[0]) self.assertAlmostEqual(numpy.radians(self.baselineData['ra'][dex]), row[1], 3) self.assertAlmostEqual(numpy.radians(self.baselineData['dec'][dex]), row[2], 3) self.assertAlmostEqual(self.baselineData['mag'][dex], row[3], 3) self.assertGreater(ct, 0) ct = 0 for entry in [xx for xx in self.baselineData if xx[0] not in goodPoints]: #make sure that the points not returned by the query are, in fact, outside of the #box bound switch = (entry[1] > raMax or entry[1] < raMin or entry[2] >decMax or entry[2] < decMin) self.assertTrue(switch) ct += 1 self.assertGreater(ct, 0)
self.sdssBandpassDict = BandpassDict.loadTotalBandpassesFromFiles( bandpassNames, bandpassRoot=bandpassRoot, bandpassDir=bandpassDir) # Actually calculate the magnitudes return self._magnitudeGetter(self.sdssBandpassDict, self.get_sdss_magnitudes._colnames) if __name__ == "__main__": obs_metadata_pointed = ObservationMetaData(mjd=2013.23, boundType='circle', pointingRA=200.0, pointingDec=-30.0, boundLength=1.0) obs_metadata_pointed.metadata = {} obs_metadata_pointed.metadata['Opsim_filter'] = 'i' dbObj = CatalogDBObject.from_objid('rrlystars') sdssStars = sdssStars(dbObj, obs_metadata=obs_metadata_pointed) sdssStars.write_catalog("example_sdss_stars.txt") obs_metadata_pointed = ObservationMetaData(mjd=50000.0, boundType='circle', pointingRA=0.0, pointingDec=0.0, boundLength=0.01)
def setRaDecMjd(self, lon, lat, mjd, degrees=False, azAlt=False, solarFlux=130., filterNames=['u', 'g', 'r', 'i', 'z', 'y']): """ Set the sky parameters by computing the sky conditions on a given MJD and sky location. lon: Longitude-like (RA or Azimuth). Can be single number, list, or numpy array lat: Latitude-like (Dec or Altitude) mjd: Modified Julian Date for the calculation. Must be single number. degrees: (False) Assumes lon and lat are radians unless degrees=True azAlt: (False) Assume lon, lat are RA, Dec unless azAlt=True solarFlux: solar flux in SFU Between 50 and 310. Default=130. 1 SFU=10^4 Jy. filterNames: list of fitlers to return magnitudes for (if initialized with mags=True). """ self.filterNames = filterNames if self.mags: self.npix = len(self.filterNames) # Wrap in array just in case single points were passed if np.size(lon) == 1: lon = np.array([lon]).ravel() lat = np.array([lat]).ravel() else: lon = np.array(lon) lat = np.array(lat) if degrees: self.ra = np.radians(lon) self.dec = np.radians(lat) else: self.ra = lon self.dec = lat if np.size(mjd) > 1: raise ValueError('mjd must be single value.') self.mjd = mjd if azAlt: self.azs = self.ra.copy() self.alts = self.dec.copy() if self.preciseAltAz: self.ra, self.dec = _raDecFromAltAz( self.alts, self.azs, ObservationMetaData(mjd=self.mjd, site=self.telescope)) else: self.ra, self.dec = stupidFast_altAz2RaDec( self.alts, self.azs, self.telescope.latitude_rad, self.telescope.longitude_rad, mjd) else: if self.preciseAltAz: self.alts, self.azs, pa = _altAzPaFromRaDec( self.ra, self.dec, ObservationMetaData(mjd=self.mjd, site=self.telescope)) else: self.alts, self.azs = stupidFast_RaDec2AltAz( self.ra, self.dec, self.telescope.latitude_rad, self.telescope.longitude_rad, mjd) self.npts = self.ra.size self._initPoints() self.solarFlux = solarFlux self.points['solarFlux'] = self.solarFlux self._setupPointGrid() self.paramsSet = True # Assume large airmasses are the same as airmass=2.5 to_fudge = np.where((self.points['airmass'] > 2.5) & (self.points['airmass'] < self.airmassLimit)) self.points['airmass'][to_fudge] = 2.499 self.points['alt'][to_fudge] = np.pi / 2 - np.arccos( 1. / self.airmassLimit) # Interpolate the templates to the set paramters self._interpSky()
def testPositionAngle(self): """ Test that GalSim is generating images with the correct position angle by creating a FITS image with one extended source in it. Measure the angle between the semi-major axis of the source and the north axis of the image. Throw an exception if that angle differs from the expected position angle by more than 2 degrees. """ scratchDir = tempfile.mkdtemp(dir=ROOT, prefix='testPositionAngle-') catName = os.path.join(scratchDir, 'pa_test_Catalog.dat') imageRoot = os.path.join(scratchDir, 'pa_test_Image') dbFileName = os.path.join(scratchDir, 'pa_test_InputCatalog.dat') baseDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData') camera = ReturnCamera(baseDir) detector = camera[0] detName = detector.getName() rng = np.random.RandomState(42) paList = rng.random_sample(7) * 360.0 rotSkyPosList = rng.random_sample(77) * 360.0 for pa, rotSkyPos in zip(paList, rotSkyPosList): imageName = '%s_%s_u.fits' % (imageRoot, detName) obs = ObservationMetaData(pointingRA=75.0, pointingDec=-12.0, boundType='circle', boundLength=4.0, rotSkyPos=rotSkyPos, mjd=49250.0) create_text_catalog(obs, dbFileName, rng.random_sample(1) * 20.0 - 10.0, rng.random_sample(1) * 20.0 - 10.0, pa=[pa], mag_norm=[17.0]) db = paFileDBObj(dbFileName, runtable='test') cat = paCat(db, obs_metadata=obs) cat.camera_wrapper = GalSimCameraWrapper(camera) cat.write_catalog(catName) cat.write_images(nameRoot=imageRoot) paTest = self.get_position_angle(imageName, camera, detector, obs, 2000.0) # need to compare against all angles displaced by either 180 or 360 degrees # from expected answer deviation = np.abs( np.array([ pa - paTest, pa - 180.0 - paTest, pa + 180.0 - paTest, pa - 360.0 - paTest, pa + 360.0 - paTest ])).min() self.assertLess(deviation, 3.0) if os.path.exists(catName): os.unlink(catName) if os.path.exists(dbFileName): os.unlink(dbFileName) if os.path.exists(imageName): os.unlink(imageName) if os.path.exists(scratchDir): shutil.rmtree(scratchDir)
def test_pixel_coords_from_ra_dec_degrees(self): """ Test that pixelCoordsFromRaDec and pixelCoordsFromRaDecLSST agree """ raP = 74.2 decP = 13.0 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=13.0, mjd=43441.0) n_obj = 1000 rng = np.random.RandomState(83241) 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) x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera) self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj / 10) self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj / 10) x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) np.testing.assert_array_equal(x_pix, x_pix_test) np.testing.assert_array_equal(y_pix, y_pix_test) # test when we force a chipName x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, chipName=['R:2,2 S:1,1'], obs_metadata=obs, camera=self.camera) self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj / 10) self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj / 10) x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST( ra_list, dec_list, chipName=['R:2,2 S:1,1'], obs_metadata=obs) np.testing.assert_array_equal(x_pix, x_pix_test) np.testing.assert_array_equal(y_pix, y_pix_test) # test without distortion x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera, includeDistortion=False) self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj / 10) self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj / 10) x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST( ra_list, dec_list, obs_metadata=obs, includeDistortion=False) np.testing.assert_array_equal(x_pix, x_pix_test) np.testing.assert_array_equal(y_pix, y_pix_test) # 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: pixelCoordsFromRaDecLSST(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: pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs) self.assertIn("mjd", context.exception.args[0]) with self.assertRaises(RuntimeError) as context: pixelCoordsFromRaDecLSST(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: pixelCoordsFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs) self.assertIn("pixelCoordsFromRaDecLSST", context.exception.args[0])
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 setUpClass(cls): cls.camera = camTestUtils.CameraWrapper().camera cls.dataDir = tempfile.mkdtemp(dir=ROOT, prefix='GalSimPhoSimTest-') cls.n_objects = 5 rng = np.random.RandomState(45) pointingRA = 45.2 pointingDec = -31.6 cls.obs = ObservationMetaData(pointingRA=pointingRA, pointingDec=pointingDec, rotSkyPos=1.2, bandpassName='r', mjd=57341.5, boundLength=0.1, boundType='circle') cls.dtype = np.dtype([ ('id', int), ('raJ2000', np.float), ('decJ2000', np.float), ('ra_deg', np.float), ('dec_deg', np.float), ('sedFilename', (str, 300)), ('magNorm', np.float), ('redshift', np.float), ('majorAxis', np.float), ('minorAxis', np.float), ('positionAngle', np.float), ('halfLightRadius', np.float), ('sindex', np.float), ('internalAv', np.float), ('internalRv', np.float), ('galacticAv', np.float), ('galacticRv', np.float), ('properMotionRa', np.float), ('properMotionDec', np.float), ('radialVelocity', np.float), ('parallax', np.float) ]) # generate some galaxy bulge data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = rng.random_sample(cls.n_objects) * 4.0 + 1.0 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects) * 10.0 + 1.0) positionAngle = rng.random_sample(cls.n_objects) * np.pi internalAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 internalRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 majorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) minorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.bulge_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_bulge.dat') with open(cls.bulge_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f Const.79E06.002Z.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some galaxy disk data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = rng.random_sample(cls.n_objects) * 4.0 + 1.0 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects) * 10.0 + 1.0) positionAngle = rng.random_sample(cls.n_objects) * np.pi internalAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 internalRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 majorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) minorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.disk_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_disk.dat') with open(cls.disk_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f Inst.79E06.02Z.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some agn data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = np.zeros(cls.n_objects) hlr = np.zeros(cls.n_objects) positionAngle = np.zeros(cls.n_objects) internalAv = np.zeros(cls.n_objects) internalRv = np.zeros(cls.n_objects) majorAxis = np.zeros(cls.n_objects) minorAxis = np.zeros(cls.n_objects) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.agn_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_agn.dat') with open(cls.agn_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f agn.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some star data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = np.zeros(cls.n_objects) hlr = np.zeros(cls.n_objects) positionAngle = np.zeros(cls.n_objects) internalAv = np.zeros(cls.n_objects) internalRv = np.zeros(cls.n_objects) majorAxis = np.zeros(cls.n_objects) minorAxis = np.zeros(cls.n_objects) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = radiansFromArcsec( rng.random_sample(cls.n_objects) * 0.0002) properMotionDec = radiansFromArcsec( rng.random_sample(cls.n_objects) * 0.0002) radialVelocity = rng.random_sample(cls.n_objects) * 200.0 parallax = radiansFromArcsec(rng.random_sample(cls.n_objects) * 0.0002) cls.star_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_star.dat') with open(cls.star_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f km30_5000.fits_g10_5040 %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix]))