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