class testGalSimGalaxies(GalSimGalaxies):
bandpassNames = ['u', 'g']
PSF = SNRdocumentPSF()
class testGalSimAgn(GalSimAgn):
bandpassNames = ['u', 'g']
#defined in galSimInterface/galSimUtilities.py
PSF = SNRdocumentPSF()
def testOutputWcsOfImage(self):
"""
Test that, when GalSim generates an image, in encodes the WCS in a
way afw can read. This is done by creating an image,then reading
it back in, getting its WCS, and comparing the pixel-to-sky conversion
both for the read WCS and the original afw.cameraGeom.detector.
Raise an exception if the median difference between the two is
greater than 0.01 arcseconds.
"""
scratchDir = os.path.join(getPackageDir('sims_GalSimInterface'),
'tests', 'scratchSpace')
catName = os.path.join(scratchDir, 'outputWcs_test_Catalog.dat')
imageRoot = os.path.join(scratchDir, 'outputWcs_test_Image')
dbFileName = os.path.join(scratchDir,
'outputWcs_test_InputCatalog.dat')
baseDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests',
'cameraData')
camera = ReturnCamera(baseDir)
detector = camera[0]
detName = detector.getName()
imageName = '%s_%s_u.fits' % (imageRoot, detName)
nSamples = 3
rng = np.random.RandomState(42)
pointingRaList = rng.random_sample(nSamples) * 360.0
pointingDecList = rng.random_sample(nSamples) * 180.0 - 90.0
rotSkyPosList = rng.random_sample(nSamples) * 360.0
for raPointing, decPointing, rotSkyPos in \
zip(pointingRaList, pointingDecList, rotSkyPosList):
obs = ObservationMetaData(pointingRA=raPointing,
pointingDec=decPointing,
boundType='circle',
boundLength=4.0,
rotSkyPos=rotSkyPos,
mjd=49250.0)
fwhm = 0.7
create_text_catalog(obs, dbFileName, np.array([3.0]),
np.array([1.0]))
db = outputWcsFileDBObj(dbFileName, runtable='test')
cat = outputWcsCat(db, obs_metadata=obs)
cat.camera = camera
psf = SNRdocumentPSF(fwhm=fwhm)
cat.setPSF(psf)
cat.write_catalog(catName)
cat.write_images(nameRoot=imageRoot)
# 20 March 2017
# the 'try' block is how it worked in SWIG;
# the 'except' block is how it works in pybind11
try:
exposure = afwImage.ExposureD_readFits(imageName)
except AttributeError:
exposure = afwImage.ExposureD.readFits(imageName)
wcs = exposure.getWcs()
xxTestList = []
yyTestList = []
raImage = []
decImage = []
for xx in np.arange(0.0, 4001.0, 100.0):
for yy in np.arange(0.0, 4001.0, 100.0):
xxTestList.append(xx)
yyTestList.append(yy)
pt = afwGeom.Point2D(xx, yy)
skyPt = wcs.pixelToSky(pt).getPosition()
raImage.append(skyPt.getX())
decImage.append(skyPt.getY())
xxTestList = np.array(xxTestList)
yyTestList = np.array(yyTestList)
raImage = np.radians(np.array(raImage))
decImage = np.radians(np.array(decImage))
raControl, \
decControl = _raDecFromPixelCoords(xxTestList, yyTestList,
[detector.getName()]*len(xxTestList),
camera=camera, obs_metadata=obs,
epoch=2000.0)
errorList = arcsecFromRadians(
haversine(raControl, decControl, raImage, decImage))
medianError = np.median(errorList)
msg = 'medianError was %e' % medianError
self.assertLess(medianError, 0.01, msg=msg)
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(imageName):
os.unlink(imageName)
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)
class testGalSimGalaxies(GalSimGalaxies):
#only draw images for u and g bands (for speed)
bandpassNames = ['u', 'g']
PSF = SNRdocumentPSF()
def testObjectPlacement(self):
"""
Test that GalSim places objects on the correct pixel by drawing
images, reading them in, and then comparing the flux contained in
circles of 2 fwhm radii about the object's expected positions with
the actual expected flux of the objects.
"""
scratchDir = tempfile.mkdtemp(dir=ROOT, prefix='testObjectPlacement-')
catName = os.path.join(scratchDir, 'placementCatalog.dat')
imageRoot = os.path.join(scratchDir, 'placementImage')
dbFileName = os.path.join(scratchDir, 'placementInputCatalog.dat')
cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData')
camera = ReturnCamera(cameraDir)
detector = camera[0]
imageName = '%s_%s_u.fits' % (imageRoot, detector.getName())
controlSed = Sed()
controlSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'),
'flatSED', 'sed_flat.txt.gz'))
uBandpass = Bandpass()
uBandpass.readThroughput(os.path.join(getPackageDir('throughputs'),
'baseline', 'total_u.dat'))
controlBandpass = Bandpass()
controlBandpass.imsimBandpass()
ff = controlSed.calcFluxNorm(self.magNorm, uBandpass)
controlSed.multiplyFluxNorm(ff)
a_int, b_int = controlSed.setupCCMab()
controlSed.addCCMDust(a_int, b_int, A_v=0.1, R_v=3.1)
nSamples = 3
rng = np.random.RandomState(42)
pointingRaList = rng.random_sample(nSamples)*360.0
pointingDecList = rng.random_sample(nSamples)*180.0 - 90.0
rotSkyPosList = rng.random_sample(nSamples)*360.0
fwhmList = rng.random_sample(nSamples)*1.0 + 0.3
actualCounts = None
for pointingRA, pointingDec, rotSkyPos, fwhm in \
zip(pointingRaList, pointingDecList, rotSkyPosList, fwhmList):
obs = ObservationMetaData(pointingRA=pointingRA,
pointingDec=pointingDec,
boundType='circle',
boundLength=4.0,
mjd=49250.0,
rotSkyPos=rotSkyPos)
xDisplacementList = rng.random_sample(nSamples)*60.0-30.0
yDisplacementList = rng.random_sample(nSamples)*60.0-30.0
create_text_catalog(obs, dbFileName, xDisplacementList, yDisplacementList,
mag_norm=[self.magNorm]*len(xDisplacementList))
db = placementFileDBObj(dbFileName, runtable='test')
cat = placementCatalog(db, obs_metadata=obs)
cat.camera_wrapper = GalSimCameraWrapper(camera)
if actualCounts is None:
actualCounts = controlSed.calcADU(uBandpass, cat.photParams)
psf = SNRdocumentPSF(fwhm=fwhm)
cat.setPSF(psf)
cat.write_catalog(catName)
cat.write_images(nameRoot=imageRoot)
objRaList = []
objDecList = []
with open(catName, 'r') as inFile:
for line in inFile:
if line[0] != '#':
words = line.split(';')
objRaList.append(np.radians(np.float(words[2])))
objDecList.append(np.radians(np.float(words[3])))
objRaList = np.array(objRaList)
objDecList = np.array(objDecList)
self.assertGreater(len(objRaList), 0) # make sure we aren't testing
# an empty catalog/image
self.check_placement(imageName, objRaList, objDecList,
[fwhm]*len(objRaList),
np.array([actualCounts]*len(objRaList)),
cat.photParams.gain, detector, camera, obs, epoch=2000.0)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(imageName):
os.unlink(imageName)
if os.path.exists(scratchDir):
shutil.rmtree(scratchDir)
def main():
"""
Drive GalSim to simulate the LSST.
"""
# Setup a parser to take command line arguments
parser = argparse.ArgumentParser()
parser.add_argument('file', help="The instance catalog")
parser.add_argument('-n',
'--numrows',
default=None,
type=int,
help="Read the first numrows of the file.")
parser.add_argument('--outdir',
type=str,
default='fits',
help='Output directory for eimage file')
parser.add_argument(
'--sensor',
type=str,
default=None,
help='Sensor to simulate, e.g., "R:2,2 S:1,1".' +
'If None, then simulate all sensors with sources on them')
parser.add_argument(
'--config_file',
type=str,
default=None,
help="Config file. If None, the default config will be used.")
parser.add_argument('--log_level',
type=str,
choices=['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'],
default='INFO',
help='Logging level. Default: "INFO"')
parser.add_argument(
'--psf',
type=str,
default='Kolmogorov',
choices=['DoubleGaussian', 'Kolmogorov'],
help="PSF model to use; either the double Gaussian "
"from LSE=40 (equation 30), or the Kolmogorov convolved "
"with a Gaussian proposed by David Kirkby at the "
"23 March 2017 SSims telecon")
parser.add_argument('--checkpoint_file',
type=str,
default=None,
help='Checkpoint file name.')
parser.add_argument('--nobj_checkpoint',
type=int,
default=1000,
help='# objects to process between checkpoints')
parser.add_argument('--seed',
type=int,
default=267,
help='integer used to seed random number generator')
arguments = parser.parse_args()
config = desc.imsim.read_config(arguments.config_file)
logger = desc.imsim.get_logger(arguments.log_level)
# Get the number of rows to read from the instance file. Use
# default if not specified.
numRows = arguments.numrows
if numRows is not None:
logger.info("Reading %i rows from the instance catalog %s.", numRows,
arguments.file)
else:
logger.info("Reading all rows from the instance catalog %s.",
arguments.file)
camera_wrapper = LSSTCameraWrapper()
catalog_contents = desc.imsim.parsePhoSimInstanceFile(arguments.file,
numRows=numRows)
obs_md = catalog_contents.obs_metadata
phot_params = catalog_contents.phot_params
sources = catalog_contents.sources
gs_object_arr = sources[0]
gs_object_dict = sources[1]
# Sub-divide the source dataframe into stars and galaxies.
if arguments.sensor is not None:
detector_list = [
make_galsim_detector(camera_wrapper, arguments.sensor, phot_params,
obs_md)
]
else:
detector_list = []
for det in camera_wrapper.camera:
det_type = det.getType()
if det_type != WAVEFRONT and det_type != GUIDER:
detector_list.append(
make_galsim_detector(camera_wrapper, det.getName(),
phot_params, obs_md))
# Add noise and sky background
# The simple code using the default lsst-GalSim interface would be:
#
# PhoSimStarCatalog.noise_and_background = ExampleCCDNoise(addNoise=True,
# addBackground=True)
#
# But, we need a more realistic sky model and we need to pass more than
# this basic info to use Peter Y's ESO sky model.
# We must pass obs_metadata, chip information etc...
noise_and_background \
= ESOSkyModel(obs_md, addNoise=True, addBackground=True)
bp_dict = BandpassDict.loadTotalBandpassesFromFiles(
bandpassNames=obs_md.bandpass)
gs_interpreter = GalSimInterpreter(obs_metadata=obs_md,
epoch=2000.0,
detectors=detector_list,
bandpassDict=bp_dict,
noiseWrapper=noise_and_background,
seed=arguments.seed)
gs_interpreter.checkpoint_file = arguments.checkpoint_file
gs_interpreter.nobj_checkpoint = arguments.nobj_checkpoint
gs_interpreter.restore_checkpoint(camera_wrapper, phot_params, obs_md)
# Add a PSF.
if arguments.psf.lower() == "doublegaussian":
# This one is taken from equation 30 of
# www.astro.washington.edu/users/ivezic/Astr511/LSST_SNRdoc.pdf .
#
# Set seeing from self.obs_metadata.
local_PSF = \
SNRdocumentPSF(obs_md.OpsimMetaData['FWHMgeom'])
elif arguments.psf.lower() == "kolmogorov":
# This PSF was presented by David Kirkby at the 23 March 2017
# Survey Simulations Working Group telecon
#
# https://confluence.slac.stanford.edu/pages/viewpage.action?spaceKey=LSSTDESC&title=SSim+2017-03-23
# equation 3 of Krisciunas and Schaefer 1991
airmass = 1.0 / np.sqrt(
1.0 - 0.96 *
(np.sin(0.5 * np.pi - obs_md.OpsimMetaData['altitude']))**2)
local_PSF = \
Kolmogorov_and_Gaussian_PSF(airmass=airmass,
rawSeeing=obs_md.OpsimMetaData['rawSeeing'],
band=obs_md.bandpass)
else:
raise RuntimeError("Do not know what to do with psf model: "
"%s" % arguments.psf)
gs_interpreter.setPSF(PSF=local_PSF)
if arguments.sensor is not None:
gs_objects_to_draw = gs_object_dict[arguments.sensor]
else:
gs_objects_to_draw = gs_object_arr
for gs_obj in gs_objects_to_draw:
if gs_obj.uniqueId in gs_interpreter.drawn_objects:
continue
gs_interpreter.drawObject(gs_obj)
desc.imsim.add_cosmic_rays(gs_interpreter, phot_params)
# Write out the fits files
outdir = arguments.outdir
if not os.path.isdir(outdir):
os.makedirs(outdir)
prefix = config['persistence']['eimage_prefix']
gs_interpreter.writeImages(nameRoot=os.path.join(outdir, prefix) +
str(obs_md.OpsimMetaData['obshistID']))
def main(file, psf, outdir):
"""
Drive GalSim to simulate the LSST.
"""
# Setup a parser to take command line arguments
config = desc.imsim.read_config(None)
logger = desc.imsim.get_logger("INFO")
# Get the number of rows to read from the instance file. Use
# default if not specified.
numRows = None
sensor = None
# The PhoSim instance file contains both pointing commands and
# objects. The parser will split them and return a both phosim
# command dictionary and a dataframe of objects.
commands, phosim_objects = \
desc.imsim.parsePhoSimInstanceFile(file, numRows)
phosim_objects = \
desc.imsim.validate_phosim_object_list(phosim_objects).accepted
# Build the ObservationMetaData with values taken from the
# PhoSim commands at the top of the instance file.
obs_md = desc.imsim.phosim_obs_metadata(commands)
#print (commands)
#obs_md.OpsimMetaData['altitude' ] = 20
camera = LsstSimMapper().camera
# Sub-divide the source dataframe into stars and galaxies.
if sensor is not None:
# Trim the input catalog to a single chip.
phosim_objects['chipName'] = \
chipNameFromRaDec(phosim_objects['raICRS'].values,
phosim_objects['decICRS'].values,
parallax=phosim_objects['parallax'].values,
camera=camera, obs_metadata=obs_md,
epoch=2000.0)
starDataBase = \
phosim_objects.query("galSimType=='pointSource' and chipName=='%s'"
% sensor)
galaxyDataBase = \
phosim_objects.query("galSimType=='sersic' and chipName=='%s'"
% sensor)
else:
starDataBase = \
phosim_objects.query("galSimType=='pointSource'")
galaxyDataBase = \
phosim_objects.query("galSimType=='sersic'")
# Simulate the objects in the Pandas Dataframes.
# First simulate stars
phoSimStarCatalog = desc.imsim.ImSimStars(starDataBase, obs_md)
phoSimStarCatalog.photParams = desc.imsim.photometricParameters(commands)
# Add noise and sky background
# The simple code using the default lsst-GalSim interface would be:
#
# PhoSimStarCatalog.noise_and_background = ExampleCCDNoise(addNoise=True,
# addBackground=True)
#
# But, we need a more realistic sky model and we need to pass more than
# this basic info to use Peter Y's ESO sky model.
# We must pass obs_metadata, chip information etc...
phoSimStarCatalog.noise_and_background = ESOSkyModel(obs_md,
addNoise=True,
addBackground=True)
# Add a PSF.
if psf.lower() == "doublegaussian":
# This one is taken from equation 30 of
# www.astro.washington.edu/users/ivezic/Astr511/LSST_SNRdoc.pdf .
#
# Set seeing from self.obs_metadata.
phoSimStarCatalog.PSF = \
SNRdocumentPSF(obs_md.OpsimMetaData['FWHMgeom'])
elif psf.lower() == "kolmogorov":
# This PSF was presented by David Kirkby at the 23 March 2017
# Survey Simulations Working Group telecon
#
# https://confluence.slac.stanford.edu/pages/viewpage.action?spaceKey=LSSTDESC&title=SSim+2017-03-23
# equation 3 of Krisciunas and Schaefer 1991
airmass = 1.0 / np.sqrt(
1.0 - 0.96 *
(np.sin(0.5 * np.pi - obs_md.OpsimMetaData['altitude']))**2)
phoSimStarCatalog.PSF = \
Kolmogorov_and_Gaussian_PSF(airmass=airmass,
rawSeeing=obs_md.OpsimMetaData['rawSeeing'],
band=obs_md.bandpass)
else:
raise RuntimeError("Do not know what to do with psf model: "
"%s" % psf)
phoSimStarCatalog.camera = camera
phoSimStarCatalog.get_fitsFiles()
# Now galaxies
phoSimGalaxyCatalog = desc.imsim.ImSimGalaxies(galaxyDataBase, obs_md)
phoSimGalaxyCatalog.copyGalSimInterpreter(phoSimStarCatalog)
phoSimGalaxyCatalog.PSF = phoSimStarCatalog.PSF
phoSimGalaxyCatalog.noise_and_background = phoSimStarCatalog.noise_and_background
phoSimGalaxyCatalog.get_fitsFiles()
# Write out the fits files
outdir = outdir
if not os.path.isdir(outdir):
os.makedirs(outdir)
prefix = config['persistence']['eimage_prefix']
phoSimGalaxyCatalog.write_images(nameRoot=os.path.join(outdir, prefix) +
str(commands['obshistid']))
def testFitsHeader(self):
"""
Create a test image with the LSST camera and with the
cartoon camera. Verify that the image created with the LSST
camera has the DM-required cards in its FITS header while the
image created with the cartoon camera does not
"""
cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'),
'tests', 'cameraData')
cartoonCamera = ReturnCamera(cameraDir)
outputDir = tempfile.mkdtemp(dir=ROOT, prefix='testFitsHeader-')
lsst_cat_name = os.path.join(outputDir, 'fits_test_lsst_cat.txt')
lsst_cat_root = os.path.join(outputDir, 'fits_test_lsst_image')
cartoon_cat_name = os.path.join(outputDir, 'fits_test_cartoon_cat.txt')
cartoon_cat_root = os.path.join(outputDir, 'fits_test_cartoon_image')
obs = ObservationMetaData(pointingRA=32.0,
pointingDec=22.0,
boundLength=0.1,
boundType='circle',
mjd=58000.0,
rotSkyPos=14.0,
bandpassName='u')
obs.OpsimMetaData = {'obshistID': 112}
dbFileName = os.path.join(outputDir, 'fits_test_db.dat')
create_text_catalog(obs, dbFileName, np.array([30.0]),
np.array([30.0]), [22.0])
db = fitsHeaderFileDBObj(dbFileName, runtable='test')
# first test the lsst camera
lsstCat = fitsHeaderCatalog(db, obs_metadata=obs)
lsstCat.camera_wrapper = LSSTCameraWrapper()
lsstCat.PSF = SNRdocumentPSF()
lsstCat.write_catalog(lsst_cat_name)
lsstCat.write_images(nameRoot=lsst_cat_root)
list_of_files = os.listdir(outputDir)
ct = 0
for file_name in list_of_files:
true_name = os.path.join(outputDir, file_name)
if lsst_cat_root in true_name:
ct += 1
with fits.open(true_name) as fitsTest:
header = fitsTest[0].header
self.assertIn('CHIPID', header)
self.assertIn('OBSID', header)
self.assertIn('OUTFILE', header)
self.assertEqual(header['OBSID'], 112)
self.assertEqual(header['CHIPID'], 'R22_S11')
self.assertEqual(header['OUTFILE'],
'lsst_e_112_f0_R22_S11_E000')
os.unlink(true_name)
self.assertGreater(ct, 0)
if os.path.exists(lsst_cat_name):
os.unlink(lsst_cat_name)
# now test with the cartoon camera
cartoonCat = fitsHeaderCatalog(db, obs_metadata=obs)
cartoonCat.camera_wrapper = GalSimCameraWrapper(cartoonCamera)
cartoonCat.PSF = SNRdocumentPSF()
cartoonCat.write_catalog(cartoon_cat_name)
cartoonCat.write_images(nameRoot=cartoon_cat_root)
list_of_files = os.listdir(outputDir)
ct = 0
for file_name in list_of_files:
true_name = os.path.join(outputDir, file_name)
if cartoon_cat_root in true_name:
ct += 1
with fits.open(true_name) as fitsTest:
header = fitsTest[0].header
self.assertNotIn('CHIPID', header)
self.assertNotIn('OBSID', header)
self.assertNotIn('OUTFILE', header)
os.unlink(true_name)
self.assertGreater(ct, 0)
if os.path.exists(cartoon_cat_name):
os.unlink(cartoon_cat_name)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(outputDir):
shutil.rmtree(outputDir)
class testGalSimStars(GalSimStars):
#only draw images for u and g bands (for speed)
bandpassNames = ['u', 'g']
#defined in galSimInterface/galSimUtilities.py
PSF = SNRdocumentPSF()
def testCamera(self):
"""
Test that GalSimCatalogs respect the allowed_chips variable by
generating a catalog with one object on each chip.
Generate images from a control catalog that allows all chips.
Verify that each image contains the expected flux.
Generate images from a test catalog that only allows two chips.
Verify that only the two expected images exist and that each
contains only the expected flux.
"""
controlCatalog = allowedChipsCatalog(self.db, obs_metadata=self.obs)
testCatalog = allowedChipsCatalog(self.db, obs_metadata=self.obs)
psf = SNRdocumentPSF()
controlCatalog.setPSF(psf)
testCatalog.setPSF(psf)
controlCatalog.camera_wrapper = GalSimCameraWrapper(self.camera)
testCatalog.camera_wrapper = GalSimCameraWrapper(self.camera)
test_root = os.path.join(self.scratchDir, 'allowed_chip_test_image')
control_root = os.path.join(self.scratchDir,
'allowed_chip_control_image')
name_list = []
for dd in self.camera:
if dd.getType() == WAVEFRONT or dd.getType() == GUIDER:
continue
name = dd.getName()
name_list.append(name)
stripped_name = name.replace(':', '')
stripped_name = stripped_name.replace(',', '')
stripped_name = stripped_name.replace(' ', '_')
test_image_name = os.path.join(
self.scratchDir, test_root + '_' + stripped_name + '_u.fits')
control_image_name = os.path.join(
self.scratchDir,
control_root + '_' + stripped_name + '_u.fits')
# remove any images that were generated the last time this test
# was run
if os.path.exists(test_image_name):
os.unlink(test_image_name)
if os.path.exists(control_image_name):
os.unlink(control_image_name)
# only allow two chips in the test catalog
allowed_chips = [name_list[3], name_list[4]]
testCatalog.allowed_chips = allowed_chips
test_cat_name = os.path.join(self.scratchDir,
'allowed_chips_test_cat.txt')
control_cat_name = os.path.join(self.scratchDir,
'allowed_chips_control_cat.txt')
testCatalog.write_catalog(test_cat_name)
controlCatalog.write_catalog(control_cat_name)
testCatalog.write_images(nameRoot=test_root)
controlCatalog.write_images(nameRoot=control_root)
test_image_ct = 0
for name in name_list:
# Loop through each chip on the camera.
# Verify that the control catalog generated an image for each chip.
# Verify that the test catalog only generated images for the two
# specified chips.
# Verify that each image contains the expected amount of flux.
stripped_name = name.replace(':', '')
stripped_name = stripped_name.replace(',', '')
stripped_name = stripped_name.replace(' ', '_')
test_image_name = os.path.join(
self.scratchDir, test_root + '_' + stripped_name + '_u.fits')
control_image_name = os.path.join(
self.scratchDir,
control_root + '_' + stripped_name + '_u.fits')
msg = '%s does not exist; it should' % control_image_name
self.assertTrue(os.path.exists(control_image_name), msg=msg)
im = afwImage.ImageF(control_image_name).getArray()
msg = "\nimage contains %e counts\nshould contain %e\n\n" % (
im.sum(), self.controlADU)
self.assertLess(np.abs(im.sum() - self.controlADU),
3.0 * self.countSigma,
msg=msg)
os.unlink(control_image_name)
if name in allowed_chips:
msg = '%s does not exist; it should' % test_image_name
self.assertTrue(os.path.exists(test_image_name), msg=msg)
im = afwImage.ImageF(test_image_name).getArray()
self.assertLess(np.abs(im.sum() - self.controlADU),
3.0 * self.countSigma)
os.unlink(test_image_name)
test_image_ct += 1
else:
msg = '%s exists; it should not' % test_image_name
self.assertFalse(os.path.exists(test_image_name), msg=msg)
self.assertEqual(test_image_ct, len(allowed_chips))
if os.path.exists(test_cat_name):
os.unlink(test_cat_name)
if os.path.exists(control_cat_name):
os.unlink(control_cat_name)
class psfCatalog(testGalaxyCatalog):
"""
Adds a PSF to testGalaxyCatalog
"""
PSF = SNRdocumentPSF()
class noisyCatalog(testGalaxyCatalog):
"""
Adds a noise and sky background wrapper to testGalaxyCatalog
"""
PSF = SNRdocumentPSF()
noise_and_background = ExampleCCDNoise(seed=42)
class backgroundCatalog(testGalaxyCatalog):
"""
Add sky background but no noise to testGalaxyCatalog
"""
PSF = SNRdocumentPSF()
noise_and_background = ExampleCCDNoise(addNoise=False, seed=42)
def testObjectPlacement(self):
"""
Test that GalSim places objects on the correct pixel by drawing
images containing single objects and no background, reading those
images back in, and comparing the flux-averaged centroids of the
images with the expected pixel positions of the input objects.
"""
scratchDir = tempfile.mkdtemp(dir=ROOT,
prefix='testLSSTObjectPlacement-')
if os.path.exists(scratchDir):
shutil.rmtree(scratchDir)
os.mkdir(scratchDir)
detector = lsst_camera()['R:0,3 S:2,2']
det_name = 'R03_S22'
magNorm = 19.0
pixel_transformer = DMtoCameraPixelTransformer()
for band in 'ugrizy':
obs = self.obs_dict[band]
catName = os.path.join(scratchDir, 'placementCatalog.dat')
imageRoot = os.path.join(scratchDir, 'placementImage')
dbFileName = os.path.join(scratchDir, 'placementInputCatalog.dat')
imageName = '%s_%s_%s.fits' % (imageRoot, det_name, obs.bandpass)
ra_c, dec_c = raDecFromPixelCoordsLSST(2000.0,
2000.0,
detector.getName(),
band=obs.bandpass,
obs_metadata=obs)
nSamples = 3
rng = np.random.RandomState(42)
fwhm = 0.2
for iteration in range(nSamples):
if os.path.exists(dbFileName):
os.unlink(dbFileName)
ra_obj = ra_c + rng.random_sample() * 0.2 - 0.1
dec_obj = dec_c + rng.random_sample() * 0.2 - 0.1
dmx_wrong, dmy_wrong = pixelCoordsFromRaDec(
ra_obj,
dec_obj,
chipName=detector.getName(),
obs_metadata=obs,
camera=lsst_camera())
dmx_pix, dmy_pix = pixelCoordsFromRaDecLSST(
ra_obj,
dec_obj,
chipName=detector.getName(),
obs_metadata=obs,
band=obs.bandpass)
x_pix, y_pix = pixel_transformer.cameraPixFromDMPix(
dmx_pix, dmy_pix, detector.getName())
x_pix_wrong, y_pix_wrong = pixel_transformer.cameraPixFromDMPix(
dmx_wrong, dmy_wrong, detector.getName())
d_ra = 3600.0 * (ra_obj - obs.pointingRA) # in arcseconds
d_dec = 3600.0 * (dec_obj - obs.pointingDec)
create_text_catalog(obs,
dbFileName,
np.array([d_ra]),
np.array([d_dec]),
mag_norm=[magNorm])
db = LSSTPlacementFileDBObj(dbFileName, runtable='test')
cat = LSSTPlacementCatalog(db, obs_metadata=obs)
cat.camera_wrapper = LSSTCameraWrapper()
psf = SNRdocumentPSF(fwhm=fwhm)
cat.setPSF(psf)
cat.write_catalog(catName)
cat.write_images(nameRoot=imageRoot)
im = afwImage.ImageF(imageName).getArray()
tot_flux = im.sum()
self.assertGreater(tot_flux, 100.0)
y_centroid = sum(
[ii * im[ii, :].sum()
for ii in range(im.shape[0])]) / tot_flux
x_centroid = sum(
[ii * im[:, ii].sum()
for ii in range(im.shape[1])]) / tot_flux
dd = np.sqrt((x_pix - x_centroid)**2 + (y_pix - y_centroid)**2)
self.assertLess(dd, 0.5 * fwhm)
dd_wrong = np.sqrt((x_pix_wrong - x_centroid)**2 +
(y_pix_wrong - y_centroid)**2)
self.assertLess(dd, dd_wrong)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(imageName):
os.unlink(imageName)
if os.path.exists(scratchDir):
shutil.rmtree(scratchDir)