def testMultipleImages(self):
"""
Test that GalSimInterpreter puts the right number of counts on images of multiple objects
"""
dbName = 'galSimTestMultipleDB.db'
driver = 'sqlite'
if os.path.exists(dbName):
os.unlink(dbName)
displacedRA = numpy.array([72.0/3600.0, 55.0/3600.0, 75.0/3600.0])
displacedDec = numpy.array([0.0, 15.0/3600.0, -15.0/3600.0])
obs_metadata = makePhoSimTestDB(filename=dbName, size=1,
displacedRA=displacedRA, displacedDec=displacedDec,
bandpass=self.bandpassNameList,
m5=self.m5, seeing=self.seeing)
gals = testGalaxyBulgeDBObj(driver=driver, database=dbName)
cat = testGalaxyCatalog(gals, obs_metadata=obs_metadata)
catName = 'multipleCatalog.sav'
cat.write_catalog(catName)
self.catalogTester(catName=catName, catalog=cat, nameRoot='multiple')
if os.path.exists(catName):
os.unlink(catName)
stars = testStarsDBObj(driver=driver, database=dbName)
cat = testStarCatalog(stars, obs_metadata=obs_metadata)
catName = 'multipleStarCatalog.sav'
cat.write_catalog(catName)
self.catalogTester(catName=catName, catalog=cat, nameRoot='multipleStars')
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(dbName):
os.unlink(dbName)
def setUp(self):
self.obs_metadata = makePhoSimTestDB(size=10)
self.bulgeDB = testGalaxyBulgeDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.diskDB = testGalaxyDiskDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.agnDB = testGalaxyAgnDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.starDB = testStarsDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
baseLineFileName = lsst.utils.getPackageDir('sims_catUtils')+'/tests/testData/phoSimControlCatalog.txt'
self.baseLineFile = open(baseLineFileName,'r')
def testCompoundFitsFiles(self):
"""
Test that GalSimInterpreter puts the right number of counts on images containgin different types of objects
"""
driver = 'sqlite'
dbName1 = 'galSimTestCompound1DB.db'
if os.path.exists(dbName1):
os.unlink(dbName1)
displacedRA = numpy.array([72.0/3600.0, 55.0/3600.0, 75.0/3600.0])
displacedDec = numpy.array([0.0, 15.0/3600.0, -15.0/3600.0])
obs_metadata1 = makePhoSimTestDB(filename=dbName1, size=1,
displacedRA=displacedRA, displacedDec=displacedDec,
bandpass=self.bandpassNameList,
m5=self.m5, seeing=self.seeing)
dbName2 = 'galSimTestCompound2DB.db'
if os.path.exists(dbName2):
os.unlink(dbName2)
displacedRA = numpy.array([55.0/3600.0, 60.0/3600.0, 62.0/3600.0])
displacedDec = numpy.array([-3.0/3600.0, 10.0/3600.0, 10.0/3600.0])
obs_metadata2 = makePhoSimTestDB(filename=dbName2, size=1,
displacedRA=displacedRA, displacedDec=displacedDec,
bandpass=self.bandpassNameList,
m5=self.m5, seeing=self.seeing)
gals = testGalaxyBulgeDBObj(driver=driver, database=dbName1)
cat1 = testGalaxyCatalog(gals, obs_metadata=obs_metadata1)
catName = 'compoundCatalog.sav'
cat1.write_catalog(catName)
stars = testStarsDBObj(driver=driver, database=dbName2)
cat2 = testStarCatalog(stars, obs_metadata=obs_metadata2)
cat2.copyGalSimInterpreter(cat1)
cat2.write_catalog(catName, write_header=False, write_mode='a')
self.catalogTester(catName=catName, catalog=cat2, nameRoot='compound')
if os.path.exists(dbName1):
os.unlink(dbName1)
if os.path.exists(dbName2):
os.unlink(dbName2)
if os.path.exists(catName):
os.unlink(catName)
def setUpClass(cls):
lsstDefaults=LSSTdefaults()
cls.dbName = 'uncertaintyTestDB.db'
if os.path.exists(cls.dbName):
os.unlink(cls.dbName)
default_obs_metadata = makePhoSimTestDB(filename=cls.dbName, size=10, radius = 5.0)
bandpass = ['u', 'g', 'r', 'i', 'z', 'y']
m5 = lsstDefaults._m5.values()
cls.obs_metadata = ObservationMetaData(
pointingRA = default_obs_metadata.pointingRA,
pointingDec = default_obs_metadata.pointingDec,
rotSkyPos = default_obs_metadata.rotSkyPos,
bandpassName = bandpass,
m5 = m5
)
cls.obs_metadata.setBandpassM5andSeeing(bandpassName=bandpass, m5=m5)
cls.driver = 'sqlite'
cls.host = ''
cls.skySeds = []
cls.hardwareBandpasses = []
cls.totalBandpasses = []
cls.bandpasses = ['u', 'g', 'r', 'i', 'z', 'y']
components = ['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat',
'lens1.dat', 'lens2.dat', 'lens3.dat']
for b in cls.bandpasses:
bandpassDummy = Bandpass()
bandpassDummy.readThroughput(os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'total_%s.dat' % b))
cls.totalBandpasses.append(bandpassDummy)
for b in cls.bandpasses:
finalComponents = []
for c in components:
finalComponents.append(os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline', c))
finalComponents.append(os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline', 'filter_%s.dat' %b))
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(finalComponents)
cls.hardwareBandpasses.append(bandpassDummy)
for i in range(len(cls.bandpasses)):
sedDummy = Sed()
sedDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline', 'darksky.dat'))
normalizedSedDummy = setM5(cls.obs_metadata.m5[cls.bandpasses[i]], sedDummy,
cls.totalBandpasses[i], cls.hardwareBandpasses[i],
FWHMeff=lsstDefaults.FWHMeff(cls.bandpasses[i]),
photParams=PhotometricParameters())
cls.skySeds.append(normalizedSedDummy)
def setUp(cls):
cls.dbName = 'PhoSimVariabilityDatabase.db'
if os.path.exists(cls.dbName):
os.unlink(cls.dbName)
cls.obs_metadata = makePhoSimTestDB(size=10, filename=cls.dbName)
cls.bulgeDB = testGalaxyBulgeDBObj(driver='sqlite', database=cls.dbName)
cls.diskDB = testGalaxyDiskDBObj(driver='sqlite', database=cls.dbName)
cls.agnDB = testGalaxyAgnDBObj(driver='sqlite', database=cls.dbName)
cls.starDB = testStarsDBObj(driver='sqlite', database=cls.dbName)
def testCreationOfPhoSimCatalog(self):
"""
Make sure that we can create PhoSim input catalogs using the returned ObservationMetaData.
This test will just make sure that all of the expected header entries are there.
"""
dbName = 'obsMetaDataGeneratorTest.db'
catName = 'testPhoSimFromObsMetaDataGenerator.txt'
if os.path.exists(dbName):
os.unlink(dbName)
junk_obs_metadata = makePhoSimTestDB(filename=dbName)
bulgeDB = testGalaxyBulge(driver='sqlite', database=dbName)
gen = ObservationMetaDataGenerator()
results = gen.getObservationMetaData(fieldRA=numpy.degrees(1.370916),telescopeFilter='i')
testCat = PhoSimCatalogSersic2D(bulgeDB, obs_metadata=results[0])
testCat.write_catalog(catName)
filterTranslation=['u','g','r','i','z','y']
with open(catName) as inputFile:
lines = inputFile.readlines()
ix = 0
for control in gen.columnMapping:
if control[0] != 'm5' and control[0]!='skyBrightness' and control[0]!='seeing':
words = lines[ix].split()
self.assertEqual(control[2].replace('pointing', 'Unrefracted_'), words[0])
if control[0] != 'telescopeFilter':
if control[4] is not None:
value = control[4](float(words[1]))
else:
value = float(words[1])
self.assertAlmostEqual(value, results[0].phoSimMetaData[control[2]][0], 5)
else:
self.assertEqual(filterTranslation[int(words[1])],results[0].phoSimMetaData[control[2]][0])
ix += 1
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(dbName):
os.unlink(dbName)
def setUpClass(cls):
cls.dbName = 'galSimTestDB.db'
if os.path.exists(cls.dbName):
os.unlink(cls.dbName)
displacedRA = numpy.array([72.0/3600.0])
displacedDec = numpy.array([0.0])
defaults = LSSTdefaults()
cls.bandpassNameList = ['u', 'g', 'r', 'i', 'z', 'y']
cls.m5 = defaults._m5.values()
cls.seeing = defaults._seeing.values()
cls.obs_metadata = makePhoSimTestDB(filename=cls.dbName, size=1,
displacedRA=displacedRA,
displacedDec=displacedDec,
bandpass=cls.bandpassNameList,
m5=cls.m5,
seeing=cls.seeing)
cls.driver = 'sqlite'
def setUp(self):
self.obs_metadata = makePhoSimTestDB(size=10)
self.bulgeDB = testGalaxyBulgeDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.diskDB = testGalaxyDiskDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.agnDB = testGalaxyAgnDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
self.starDB = testStarsDBObj(driver='sqlite', database='PhoSimTestDatabase.db')
filter_translation={'u':0,'g':1, 'r':2, 'i':3, 'z':4, 'y':5}
self.control_header = ['Opsim_moondec %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_moondec'][0]),
'Opsim_rottelpos %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_rottelpos'][0]),
'Unrefracted_Dec %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['pointingDec'][0]),
'Opsim_moonalt %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_moonalt'][0]),
'Opsim_rotskypos %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_rotskypos'][0]),
'Opsim_moonra %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_moonra'][0]),
'Opsim_sunalt %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_sunalt'][0]),
'Opsim_expmjd %.9g\n' % self.obs_metadata.phoSimMetaData['Opsim_expmjd'][0],
'Unrefracted_Azimuth %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Unrefracted_Azimuth'][0]),
'Unrefracted_RA %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['pointingRA'][0]),
'Opsim_dist2moon %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Opsim_dist2moon'][0]),
'Opsim_filter %d\n' % filter_translation[self.obs_metadata.phoSimMetaData['Opsim_filter'][0]],
'Unrefracted_Altitude %.9g\n' % numpy.degrees(self.obs_metadata.phoSimMetaData['Unrefracted_Altitude'][0])]
def testPlacement(self):
"""
Test that GalSimInterpreter puts objects on the right detectors.
Do so by creating a catalog of 10 closely-packed stars. Draw test FITS
images of them using the GalSim Catalog infrastructure. Draw control FITS
images of the detectors in the camera, paranoidly including every star
in every control image (GalSim contains code such that it will not
actually add flux to an image in cases where we try to include a
star that does not actually fall on a detector). Compare that
a) the fluxes of the test and control images agree within some tolerance
b) the fluxes of control images that have no corresponding test image
(i.e. detectors on which no star actually fell) are effectively zero
"""
#generate the database
numpy.random.seed(32)
catSize = 10
dbName = 'galSimPlacementTestDB.db'
driver = 'sqlite'
if os.path.exists(dbName):
os.unlink(dbName)
displacedRA = (-40.0 + numpy.random.sample(catSize)*(120.0))/3600.0
displacedDec = (-20.0 + numpy.random.sample(catSize)*(80.0))/3600.0
obs_metadata = makePhoSimTestDB(filename=dbName, displacedRA=displacedRA, displacedDec=displacedDec,
bandpass=self.bandpassNameList,
m5=self.m5, seeing=self.seeing)
catName = 'testPlacementCat.sav'
stars = testStarsDBObj(driver=driver, database=dbName)
#create the catalog
cat = testStarCatalog(stars, obs_metadata = obs_metadata)
results = cat.iter_catalog()
firstLine = True
#iterate over the catalog, giving every star a chance to
#illumine every detector
controlImages = {}
for i, line in enumerate(results):
galSimType = line[0]
xPupil = line[5]
yPupil = line[6]
majorAxis = line[8]
minorAxis = line[9]
sindex = line[10]
halfLightRadius = line[11]
positionAngle = line[12]
if firstLine:
sedList = cat._calculateGalSimSeds()
for detector in cat.galSimInterpreter.detectors:
for bandpass in cat.galSimInterpreter.bandpasses:
controlImages['placementControl_' + \
cat.galSimInterpreter._getFileName(detector=detector, bandpassName=bandpass)] = \
cat.galSimInterpreter.blankImage(detector=detector)
firstLine = False
spectrum = galsim.SED(spec=lambda ll: numpy.interp(ll, sedList[i].wavelen, sedList[i].flambda), flux_type='flambda')
for bp in cat.galSimInterpreter.bandpasses:
bandpass = cat.galSimInterpreter.bandpasses[bp]
for detector in cat.galSimInterpreter.detectors:
centeredObj = cat.galSimInterpreter.PSF.applyPSF(xPupil=xPupil, yPupil=yPupil, bandpass=bandpass)
xPix, yPix = pixelCoordsFromPupilCoords(numpy.array([radiansFromArcsec(xPupil)]),
numpy.array([radiansFromArcsec(yPupil)]),
chipNames = [detector.name],
camera = detector.afwCamera)
dx = xPix[0] - detector.xCenterPix
dy = yPix[0] - detector.yCenterPix
obj = centeredObj*spectrum
localImage = cat.galSimInterpreter.blankImage(detector=detector)
localImage = obj.drawImage(bandpass=bandpass, wcs=detector.wcs, method='phot',
gain=detector.photParams.gain, image=localImage,
offset=galsim.PositionD(dx, dy))
controlImages['placementControl_' + \
cat.galSimInterpreter._getFileName(detector=detector, bandpassName=bp)] += \
localImage
for name in controlImages:
controlImages[name].write(file_name=name)
#write the test images using the catalog infrastructure
testNames = cat.write_images(nameRoot='placementTest')
#make sure that every test image has a corresponding control image
for testName in testNames:
controlName = testName.replace('Test', 'Control')
msg = '%s has no counterpart ' % testName
self.assertTrue(controlName in controlImages, msg=msg)
#make sure that the test and control images agree to some tolerance
ignored = 0
zeroFlux = 0
for controlName in controlImages:
controlImage = afwImage.ImageF(controlName)
controlFlux = controlImage.getArray().sum()
testName = controlName.replace('Control', 'Test')
if testName in testNames:
testImage = afwImage.ImageF(testName)
testFlux = testImage.getArray().sum()
msg = '%s: controlFlux = %e, testFlux = %e' % (controlName, controlFlux, testFlux)
if controlFlux>1000.0:
#the randomness of photon shooting means that faint images won't agree
self.assertTrue(numpy.abs(controlFlux/testFlux - 1.0)<0.1, msg=msg)
else:
ignored += 1
else:
#make sure that controlImages that have no corresponding test image really do
#have zero flux (because no star fell on them)
zeroFlux += 1
msg = '%s has flux %e but was not written by catalog' % (controlName, controlFlux)
self.assertTrue(controlFlux<1.0, msg=msg)
self.assertTrue(ignored<len(testNames)/2)
self.assertTrue(zeroFlux>0)
for testName in testNames:
if os.path.exists(testName):
os.unlink(testName)
for controlName in controlImages:
if os.path.exists(controlName):
os.unlink(controlName)
if os.path.exists(dbName):
os.unlink(dbName)
