Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1from __future__ import with_statement 

2from builtins import range 

3import os 

4import numpy as np 

5import unittest 

6import tempfile 

7import shutil 

8import lsst.utils.tests 

9 

10import lsst.afw.cameraGeom.testUtils as camTestUtils 

11from lsst.sims.utils.CodeUtilities import sims_clean_up 

12from lsst.sims.utils import ObservationMetaData, radiansFromArcsec 

13from lsst.sims.catalogs.db import fileDBObject 

14from lsst.sims.GalSimInterface import GalSimPhoSimGalaxies, GalSimPhoSimStars, GalSimPhoSimAgn 

15from lsst.sims.GalSimInterface import SNRdocumentPSF, GalSimCameraWrapper 

16from lsst.sims.catUtils.exampleCatalogDefinitions import (PhoSimCatalogSersic2D, PhoSimCatalogPoint, 

17 PhoSimCatalogZPoint) 

18 

19ROOT = os.path.abspath(os.path.dirname(__file__)) 

20 

21 

22def setup_module(module): 

23 lsst.utils.tests.init() 

24 

25 

26class GalSimPhoSimTest(unittest.TestCase): 

27 """ 

28 Class to test that GalSimPhoSim catalogs produce both GalSim images 

29 and PhoSim-ready InstanceCatalogs 

30 """ 

31 

32 @classmethod 

33 def setUpClass(cls): 

34 cls.camera = camTestUtils.CameraWrapper().camera 

35 cls.dataDir = tempfile.mkdtemp(dir=ROOT, prefix='GalSimPhoSimTest-') 

36 cls.n_objects = 5 

37 rng = np.random.RandomState(45) 

38 pointingRA = 45.2 

39 pointingDec = -31.6 

40 

41 cls.obs = ObservationMetaData(pointingRA=pointingRA, pointingDec=pointingDec, 

42 rotSkyPos=1.2, bandpassName='r', mjd=57341.5, 

43 boundLength=0.1, boundType='circle') 

44 

45 cls.dtype = np.dtype([('id', int), 

46 ('raJ2000', np.float), 

47 ('decJ2000', np.float), 

48 ('ra_deg', np.float), 

49 ('dec_deg', np.float), 

50 ('sedFilename', (str, 300)), 

51 ('magNorm', np.float), 

52 ('redshift', np.float), 

53 ('majorAxis', np.float), 

54 ('minorAxis', np.float), 

55 ('positionAngle', np.float), 

56 ('halfLightRadius', np.float), 

57 ('sindex', np.float), 

58 ('internalAv', np.float), 

59 ('internalRv', np.float), 

60 ('galacticAv', np.float), 

61 ('galacticRv', np.float), 

62 ('properMotionRa', np.float), 

63 ('properMotionDec', np.float), 

64 ('radialVelocity', np.float), 

65 ('parallax', np.float)]) 

66 

67 # generate some galaxy bulge data 

68 redshift = rng.random_sample(cls.n_objects)*1.5 

69 rr = rng.random_sample(cls.n_objects)*0.05 

70 theta = rng.random_sample(cls.n_objects)*2.0*np.pi 

71 ra = np.radians(pointingRA + rr*np.cos(theta)) 

72 dec = np.radians(pointingDec + rr*np.sin(theta)) 

73 magNorm = rng.random_sample(cls.n_objects)*7.0 + 18.0 

74 sindex = rng.random_sample(cls.n_objects)*4.0+1.0 

75 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects)*10.0 + 1.0) 

76 positionAngle = rng.random_sample(cls.n_objects)*np.pi 

77 internalAv = rng.random_sample(cls.n_objects)*0.5+0.1 

78 internalRv = rng.random_sample(cls.n_objects)*0.5+2.7 

79 majorAxis = radiansFromArcsec(rng.random_sample(cls.n_objects)*2.0 + 0.5) 

80 minorAxis = radiansFromArcsec(rng.random_sample(cls.n_objects)*2.0 + 0.5) 

81 galacticAv = rng.random_sample(cls.n_objects)*0.5+0.1 

82 galacticRv = rng.random_sample(cls.n_objects)*0.5+2.7 

83 properMotionRa = np.zeros(cls.n_objects) 

84 properMotionDec = np.zeros(cls.n_objects) 

85 radialVelocity = np.zeros(cls.n_objects) 

86 parallax = np.zeros(cls.n_objects) 

87 cls.bulge_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_bulge.dat') 

88 with open(cls.bulge_name, 'w') as output_file: 

89 output_file.write('# header\n') 

90 for ix in range(cls.n_objects): 

91 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' % 

92 (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), 

93 magNorm[ix], redshift[ix], 

94 max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), 

95 positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], 

96 galacticAv[ix], galacticRv[ix], 

97 properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) 

98 

99 # generate some galaxy disk data 

100 redshift = rng.random_sample(cls.n_objects)*1.5 

101 rr = rng.random_sample(cls.n_objects)*0.05 

102 theta = rng.random_sample(cls.n_objects)*2.0*np.pi 

103 ra = np.radians(pointingRA + rr*np.cos(theta)) 

104 dec = np.radians(pointingDec + rr*np.sin(theta)) 

105 magNorm = rng.random_sample(cls.n_objects)*7.0 + 18.0 

106 sindex = rng.random_sample(cls.n_objects)*4.0+1.0 

107 hlr = radiansFromArcsec(rng.random_sample(cls.n_objects)*10.0 + 1.0) 

108 positionAngle = rng.random_sample(cls.n_objects)*np.pi 

109 internalAv = rng.random_sample(cls.n_objects)*0.5+0.1 

110 internalRv = rng.random_sample(cls.n_objects)*0.5+2.7 

111 majorAxis = radiansFromArcsec(rng.random_sample(cls.n_objects)*2.0 + 0.5) 

112 minorAxis = radiansFromArcsec(rng.random_sample(cls.n_objects)*2.0 + 0.5) 

113 galacticAv = rng.random_sample(cls.n_objects)*0.5+0.1 

114 galacticRv = rng.random_sample(cls.n_objects)*0.5+2.7 

115 properMotionRa = np.zeros(cls.n_objects) 

116 properMotionDec = np.zeros(cls.n_objects) 

117 radialVelocity = np.zeros(cls.n_objects) 

118 parallax = np.zeros(cls.n_objects) 

119 cls.disk_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_disk.dat') 

120 with open(cls.disk_name, 'w') as output_file: 

121 output_file.write('# header\n') 

122 for ix in range(cls.n_objects): 

123 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' % 

124 (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), 

125 magNorm[ix], redshift[ix], 

126 max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), 

127 positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], 

128 galacticAv[ix], galacticRv[ix], 

129 properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) 

130 

131 # generate some agn data 

132 redshift = rng.random_sample(cls.n_objects)*1.5 

133 rr = rng.random_sample(cls.n_objects)*0.05 

134 theta = rng.random_sample(cls.n_objects)*2.0*np.pi 

135 ra = np.radians(pointingRA + rr*np.cos(theta)) 

136 dec = np.radians(pointingDec + rr*np.sin(theta)) 

137 magNorm = rng.random_sample(cls.n_objects)*7.0 + 18.0 

138 sindex = np.zeros(cls.n_objects) 

139 hlr = np.zeros(cls.n_objects) 

140 positionAngle = np.zeros(cls.n_objects) 

141 internalAv = np.zeros(cls.n_objects) 

142 internalRv = np.zeros(cls.n_objects) 

143 majorAxis = np.zeros(cls.n_objects) 

144 minorAxis = np.zeros(cls.n_objects) 

145 galacticAv = rng.random_sample(cls.n_objects)*0.5+0.1 

146 galacticRv = rng.random_sample(cls.n_objects)*0.5+2.7 

147 properMotionRa = np.zeros(cls.n_objects) 

148 properMotionDec = np.zeros(cls.n_objects) 

149 radialVelocity = np.zeros(cls.n_objects) 

150 parallax = np.zeros(cls.n_objects) 

151 cls.agn_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_agn.dat') 

152 with open(cls.agn_name, 'w') as output_file: 

153 output_file.write('# header\n') 

154 for ix in range(cls.n_objects): 

155 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' % 

156 (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), 

157 magNorm[ix], redshift[ix], 

158 max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), 

159 positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], 

160 galacticAv[ix], galacticRv[ix], 

161 properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) 

162 

163 # generate some star data 

164 redshift = rng.random_sample(cls.n_objects)*1.5 

165 rr = rng.random_sample(cls.n_objects)*0.05 

166 theta = rng.random_sample(cls.n_objects)*2.0*np.pi 

167 ra = np.radians(pointingRA + rr*np.cos(theta)) 

168 dec = np.radians(pointingDec + rr*np.sin(theta)) 

169 magNorm = rng.random_sample(cls.n_objects)*7.0 + 18.0 

170 sindex = np.zeros(cls.n_objects) 

171 hlr = np.zeros(cls.n_objects) 

172 positionAngle = np.zeros(cls.n_objects) 

173 internalAv = np.zeros(cls.n_objects) 

174 internalRv = np.zeros(cls.n_objects) 

175 majorAxis = np.zeros(cls.n_objects) 

176 minorAxis = np.zeros(cls.n_objects) 

177 galacticAv = rng.random_sample(cls.n_objects)*0.5+0.1 

178 galacticRv = rng.random_sample(cls.n_objects)*0.5+2.7 

179 properMotionRa = radiansFromArcsec(rng.random_sample(cls.n_objects)*0.0002) 

180 properMotionDec = radiansFromArcsec(rng.random_sample(cls.n_objects)*0.0002) 

181 radialVelocity = rng.random_sample(cls.n_objects)*200.0 

182 parallax = radiansFromArcsec(rng.random_sample(cls.n_objects)*0.0002) 

183 cls.star_name = os.path.join(cls.dataDir, 'galSimPhoSim_test_star.dat') 

184 with open(cls.star_name, 'w') as output_file: 

185 output_file.write('# header\n') 

186 for ix in range(cls.n_objects): 

187 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' % 

188 (ix, ra[ix], dec[ix], np.degrees(ra[ix]), np.degrees(dec[ix]), 

189 magNorm[ix], redshift[ix], 

190 max(majorAxis[ix], minorAxis[ix]), min(majorAxis[ix], minorAxis[ix]), 

191 positionAngle[ix], hlr[ix], sindex[ix], internalAv[ix], internalRv[ix], 

192 galacticAv[ix], galacticRv[ix], 

193 properMotionRa[ix], properMotionDec[ix], radialVelocity[ix], parallax[ix])) 

194 

195 @classmethod 

196 def tearDownClass(cls): 

197 sims_clean_up() 

198 del cls.camera 

199 

200 if os.path.exists(cls.bulge_name): 

201 os.unlink(cls.bulge_name) 

202 

203 if os.path.exists(cls.disk_name): 

204 os.unlink(cls.disk_name) 

205 

206 if os.path.exists(cls.agn_name): 

207 os.unlink(cls.agn_name) 

208 

209 if os.path.exists(cls.star_name): 

210 os.unlink(cls.star_name) 

211 

212 if os.path.exists(cls.dataDir): 

213 shutil.rmtree(cls.dataDir) 

214 

215 def testGalSimPhoSimCat(self): 

216 """ 

217 Run a GalSimPhoSim catalog on some data. Then, generate an ordinary PhoSim catalog using 

218 the same data. Verify that the two resulting PhoSim catalogs are identical. 

219 """ 

220 

221 galsim_cat_name = os.path.join(self.dataDir, 'galSimPhoSim_galsim_cat.txt') 

222 phosim_cat_name = os.path.join(self.dataDir, 'galSimPhoSim_phosim_cat.txt') 

223 galsim_image_root = os.path.join(self.dataDir, 'galSimPhoSim_images') 

224 db = fileDBObject(self.bulge_name, dtype=self.dtype, runtable='test_bulges', idColKey='id') 

225 db.raColName = 'ra_deg' 

226 db.decColName = 'dec_deg' 

227 db.objectTypeId = 55 

228 

229 gs_cat = GalSimPhoSimGalaxies(db, obs_metadata=self.obs) 

230 gs_cat.camera_wrapper = GalSimCameraWrapper(self.camera) 

231 gs_cat.bandpassNames = self.obs.bandpass 

232 gs_cat.PSF = SNRdocumentPSF() 

233 gs_cat.phoSimHeaderMap = {} 

234 gs_cat.write_catalog(galsim_cat_name) 

235 

236 gs_cat_0 = gs_cat 

237 

238 ps_cat = PhoSimCatalogSersic2D(db, obs_metadata=self.obs) 

239 ps_cat.phoSimHeaderMap = {} 

240 ps_cat.write_catalog(phosim_cat_name) 

241 

242 db = fileDBObject(self.disk_name, dtype=self.dtype, runtable='test_disks', idColKey='id') 

243 db.raColName = 'ra_deg' 

244 db.decColName = 'dec_deg' 

245 db.objectTypeId = 155 

246 

247 gs_cat = GalSimPhoSimGalaxies(db, obs_metadata=self.obs) 

248 gs_cat.bandpassNames = self.obs.bandpass 

249 gs_cat.copyGalSimInterpreter(gs_cat_0) 

250 gs_cat.write_catalog(galsim_cat_name, write_header=False, write_mode='a') 

251 

252 gs_cat_0 = gs_cat 

253 

254 ps_cat = PhoSimCatalogSersic2D(db, obs_metadata=self.obs) 

255 ps_cat.write_catalog(phosim_cat_name, write_header=False, write_mode='a') 

256 

257 db = fileDBObject(self.agn_name, dtype=self.dtype, runtable='test_agn', idColKey='id') 

258 db.raColName = 'ra_deg' 

259 db.decColName = 'dec_deg' 

260 db.objectTypeId = 255 

261 

262 gs_cat = GalSimPhoSimAgn(db, obs_metadata=self.obs) 

263 gs_cat.bandpassNames = self.obs.bandpass 

264 gs_cat.copyGalSimInterpreter(gs_cat_0) 

265 gs_cat.write_catalog(galsim_cat_name, write_header=False, write_mode='a') 

266 

267 gs_cat_0 = gs_cat 

268 

269 ps_cat = PhoSimCatalogZPoint(db, obs_metadata=self.obs) 

270 ps_cat.write_catalog(phosim_cat_name, write_header=False, write_mode='a') 

271 

272 db = fileDBObject(self.star_name, dtype=self.dtype, runtable='test_agn', idColKey='id') 

273 db.raColName = 'ra_deg' 

274 db.decColName = 'dec_deg' 

275 db.objectTypeId = 255 

276 

277 gs_cat = GalSimPhoSimStars(db, obs_metadata=self.obs) 

278 gs_cat.bandpassNames = self.obs.bandpass 

279 gs_cat.copyGalSimInterpreter(gs_cat_0) 

280 gs_cat.write_catalog(galsim_cat_name, write_header=False, write_mode='a') 

281 

282 ps_cat = PhoSimCatalogPoint(db, obs_metadata=self.obs) 

283 ps_cat.write_catalog(phosim_cat_name, write_header=False, write_mode='a') 

284 

285 written_files = gs_cat.write_images(nameRoot=galsim_image_root) 

286 self.assertGreater(len(written_files), 0) 

287 for name in written_files: 

288 os.unlink(name) 

289 

290 with open(galsim_cat_name, 'r') as galsim_input: 

291 with open(phosim_cat_name, 'r') as phosim_input: 

292 galsim_lines = galsim_input.readlines() 

293 phosim_lines = phosim_input.readlines() 

294 self.assertEqual(len(galsim_lines), len(phosim_lines)) 

295 self.assertEqual(len(galsim_lines), 4*self.n_objects+7) 

296 for line in galsim_lines: 

297 self.assertIn(line, phosim_lines) 

298 for line in phosim_lines: 

299 self.assertIn(line, galsim_lines) 

300 

301 if os.path.exists(galsim_cat_name): 

302 os.unlink(galsim_cat_name) 

303 

304 if os.path.exists(phosim_cat_name): 

305 os.unlink(phosim_cat_name) 

306 

307 

308class MemoryTestClass(lsst.utils.tests.MemoryTestCase): 

309 pass 

310 

311if __name__ == "__main__": 311 ↛ 312line 311 didn't jump to line 312, because the condition on line 311 was never true

312 lsst.utils.tests.init() 

313 unittest.main()