def setUp(self): self.lsstCamWrapper = testUtils.CameraWrapper(isLsstLike=True) self.scCamWrapper = testUtils.CameraWrapper(isLsstLike=False) self.cameraList = (self.lsstCamWrapper, self.scCamWrapper) self.assemblyList = {} self.assemblyList[self.lsstCamWrapper.camera.getName()] =\ [afwImage.ImageU('tests/test_amp.fits.gz') for i in range(8)] self.assemblyList[self.scCamWrapper.camera.getName()] =\ [afwImage.ImageU('tests/test.fits.gz')]
def setUp(self): self.lsstCamWrapper = testUtils.CameraWrapper(isLsstLike=True) self.scCamWrapper = testUtils.CameraWrapper(isLsstLike=False) self.cameraList = (self.lsstCamWrapper, self.scCamWrapper) self.assemblyList = {} self.assemblyList[self.lsstCamWrapper.camera.getName()] =\ [afwImage.ImageU(os.path.join(testPath, 'test_amp.fits.gz')) for i in range(8)] self.assemblyList[self.scCamWrapper.camera.getName()] =\ [afwImage.ImageU(os.path.join(testPath, 'test.fits.gz'), allowUnsafe=True)]
def getCamera(self): """Construct a test camera object. Returns ------- camera : `lsst.afw.cameraGeom.camera` Test camera. """ cameraWrapper = afwTestUtils.CameraWrapper(self.config.isLsstLike) camera = cameraWrapper.camera return camera
class testStellarCatalog(InstanceCatalog, AstrometryStars, CameraCoords): """ Define a catalog of stars with all possible astrometric columns """ camera = camTestUtils.CameraWrapper().camera column_outputs = [ 'glon', 'glat', 'x_pupil', 'y_pupil', 'xPix', 'yPix', 'xFocalPlane', 'yFocalPlane', 'chipName', 'raObserved', 'decObserved' ]
def setUpClass(cls): cls.scratchDir = tempfile.mkdtemp(dir=ROOT, prefix='allowedChipsTest-') cls.obs = ObservationMetaData(pointingRA=122.0, pointingDec=-29.1, mjd=57381.2, rotSkyPos=43.2, bandpassName='r') cls.camera = camTestUtils.CameraWrapper().camera cls.dbFileName = os.path.join(cls.scratchDir, 'allowed_chips_test_db.txt') if os.path.exists(cls.dbFileName): os.unlink(cls.dbFileName) cls.controlSed = Sed() cls.controlSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'), 'flatSED', 'sed_flat.txt.gz')) cls.magNorm = 18.1 imsim = Bandpass() imsim.imsimBandpass() ff = cls.controlSed.calcFluxNorm(cls.magNorm, imsim) cls.controlSed.multiplyFluxNorm(ff) a_x, b_x = cls.controlSed.setupCCMab() cls.controlSed.addCCMDust(a_x, b_x, A_v=0.1, R_v=3.1) bpd = BandpassDict.loadTotalBandpassesFromFiles() pp = PhotometricParameters() cls.controlADU = cls.controlSed.calcADU(bpd['u'], pp) cls.countSigma = np.sqrt(cls.controlADU/pp.gain) cls.x_pix = 50 cls.y_pix = 50 x_list = [] y_list = [] name_list = [] for dd in cls.camera: x_list.append(cls.x_pix) y_list.append(cls.y_pix) name_list.append(dd.getName()) x_list = np.array(x_list) y_list = np.array(y_list) ra_list, dec_list = raDecFromPixelCoords(x_list, y_list, name_list, camera=cls.camera, obs_metadata=cls.obs, epoch=2000.0) dra_list = 3600.0*(ra_list-cls.obs.pointingRA) ddec_list = 3600.0*(dec_list-cls.obs.pointingDec) create_text_catalog(cls.obs, cls.dbFileName, dra_list, ddec_list, mag_norm=[cls.magNorm]*len(dra_list)) cls.db = allowedChipsFileDBObj(cls.dbFileName, runtable='test')
def getCamera(self): """Construct a test camera object. Returns ------- camera : `lsst.afw.cameraGeom.camera` Test camera. """ cameraWrapper = afwTestUtils.CameraWrapper( plateScale=self.config.plateScale, radialDistortion=self.config.radialDistortion, isLsstLike=self.config.isLsstLike, ) camera = cameraWrapper.camera return camera
def setUpClass(cls): cls.camera = camTestUtils.CameraWrapper().camera cls.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix='GalSimInterfaceTest-') cls.dbName = os.path.join(cls.scratch_dir, 'galSimTestDB.db') deltaRA = np.array([72.0/3600.0]) deltaDec = np.array([0.0]) defaults = LSSTdefaults() cls.bandpassNameList = ['u', 'g', 'r', 'i', 'z', 'y'] cls.m5 = [16.0+ix for ix in range(len(cls.bandpassNameList))] cls.seeing = [defaults._FWHMeff[bb] for bb in cls.bandpassNameList] cls.obs_metadata = makePhoSimTestDB(filename=cls.dbName, size=1, deltaRA=deltaRA, deltaDec=deltaDec, bandpass=cls.bandpassNameList, m5=cls.m5, seeing=cls.seeing, seedVal=65) cls.driver = 'sqlite'
class testCatalog(InstanceCatalog, AstrometryStars, CameraCoords): """ A (somewhat meaningless) instance catalog class that will allow us to run the astrometry routines for testing purposes """ catalog_type = __file__ + 'test_stars' column_outputs = ['id', 'raICRS', 'decICRS', 'parallax', 'radial_velocity', 'x_pupil', 'y_pupil', 'chipName', 'xPix', 'yPix', 'xFocalPlane', 'yFocalPlane'] # Needed to do camera coordinate transforms. camera = camTestUtils.CameraWrapper().camera default_formats = {'f': '%.12f'} delimiter = ';' # so that np.loadtxt can parse the chipNames which may contain commas # (see testClassMethods) default_columns = [('properMotionRa', 0., float), ('properMotionDec', 0., float), ('parallax', 1.2, float), ('radial_velocity', 0., float)]
def setUpClass(cls): cls.camera = camTestUtils.CameraWrapper().camera cls.dataDir = tempfile.mkdtemp(dir=ROOT, prefix='GalSimPhoSimTest-') cls.n_objects = 5 rng = np.random.RandomState(45) pointingRA = 45.2 pointingDec = -31.6 cls.obs = ObservationMetaData(pointingRA=pointingRA, pointingDec=pointingDec, rotSkyPos=1.2, bandpassName='r', mjd=57341.5, boundLength=0.1, boundType='circle') cls.dtype = np.dtype([ ('id', int), ('raJ2000', np.float), ('decJ2000', np.float), ('ra_deg', np.float), ('dec_deg', np.float), ('sedFilename', (str, 300)), ('magNorm', np.float), ('redshift', np.float), ('majorAxis', np.float), ('minorAxis', np.float), ('positionAngle', np.float), ('halfLightRadius', np.float), ('sindex', np.float), ('internalAv', np.float), ('internalRv', np.float), ('galacticAv', np.float), ('galacticRv', np.float), ('properMotionRa', np.float), ('properMotionDec', np.float), ('radialVelocity', np.float), ('parallax', np.float) ]) # generate some galaxy bulge data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = rng.random_sample(cls.n_objects) * 4.0 + 1.0 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects) * 10.0 + 1.0) positionAngle = rng.random_sample(cls.n_objects) * np.pi internalAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 internalRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 majorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) minorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.bulge_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_bulge.dat') with open(cls.bulge_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f Const.79E06.002Z.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some galaxy disk data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = rng.random_sample(cls.n_objects) * 4.0 + 1.0 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects) * 10.0 + 1.0) positionAngle = rng.random_sample(cls.n_objects) * np.pi internalAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 internalRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 majorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) minorAxis = radiansFromArcsec( rng.random_sample(cls.n_objects) * 2.0 + 0.5) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.disk_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_disk.dat') with open(cls.disk_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f Inst.79E06.02Z.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some agn data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = np.zeros(cls.n_objects) hlr = np.zeros(cls.n_objects) positionAngle = np.zeros(cls.n_objects) internalAv = np.zeros(cls.n_objects) internalRv = np.zeros(cls.n_objects) majorAxis = np.zeros(cls.n_objects) minorAxis = np.zeros(cls.n_objects) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = np.zeros(cls.n_objects) properMotionDec = np.zeros(cls.n_objects) radialVelocity = np.zeros(cls.n_objects) parallax = np.zeros(cls.n_objects) cls.agn_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_agn.dat') with open(cls.agn_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f agn.spec %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) # generate some star data redshift = rng.random_sample(cls.n_objects) * 1.5 rr = rng.random_sample(cls.n_objects) * 0.05 theta = rng.random_sample(cls.n_objects) * 2.0 * np.pi ra = np.radians(pointingRA + rr * np.cos(theta)) dec = np.radians(pointingDec + rr * np.sin(theta)) magNorm = rng.random_sample(cls.n_objects) * 7.0 + 18.0 sindex = np.zeros(cls.n_objects) hlr = np.zeros(cls.n_objects) positionAngle = np.zeros(cls.n_objects) internalAv = np.zeros(cls.n_objects) internalRv = np.zeros(cls.n_objects) majorAxis = np.zeros(cls.n_objects) minorAxis = np.zeros(cls.n_objects) galacticAv = rng.random_sample(cls.n_objects) * 0.5 + 0.1 galacticRv = rng.random_sample(cls.n_objects) * 0.5 + 2.7 properMotionRa = radiansFromArcsec( rng.random_sample(cls.n_objects) * 0.0002) properMotionDec = radiansFromArcsec( rng.random_sample(cls.n_objects) * 0.0002) radialVelocity = rng.random_sample(cls.n_objects) * 200.0 parallax = radiansFromArcsec(rng.random_sample(cls.n_objects) * 0.0002) cls.star_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_star.dat') with open(cls.star_name, 'w') as output_file: output_file.write('# header\n') for ix in range(cls.n_objects): output_file.write( '%d %f %f %f %f km30_5000.fits_g10_5040 %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n' % (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), magNorm[ix], redshift[ix], max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], galacticAv[ix], galacticRv[ix], properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix]))
def test_generic_camera_wrapper(self): """ Test that GalSimCameraWrapper wraps its methods as expected. This is mostly to catch changes in afw API. """ camera = camTestUtils.CameraWrapper().camera camera_wrapper = GalSimCameraWrapper(camera) obs_mjd = ObservationMetaData(mjd=60000.0) ra, dec = raDecFromAltAz(35.0, 112.0, obs_mjd) obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, mjd=obs_mjd.mjd, rotSkyPos=22.4) rng = np.random.RandomState(8124) for detector in camera: name = detector.getName() bbox = camera[name].getBBox() bbox_wrapper = camera_wrapper.getBBox(name) self.assertEqual(bbox.getMinX(), bbox_wrapper.getMinX()) self.assertEqual(bbox.getMaxX(), bbox_wrapper.getMaxX()) self.assertEqual(bbox.getMinY(), bbox_wrapper.getMinY()) self.assertEqual(bbox.getMaxY(), bbox_wrapper.getMaxY()) center_point = camera[name].getCenter(FOCAL_PLANE) pixel_system = camera[name].makeCameraSys(PIXELS) center_pix = camera.transform(center_point, FOCAL_PLANE, pixel_system) center_pix_wrapper = camera_wrapper.getCenterPixel(name) self.assertEqual(center_pix.getX(), center_pix_wrapper.getX()) self.assertEqual(center_pix.getY(), center_pix_wrapper.getY()) pupil_system = camera[name].makeCameraSys(FIELD_ANGLE) center_pupil = camera.transform(center_point, FOCAL_PLANE, pupil_system) center_pupil_wrapper = camera_wrapper.getCenterPupil(name) self.assertEqual(center_pupil.getX(), center_pupil_wrapper.getX()) self.assertEqual(center_pupil.getY(), center_pupil_wrapper.getY()) corner_pupil_wrapper = camera_wrapper.getCornerPupilList(name) corner_point_list = camera[name].getCorners(FOCAL_PLANE) for point in corner_point_list: point_pupil = camera.transform(point, FOCAL_PLANE, pupil_system) dd_min = 1.0e10 for wrapper_point in corner_pupil_wrapper: dd = np.sqrt( (point_pupil.getX() - wrapper_point.getX())**2 + (point_pupil.getY() - wrapper_point.getY())**2) if dd < dd_min: dd_min = dd self.assertLess(dd_min, 1.0e-20) xpix_min = None xpix_max = None ypix_min = None ypix_max = None focal_to_tan_pix = camera[name].getTransform( FOCAL_PLANE, TAN_PIXELS) for point in corner_point_list: pixel_point = focal_to_tan_pix.applyForward(point) xx = pixel_point.getX() yy = pixel_point.getY() if xpix_min is None or xx < xpix_min: xpix_min = xx if ypix_min is None or yy < ypix_min: ypix_min = yy if xpix_max is None or xx > xpix_max: xpix_max = xx if ypix_max is None or yy > ypix_max: ypix_max = yy pix_bounds_wrapper = camera_wrapper.getTanPixelBounds(name) self.assertEqual(pix_bounds_wrapper[0], xpix_min) self.assertEqual(pix_bounds_wrapper[1], xpix_max) self.assertEqual(pix_bounds_wrapper[2], ypix_min) self.assertEqual(pix_bounds_wrapper[3], ypix_max) x_pup = rng.random_sample(10) * 0.005 - 0.01 y_pup = rng.random_sample(10) * 0.005 - 0.01 x_pix, y_pix = pixelCoordsFromPupilCoords(x_pup, y_pup, chipName=name, camera=camera) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper.pixelCoordsFromPupilCoords( x_pup, y_pup, name, obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) x_pix = rng.random_sample(10) * 100.0 - 200.0 y_pix = rng.random_sample(10) * 100.0 - 200.0 x_pup, y_pup = pupilCoordsFromPixelCoords(x_pix, y_pix, chipName=name, camera=camera) (x_pup_wrapper, y_pup_wrapper) = camera_wrapper.pupilCoordsFromPixelCoords( x_pix, y_pix, name, obs) nan_x = np.where(np.isnan(x_pup)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pup, x_pup_wrapper) np.testing.assert_array_equal(y_pup, y_pup_wrapper) ra, dec = raDecFromPixelCoords(x_pix, y_pix, name, camera=camera, obs_metadata=obs) (ra_wrapper, dec_wrapper) = camera_wrapper.raDecFromPixelCoords( x_pix, y_pix, name, obs) nan_ra = np.where(np.isnan(ra)) self.assertEqual(len(nan_ra[0]), 0) np.testing.assert_array_equal(ra, ra_wrapper) np.testing.assert_array_equal(dec, dec_wrapper) ra, dec = _raDecFromPixelCoords(x_pix, y_pix, name, camera=camera, obs_metadata=obs) (ra_wrapper, dec_wrapper) = camera_wrapper._raDecFromPixelCoords( x_pix, y_pix, name, obs) nan_ra = np.where(np.isnan(ra)) self.assertEqual(len(nan_ra[0]), 0) np.testing.assert_array_equal(ra, ra_wrapper) np.testing.assert_array_equal(dec, dec_wrapper) ra = obs.pointingRA + (rng.random_sample(10) * 150.0 - 100.0) / 160.0 dec = obs.pointingDec + (rng.random_sample(10) * 150.0 - 100.0) / 160.0 x_pix, y_pix = pixelCoordsFromRaDec(ra, dec, chipName=name, camera=camera, obs_metadata=obs) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper.pixelCoordsFromRaDec( ra, dec, chipName=name, obs_metadata=obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) ra = np.radians(ra) dec = np.radians(dec) x_pix, y_pix = _pixelCoordsFromRaDec(ra, dec, chipName=name, camera=camera, obs_metadata=obs) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper._pixelCoordsFromRaDec( ra, dec, chipName=name, obs_metadata=obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) del camera
#!/usr/bin/env python2 import lsst.afw.cameraGeom.testUtils as testUtils import lsst.afw.cameraGeom as cameraGeom import lsst.afw.geom as afwGeom # Construct a mock LSST-like camera. # Normally you would obtain a camera from a data butler using butler.get("camera") # but when this example was written the software stack did not including a sample data repository. camera = testUtils.CameraWrapper(isLsstLike=True).camera # Get a detector from the camera by name (though you may specify an ID, if you prefer). det = camera["R:1,0 S:1,1"] # Convert a 2-d point from PIXELS to both FOCAL_PLANE and PUPIL coordinates. detPoint = det.makeCameraPoint(afwGeom.Point2D( 25, 43.2), cameraGeom.PIXELS) # position on detector in pixels fpPoint = det.transform( detPoint, cameraGeom.FOCAL_PLANE) # position in focal plane in mm pupilPoint = camera.transform( detPoint, cameraGeom.PUPIL) # position in pupil, in radians # Find all detectors that overlap a specific point (in this case find the detector we already have) detList = camera.findDetectors(fpPoint) assert len(detList) == 1 assert detList[0].getName() == det.getName() # Convert a point from PUPIL to PIXELS coordinates. # For a detector-based coordinate system, such as PIXELS, may specify a particular detector # or let the Camera find a detector: # * To specify a particular detector, specify the target coordinate system as a CameraSys # with the specified detectorName filled in (e.g. use detector.makeCameraSys).
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 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 @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') 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 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.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 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 = otherCatalog.camera self.photParams = otherCatalog.photParams self.bandpassDict = otherCatalog.bandpassDict self.galSimInterpreter = otherCatalog.galSimInterpreter self.PSF = otherCatalog.PSF self.noise_and_background = otherCatalog.noise_and_background 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 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 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))