def testCatalog(self):
"""
This test writes a PhoSim input catalog and compares it, one line at a time
to a previously written catalog that should be identical.
"""
testBulge = PhoSimCatalogSersic2D(self.bulgeDB,
obs_metadata=self.obs_metadata)
testDisk = PhoSimCatalogSersic2D(self.diskDB,
obs_metadata=self.obs_metadata)
testAgn = PhoSimCatalogZPoint(self.agnDB,
obs_metadata=self.obs_metadata)
testStar = PhoSimCatalogPoint(self.starDB,
obs_metadata=self.obs_metadata)
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests',
'scratchSpace', 'phoSimTestCatalog.txt')
testBulge.phoSimHeaderMap = test_header_map
testBulge.write_catalog(catName)
testDisk.write_catalog(catName, write_header=False, write_mode='a')
testAgn.write_catalog(catName, write_header=False, write_mode='a')
testStar.write_catalog(catName, write_header=False, write_mode='a')
self.verify_catalog(catName)
if os.path.exists(catName):
os.unlink(catName)
def testPointSourceSchema(self):
"""
Create a PhoSim InstanceCatalog of point sources (stars). Verify
that the schema of the actual objects conforms to what PhoSim expects,
as defined here
https://bitbucket.org/phosim/phosim_release/wiki/Instance%20Catalog
"""
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=self.obs_metadata)
cat.phoSimHeaderMap = test_header_map
cat_name = os.path.join(getPackageDir('sims_catUtils'), 'tests',
'scratchSpace',
'phosim_point_source_schema_cat.txt')
if os.path.exists(cat_name):
os.unlink(cat_name)
cat.write_catalog(cat_name)
with open(cat_name, 'r') as input_file:
cat_lines = input_file.readlines()
n_obj = 0
for line in cat_lines:
params = line.split()
if len(params) > 2:
n_obj += 1
self.assertEqual(len(params), 17)
self.assertEqual(params[0], 'object')
self.assertEqual(round(float(params[1])), float(params[1]),
10) # id
float(params[2]) # ra
float(params[3]) # dec
float(params[4]) # mag norm
self.assertIn('starSED', params[5]) # sed name
self.assertAlmostEqual(float(params[6]), 0.0, 10) # redshift
self.assertAlmostEqual(float(params[7]), 0.0, 10) # gamma1
self.assertAlmostEqual(float(params[8]), 0.0, 10) # gamma2
self.assertAlmostEqual(float(params[9]), 0.0, 10) # kappa
self.assertAlmostEqual(float(params[10]), 0.0, 10) # delta_ra
self.assertAlmostEqual(float(params[11]), 0.0, 10) # delta_dec
self.assertEqual(params[12], 'point') # source type
dust_msg = (
'It is possible you are outputting Milky Way dust parameters before '
'internal dust parameters; internal dust should come first'
)
self.assertEqual(params[13], 'none',
msg=dust_msg) # internal dust
self.assertEqual(params[14], 'CCM',
msg=dust_msg) # Milky Way dust
self.assertGreater(float(params[15]), 0.0, msg=dust_msg) # Av
self.assertAlmostEqual(float(params[16]), 3.1,
msg=dust_msg) # Rv
self.assertGreater(n_obj, 0)
if os.path.exists(cat_name):
os.unlink(cat_name)
def make_instcat_header(star_db,
obs_md,
outfile,
object_catalogs=(),
imsim_catalog=False,
nsnap=1,
vistime=30.,
minsource=100):
"""
Write the header part of an instance catalog.
Parameters
----------
star_db: lsst.sims.catUtils.baseCatalogModels.StarObj
InstanceCatalog object for stars. Connects to the UW fatboy db server.
obs_md: lsst.sims.utils.ObservationMetaData
Observation metadata object.
object_catalogs: sequence [()]
Object catalog names to include in base phosim instance catalog.
Defaults to an empty tuple.
imsim_catalog: bool [False]
Flag to write an imSim-style object catalog.
nsnap: int [1]
Number of snaps per visit.
vistime: float [30.]
Visit time in seconds.
minsource: int [100]
Minimum number of objects for phosim.py to simulate a chip.
Returns
-------
lsst.sims.catUtils.exampleCatalogDefinitions.PhoSimCatalogPoint object
"""
cat = PhoSimCatalogPoint(star_db, obs_metadata=obs_md)
cat.phoSimHeaderMap = copy.deepcopy(DefaultPhoSimHeaderMap)
cat.phoSimHeaderMap['nsnap'] = nsnap
cat.phoSimHeaderMap['vistime'] = vistime
if imsim_catalog:
cat.phoSimHeaderMap['rawSeeing'] = ('rawSeeing', None)
cat.phoSimHeaderMap['FWHMgeom'] = ('FWHMgeom', None)
cat.phoSimHeaderMap['FWHMeff'] = ('FWHMeff', None)
else:
cat.phoSimHeaderMap['camconfig'] = 1
with open(outfile, 'w') as output:
cat.write_header(output)
if not imsim_catalog:
output.write('minsource %i\n' % minsource)
for cat_name in object_catalogs:
output.write('includeobj %s.gz\n' % cat_name)
return cat
def make_instcat_header(star_db,
obs_md,
outfile,
object_catalogs=(),
nsnap=1,
vistime=30.,
minsource=100):
"""
Write the header part of an instance catalog.
Parameters
----------
star_db: lsst.sims.catUtils.baseCatalogModels.StarObj
InstanceCatalog object for stars. Connects to the UW fatboy db server.
obs_md: lsst.sims.utils.ObservationMetaData
Observation metadata object.
object_catalogs: sequence [()]
Object catalog names to include in base phosim instance catalog.
Defaults to an empty tuple.
nsnap: int [1]
Number of snaps per visit.
vistime: float [30.]
Visit time in seconds.
minsource: int [100]
Minimum number of objects for phosim.py to simulate a chip.
Ignored. As of 26 Nov. 2019 this value is no longer written to the
header file.
Returns
-------
lsst.sims.catUtils.exampleCatalogDefinitions.PhoSimCatalogPoint object
"""
cat = PhoSimCatalogPoint(star_db, obs_metadata=obs_md)
cat.phoSimHeaderMap = copy.deepcopy(DefaultPhoSimHeaderMap)
cat.phoSimHeaderMap['nsnap'] = nsnap
cat.phoSimHeaderMap['vistime'] = vistime
with open(outfile, 'w') as output:
cat.write_header(output)
for cat_name in object_catalogs:
output.write('includeobj %s.gz\n' % cat_name)
return cat
def testCatalog(self):
"""
This test writes a PhoSim input catalog and compares it, one line at a time
to a previously written catalog that should be identical.
"""
testBulge = PhoSimCatalogSersic2D(self.bulgeDB,
obs_metadata=self.obs_metadata)
testDisk = PhoSimCatalogSersic2D(self.diskDB,
obs_metadata=self.obs_metadata)
testAgn = PhoSimCatalogZPoint(self.agnDB,
obs_metadata=self.obs_metadata)
testStar = PhoSimCatalogPoint(self.starDB,
obs_metadata=self.obs_metadata)
testBulge.phoSimHeaderMap = test_header_map
with lsst.utils.tests.getTempFilePath('.txt') as catName:
testBulge.write_catalog(catName)
testDisk.write_catalog(catName, write_header=False, write_mode='a')
testAgn.write_catalog(catName, write_header=False, write_mode='a')
testStar.write_catalog(catName, write_header=False, write_mode='a')
self.verify_catalog(catName)
def testSpecFileMap(self):
"""
Test that the PhoSim InstanceCatalog SpecFileMaps map MLT dwarf spectra
to the starSED/phoSimMLT/ directory (that is where the MLT spectra which
have been clipped to honor PhoSim's 'no more than 24,999 lines per SED
file' requirement reside)
"""
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=self.obs_metadata)
self.assertEqual(cat.specFileMap['lte_123.txt'],
'starSED/phoSimMLT/lte_123.txt.gz')
self.assertEqual(cat.specFileMap['lte_123.txt.gz'],
'starSED/phoSimMLT/lte_123.txt.gz')
self.assertNotEqual(cat.specFileMap['lte_123.txt'],
defaultSpecMap['lte_123.txt'])
# verify that the usual stellar mappings still apply
for test_name in ('kp_123.txt', 'km_123.txt', 'Const_123.txt',
'Exp_123.txt', 'Burst_123.txt', 'bergeron_123.txt',
'burrows_123.txt', 'm1_123.txt', 'L1_123.txt',
'l1_123.txt', 'Inst_123.txt'):
self.assertEqual(cat.specFileMap[test_name],
defaultSpecMap[test_name])
def testGalSimPhoSimCat(self):
"""
Run a GalSimPhoSim catalog on some data. Then, generate an ordinary PhoSim catalog using
the same data. Verify that the two resulting PhoSim catalogs are identical.
"""
galsim_cat_name = os.path.join(self.dataDir,
'galSimPhoSim_galsim_cat.txt')
phosim_cat_name = os.path.join(self.dataDir,
'galSimPhoSim_phosim_cat.txt')
galsim_image_root = os.path.join(self.dataDir, 'galSimPhoSim_images')
db = fileDBObject(self.bulge_name,
dtype=self.dtype,
runtable='test_bulges',
idColKey='id')
db.raColName = 'ra_deg'
db.decColName = 'dec_deg'
db.objectTypeId = 55
gs_cat = GalSimPhoSimGalaxies(db, obs_metadata=self.obs)
gs_cat.camera_wrapper = GalSimCameraWrapper(self.camera)
gs_cat.bandpassNames = self.obs.bandpass
gs_cat.PSF = SNRdocumentPSF()
gs_cat.phoSimHeaderMap = {}
gs_cat.write_catalog(galsim_cat_name)
gs_cat_0 = gs_cat
ps_cat = PhoSimCatalogSersic2D(db, obs_metadata=self.obs)
ps_cat.phoSimHeaderMap = {}
ps_cat.write_catalog(phosim_cat_name)
db = fileDBObject(self.disk_name,
dtype=self.dtype,
runtable='test_disks',
idColKey='id')
db.raColName = 'ra_deg'
db.decColName = 'dec_deg'
db.objectTypeId = 155
gs_cat = GalSimPhoSimGalaxies(db, obs_metadata=self.obs)
gs_cat.bandpassNames = self.obs.bandpass
gs_cat.copyGalSimInterpreter(gs_cat_0)
gs_cat.write_catalog(galsim_cat_name,
write_header=False,
write_mode='a')
gs_cat_0 = gs_cat
ps_cat = PhoSimCatalogSersic2D(db, obs_metadata=self.obs)
ps_cat.write_catalog(phosim_cat_name,
write_header=False,
write_mode='a')
db = fileDBObject(self.agn_name,
dtype=self.dtype,
runtable='test_agn',
idColKey='id')
db.raColName = 'ra_deg'
db.decColName = 'dec_deg'
db.objectTypeId = 255
gs_cat = GalSimPhoSimAgn(db, obs_metadata=self.obs)
gs_cat.bandpassNames = self.obs.bandpass
gs_cat.copyGalSimInterpreter(gs_cat_0)
gs_cat.write_catalog(galsim_cat_name,
write_header=False,
write_mode='a')
gs_cat_0 = gs_cat
ps_cat = PhoSimCatalogZPoint(db, obs_metadata=self.obs)
ps_cat.write_catalog(phosim_cat_name,
write_header=False,
write_mode='a')
db = fileDBObject(self.star_name,
dtype=self.dtype,
runtable='test_agn',
idColKey='id')
db.raColName = 'ra_deg'
db.decColName = 'dec_deg'
db.objectTypeId = 255
gs_cat = GalSimPhoSimStars(db, obs_metadata=self.obs)
gs_cat.bandpassNames = self.obs.bandpass
gs_cat.copyGalSimInterpreter(gs_cat_0)
gs_cat.write_catalog(galsim_cat_name,
write_header=False,
write_mode='a')
ps_cat = PhoSimCatalogPoint(db, obs_metadata=self.obs)
ps_cat.write_catalog(phosim_cat_name,
write_header=False,
write_mode='a')
written_files = gs_cat.write_images(nameRoot=galsim_image_root)
self.assertGreater(len(written_files), 0)
for name in written_files:
os.unlink(name)
with open(galsim_cat_name, 'r') as galsim_input:
with open(phosim_cat_name, 'r') as phosim_input:
galsim_lines = galsim_input.readlines()
phosim_lines = phosim_input.readlines()
self.assertEqual(len(galsim_lines), len(phosim_lines))
self.assertEqual(len(galsim_lines), 4 * self.n_objects + 7)
for line in galsim_lines:
self.assertIn(line, phosim_lines)
for line in phosim_lines:
self.assertIn(line, galsim_lines)
if os.path.exists(galsim_cat_name):
os.unlink(galsim_cat_name)
if os.path.exists(phosim_cat_name):
os.unlink(phosim_cat_name)
def testCompoundCatalog(self):
"""
This test writes a PhoSim input catalog and compares it, one line at a time
to a previously written catalog that should be identical.
This test uses CompoundInstanceCatalog
"""
# first, generate the catalog without a CompoundInstanceCatalog
single_catName = tempfile.mktemp(dir=ROOT,
prefix='phoSimTestCatalog_single',
suffix='.txt')
testBulge = PhoSimCatalogSersic2D(self.bulgeDB,
obs_metadata=self.obs_metadata)
testDisk = PhoSimCatalogSersic2D(self.diskDB,
obs_metadata=self.obs_metadata)
testAgn = PhoSimCatalogZPoint(self.agnDB,
obs_metadata=self.obs_metadata)
testStar = PhoSimCatalogPoint(self.starDB,
obs_metadata=self.obs_metadata)
testBulge.phoSimHeaderMap = test_header_map
testBulge.write_catalog(single_catName)
testDisk.write_catalog(single_catName,
write_header=False,
write_mode='a')
testAgn.write_catalog(single_catName,
write_header=False,
write_mode='a')
testStar.write_catalog(single_catName,
write_header=False,
write_mode='a')
# now, generate the catalog using CompoundInstanceCatalog
#
# because the CompoundCatalogDBObject requires that database
# connection parameters be set in the input CatalogDBObject
# daughter class definitions, we have to declare dummy
# CatalogDBObject daughter classes below
class dummyDBbase(object):
driver = 'sqlite'
database = 'PhoSimTestDatabase.db'
dummyDBbase.database = self.tempDB
class dummyBulgeDB(dummyDBbase, testGalaxyBulgeDBObj):
objid = 'dummy_bulge'
class dummyDiskDB(dummyDBbase, testGalaxyDiskDBObj):
objid = 'dummy_disk'
class dummyAgnDB(dummyDBbase, testGalaxyAgnDBObj):
objid = 'dummy_agn'
class dummyStarDB(dummyDBbase, testStarsDBObj):
objid = 'dummy_stars'
compoundCatalog = CompoundInstanceCatalog(
[
PhoSimCatalogSersic2D, PhoSimCatalogSersic2D,
PhoSimCatalogZPoint, PhoSimCatalogPoint
], [dummyBulgeDB, dummyDiskDB, dummyAgnDB, dummyStarDB],
obs_metadata=self.obs_metadata)
self.assertEqual(len(compoundCatalog._dbObjectGroupList[0]), 3)
compound_catName = tempfile.mktemp(dir=ROOT,
prefix='phoSimTestCatalog_compound',
suffix='.txt')
compoundCatalog.phoSimHeaderMap = test_header_map
compoundCatalog.write_catalog(compound_catName)
# verify that the compound catalog is what we expect
self.verify_catalog(compound_catName)
# verify that the two catalogs are equivalent
with open(single_catName, 'r') as single_file:
with open(compound_catName, 'r') as compound_file:
single_lines = single_file.readlines()
compound_lines = compound_file.readlines()
for line in single_lines:
self.assertIn(line, compound_lines)
for line in compound_lines:
self.assertIn(line, single_lines)
if os.path.exists(compound_catName):
os.unlink(compound_catName)
if os.path.exists(single_catName):
os.unlink(single_catName)
def test_incomplete_obs(self):
"""
Test that an exception gets raised if you try to make a PhoSim InstanceCatalog
with an ObservationMetaData that lacks RA, Dec, mjd, bandpass, or rotSkyPos
"""
obs = ObservationMetaData(pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(RuntimeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0)
with self.assertRaises(KeyError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
obs.OpsimMetaData['randomDitherFieldPerVisitRA'])
obs.pointingDec = np.degrees(
obs.OpsimMetaData['randomDitherFieldPerVisitDec'])
rotSky = _getRotSkyPos(obs._pointingRA, obs._pointingDec, obs,
obs.OpsimMetaData['ditheredRotTelPos'])
obs.rotSkyPos = np.degrees(rotSky)
obs.OpsimMetaData['rotTelPos'] = obs.OpsimMetaData[
'ditheredRotTelPos']
cat_name = os.path.join(out_dir, 'phosim_cat_%d.txt' % obshistid)
star_name = 'star_cat_%d.txt' % obshistid
gal_name = 'gal_cat_%d.txt' % obshistid
agn_name = 'agn_cat_%d.txt' % obshistid
cat = PhoSimCatalogPoint(star_db, obs_metadata=obs)
cat.phoSimHeaderMap = phosim_header_map
with open(cat_name, 'w') as output:
cat.write_header(output)
output.write('includeobj %s.gz\n' % star_name)
output.write('includeobj %s.gz\n' % gal_name)
output.write('includeobj %s.gz\n' % agn_name)
star_cat = MaskedPhoSimCatalogPoint(star_db, obs_metadata=obs)
star_cat.phoSimHeaderMap = phosim_header_map
bright_cat = BrightStarCatalog(star_db,
obs_metadata=obs,
cannot_be_null=['isBright'])
star_cat.min_mag = args.min_mag
bright_cat.min_mag = args.min_mag
def test_incomplete_obs(self):
"""
Test that an exception gets raised if you try to make a PhoSim InstanceCatalog
with an ObservationMetaData that lacks RA, Dec, mjd, bandpass, or rotSkyPos
"""
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests',
'scratchSpace', 'bad_obs_test_phosim_cat.txt')
obs = ObservationMetaData(pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
rotSkyPos=19.0,
bandpassName='u')
with self.assertRaises(RuntimeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
bandpassName='u')
with self.assertRaises(TypeError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0)
with self.assertRaises(KeyError):
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
obs = ObservationMetaData(pointingRA=88.0,
pointingDec=19.0,
mjd=43000.0,
rotSkyPos=19.0,
bandpassName='u')
cat = PhoSimCatalogPoint(self.starDB, obs_metadata=obs)
cat.phoSimHeaderMap = {}
cat.write_catalog(catName)
if os.path.exists(catName):
os.unlink(catName)
