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

1import os 

2import numpy as np 

3import unittest 

4import tempfile 

5import lsst.utils.tests 

6 

7from lsst.utils import getPackageDir 

8from lsst.sims.utils import ObservationMetaData 

9from lsst.sims.catalogs.db import fileDBObject 

10from lsst.sims.catalogs.definitions import InstanceCatalog 

11from lsst.sims.catUtils.mixins import (PhotometryStars, PhotometrySSM, 

12 PhotometryGalaxies) 

13 

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

15 

16 

17def setup_module(module): 

18 lsst.utils.tests.init() 

19 

20 

21class baselineStarCatalog(InstanceCatalog, PhotometryStars): 

22 catalog_type = __file__ + 'baseline_star_catalog' 

23 

24 column_outputs = ['raJ2000', 'decJ2000', 

25 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

26 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r', 

27 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y'] 

28 

29 default_formats = {'f': '%.13f'} 

30 

31 

32class uStarCatalog(InstanceCatalog, PhotometryStars): 

33 column_outputs = ['raJ2000', 'decJ2000', 'lsst_u', 'sigma_lsst_u'] 

34 

35 default_formats = {'f': '%.13f'} 

36 

37 

38class gzStarCatalog(InstanceCatalog, PhotometryStars): 

39 column_outputs = ['raJ2000', 'decJ2000', 'lsst_g', 'lsst_z', 

40 'sigma_lsst_g', 'sigma_lsst_z'] 

41 

42 default_formats = {'f': '%.13f'} 

43 

44 

45class gzUncertaintyStarCatalog(InstanceCatalog, PhotometryStars): 

46 column_outputs = ['raJ2000', 'decJ2000', 'sigma_lsst_g', 'sigma_lsst_z'] 

47 

48 default_formats = {'f': '%.13f'} 

49 

50 

51class IndexTestCaseStars(unittest.TestCase): 

52 """ 

53 This unit test suite will test that the 'indices' framework for making 

54 sure that an InstanceCatalog only calculates the magnitudes requested 

55 works in the case of stars. 

56 """ 

57 

58 @classmethod 

59 def setUpClass(cls): 

60 

61 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'], 

62 m5 = [22.0, 23.0, 24.0, 25.0, 26.0, 27.0]) 

63 

64 baselineDtype = np.dtype([(name, np.float) for name in baselineStarCatalog.column_outputs]) 

65 

66 dbdtype = np.dtype([ 

67 ('id', np.int), 

68 ('raJ2000', np.float), 

69 ('decJ2000', np.float), 

70 ('sedFilename', str, 100), 

71 ('magNorm', np.float), 

72 ('galacticAv', np.float) 

73 ]) 

74 

75 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData') 

76 inputFile = os.path.join(inputDir, 'IndicesTestCatalogStars.txt') 

77 

78 cls.db = fileDBObject(inputFile, runtable='test', 

79 idColKey='id', dtype=dbdtype) 

80 

81 cat = baselineStarCatalog(cls.db, obs_metadata=cls.obs) 

82 cls.catName = tempfile.mktemp(dir=ROOT, prefix='indicesStarControlCat-', suffix='.txt') 

83 cat.write_catalog(cls.catName) 

84 cls.controlData = np.genfromtxt(cls.catName, dtype=baselineDtype, delimiter=',') 

85 os.unlink(cls.catName) 

86 

87 def test_u_star_catalog(self): 

88 """ 

89 Test that a catalog which only cares about u does not calculate any other magnitudes. 

90 """ 

91 dtype = np.dtype([(name, np.float) for name in uStarCatalog.column_outputs]) 

92 

93 cat = uStarCatalog(self.db, obs_metadata=self.obs) 

94 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

95 cat.write_catalog(catName) 

96 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

97 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10) 

98 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10) 

99 np.testing.assert_array_almost_equal(self.controlData['lsst_u'], testData['lsst_u'], 10) 

100 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_u'], testData['sigma_lsst_u'], 10) 

101 

102 self.assertNotIn('lsst_g', cat._actually_calculated_columns) 

103 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns) 

104 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

105 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

106 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

107 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

108 self.assertNotIn('lsst_z', cat._actually_calculated_columns) 

109 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns) 

110 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

111 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

112 

113 def test_gz_star_catalog(self): 

114 """ 

115 Test that a catalog which only cares about g and z does not calculate any other magnitudes 

116 """ 

117 dtype = np.dtype([(name, np.float) for name in gzStarCatalog.column_outputs]) 

118 

119 cat = gzStarCatalog(self.db, obs_metadata=self.obs) 

120 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

121 cat.write_catalog(catName) 

122 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

123 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10) 

124 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10) 

125 np.testing.assert_array_almost_equal(self.controlData['lsst_g'], testData['lsst_g'], 10) 

126 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10) 

127 np.testing.assert_array_almost_equal(self.controlData['lsst_z'], testData['lsst_z'], 10) 

128 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10) 

129 

130 self.assertNotIn('lsst_u', cat._actually_calculated_columns) 

131 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns) 

132 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

133 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

134 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

135 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

136 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

137 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

138 

139 def test_gz_uncertainty_star_catalog(self): 

140 """ 

141 Test that a catalog which only cares about g and z uncertainties 

142 does not calculate any other magnitudes 

143 """ 

144 dtype = np.dtype([(name, np.float) for name in gzUncertaintyStarCatalog.column_outputs]) 

145 

146 cat = gzUncertaintyStarCatalog(self.db, obs_metadata=self.obs) 

147 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

148 cat.write_catalog(catName) 

149 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

150 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10) 

151 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10) 

152 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10) 

153 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10) 

154 

155 self.assertNotIn('lsst_u', cat._actually_calculated_columns) 

156 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns) 

157 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

158 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

159 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

160 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

161 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

162 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

163 self.assertIn('lsst_g', cat._actually_calculated_columns) 

164 self.assertIn('lsst_z', cat._actually_calculated_columns) 

165 

166 

167class baselineSSMCatalog(InstanceCatalog, PhotometrySSM): 

168 column_outputs = ['lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

169 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r', 

170 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y'] 

171 

172 default_formats = {'f': '%.13f'} 

173 

174 

175class uSSMCatalog(InstanceCatalog, PhotometrySSM): 

176 column_outputs = ['lsst_u', 'sigma_lsst_u'] 

177 

178 default_formats = {'f': '%.13f'} 

179 

180 

181class gzSSMCatalog(InstanceCatalog, PhotometrySSM): 

182 column_outputs = ['lsst_g', 'lsst_z', 

183 'sigma_lsst_g', 'sigma_lsst_z'] 

184 

185 default_formats = {'f': '%.13f'} 

186 

187 

188class gzUncertaintySSMCatalog(InstanceCatalog, PhotometrySSM): 

189 column_outputs = ['sigma_lsst_g', 'sigma_lsst_z'] 

190 

191 default_formats = {'f': '%.13f'} 

192 

193 

194class IndexTestCaseSSM(unittest.TestCase): 

195 """ 

196 This unit test suite will test that the 'indices' framework for making 

197 sure that an InstanceCatalog only calculates the magnitudes requested 

198 works in the case of solar system objects. 

199 """ 

200 

201 @classmethod 

202 def setUpClass(cls): 

203 

204 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'], 

205 m5 = [22.0, 23.0, 24.0, 25.0, 26.0, 27.0]) 

206 

207 baselineDtype = np.dtype([(name, np.float) for name in baselineSSMCatalog.column_outputs]) 

208 

209 dbdtype = np.dtype([ 

210 ('id', np.int), 

211 ('sedFilename', str, 100), 

212 ('magNorm', np.float), 

213 ('velRA', np.float), 

214 ('velDec', np.float) 

215 ]) 

216 

217 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData') 

218 inputFile = os.path.join(inputDir, 'SSMphotometryCatalog.txt') 

219 

220 cls.db = fileDBObject(inputFile, runtable='test', 

221 idColKey='id', dtype=dbdtype) 

222 

223 cat = baselineSSMCatalog(cls.db, obs_metadata=cls.obs) 

224 catName = tempfile.mktemp(prefix='IndexTestCase_setUpClass') 

225 cat.write_catalog(catName) 

226 cls.controlData = np.genfromtxt(catName, dtype=baselineDtype, delimiter=',') 

227 os.unlink(catName) 

228 

229 def test_u_ssm_catalog(self): 

230 """ 

231 Test that a catalog which only cares about u does not calculate any other magnitudes. 

232 """ 

233 dtype = np.dtype([(name, np.float) for name in uSSMCatalog.column_outputs]) 

234 

235 cat = uSSMCatalog(self.db, obs_metadata=self.obs) 

236 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

237 cat.write_catalog(catName) 

238 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

239 np.testing.assert_array_almost_equal(self.controlData['lsst_u'], testData['lsst_u'], 10) 

240 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_u'], testData['sigma_lsst_u'], 10) 

241 

242 self.assertNotIn('lsst_g', cat._actually_calculated_columns) 

243 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns) 

244 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

245 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

246 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

247 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

248 self.assertNotIn('lsst_z', cat._actually_calculated_columns) 

249 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns) 

250 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

251 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

252 

253 def test_gz_ssm_catalog(self): 

254 """ 

255 Test that a catalog which only cares about g and z does not calculate any other magnitudes 

256 """ 

257 dtype = np.dtype([(name, np.float) for name in gzSSMCatalog.column_outputs]) 

258 

259 cat = gzSSMCatalog(self.db, obs_metadata=self.obs) 

260 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

261 cat.write_catalog(catName) 

262 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

263 np.testing.assert_array_almost_equal(self.controlData['lsst_g'], testData['lsst_g'], 10) 

264 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10) 

265 np.testing.assert_array_almost_equal(self.controlData['lsst_z'], testData['lsst_z'], 10) 

266 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10) 

267 

268 self.assertNotIn('lsst_u', cat._actually_calculated_columns) 

269 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns) 

270 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

271 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

272 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

273 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

274 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

275 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

276 

277 def test_gz_uncertainty_ssm_catalog(self): 

278 """ 

279 Test that a catalog which only cares about g and z uncertainties 

280 does not calculate any other magnitudes 

281 """ 

282 dtype = np.dtype([(name, np.float) for name in gzUncertaintySSMCatalog.column_outputs]) 

283 

284 cat = gzUncertaintySSMCatalog(self.db, obs_metadata=self.obs) 

285 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

286 cat.write_catalog(catName) 

287 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

288 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10) 

289 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10) 

290 

291 self.assertNotIn('lsst_u', cat._actually_calculated_columns) 

292 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns) 

293 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

294 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

295 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

296 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

297 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

298 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

299 self.assertIn('lsst_g', cat._actually_calculated_columns) 

300 self.assertIn('lsst_z', cat._actually_calculated_columns) 

301 

302class baselineGalaxyCatalog(InstanceCatalog, PhotometryGalaxies): 

303 column_outputs = ['uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge', 

304 'uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk', 

305 'uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn', 

306 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

307 'sigma_uBulge', 'sigma_gBulge', 'sigma_rBulge', 

308 'sigma_iBulge', 'sigma_zBulge', 'sigma_yBulge', 

309 'sigma_uDisk', 'sigma_gDisk', 'sigma_rDisk', 

310 'sigma_iDisk', 'sigma_zDisk', 'sigma_yDisk', 

311 'sigma_uAgn', 'sigma_gAgn', 'sigma_rAgn', 

312 'sigma_iAgn', 'sigma_zAgn', 'sigma_yAgn', 

313 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r', 

314 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y'] 

315 

316 default_formats = {'f': '%.13f'} 

317 

318 

319class uGalaxyCatalog(InstanceCatalog, PhotometryGalaxies): 

320 column_outputs = ['uBulge', 'uDisk', 'uAgn', 'lsst_u', 

321 'sigma_uBulge', 'sigma_uDisk', 'sigma_uAgn', 

322 'sigma_lsst_u'] 

323 

324 default_formats = {'f': '%.13f'} 

325 

326 

327class gzGalaxyCatalog(InstanceCatalog, PhotometryGalaxies): 

328 column_outputs = ['gBulge', 'gDisk', 'gAgn', 'lsst_g', 

329 'zBulge', 'zDisk', 'zAgn', 'lsst_z', 

330 'sigma_gBulge', 'sigma_gDisk', 'sigma_gAgn', 

331 'sigma_lsst_g', 

332 'sigma_zBulge', 'sigma_zDisk', 'sigma_zAgn', 

333 'sigma_lsst_z'] 

334 

335 default_formats = {'f': '%.13f'} 

336 

337 

338class IndexTestCaseGalaxies(unittest.TestCase): 

339 """ 

340 This unit test suite will test that the 'indices' framework for making 

341 sure that an InstanceCatalog only calculates the magnitudes requested 

342 works in the case of galaxies. 

343 """ 

344 

345 @classmethod 

346 def setUpClass(cls): 

347 

348 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'], 

349 m5=[24.0, 25.0, 26.0, 27.0, 28.0, 29.0]) 

350 

351 dtype = np.dtype([ 

352 ('id', np.int), 

353 ('sedFilenameBulge', str, 100), 

354 ('magNormBulge', np.float), 

355 ('sedFilenameDisk', str, 100), 

356 ('magNormDisk', np.float), 

357 ('sedFilenameAgn', str, 100), 

358 ('magNormAgn', np.float), 

359 ('internalAvBulge', np.float), 

360 ('internalAvDisk', np.float), 

361 ('galacticAv', np.float), 

362 ('redshift', np.float) 

363 ]) 

364 

365 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData') 

366 inputFile = os.path.join(inputDir, 'IndicesTestCatalogGalaxies.txt') 

367 cls.db = fileDBObject(inputFile, dtype=dtype, runtable='test', 

368 idColKey='id') 

369 

370 cls.db.objectTypeId = 44 

371 

372 cat = baselineGalaxyCatalog(cls.db, obs_metadata=cls.obs) 

373 dtype = np.dtype([(name, np.float) for name in cat.column_outputs]) 

374 catName = tempfile.mktemp(dir=ROOT, prefix='', suffix='.txt') 

375 cat.write_catalog(catName) 

376 cls.controlData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

377 os.remove(catName) 

378 

379 def test_u_catalog(self): 

380 """ 

381 Test that a catalog which only requests u band magnitudes does not 

382 calculate anything it shouldn't 

383 """ 

384 cat = uGalaxyCatalog(self.db, obs_metadata=self.obs) 

385 dtype = np.dtype([(name, np.float) for name in cat.column_outputs]) 

386 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

387 cat.write_catalog(catName) 

388 

389 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

390 

391 for name in ('uBulge', 'uDisk', 'uAgn', 'lsst_u', 

392 'sigma_uBulge', 'sigma_uDisk', 'sigma_uAgn', 'sigma_lsst_u'): 

393 

394 np.testing.assert_array_almost_equal(testData[name], 

395 self.controlData[name], 10) 

396 

397 self.assertNotIn('gBulge', cat._actually_calculated_columns) 

398 self.assertNotIn('rBulge', cat._actually_calculated_columns) 

399 self.assertNotIn('iBulge', cat._actually_calculated_columns) 

400 self.assertNotIn('zBulge', cat._actually_calculated_columns) 

401 self.assertNotIn('yBulge', cat._actually_calculated_columns) 

402 self.assertNotIn('gDisk', cat._actually_calculated_columns) 

403 self.assertNotIn('rDisk', cat._actually_calculated_columns) 

404 self.assertNotIn('iDisk', cat._actually_calculated_columns) 

405 self.assertNotIn('zDisk', cat._actually_calculated_columns) 

406 self.assertNotIn('yDisk', cat._actually_calculated_columns) 

407 self.assertNotIn('gAgn', cat._actually_calculated_columns) 

408 self.assertNotIn('rAgn', cat._actually_calculated_columns) 

409 self.assertNotIn('iAgn', cat._actually_calculated_columns) 

410 self.assertNotIn('zAgn', cat._actually_calculated_columns) 

411 self.assertNotIn('yAgn', cat._actually_calculated_columns) 

412 self.assertNotIn('lsst_g', cat._actually_calculated_columns) 

413 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

414 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

415 self.assertNotIn('lsst_z', cat._actually_calculated_columns) 

416 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

417 self.assertNotIn('sigma_gBulge', cat._actually_calculated_columns) 

418 self.assertNotIn('sigma_rBulge', cat._actually_calculated_columns) 

419 self.assertNotIn('sigma_iBulge', cat._actually_calculated_columns) 

420 self.assertNotIn('sigma_zBulge', cat._actually_calculated_columns) 

421 self.assertNotIn('sigma_yBulge', cat._actually_calculated_columns) 

422 self.assertNotIn('sigma_gDisk', cat._actually_calculated_columns) 

423 self.assertNotIn('sigma_rDisk', cat._actually_calculated_columns) 

424 self.assertNotIn('sigma_iDisk', cat._actually_calculated_columns) 

425 self.assertNotIn('sigma_zDisk', cat._actually_calculated_columns) 

426 self.assertNotIn('sigma_yDisk', cat._actually_calculated_columns) 

427 self.assertNotIn('sigma_gAgn', cat._actually_calculated_columns) 

428 self.assertNotIn('sigma_rAgn', cat._actually_calculated_columns) 

429 self.assertNotIn('sigma_iAgn', cat._actually_calculated_columns) 

430 self.assertNotIn('sigma_zAgn', cat._actually_calculated_columns) 

431 self.assertNotIn('sigma_yAgn', cat._actually_calculated_columns) 

432 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns) 

433 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

434 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

435 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns) 

436 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

437 

438 def test_gz_catalog(self): 

439 """ 

440 Test that a catalog which only requests g and z band magnitudes does not 

441 calculate anything it shouldn't 

442 """ 

443 cat = gzGalaxyCatalog(self.db, obs_metadata=self.obs) 

444 dtype = np.dtype([(name, np.float) for name in cat.column_outputs]) 

445 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

446 cat.write_catalog(catName) 

447 

448 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

449 

450 for name in ('gBulge', 'gDisk', 'gAgn', 'lsst_g', 

451 'zBulge', 'zDisk', 'zAgn', 'lsst_z', 

452 'sigma_gBulge', 'sigma_gDisk', 'sigma_gAgn', 

453 'sigma_lsst_g', 

454 'sigma_zBulge', 'sigma_zDisk', 'sigma_zAgn', 

455 'sigma_lsst_z'): 

456 

457 np.testing.assert_array_almost_equal(testData[name], 

458 self.controlData[name], 10) 

459 

460 self.assertNotIn('uBulge', cat._actually_calculated_columns) 

461 self.assertNotIn('rBulge', cat._actually_calculated_columns) 

462 self.assertNotIn('iBulge', cat._actually_calculated_columns) 

463 self.assertNotIn('yBulge', cat._actually_calculated_columns) 

464 self.assertNotIn('uDisk', cat._actually_calculated_columns) 

465 self.assertNotIn('rDisk', cat._actually_calculated_columns) 

466 self.assertNotIn('iDisk', cat._actually_calculated_columns) 

467 self.assertNotIn('yDisk', cat._actually_calculated_columns) 

468 self.assertNotIn('uAgn', cat._actually_calculated_columns) 

469 self.assertNotIn('rAgn', cat._actually_calculated_columns) 

470 self.assertNotIn('iAgn', cat._actually_calculated_columns) 

471 self.assertNotIn('yAgn', cat._actually_calculated_columns) 

472 self.assertNotIn('lsst_u', cat._actually_calculated_columns) 

473 self.assertNotIn('lsst_r', cat._actually_calculated_columns) 

474 self.assertNotIn('lsst_i', cat._actually_calculated_columns) 

475 self.assertNotIn('lsst_y', cat._actually_calculated_columns) 

476 self.assertNotIn('sigma_uBulge', cat._actually_calculated_columns) 

477 self.assertNotIn('sigma_rBulge', cat._actually_calculated_columns) 

478 self.assertNotIn('sigma_iBulge', cat._actually_calculated_columns) 

479 self.assertNotIn('sigma_yBulge', cat._actually_calculated_columns) 

480 self.assertNotIn('sigma_uDisk', cat._actually_calculated_columns) 

481 self.assertNotIn('sigma_rDisk', cat._actually_calculated_columns) 

482 self.assertNotIn('sigma_iDisk', cat._actually_calculated_columns) 

483 self.assertNotIn('sigma_yDisk', cat._actually_calculated_columns) 

484 self.assertNotIn('sigma_uAgn', cat._actually_calculated_columns) 

485 self.assertNotIn('sigma_rAgn', cat._actually_calculated_columns) 

486 self.assertNotIn('sigma_iAgn', cat._actually_calculated_columns) 

487 self.assertNotIn('sigma_yAgn', cat._actually_calculated_columns) 

488 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns) 

489 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns) 

490 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns) 

491 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns) 

492 

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

494 pass 

495 

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

497 lsst.utils.tests.init() 

498 unittest.main()