def test_read_tree_rings(self):
"""Check reading of tree_ring_parameters file"""
camera_wrapper = LSSTCameraWrapper()
desc.imsim.read_config()
needed_stuff = desc.imsim.parsePhoSimInstanceFile(self.instcat_file, ())
obs_md = needed_stuff.obs_metadata
phot_params = needed_stuff.phot_params
detector_list = []
for sensor in self.sensors:
detector_list.append(make_galsim_detector(camera_wrapper, sensor, phot_params, obs_md))
gs_interpreter = GalSimInterpreter(detectors=detector_list)
tr_filename = os.path.join(lsstUtils.getPackageDir('imsim'),
'data', 'tree_ring_data',
'tree_ring_parameters_19mar18.txt')
desc.imsim.add_treering_info(gs_interpreter.detectors,
tr_filename=tr_filename)
for i, detector in enumerate(gs_interpreter.detectors):
center = detector.tree_rings.center
shifted_center = (center.x - detector._xCenterPix, center.y - detector._yCenterPix)
self.assertAlmostEqual(shifted_center, self.centers[i], 1)
r_value_test = detector.tree_rings.func(self.rtest)
self.assertAlmostEqual(r_value_test, self.rvalues[i], 6)
def compare_to_imsim(phosim_commands):
bandpass = bandpass_all[int(phosim_commands['filter'].values[0])]
obs_md = ObservationMetaData(
pointingRA=float(phosim_commands['rightascension'].values[0]),
pointingDec=float(phosim_commands['declination'].values[0]),
mjd=float(phosim_commands['mjd'].values[0]),
rotSkyPos=float(phosim_commands['rotskypos'].values[0]),
bandpassName=bandpass,
m5=LSSTdefaults().m5(bandpass),
seeing=float(phosim_commands['seeing'].values[0]))
noise_and_background = ESOSkyModel(obs_md,
addNoise=True,
addBackground=True)
phot_params = PhotometricParameters(
exptime=float(phosim_commands['vistime'].values[0]),
nexp=int(phosim_commands['nsnap'].values[0]),
gain=1,
readnoise=0,
darkcurrent=0,
bandpass=bandpass)
# We are going to check one sensor only
detector_list = [
make_galsim_detector(camera_wrapper, "R:2,2 S:1,1", phot_params,
obs_md)
]
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=1234)
image = gs_interpreter.blankImage(detector=detector_list[0])
image_2 = noise_and_background.addNoiseAndBackground(
image,
bandpass=obs_md.bandpass,
m5=obs_md.m5,
FWHMeff=obs_md.seeing,
photParams=phot_params,
chipName=detector_list[0].name)
return compute_bkg(image_2.array)
def _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if self.galSimInterpreter is None:
#This list will contain instantiations of the GalSimDetector class
#(see galSimInterpreter.py), which stores detector information in a way
#that the GalSimInterpreter will understand
detectors = []
for dd in self.camera:
if self.allowed_chips is None or dd.getName() in self.allowed_chips:
cs = dd.makeCameraSys(PUPIL)
centerPupil = self.camera.transform(dd.getCenter(FOCAL_PLANE),cs).getPoint()
centerPixel = dd.getCenter(PIXELS).getPoint()
translationPixel = afwGeom.Point2D(centerPixel.getX()+1, centerPixel.getY()+1)
translationPupil = self.camera.transform(
dd.makeCameraPoint(translationPixel, PIXELS), cs).getPoint()
plateScale = numpy.sqrt(numpy.power(translationPupil.getX()-centerPupil.getX(),2)+
numpy.power(translationPupil.getY()-centerPupil.getY(),2))/numpy.sqrt(2.0)
plateScale = 3600.0*numpy.degrees(plateScale)
#make a detector-custom photParams that copies all of the quantities
#in the catalog photParams, except the platescale, which is
#calculated above
params = PhotometricParameters(exptime=self.photParams.exptime,
nexp=self.photParams.nexp,
effarea=self.photParams.effarea,
gain=self.photParams.gain,
readnoise=self.photParams.readnoise,
darkcurrent=self.photParams.darkcurrent,
othernoise=self.photParams.othernoise,
platescale=plateScale)
detector = GalSimDetector(dd, self.camera,
obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch,
photParams=params)
detectors.append(detector)
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify m5 in your '+
'obs_metadata. m5 is required in order to add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'm5 has: %s ' % self.obs_metadata.m5.keys().__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify seeing in your '+
'obs_metadata. seeing is required in order to add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'seeing has: %s ' % self.obs_metadata.seeing.keys().__repr__())
self.bandpassDict, hardwareDict = BandpassDict.loadBandpassesFromFiles(bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir, self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch, detectors=detectors,
bandpassDict=self.bandpassDict, noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
class GalSimBase(InstanceCatalog, CameraCoords):
"""
The catalog classes in this file use the InstanceCatalog infrastructure to construct
FITS images for each detector-filter combination on a simulated camera. This is done by
instantiating the class GalSimInterpreter. GalSimInterpreter is the class which
actually generates the FITS images. As the GalSim InstanceCatalogs are iterated over,
each object in the catalog is passed to the GalSimInterpeter, which adds the object
to the appropriate FITS images. The user can then write the images to disk by calling
the write_images method in the GalSim InstanceCatalog.
Objects are passed to the GalSimInterpreter by the get_fitsFiles getter function, which
adds a column to the InstanceCatalog indicating which detectors' FITS files contain each
object.
Note: because each GalSim InstanceCatalog has its own GalSimInterpreter, it means
that each GalSimInterpreter will only draw FITS images containing one type of object
(whatever type of object is contained in the GalSim InstanceCatalog). If the user
wishes to generate FITS images containing multiple types of object, the method
copyGalSimInterpreter allows the user to pass the GalSimInterpreter from one
GalSim InstanceCatalog to another (so, the user could create a GalSim Instance
Catalog of stars, generate that InstanceCatalog, then create a GalSim InstanceCatalog
of galaxies, pass the GalSimInterpreter from the star catalog to this new catalog,
and thus create FITS images that contain both stars and galaxies; see galSimCompoundGenerator.py
in the examples/ directory of sims_catUtils for an example).
This class (GalSimBase) is the base class for all GalSim InstanceCatalogs. Daughter
classes of this class need to behave like ordinary InstanceCatalog daughter classes
with the following exceptions:
1) If they re-define column_outputs, they must be certain to include the column
'fitsFiles.' The getter for this column (defined in this class) calls all of the
GalSim image generation infrastructure
2) Daughter classes of this class must define a member variable galsim_type that is either
'sersic' or 'pointSource'. This variable tells the GalSimInterpreter how to draw the
object (to allow a different kind of image profile, define a new method in the GalSimInterpreter
class similar to drawPoinSource and drawSersic)
3) The variables bandpass_names (a list of the form ['u', 'g', 'r', 'i', 'z', 'y']),
bandpass_directory, and bandpass_root should be defined to tell the GalSim InstanceCatalog
where to find the files defining the bandpasses to be used for these FITS files.
The GalSim InstanceCatalog will look for bandpass files in files with the names
for bpn in bandpass_names:
name = self.bandpass_directory+'/'+self.bandpass_root+'_'+bpn+'.dat'
one should also define the following member variables:
componentList is a list of files ins banpass_directory containing the response
curves for the different components of the camera, e.g.
['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat', 'lens1.dat', 'lens2.dat', 'lens3.dat']
atomTransmissionName is the name of the file in bandpass_directory that contains the
atmostpheric transmissivity, e.g. 'atmos_std.dat'
4) Telescope parameters such as exposure time, area, and gain are stored in the
GalSim InstanceCatalog member variable photParams, which is an instantiation of
the class PhotometricParameters defined in sims_photUtils.
Daughter classes of GalSimBase will generate both FITS images for all of the detectors/filters
in their corresponding cameras and InstanceCatalogs listing all of the objects
contained in those images. The catalog is written using the normal write_catalog()
method provided for all InstanceClasses. The FITS files are drawn using the write_images()
method that is unique to GalSim InstanceCatalogs. The FITS file will be named something like:
DetectorName_FilterName.fits
(a typical LSST fits file might be R_0_0_S_1_0_y.fits)
Note: If you call write_images() before iterating over the catalog (either by calling
write_catalog() or using the iterator returned by InstanceCatalog.iter_catalog()),
you will get empty or incomplete FITS files. Objects are only added to the GalSimInterpreter
in the course of iterating over the InstanceCatalog.
"""
seed = 42
#This is sort of a hack; it prevents findChipName in coordUtils from dying
#if an object lands on multiple science chips.
allow_multiple_chips = True
#There is no point in writing things to the InstanceCatalog that do not have SEDs and/or
#do not land on any detectors
cannot_be_null = ['sedFilepath', 'fitsFiles']
column_outputs = ['galSimType', 'uniqueId', 'raICRS', 'decICRS',
'chipName', 'x_pupil', 'y_pupil', 'sedFilepath',
'majorAxis', 'minorAxis', 'sindex', 'halfLightRadius',
'positionAngle','fitsFiles']
transformations = {'raICRS':numpy.degrees,
'decICRS':numpy.degrees,
'x_pupil':arcsecFromRadians,
'y_pupil':arcsecFromRadians,
'halfLightRadius':arcsecFromRadians}
default_formats = {'S':'%s', 'f':'%.9g', 'i':'%i'}
#This is used as the delimiter because the names of the detectors printed in the fitsFiles
#column contain both ':' and ','
delimiter = '; '
sedDir = lsst.utils.getPackageDir('sims_sed_library')
bandpassNames = ['u', 'g', 'r', 'i', 'z', 'y']
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline')
bandpassRoot = 'filter_'
componentList = ['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat',
'lens1.dat', 'lens2.dat', 'lens3.dat']
atmoTransmissionName = 'atmos_std.dat'
# allowed_chips is a list of the names of the detectors we actually want to draw.
# If 'None', then all chips are drawn.
allowed_chips = None
#This member variable will define a PSF to convolve with the sources.
#See the classes PSFbase and DoubleGaussianPSF in
#galSimUtilities.py for more information
PSF = None
#This member variable can store a GalSim noise model instantiation
#which will be applied to the FITS images when they are created
noise_and_background = None
#Stores the gain and readnoise
photParams = PhotometricParameters()
#This is just a place holder for the camera object associated with the InstanceCatalog.
#If you want to assign a different camera, you can do so immediately after instantiating this class
camera = camTestUtils.CameraWrapper().camera
uniqueSeds = {} #a cache for un-normalized SED files, so that we do not waste time on I/O
hasBeenInitialized = False
galSimInterpreter = None #the GalSimInterpreter instantiation for this catalog
totalDrawings = 0
totalObjects = 0
def _initializeGalSimCatalog(self):
"""
Initializes an empty list of objects that have already been drawn to FITS images.
We do not want to accidentally draw an object twice.
Also initializes the GalSimInterpreter by calling self._initializeGalSimInterpreter()
Objects are stored based on their uniqueId values.
"""
self.objectHasBeenDrawn = []
self._initializeGalSimInterpreter()
self.hasBeenInitialized = True
def get_sedFilepath(self):
"""
Maps the name of the SED as stored in the database to the file stored in
sims_sed_library
"""
#copied from the phoSim catalogs
return numpy.array([self.specFileMap[k] if self.specFileMap.has_key(k) else None
for k in self.column_by_name('sedFilename')])
def _calculateGalSimSeds(self):
"""
Apply any physical corrections to the objects' SEDS (redshift them, apply dust, etc.).
Return a list of Sed objects containing the SEDS
"""
sedList = []
actualSEDnames = self.column_by_name('sedFilepath')
redshift = self.column_by_name('redshift')
internalAv = self.column_by_name('internalAv')
internalRv = self.column_by_name('internalRv')
galacticAv = self.column_by_name('galacticAv')
galacticRv = self.column_by_name('galacticRv')
magNorm = self.column_by_name('magNorm')
#for setting magNorm
imsimband = Bandpass()
imsimband.imsimBandpass()
outputNames=[]
for (sedName, zz, iAv, iRv, gAv, gRv, norm) in \
zip(actualSEDnames, redshift, internalAv, internalRv, galacticAv, galacticRv, magNorm):
if is_null(sedName):
sedList.append(None)
else:
if sedName in self.uniqueSeds:
#we have already read in this file; no need to do it again
sed = Sed(wavelen=self.uniqueSeds[sedName].wavelen,
flambda=self.uniqueSeds[sedName].flambda,
fnu=self.uniqueSeds[sedName].fnu,
name=self.uniqueSeds[sedName].name)
else:
#load the SED of the object
sed = Sed()
sedFile = os.path.join(self.sedDir, sedName)
sed.readSED_flambda(sedFile)
flambdaCopy = copy.deepcopy(sed.flambda)
#If the SED is zero inside of the bandpass, GalSim raises an error.
#This sets a minimum flux value of 1.0e-30 so that the SED is never technically
#zero inside of the bandpass.
sed.flambda = numpy.array([ff if ff>1.0e-30 else 1.0e-30 for ff in flambdaCopy])
sed.fnu = None
#copy the unnormalized file to uniqueSeds so we don't have to read it in again
sedCopy = Sed(wavelen=sed.wavelen, flambda=sed.flambda,
fnu=sed.fnu, name=sed.name)
self.uniqueSeds[sedName] = sedCopy
#normalize the SED
#Consulting the file sed.py in GalSim/galsim/ it appears that GalSim expects
#its SEDs to ultimately be in units of ergs/nm so that, when called, they can
#be converted to photons/nm (see the function __call__() and the assignment of
#self._rest_photons in the __init__() of galsim's sed.py file). Thus, we need
#to read in our SEDs, normalize them, and then multiply by the exposure time
#and the effective area to get from ergs/s/cm^2/nm to ergs/nm.
#
#The gain parameter should convert between photons and ADU (so: it is the
#traditional definition of "gain" -- electrons per ADU -- multiplied by the
#quantum efficiency of the detector). Because we fold the quantum efficiency
#of the detector into our total_[u,g,r,i,z,y].dat bandpass files
#(see the readme in the THROUGHPUTS_DIR/baseline/), we only need to multiply
#by the electrons per ADU gain.
#
#We will take these parameters from an instantiation of the PhotometricParameters
#class (which can be reassigned by defining a daughter class of this class)
#
fNorm = sed.calcFluxNorm(norm, imsimband)
sed.multiplyFluxNorm(fNorm)
#apply dust extinction (internal)
if iAv != 0.0 and iRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=iAv, R_v=iRv)
#22 June 2015
#apply redshift; there is no need to apply the distance modulus from
#sims/photUtils/CosmologyWrapper; magNorm takes that into account
#however, magNorm does not take into account cosmological dimming
if zz != 0.0:
sed.redshiftSED(zz, dimming=True)
#apply dust extinction (galactic)
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=gAv, R_v=gRv)
sedList.append(sed)
return sedList
def get_fitsFiles(self):
"""
This getter returns a column listing the names of the detectors whose corresponding
FITS files contain the object in question. The detector names will be separated by a '//'
This getter also passes objects to the GalSimInterpreter to actually draw the FITS
images.
"""
objectNames = self.column_by_name('uniqueId')
raICRS = self.column_by_name('raICRS')
decICRS = self.column_by_name('decICRS')
xPupil = self.column_by_name('x_pupil')
yPupil = self.column_by_name('y_pupil')
halfLight = self.column_by_name('halfLightRadius')
minorAxis = self.column_by_name('minorAxis')
majorAxis = self.column_by_name('majorAxis')
positionAngle = self.column_by_name('positionAngle')
sindex = self.column_by_name('sindex')
#correct the SEDs for redshift, dust, etc. Return a list of Sed objects as defined in
#sims_photUtils/../../Sed.py
sedList = self._calculateGalSimSeds()
if self.hasBeenInitialized is False and len(objectNames)>0:
#This needs to be here in case, instead of writing the whole catalog with write_catalog(),
#the user wishes to iterate through the catalog with InstanceCatalog.iter_catalog(),
#which will not call write_header()
self._initializeGalSimCatalog()
if not hasattr(self, 'bandpassDict'):
raise RuntimeError('ran initializeGalSimCatalog but do not have bandpassDict')
output = []
for (name, ra, dec, xp, yp, hlr, minor, major, pa, ss, sn) in \
zip(objectNames, raICRS, decICRS, xPupil, yPupil, halfLight, \
minorAxis, majorAxis, positionAngle, sedList, sindex):
if ss is None or name in self.objectHasBeenDrawn:
#do not draw objects that have no SED or have already been drawn
output.append(None)
if name in self.objectHasBeenDrawn:
#15 December 2014
#This should probably be an error. However, something is wrong with
#the SQL on fatboy such that it does return the same objects more than
#once (at least in the case of stars). Yusra is currently working to fix
#the problem. Until then, this will just warn you that the same object
#appears twice in your catalog and will refrain from drawing it the second
#time.
print 'Trying to draw %s more than once ' % str(name)
else:
self.objectHasBeenDrawn.append(name)
flux_dict = {}
for bb in self.bandpassNames:
adu = ss.calcADU(self.bandpassDict[bb], self.photParams)
flux_dict[bb] = adu*self.photParams.gain
gsObj = GalSimCelestialObject(self.galsim_type, ss, ra, dec, xp, yp, \
hlr, minor, major, pa, sn, flux_dict)
#actually draw the object
detectorsString = self.galSimInterpreter.drawObject(gsObj)
output.append(detectorsString)
return numpy.array(output)
def setPSF(self, PSF):
"""
Set the PSF of this GalSimCatalog after instantiation.
@param [in] PSF is an instantiation of a GalSimPSF class.
"""
self.PSF=PSF
if self.galSimInterpreter is not None:
self.galSimInterpreter.setPSF(PSF=PSF)
def copyGalSimInterpreter(self, otherCatalog):
"""
Copy the camera, GalSimInterpreter, from another GalSim InstanceCatalog
so that multiple types of object (stars, AGN, galaxy bulges, galaxy disks, etc.)
can be drawn on the same FITS files.
Note: This method does not copy the member variables PSF or noise_and_background
from one catalog to another. Those need to be defined in each catalog separately.
@param [in] otherCatalog is another GalSim InstanceCatalog that already has
an initialized GalSimInterpreter
See galSimCompoundGenerator.py in the examples/ directory of sims_catUtils for
an example of how this is used.
"""
self.camera = otherCatalog.camera
self.photParams = otherCatalog.photParams
self.bandpassDict = otherCatalog.bandpassDict
self.galSimInterpreter = otherCatalog.galSimInterpreter
def _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if self.galSimInterpreter is None:
#This list will contain instantiations of the GalSimDetector class
#(see galSimInterpreter.py), which stores detector information in a way
#that the GalSimInterpreter will understand
detectors = []
for dd in self.camera:
if self.allowed_chips is None or dd.getName() in self.allowed_chips:
cs = dd.makeCameraSys(PUPIL)
centerPupil = self.camera.transform(dd.getCenter(FOCAL_PLANE),cs).getPoint()
centerPixel = dd.getCenter(PIXELS).getPoint()
translationPixel = afwGeom.Point2D(centerPixel.getX()+1, centerPixel.getY()+1)
translationPupil = self.camera.transform(
dd.makeCameraPoint(translationPixel, PIXELS), cs).getPoint()
plateScale = numpy.sqrt(numpy.power(translationPupil.getX()-centerPupil.getX(),2)+
numpy.power(translationPupil.getY()-centerPupil.getY(),2))/numpy.sqrt(2.0)
plateScale = 3600.0*numpy.degrees(plateScale)
#make a detector-custom photParams that copies all of the quantities
#in the catalog photParams, except the platescale, which is
#calculated above
params = PhotometricParameters(exptime=self.photParams.exptime,
nexp=self.photParams.nexp,
effarea=self.photParams.effarea,
gain=self.photParams.gain,
readnoise=self.photParams.readnoise,
darkcurrent=self.photParams.darkcurrent,
othernoise=self.photParams.othernoise,
platescale=plateScale)
detector = GalSimDetector(dd, self.camera,
obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch,
photParams=params)
detectors.append(detector)
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify m5 in your '+
'obs_metadata. m5 is required in order to add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'm5 has: %s ' % self.obs_metadata.m5.keys().__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify seeing in your '+
'obs_metadata. seeing is required in order to add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'seeing has: %s ' % self.obs_metadata.seeing.keys().__repr__())
self.bandpassDict, hardwareDict = BandpassDict.loadBandpassesFromFiles(bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir, self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch, detectors=detectors,
bandpassDict=self.bandpassDict, noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
def write_images(self, nameRoot=None):
"""
Writes the FITS images associated with this InstanceCatalog.
Cannot be called before write_catalog is called.
@param [in] nameRoot is an optional string prepended to the names
of the FITS images. The FITS images will be named
@param [out] namesWritten is a list of the names of the FITS files generated
nameRoot_DetectorName_FilterName.fits
(e.g. myImages_R_0_0_S_1_1_y.fits for an LSST-like camera with
nameRoot = 'myImages')
"""
namesWritten = self.galSimInterpreter.writeImages(nameRoot=nameRoot)
return namesWritten
class GalSimBase(InstanceCatalog, CameraCoords):
"""
The catalog classes in this file use the InstanceCatalog infrastructure to construct
FITS images for each detector-filter combination on a simulated camera. This is done by
instantiating the class GalSimInterpreter. GalSimInterpreter is the class which
actually generates the FITS images. As the GalSim InstanceCatalogs are iterated over,
each object in the catalog is passed to the GalSimInterpeter, which adds the object
to the appropriate FITS images. The user can then write the images to disk by calling
the write_images method in the GalSim InstanceCatalog.
Objects are passed to the GalSimInterpreter by the get_fitsFiles getter function, which
adds a column to the InstanceCatalog indicating which detectors' FITS files contain each
object.
Note: because each GalSim InstanceCatalog has its own GalSimInterpreter, it means
that each GalSimInterpreter will only draw FITS images containing one type of object
(whatever type of object is contained in the GalSim InstanceCatalog). If the user
wishes to generate FITS images containing multiple types of object, the method
copyGalSimInterpreter allows the user to pass the GalSimInterpreter from one
GalSim InstanceCatalog to another (so, the user could create a GalSim Instance
Catalog of stars, generate that InstanceCatalog, then create a GalSim InstanceCatalog
of galaxies, pass the GalSimInterpreter from the star catalog to this new catalog,
and thus create FITS images that contain both stars and galaxies; see galSimCompoundGenerator.py
in the examples/ directory of sims_catUtils for an example).
This class (GalSimBase) is the base class for all GalSim InstanceCatalogs. Daughter
classes of this class need to behave like ordinary InstanceCatalog daughter classes
with the following exceptions:
1) If they re-define column_outputs, they must be certain to include the column
'fitsFiles.' The getter for this column (defined in this class) calls all of the
GalSim image generation infrastructure
2) Daughter classes of this class must define a member variable galsim_type that is either
'sersic' or 'pointSource'. This variable tells the GalSimInterpreter how to draw the
object (to allow a different kind of image profile, define a new method in the GalSimInterpreter
class similar to drawPoinSource and drawSersic)
3) The variables bandpass_names (a list of the form ['u', 'g', 'r', 'i', 'z', 'y']),
bandpass_directory, and bandpass_root should be defined to tell the GalSim InstanceCatalog
where to find the files defining the bandpasses to be used for these FITS files.
The GalSim InstanceCatalog will look for bandpass files in files with the names
for bpn in bandpass_names:
name = self.bandpass_directory+'/'+self.bandpass_root+'_'+bpn+'.dat'
one should also define the following member variables:
componentList is a list of files ins banpass_directory containing the response
curves for the different components of the camera, e.g.
['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat', 'lens1.dat', 'lens2.dat', 'lens3.dat']
atomTransmissionName is the name of the file in bandpass_directory that contains the
atmostpheric transmissivity, e.g. 'atmos_std.dat'
4) Telescope parameters such as exposure time, area, and gain are stored in the
GalSim InstanceCatalog member variable photParams, which is an instantiation of
the class PhotometricParameters defined in sims_photUtils.
Daughter classes of GalSimBase will generate both FITS images for all of the detectors/filters
in their corresponding cameras and InstanceCatalogs listing all of the objects
contained in those images. The catalog is written using the normal write_catalog()
method provided for all InstanceClasses. The FITS files are drawn using the write_images()
method that is unique to GalSim InstanceCatalogs. The FITS file will be named something like:
DetectorName_FilterName.fits
(a typical LSST fits file might be R_0_0_S_1_0_y.fits)
Note: If you call write_images() before iterating over the catalog (either by calling
write_catalog() or using the iterator returned by InstanceCatalog.iter_catalog()),
you will get empty or incomplete FITS files. Objects are only added to the GalSimInterpreter
in the course of iterating over the InstanceCatalog.
"""
seed = 42
# This is sort of a hack; it prevents findChipName in coordUtils from dying
# if an object lands on multiple science chips.
allow_multiple_chips = True
# There is no point in writing things to the InstanceCatalog that do not have SEDs and/or
# do not land on any detectors
cannot_be_null = ['sedFilepath']
column_outputs = ['galSimType', 'uniqueId', 'raICRS', 'decICRS',
'chipName', 'x_pupil', 'y_pupil', 'sedFilepath',
'majorAxis', 'minorAxis', 'sindex', 'halfLightRadius',
'positionAngle', 'fitsFiles']
transformations = {'raICRS': np.degrees,
'decICRS': np.degrees,
'x_pupil': arcsecFromRadians,
'y_pupil': arcsecFromRadians,
'halfLightRadius': arcsecFromRadians}
default_formats = {'S': '%s', 'f': '%.9g', 'i': '%i'}
# This is used as the delimiter because the names of the detectors printed in the fitsFiles
# column contain both ':' and ','
delimiter = '; '
sedDir = lsst.utils.getPackageDir('sims_sed_library')
bandpassNames = None
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline')
bandpassRoot = 'filter_'
componentList = ['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat',
'lens1.dat', 'lens2.dat', 'lens3.dat']
atmoTransmissionName = 'atmos_std.dat'
# allowed_chips is a list of the names of the detectors we actually want to draw.
# If 'None', then all chips are drawn.
allowed_chips = None
# This member variable will define a PSF to convolve with the sources.
# See the classes PSFbase and DoubleGaussianPSF in
# galSimUtilities.py for more information
PSF = None
# This member variable can store a GalSim noise model instantiation
# which will be applied to the FITS images when they are created
noise_and_background = None
# Stores the gain and readnoise
photParams = PhotometricParameters()
# This must be an instantiation of the GalSimCameraWrapper class defined in
# galSimCameraWrapper.py
_camera_wrapper = None
uniqueSeds = {} # a cache for un-normalized SED files, so that we do not waste time on I/O
hasBeenInitialized = False
galSimInterpreter = None # the GalSimInterpreter instantiation for this catalog
totalDrawings = 0
totalObjects = 0
@property
def camera_wrapper(self):
return self._camera_wrapper
@camera_wrapper.setter
def camera_wrapper(self, val):
self._camera_wrapper = val
self.camera = val.camera
def _initializeGalSimCatalog(self):
"""
Initializes an empty list of objects that have already been drawn to FITS images.
We do not want to accidentally draw an object twice.
Also initializes the GalSimInterpreter by calling self._initializeGalSimInterpreter()
Objects are stored based on their uniqueId values.
"""
self.objectHasBeenDrawn = set()
self._initializeGalSimInterpreter()
self.hasBeenInitialized = True
@cached
def get_sedFilepath(self):
"""
Maps the name of the SED as stored in the database to the file stored in
sims_sed_library
"""
# copied from the phoSim catalogs
return np.array([self.specFileMap[k] if k in self.specFileMap else None
for k in self.column_by_name('sedFilename')])
def _calcSingleGalSimSed(self, sedName, zz, iAv, iRv, gAv, gRv, norm):
"""
correct the SED for redshift, dust, etc. Return an Sed object as defined in
sims_photUtils/../../Sed.py
"""
if _is_null(sedName):
return None
sed = self._getSedCopy(sedName)
imsimband = Bandpass()
imsimband.imsimBandpass()
# normalize the SED
# Consulting the file sed.py in GalSim/galsim/ it appears that GalSim expects
# its SEDs to ultimately be in units of ergs/nm so that, when called, they can
# be converted to photons/nm (see the function __call__() and the assignment of
# self._rest_photons in the __init__() of galsim's sed.py file). Thus, we need
# to read in our SEDs, normalize them, and then multiply by the exposure time
# and the effective area to get from ergs/s/cm^2/nm to ergs/nm.
#
# The gain parameter should convert between photons and ADU (so: it is the
# traditional definition of "gain" -- electrons per ADU -- multiplied by the
# quantum efficiency of the detector). Because we fold the quantum efficiency
# of the detector into our total_[u,g,r,i,z,y].dat bandpass files
# (see the readme in the THROUGHPUTS_DIR/baseline/), we only need to multiply
# by the electrons per ADU gain.
#
# We will take these parameters from an instantiation of the PhotometricParameters
# class (which can be reassigned by defining a daughter class of this class)
#
fNorm = sed.calcFluxNorm(norm, imsimband)
sed.multiplyFluxNorm(fNorm)
# apply dust extinction (internal)
if iAv != 0.0 and iRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=iAv, R_v=iRv)
# 22 June 2015
# apply redshift; there is no need to apply the distance modulus from
# sims/photUtils/CosmologyWrapper; magNorm takes that into account
# however, magNorm does not take into account cosmological dimming
if zz != 0.0:
sed.redshiftSED(zz, dimming=True)
# apply dust extinction (galactic)
if gAv != 0.0 and gRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=gAv, R_v=gRv)
return sed
def _getSedCopy(self, sedName):
"""
Return a copy of the requested SED, either from the cached
version or creating a new one and caching a copy for later
reuse.
"""
if sedName in self.uniqueSeds:
# we have already read in this file; no need to do it again
sed = Sed(wavelen=self.uniqueSeds[sedName].wavelen,
flambda=self.uniqueSeds[sedName].flambda,
fnu=self.uniqueSeds[sedName].fnu,
name=self.uniqueSeds[sedName].name)
else:
# load the SED of the object
sed = Sed()
sedFile = os.path.join(self.sedDir, sedName)
sed.readSED_flambda(sedFile)
flambdaCopy = copy.deepcopy(sed.flambda)
# If the SED is zero inside of the bandpass, GalSim raises an error.
# This sets a minimum flux value of 1.0e-30 so that the SED is never technically
# zero inside of the bandpass.
sed.flambda = np.array([ff if ff > 1.0e-30 else 1.0e-30 for ff in flambdaCopy])
sed.fnu = None
# copy the unnormalized file to uniqueSeds so we don't have to read it in again
sedCopy = Sed(wavelen=sed.wavelen, flambda=sed.flambda,
fnu=sed.fnu, name=sed.name)
self.uniqueSeds[sedName] = sedCopy
return sed
def _calculateGalSimSeds(self):
"""
Apply any physical corrections to the objects' SEDS (redshift them, apply dust, etc.).
Return a generator that serves up the Sed objects in order.
"""
actualSEDnames = self.column_by_name('sedFilepath')
redshift = self.column_by_name('redshift')
internalAv = self.column_by_name('internalAv')
internalRv = self.column_by_name('internalRv')
galacticAv = self.column_by_name('galacticAv')
galacticRv = self.column_by_name('galacticRv')
magNorm = self.column_by_name('magNorm')
return (self._calcSingleGalSimSed(*args) for args in
zip(actualSEDnames, redshift, internalAv, internalRv,
galacticAv, galacticRv, magNorm))
@cached
def get_fitsFiles(self):
"""
This getter returns a column listing the names of the detectors whose corresponding
FITS files contain the object in question. The detector names will be separated by a '//'
This getter also passes objects to the GalSimInterpreter to actually draw the FITS
images.
WARNING: do not include 'fitsFiles' in the cannot_be_null list of non-null columns.
If you do that, this method will be called several times by the catalog, as it
attempts to determine which rows are actually in the catalog. That will cause
your images to have too much flux in them.
"""
if self.bandpassNames is None:
if isinstance(self.obs_metadata.bandpass, list):
self.bandpassNames = [self.obs_metadata.bandpass]
else:
self.bandpassNames = self.obs_metadata.bandpass
objectNames = self.column_by_name('uniqueId')
raICRS = self.column_by_name('raICRS')
decICRS = self.column_by_name('decICRS')
xPupil = self.column_by_name('x_pupil')
yPupil = self.column_by_name('y_pupil')
halfLight = self.column_by_name('halfLightRadius')
minorAxis = self.column_by_name('minorAxis')
majorAxis = self.column_by_name('majorAxis')
positionAngle = self.column_by_name('positionAngle')
sindex = self.column_by_name('sindex')
gamma1 = self.column_by_name('gamma1')
gamma2 = self.column_by_name('gamma2')
kappa = self.column_by_name('kappa')
sedList = self._calculateGalSimSeds()
if self.hasBeenInitialized is False and len(objectNames) > 0:
# This needs to be here in case, instead of writing the whole catalog with write_catalog(),
# the user wishes to iterate through the catalog with InstanceCatalog.iter_catalog(),
# which will not call write_header()
self._initializeGalSimCatalog()
if not hasattr(self, 'bandpassDict'):
raise RuntimeError('ran initializeGalSimCatalog but do not have bandpassDict')
output = []
for (name, ra, dec, xp, yp, hlr, minor, major, pa, ss, sn, gam1, gam2, kap) in \
zip(objectNames, raICRS, decICRS, xPupil, yPupil, halfLight,
minorAxis, majorAxis, positionAngle, sedList, sindex,
gamma1, gamma2, kappa):
if name in self.objectHasBeenDrawn:
raise RuntimeError('Trying to draw %s more than once ' % str(name))
elif ss is None:
raise RuntimeError('Trying to draw an object with SED == None')
else:
self.objectHasBeenDrawn.add(name)
flux_dict = {}
for bb in self.bandpassNames:
adu = ss.calcADU(self.bandpassDict[bb], self.photParams)
flux_dict[bb] = adu*self.photParams.gain
gsObj = GalSimCelestialObject(self.galsim_type, ss, ra, dec, xp, yp,
hlr, minor, major, pa, sn, flux_dict, gam1, gam2, kap)
# actually draw the object
detectorsString = self.galSimInterpreter.drawObject(gsObj)
output.append(detectorsString)
return np.array(output)
def setPSF(self, PSF):
"""
Set the PSF of this GalSimCatalog after instantiation.
@param [in] PSF is an instantiation of a GalSimPSF class.
"""
self.PSF = PSF
if self.galSimInterpreter is not None:
self.galSimInterpreter.setPSF(PSF=PSF)
def copyGalSimInterpreter(self, otherCatalog):
"""
Copy the camera, GalSimInterpreter, from another GalSim InstanceCatalog
so that multiple types of object (stars, AGN, galaxy bulges, galaxy disks, etc.)
can be drawn on the same FITS files.
@param [in] otherCatalog is another GalSim InstanceCatalog that already has
an initialized GalSimInterpreter
See galSimCompoundGenerator.py in the examples/ directory of sims_catUtils for
an example of how this is used.
"""
self.camera_wrapper = otherCatalog.camera_wrapper
self.photParams = otherCatalog.photParams
self.PSF = otherCatalog.PSF
self.noise_and_background = otherCatalog.noise_and_background
if otherCatalog.hasBeenInitialized:
self.bandpassDict = otherCatalog.bandpassDict
self.galSimInterpreter = otherCatalog.galSimInterpreter
def _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if not isinstance(self.camera_wrapper, GalSimCameraWrapper):
raise RuntimeError("GalSimCatalog.camera_wrapper must be an instantiation of "
"GalSimCameraWrapper or one of its daughter classes\n"
"It is actually of type %s" % str(type(self.camera_wrapper)))
if self.galSimInterpreter is None:
# This list will contain instantiations of the GalSimDetector class
# (see galSimInterpreter.py), which stores detector information in a way
# that the GalSimInterpreter will understand
detectors = []
for dd in self.camera_wrapper.camera:
if dd.getType() == WAVEFRONT or dd.getType() == GUIDER:
# This package does not yet handle the 90-degree rotation
# in WCS that occurs for wavefront or guide sensors
continue
if self.allowed_chips is None or dd.getName() in self.allowed_chips:
centerPupil = self.camera_wrapper.getCenterPupil(dd.getName())
centerPixel = self.camera_wrapper.getCenterPixel(dd.getName())
translationPupil = self.camera_wrapper.pupilCoordsFromPixelCoords(centerPixel.getX()+1,
centerPixel.getY()+1,
dd.getName())
plateScale = np.sqrt(np.power(translationPupil[0]-centerPupil.getX(), 2) +
np.power(translationPupil[1]-centerPupil.getY(), 2))/np.sqrt(2.0)
plateScale = 3600.0*np.degrees(plateScale)
# make a detector-custom photParams that copies all of the quantities
# in the catalog photParams, except the platescale, which is
# calculated above
params = PhotometricParameters(exptime=self.photParams.exptime,
nexp=self.photParams.nexp,
effarea=self.photParams.effarea,
gain=self.photParams.gain,
readnoise=self.photParams.readnoise,
darkcurrent=self.photParams.darkcurrent,
othernoise=self.photParams.othernoise,
platescale=plateScale)
detector = GalSimDetector(dd.getName(), self.camera_wrapper,
obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch,
photParams=params)
detectors.append(detector)
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify m5 in your '
'obs_metadata. m5 is required in order to '
'add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'm5 has: %s ' % list(self.obs_metadata.m5.keys()).__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify seeing in your '
'obs_metadata. seeing is required in order to add '
'noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'seeing has: %s ' % list(self.obs_metadata.seeing.keys()).__repr__())
(self.bandpassDict,
hardwareDict) = BandpassDict.loadBandpassesFromFiles(bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir,
self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(obs_metadata=self.obs_metadata,
epoch=self.db_obj.epoch,
detectors=detectors,
bandpassDict=self.bandpassDict,
noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
def write_images(self, nameRoot=None):
"""
Writes the FITS images associated with this InstanceCatalog.
Cannot be called before write_catalog is called.
@param [in] nameRoot is an optional string prepended to the names
of the FITS images. The FITS images will be named
@param [out] namesWritten is a list of the names of the FITS files generated
nameRoot_DetectorName_FilterName.fits
(e.g. myImages_R_0_0_S_1_1_y.fits for an LSST-like camera with
nameRoot = 'myImages')
"""
namesWritten = self.galSimInterpreter.writeImages(nameRoot=nameRoot)
return namesWritten
def _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if not isinstance(self.camera_wrapper, GalSimCameraWrapper):
raise RuntimeError("GalSimCatalog.camera_wrapper must be an instantiation of "
"GalSimCameraWrapper or one of its daughter classes\n"
"It is actually of type %s" % str(type(self.camera_wrapper)))
if self.galSimInterpreter is None:
# This list will contain instantiations of the GalSimDetector class
# (see galSimInterpreter.py), which stores detector information in a way
# that the GalSimInterpreter will understand
detectors = []
for dd in self.camera_wrapper.camera:
if dd.getType() == WAVEFRONT or dd.getType() == GUIDER:
# This package does not yet handle the 90-degree rotation
# in WCS that occurs for wavefront or guide sensors
continue
if self.allowed_chips is None or dd.getName() in self.allowed_chips:
centerPupil = self.camera_wrapper.getCenterPupil(dd.getName())
centerPixel = self.camera_wrapper.getCenterPixel(dd.getName())
translationPupil = self.camera_wrapper.pupilCoordsFromPixelCoords(centerPixel.getX()+1,
centerPixel.getY()+1,
dd.getName())
plateScale = np.sqrt(np.power(translationPupil[0]-centerPupil.getX(), 2) +
np.power(translationPupil[1]-centerPupil.getY(), 2))/np.sqrt(2.0)
plateScale = 3600.0*np.degrees(plateScale)
# make a detector-custom photParams that copies all of the quantities
# in the catalog photParams, except the platescale, which is
# calculated above
params = PhotometricParameters(exptime=self.photParams.exptime,
nexp=self.photParams.nexp,
effarea=self.photParams.effarea,
gain=self.photParams.gain,
readnoise=self.photParams.readnoise,
darkcurrent=self.photParams.darkcurrent,
othernoise=self.photParams.othernoise,
platescale=plateScale)
detector = GalSimDetector(dd.getName(), self.camera_wrapper,
obs_metadata=self.obs_metadata, epoch=self.db_obj.epoch,
photParams=params)
detectors.append(detector)
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify m5 in your '
'obs_metadata. m5 is required in order to '
'add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'm5 has: %s ' % list(self.obs_metadata.m5.keys()).__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError('WARNING in GalSimCatalog; you did not specify seeing in your '
'obs_metadata. seeing is required in order to add '
'noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError('WARNING in GalSimCatalog; your obs_metadata does not have ' +
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' % self.bandpassNames.__repr__() +
'seeing has: %s ' % list(self.obs_metadata.seeing.keys()).__repr__())
(self.bandpassDict,
hardwareDict) = BandpassDict.loadBandpassesFromFiles(bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir,
self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(obs_metadata=self.obs_metadata,
epoch=self.db_obj.epoch,
detectors=detectors,
bandpassDict=self.bandpassDict,
noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
def _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if not isinstance(self.camera_wrapper, GalSimCameraWrapper):
raise RuntimeError(
"GalSimCatalog.camera_wrapper must be an instantiation of "
"GalSimCameraWrapper or one of its daughter classes\n"
"It is actually of type %s" % str(type(self.camera_wrapper)))
if self.galSimInterpreter is None:
# This list will contain instantiations of the GalSimDetector class
# (see galSimInterpreter.py), which stores detector information in a way
# that the GalSimInterpreter will understand
detectors = []
for dd in self.camera_wrapper.camera:
if dd.getType() == WAVEFRONT or dd.getType() == GUIDER:
# This package does not yet handle the 90-degree rotation
# in WCS that occurs for wavefront or guide sensors
continue
if self.allowed_chips is None or dd.getName(
) in self.allowed_chips:
detectors.append(
make_galsim_detector(self.camera_wrapper,
dd.getName(),
self.photParams,
self.obs_metadata,
epoch=self.db_obj.epoch))
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError(
'WARNING in GalSimCatalog; you did not specify m5 in your '
'obs_metadata. m5 is required in order to '
'add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError(
'WARNING in GalSimCatalog; your obs_metadata does not have '
+ 'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' %
self.bandpassNames.__repr__() + 'm5 has: %s ' %
list(self.obs_metadata.m5.keys()).__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError(
'WARNING in GalSimCatalog; you did not specify seeing in your '
'obs_metadata. seeing is required in order to add '
'noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError(
'WARNING in GalSimCatalog; your obs_metadata does not have '
+
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' %
self.bandpassNames.__repr__() +
'seeing has: %s ' %
list(self.obs_metadata.seeing.keys()).__repr__(
))
(self.bandpassDict,
hardwareDict) = BandpassDict.loadBandpassesFromFiles(
bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir,
self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(
obs_metadata=self.obs_metadata,
epoch=self.db_obj.epoch,
detectors=detectors,
bandpassDict=self.bandpassDict,
noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
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 _initializeGalSimInterpreter(self):
"""
This method creates the GalSimInterpreter (if it is None)
This method reads in all of the data about the camera and pass it into
the GalSimInterpreter.
This method calls _getBandpasses to construct the paths to
the files containing the bandpass data.
"""
if self.galSimInterpreter is None:
# This list will contain instantiations of the GalSimDetector class
# (see galSimInterpreter.py), which stores detector information in a way
# that the GalSimInterpreter will understand
detectors = []
for dd in self.camera:
if self.allowed_chips is None or dd.getName(
) in self.allowed_chips:
cs = dd.makeCameraSys(PUPIL)
centerPupil = self.camera.transform(
dd.getCenter(FOCAL_PLANE), cs).getPoint()
centerPixel = dd.getCenter(PIXELS).getPoint()
translationPixel = afwGeom.Point2D(centerPixel.getX() + 1,
centerPixel.getY() + 1)
translationPupil = self.camera.transform(
dd.makeCameraPoint(translationPixel, PIXELS),
cs).getPoint()
plateScale = np.sqrt(
np.power(translationPupil.getX() -
centerPupil.getX(), 2) +
np.power(translationPupil.getY() -
centerPupil.getY(), 2)) / np.sqrt(2.0)
plateScale = 3600.0 * np.degrees(plateScale)
# make a detector-custom photParams that copies all of the quantities
# in the catalog photParams, except the platescale, which is
# calculated above
params = PhotometricParameters(
exptime=self.photParams.exptime,
nexp=self.photParams.nexp,
effarea=self.photParams.effarea,
gain=self.photParams.gain,
readnoise=self.photParams.readnoise,
darkcurrent=self.photParams.darkcurrent,
othernoise=self.photParams.othernoise,
platescale=plateScale)
detector = GalSimDetector(dd,
self.camera,
obs_metadata=self.obs_metadata,
epoch=self.db_obj.epoch,
photParams=params)
detectors.append(detector)
if not hasattr(self, 'bandpassDict'):
if self.noise_and_background is not None:
if self.obs_metadata.m5 is None:
raise RuntimeError(
'WARNING in GalSimCatalog; you did not specify m5 in your '
'obs_metadata. m5 is required in order to '
'add noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.m5:
raise RuntimeError(
'WARNING in GalSimCatalog; your obs_metadata does not have '
+ 'm5 values for all of your bandpasses \n' +
'bandpass has: %s \n' %
self.bandpassNames.__repr__() + 'm5 has: %s ' %
list(self.obs_metadata.m5.keys()).__repr__())
if self.obs_metadata.seeing is None:
raise RuntimeError(
'WARNING in GalSimCatalog; you did not specify seeing in your '
'obs_metadata. seeing is required in order to add '
'noise to your images')
for name in self.bandpassNames:
if name not in self.obs_metadata.seeing:
raise RuntimeError(
'WARNING in GalSimCatalog; your obs_metadata does not have '
+
'seeing values for all of your bandpasses \n' +
'bandpass has: %s \n' %
self.bandpassNames.__repr__() +
'seeing has: %s ' %
list(self.obs_metadata.seeing.keys()).__repr__(
))
(self.bandpassDict,
hardwareDict) = BandpassDict.loadBandpassesFromFiles(
bandpassNames=self.bandpassNames,
filedir=self.bandpassDir,
bandpassRoot=self.bandpassRoot,
componentList=self.componentList,
atmoTransmission=os.path.join(self.bandpassDir,
self.atmoTransmissionName))
self.galSimInterpreter = GalSimInterpreter(
obs_metadata=self.obs_metadata,
epoch=self.db_obj.epoch,
detectors=detectors,
bandpassDict=self.bandpassDict,
noiseWrapper=self.noise_and_background,
seed=self.seed)
self.galSimInterpreter.setPSF(PSF=self.PSF)
def test_checkpointing(self):
"Test checkpointing of .detectorImages data."
camera = camTestUtils.CameraWrapper().camera
camera_wrapper = GalSimCameraWrapper(camera)
phot_params = PhotometricParameters()
obs_md = ObservationMetaData(pointingRA=23.0,
pointingDec=12.0,
rotSkyPos=13.2,
mjd=59580.0,
bandpassName='r')
detectors = [
make_galsim_detector(camera_wrapper, dd.getName(), phot_params,
obs_md) for dd in camera_wrapper.camera
]
# Create a GalSimInterpreter object and set the checkpoint
# attributes.
gs_interpreter = GalSimInterpreter(detectors=detectors)
gs_interpreter.checkpoint_file = self.cp_file
nobj = 10
gs_interpreter.nobj_checkpoint = nobj
# Set the image data by hand.
key = "R00_S00_r.fits"
detname = "R:0,0 S:0,0"
detector = make_galsim_detector(camera_wrapper, detname, phot_params,
obs_md)
image = gs_interpreter.blankImage(detector=detector)
image += 17
gs_interpreter.detectorImages[key] = image
# Add some drawn objects and check that the checkpoint file is
# written at the right cadence.
for uniqueId in range(1, nobj + 1):
gs_interpreter.drawn_objects.add(uniqueId)
gs_interpreter.write_checkpoint()
if uniqueId < nobj:
self.assertFalse(os.path.isfile(self.cp_file))
else:
self.assertTrue(os.path.isfile(self.cp_file))
# Verify that the checkpointed data has the expected content.
with open(self.cp_file, 'rb') as input_:
cp_data = pickle.load(input_)
self.assertTrue(np.array_equal(cp_data['images'][key], image.array))
# Check the restore_checkpoint function.
new_interpreter = GalSimInterpreter(detectors=detectors)
new_interpreter.checkpoint_file = self.cp_file
new_interpreter.restore_checkpoint(camera_wrapper, phot_params, obs_md)
self.assertEqual(new_interpreter.drawn_objects,
gs_interpreter.drawn_objects)
self.assertEqual(set(new_interpreter.detectorImages.keys()),
set(gs_interpreter.detectorImages.keys()))
for det_name in new_interpreter.detectorImages.keys():
new_img = new_interpreter.detectorImages[det_name]
gs_img = gs_interpreter.detectorImages[det_name]
np.testing.assert_array_equal(new_img.array, gs_img.array)
self.assertEqual(new_img.bounds, gs_img.bounds)
self.assertEqual(new_img.wcs.crpix1, gs_img.wcs.crpix1)
self.assertEqual(new_img.wcs.crpix2, gs_img.wcs.crpix2)
self.assertEqual(new_img.wcs.crval1, gs_img.wcs.crval1)
self.assertEqual(new_img.wcs.crval2, gs_img.wcs.crval2)
self.assertEqual(new_img.wcs.detectorName, gs_img.wcs.detectorName)
for name in new_img.wcs.fitsHeader.names():
self.assertEqual(new_img.wcs.fitsHeader.get(name),
gs_img.wcs.fitsHeader.get(name))