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 zip 

3from builtins import range 

4from builtins import object 

5from builtins import super 

6import os 

7import numpy as np 

8import unittest 

9import tempfile 

10import shutil 

11import lsst.utils.tests 

12from lsst.sims.utils.CodeUtilities import sims_clean_up 

13from lsst.sims.utils import ObservationMetaData 

14from lsst.sims.catalogs.db import fileDBObject, CatalogDBObject, CompoundCatalogDBObject 

15from lsst.sims.catalogs.definitions import InstanceCatalog, CompoundInstanceCatalog 

16 

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

18 

19 

20def setup_module(module): 

21 lsst.utils.tests.init() 

22 

23 

24class negativeRaCompound(CompoundCatalogDBObject): 

25 

26 def _final_pass(self, results): 

27 for name in results.dtype.fields: 

28 if 'raJ2000' in name: 

29 results[name] *= -1.0 

30 

31 return results 

32 

33 

34class negativeDecCompound_table2(CompoundCatalogDBObject): 

35 

36 _table_restriction = ['table2'] 

37 

38 def _final_pass(self, results): 

39 for name in results.dtype.fields: 

40 if 'decJ2000' in name: 

41 results[name] *= -1.0 

42 

43 return results 

44 

45 

46class cartoonDBbase(object): 

47 driver = 'sqlite' 

48 database = None 

49 

50 

51class table1DB1(CatalogDBObject, cartoonDBbase): 

52 tableid = 'table1' 

53 objid = 'table1DB1' 

54 idColKey = 'id' 

55 raColName = 'ra' 

56 decColName = 'dec' 

57 

58 columns = [('raJ2000', 'ra'), 

59 ('decJ2000', 'dec'), 

60 ('mag', None, np.float), 

61 ('dmag', None, np.float), 

62 ('dra', None, np.float), 

63 ('ddec', None, np.float)] 

64 

65 

66class table1DB2(CatalogDBObject, cartoonDBbase): 

67 tableid = 'table1' 

68 objid = 'table1DB2' 

69 idColKey = 'id' 

70 raColName = 'ra' 

71 decColName = 'dec' 

72 

73 columns = [('raJ2000', '2.0*ra'), 

74 ('decJ2000', '2.0*dec'), 

75 ('mag', None, np.float), 

76 ('dmag', None, np.float), 

77 ('dra', None, np.float), 

78 ('ddec', None, np.float)] 

79 

80 

81class table2DB1(CatalogDBObject, cartoonDBbase): 

82 tableid = 'table2' 

83 objid = 'table2DB1' 

84 idColKey = 'id' 

85 raColName = 'ra' 

86 decColName = 'dec' 

87 

88 columns = [('raJ2000', 'ra'), 

89 ('decJ2000', 'dec'), 

90 ('mag', None, np.float)] 

91 

92 

93class table2DB2(CatalogDBObject, cartoonDBbase): 

94 tableid = 'table2' 

95 objid = 'table2DB2' 

96 idColKey = 'id' 

97 raColName = 'ra' 

98 decColName = 'dec' 

99 

100 columns = [('raJ2000', '2.0*ra'), 

101 ('decJ2000', '2.0*dec'), 

102 ('mag', None, np.float)] 

103 

104 

105class Cat1(InstanceCatalog): 

106 delimiter = ' ' 

107 default_formats = {'f': '%.12f'} 

108 column_outputs = ['testId', 'raObs', 'decObs', 'final_mag'] 

109 

110 def get_testId(self): 

111 return self.column_by_name('id')+1000 

112 

113 def get_raObs(self): 

114 return self.column_by_name('raJ2000') 

115 

116 def get_decObs(self): 

117 return self.column_by_name('decJ2000') 

118 

119 def get_final_mag(self): 

120 return self.column_by_name('mag') + self.column_by_name('dmag') 

121 

122 

123class Cat2(Cat1): 

124 

125 def get_testId(self): 

126 return self.column_by_name('id')+2000 

127 

128 def get_raObs(self): 

129 return self.column_by_name('raJ2000') + self.column_by_name('dra') 

130 

131 def get_decObs(self): 

132 return self.column_by_name('decJ2000') + self.column_by_name('ddec') 

133 

134 

135class Cat3(Cat1): 

136 

137 def get_testId(self): 

138 return self.column_by_name('id')+3000 

139 

140 def get_final_mag(self): 

141 return self.column_by_name('mag') 

142 

143 

144class Cat4(Cat3): 

145 

146 def get_testId(self): 

147 return self.column_by_name('id')+4000 

148 

149 

150class CompoundCatalogTest(unittest.TestCase): 

151 

152 longMessage = True 

153 

154 @classmethod 

155 def setUpClass(cls): 

156 cls.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix="CompoundCatalogTest") 

157 

158 cls.table1FileName = os.path.join(cls.scratch_dir, 'compound_table1.txt') 

159 cls.table2FileName = os.path.join(cls.scratch_dir, 'compound_table2.txt') 

160 

161 if os.path.exists(cls.table1FileName): 

162 os.unlink(cls.table1FileName) 

163 if os.path.exists(cls.table2FileName): 

164 os.unlink(cls.table2FileName) 

165 

166 dtype1 = np.dtype([('ra', np.float), 

167 ('dec', np.float), 

168 ('mag', np.float), 

169 ('dmag', np.float), 

170 ('dra', np.float), 

171 ('ddec', np.float)]) 

172 

173 dbDtype1 = np.dtype([('id', np.int), 

174 ('ra', np.float), 

175 ('dec', np.float), 

176 ('mag', np.float), 

177 ('dmag', np.float), 

178 ('dra', np.float), 

179 ('ddec', np.float)]) 

180 

181 nPts = 100 

182 np.random.seed(42) 

183 raList = np.random.random_sample(nPts)*360.0 

184 decList = np.random.random_sample(nPts)*180.0-90.0 

185 magList = np.random.random_sample(nPts)*10.0+15.0 

186 dmagList = np.random.random_sample(nPts)*10.0 - 5.0 

187 draList = np.random.random_sample(nPts)*5.0 - 2.5 

188 ddecList = np.random.random_sample(nPts)*(-2.0) - 4.0 

189 

190 cls.table1Control = np.rec.fromrecords([(r, d, mm, dm, dr, dd) 

191 for r, d, mm, dm, dr, dd 

192 in zip(raList, decList, 

193 magList, dmagList, 

194 draList, ddecList)], 

195 dtype=dtype1) 

196 

197 with open(cls.table1FileName, 'w') as output: 

198 output.write("# id ra dec mag dmag dra ddec\n") 

199 for ix, (r, d, mm, dm, dr, dd) in \ 

200 enumerate(zip(raList, decList, magList, dmagList, draList, ddecList)): 

201 

202 output.write('%d %.12f %.12f %.12f %.12f %.12f %.12f\n' 

203 % (ix, r, d, mm, dm, dr, dd)) 

204 

205 dtype2 = np.dtype([('ra', np.float), 

206 ('dec', np.float), 

207 ('mag', np.float)]) 

208 

209 dbDtype2 = np.dtype([('id', np.int), 

210 ('ra', np.float), 

211 ('dec', np.float), 

212 ('mag', np.float)]) 

213 

214 ra2List = np.random.random_sample(nPts)*360.0 

215 dec2List = np.random.random_sample(nPts)*180.0-90.0 

216 mag2List = np.random.random_sample(nPts)*10+18.0 

217 

218 cls.table2Control = np.rec.fromrecords([(r, d, m) 

219 for r, d, m in 

220 zip(ra2List, dec2List, mag2List)], dtype=dtype2) 

221 

222 with open(cls.table2FileName, 'w') as output: 

223 output.write('# id ra dec mag\n') 

224 for ix, (r, d, m) in enumerate(zip(ra2List, dec2List, mag2List)): 

225 output.write('%d %.12f %.12f %.12f\n' % (ix, r, d, m)) 

226 

227 cls.dbName = os.path.join(cls.scratch_dir, 'compound_db.db') 

228 if os.path.exists(cls.dbName): 

229 os.unlink(cls.dbName) 

230 

231 fileDBObject(cls.table1FileName, runtable='table1', 

232 database=cls.dbName, dtype=dbDtype1, 

233 idColKey='id') 

234 

235 fileDBObject(cls.table2FileName, runtable='table2', 

236 database=cls.dbName, dtype=dbDtype2, 

237 idColKey='id') 

238 

239 @classmethod 

240 def tearDownClass(cls): 

241 sims_clean_up() 

242 if os.path.exists(cls.table1FileName): 

243 os.unlink(cls.table1FileName) 

244 if os.path.exists(cls.table2FileName): 

245 os.unlink(cls.table2FileName) 

246 if os.path.exists(cls.dbName): 

247 os.unlink(cls.dbName) 

248 if os.path.exists(cls.scratch_dir): 

249 shutil.rmtree(cls.scratch_dir) 

250 

251 def setUp(self): 

252 table1DB1.database = self.dbName 

253 table1DB2.database = self.dbName 

254 table2DB1.database = self.dbName 

255 table2DB2.database = self.dbName 

256 

257 def tearDown(self): 

258 table1DB1.database = None 

259 table1DB2.database = None 

260 table2DB1.database = None 

261 table2DB2.database = None 

262 

263 def testCompoundCatalog(self): 

264 """ 

265 Test that a CompoundInstanceCatalog produces the expected output 

266 """ 

267 fileName = os.path.join(self.scratch_dir, 'simplest_compound_catalog.txt') 

268 

269 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1]) 

270 

271 compoundCat.write_catalog(fileName) 

272 

273 self.assertEqual(len(compoundCat._dbObjectGroupList), 2) 

274 self.assertEqual(len(compoundCat._dbObjectGroupList[0]), 2) 

275 self.assertEqual(len(compoundCat._dbObjectGroupList[1]), 1) 

276 self.assertIn(0, compoundCat._dbObjectGroupList[0]) 

277 self.assertIn(1, compoundCat._dbObjectGroupList[0]) 

278 self.assertIn(2, compoundCat._dbObjectGroupList[1]) 

279 

280 dtype = np.dtype([('id', np.int), 

281 ('raObs', np.float), 

282 ('decObs', np.float), 

283 ('final_mag', np.float)]) 

284 

285 testData = np.genfromtxt(fileName, dtype=dtype) 

286 

287 for line in testData: 

288 if line[0] < 2000: 

289 ix = line[0]-1000 

290 self.assertAlmostEqual(line[1], self.table1Control['ra'][ix], 6) 

291 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

292 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

293 line[3], 6) 

294 elif line[0] < 3000: 

295 ix = line[0] - 2000 

296 self.assertAlmostEqual(2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

297 line[1], 6) 

298 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

299 line[2], 6) 

300 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

301 line[3], 6) 

302 else: 

303 ix = line[0]-3000 

304 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

305 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

306 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

307 

308 if os.path.exists(fileName): 

309 os.unlink(fileName) 

310 

311 def testSharedVariables(self): 

312 """ 

313 Test that, if I set a transformations dict in the CompoundInstanceCatalog, that 

314 gets propagated to all of the InstanceCatalogs inside it. 

315 """ 

316 fileName = os.path.join(self.scratch_dir, 'transformed_compound_catalog.txt') 

317 

318 class TransformedCompoundCatalog(CompoundInstanceCatalog): 

319 transformations = {'raObs': np.degrees, 'decObs': np.degrees} 

320 

321 compoundCat = TransformedCompoundCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1]) 

322 

323 compoundCat.write_catalog(fileName) 

324 

325 self.assertEqual(len(compoundCat._dbObjectGroupList), 2) 

326 self.assertEqual(len(compoundCat._dbObjectGroupList[0]), 2) 

327 self.assertEqual(len(compoundCat._dbObjectGroupList[1]), 1) 

328 self.assertIn(0, compoundCat._dbObjectGroupList[0]) 

329 self.assertIn(1, compoundCat._dbObjectGroupList[0]) 

330 self.assertIn(2, compoundCat._dbObjectGroupList[1]) 

331 

332 dtype = np.dtype([('id', np.int), 

333 ('raObs', np.float), 

334 ('decObs', np.float), 

335 ('final_mag', np.float)]) 

336 

337 testData = np.genfromtxt(fileName, dtype=dtype) 

338 

339 for line in testData: 

340 if line[0] < 2000: 

341 ix = line[0]-1000 

342 self.assertAlmostEqual(line[1], np.degrees(self.table1Control['ra'][ix]), 6) 

343 self.assertAlmostEqual(line[2], np.degrees(self.table1Control['dec'][ix]), 6) 

344 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

345 line[3], 6) 

346 elif line[0] < 3000: 

347 ix = line[0] - 2000 

348 self.assertAlmostEqual(line[1], 

349 np.degrees(2.0*self.table1Control['ra'][ix] + 

350 self.table1Control['dra'][ix]), 6) 

351 self.assertAlmostEqual(line[2], 

352 np.degrees(2.0*self.table1Control['dec'][ix] + 

353 self.table1Control['ddec'][ix]), 6) 

354 self.assertAlmostEqual(self.table1Control['mag'][ix] + self.table1Control['dmag'][ix], 

355 line[3], 6) 

356 else: 

357 ix = line[0]-3000 

358 self.assertAlmostEqual(line[1], np.degrees(self.table2Control['ra'][ix]), 6) 

359 self.assertAlmostEqual(line[2], np.degrees(self.table2Control['dec'][ix]), 6) 

360 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

361 

362 if os.path.exists(fileName): 

363 os.unlink(fileName) 

364 

365 def testObservationMetaData(self): 

366 """ 

367 Test that CompoundInstanceCatalog handles ObservationMetaData 

368 properly 

369 """ 

370 fileName = os.path.join(self.scratch_dir, 'compound_obs_metadata_test_cat.txt') 

371 obs = ObservationMetaData(pointingRA = 180.0, 

372 pointingDec = 0.0, 

373 boundType = 'box', 

374 boundLength = (80.0, 25.0), 

375 mjd=53850.0) 

376 

377 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1], 

378 obs_metadata=obs) 

379 

380 compoundCat.write_catalog(fileName) 

381 dtype = np.dtype([('id', np.int), 

382 ('raObs', np.float), 

383 ('decObs', np.float), 

384 ('final_mag', np.float)]) 

385 

386 testData = np.genfromtxt(fileName, dtype=dtype) 

387 

388 table1_good_rows = [] 

389 table2_good_rows = [] 

390 for line in testData: 

391 if line[0] < 2000: 

392 ix = line[0] - 1000 

393 if ix not in table1_good_rows: 

394 table1_good_rows.append(ix) 

395 self.assertAlmostEqual(line[1], self.table1Control['ra'][ix], 6) 

396 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

397 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

398 line[3], 6) 

399 self.assertGreater(self.table1Control['ra'][ix], 100.0) 

400 self.assertLess(self.table1Control['ra'][ix], 260.0) 

401 self.assertGreater(self.table1Control['dec'][ix], -25.0) 

402 self.assertLess(self.table1Control['dec'][ix], 25.0) 

403 elif line[0] < 3000: 

404 ix = line[0] - 2000 

405 if ix not in table1_good_rows: 

406 table1_good_rows.append(ix) 

407 self.assertAlmostEqual(2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

408 line[1], 6) 

409 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

410 line[2], 6) 

411 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

412 line[3], 6) 

413 self.assertGreater(self.table1Control['ra'][ix], 100.0) 

414 self.assertLess(self.table1Control['ra'][ix], 260.0) 

415 self.assertGreater(self.table1Control['dec'][ix], -25.0) 

416 self.assertLess(self.table1Control['dec'][ix], 25.0) 

417 else: 

418 ix = line[0]-3000 

419 if ix not in table2_good_rows: 

420 table2_good_rows.append(ix) 

421 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

422 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

423 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

424 self.assertGreater(self.table2Control['ra'][ix], 100.0) 

425 self.assertLess(self.table2Control['ra'][ix], 260.0) 

426 self.assertGreater(self.table2Control['dec'][ix], -25.0) 

427 self.assertLess(self.table2Control['dec'][ix], 25.0) 

428 

429 table1_bad_rows = [ii for ii in range(self.table1Control.shape[0]) if ii not in table1_good_rows] 

430 table2_bad_rows = [ii for ii in range(self.table2Control.shape[0]) if ii not in table2_good_rows] 

431 

432 in_bounds = [rr > 100.0 and rr < 260.0 and dd > -25.0 and dd < 25.0 

433 for rr, dd in zip(self.table1Control['ra'][table1_bad_rows], 

434 self.table1Control['dec'][table1_bad_rows])] 

435 

436 self.assertNotIn(True, in_bounds, msg='failed to assemble table1_bad_rows') 

437 

438 in_bounds = [rr > 100.0 and rr < 260.0 and dd > -25.0 and dd < 25.0 

439 for rr, dd in zip(self.table2Control['ra'][table2_bad_rows], 

440 self.table2Control['dec'][table2_bad_rows])] 

441 

442 self.assertNotIn(True, in_bounds, msg='failed to assemble table2_bad_rows') 

443 

444 self.assertGreater(len(table1_good_rows), 0) 

445 self.assertGreater(len(table2_good_rows), 0) 

446 self.assertGreater(len(table1_bad_rows), 0) 

447 self.assertGreater(len(table2_bad_rows), 0) 

448 self.assertEqual(len(table1_good_rows)+len(table1_bad_rows), self.table1Control.shape[0]) 

449 self.assertEqual(len(table2_good_rows)+len(table2_bad_rows), self.table2Control.shape[0]) 

450 

451 if os.path.exists(fileName): 

452 os.unlink(fileName) 

453 

454 def testConstraint(self): 

455 """ 

456 Test that CompoundInstanceCatalog handles constraint 

457 properly 

458 """ 

459 fileName = os.path.join(self.scratch_dir, 'compound_constraint_test_cat.txt') 

460 

461 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1], 

462 constraint='mag>20.0') 

463 

464 compoundCat.write_catalog(fileName) 

465 dtype = np.dtype([('id', np.int), 

466 ('raObs', np.float), 

467 ('decObs', np.float), 

468 ('final_mag', np.float)]) 

469 

470 testData = np.genfromtxt(fileName, dtype=dtype) 

471 

472 table1_good_rows = [] 

473 table2_good_rows = [] 

474 for line in testData: 

475 if line[0] < 2000: 

476 ix = line[0]-1000 

477 if ix not in table1_good_rows: 

478 table1_good_rows.append(ix) 

479 self.assertAlmostEqual(line[1], self.table1Control['ra'][ix], 6) 

480 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

481 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

482 line[3], 6) 

483 self.assertGreater(self.table1Control['mag'][ix], 20.0) 

484 elif line[0] < 3000: 

485 ix = line[0] - 2000 

486 if ix not in table1_good_rows: 

487 table1_good_rows.append(ix) 

488 self.assertAlmostEqual(2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

489 line[1], 6) 

490 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

491 line[2], 6) 

492 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

493 line[3], 6) 

494 self.assertGreater(self.table1Control['mag'][ix], 20.0) 

495 else: 

496 ix = line[0]-3000 

497 if ix not in table2_good_rows: 

498 table2_good_rows.append(ix) 

499 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

500 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

501 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

502 self.assertGreater(self.table2Control['mag'][ix], 20.0) 

503 

504 table1_bad_rows = [ii for ii in range(self.table1Control.shape[0]) if ii not in table1_good_rows] 

505 table2_bad_rows = [ii for ii in range(self.table2Control.shape[0]) if ii not in table2_good_rows] 

506 

507 in_bounds = [mm > 20.0 for mm in self.table1Control['mag'][table1_bad_rows]] 

508 

509 self.assertNotIn(True, in_bounds, msg='failed to assemble table1_bad_rows') 

510 

511 in_bounds = [mm > 20.0 for mm in self.table2Control['mag'][table2_bad_rows]] 

512 

513 self.assertNotIn(True, in_bounds, msg='failed to assemble table2_bad_rows') 

514 

515 self.assertGreater(len(table1_good_rows), 0) 

516 self.assertGreater(len(table2_good_rows), 0) 

517 self.assertGreater(len(table1_bad_rows), 0) 

518 self.assertGreater(len(table2_bad_rows), 0) 

519 self.assertEqual(len(table1_good_rows)+len(table1_bad_rows), self.table1Control.shape[0]) 

520 self.assertEqual(len(table2_good_rows)+len(table2_bad_rows), self.table2Control.shape[0]) 

521 

522 if os.path.exists(fileName): 

523 os.unlink(fileName) 

524 

525 def testObservationMetaDataAndConstraint(self): 

526 """ 

527 Test that CompoundInstanceCatalog handles ObservationMetaData 

528 and a constraint properly 

529 """ 

530 fileName = os.path.join(self.scratch_dir, 'compound_obs_metadata_test_cat.txt') 

531 obs = ObservationMetaData(pointingRA = 180.0, 

532 pointingDec = 0.0, 

533 boundType = 'box', 

534 boundLength = (80.0, 25.0), 

535 mjd=53850.0) 

536 

537 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1], 

538 obs_metadata=obs, 

539 constraint='mag>20.0') 

540 

541 compoundCat.write_catalog(fileName) 

542 dtype = np.dtype([('id', np.int), 

543 ('raObs', np.float), 

544 ('decObs', np.float), 

545 ('final_mag', np.float)]) 

546 

547 testData = np.genfromtxt(fileName, dtype=dtype) 

548 

549 table1_good_rows = [] 

550 table2_good_rows = [] 

551 for line in testData: 

552 if line[0] < 2000: 

553 ix = line[0] - 1000 

554 if ix not in table1_good_rows: 

555 table1_good_rows.append(ix) 

556 self.assertAlmostEqual(line[1], self.table1Control['ra'][ix], 6) 

557 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

558 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

559 line[3], 6) 

560 self.assertGreater(self.table1Control['ra'][ix], 100.0) 

561 self.assertLess(self.table1Control['ra'][ix], 260.0) 

562 self.assertGreater(self.table1Control['dec'][ix], -25.0) 

563 self.assertLess(self.table1Control['dec'][ix], 25.0) 

564 self.assertGreater(self.table1Control['mag'][ix], 20.0) 

565 elif line[0] < 3000: 

566 ix = line[0] - 2000 

567 if ix not in table1_good_rows: 

568 table1_good_rows.append(ix) 

569 self.assertAlmostEqual(2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

570 line[1], 6) 

571 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

572 line[2], 6) 

573 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

574 line[3], 6) 

575 self.assertGreater(self.table1Control['ra'][ix], 100.0) 

576 self.assertLess(self.table1Control['ra'][ix], 260.0) 

577 self.assertGreater(self.table1Control['dec'][ix], -25.0) 

578 self.assertLess(self.table1Control['dec'][ix], 25.0) 

579 self.assertGreater(self.table1Control['mag'][ix], 20.0) 

580 else: 

581 ix = line[0]-3000 

582 if ix not in table2_good_rows: 

583 table2_good_rows.append(ix) 

584 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

585 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

586 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

587 self.assertGreater(self.table2Control['ra'][ix], 100.0) 

588 self.assertLess(self.table2Control['ra'][ix], 260.0) 

589 self.assertGreater(self.table2Control['dec'][ix], -25.0) 

590 self.assertLess(self.table2Control['dec'][ix], 25.0) 

591 self.assertGreater(self.table2Control['mag'][ix], 20.0) 

592 

593 table1_bad_rows = [ii for ii in range(self.table1Control.shape[0]) if ii not in table1_good_rows] 

594 table2_bad_rows = [ii for ii in range(self.table2Control.shape[0]) if ii not in table2_good_rows] 

595 

596 in_bounds = [rr > 100.0 and rr < 260.0 and dd > -25.0 and dd < 25.0 and mm > 20.0 

597 for rr, dd, mm in zip(self.table1Control['ra'][table1_bad_rows], 

598 self.table1Control['dec'][table1_bad_rows], 

599 self.table1Control['mag'][table1_bad_rows])] 

600 

601 self.assertNotIn(True, in_bounds, msg='failed to assemble table1_bad_rows') 

602 

603 in_bounds = [rr > 100.0 and rr < 260.0 and dd > -25.0 and dd < 25.0 and mm > 20.0 

604 for rr, dd, mm in zip(self.table2Control['ra'][table2_bad_rows], 

605 self.table2Control['dec'][table2_bad_rows], 

606 self.table2Control['mag'][table2_bad_rows])] 

607 

608 self.assertNotIn(True, in_bounds, msg='failed to assemble table2_bad_rows') 

609 

610 self.assertGreater(len(table1_good_rows), 0) 

611 self.assertGreater(len(table2_good_rows), 0) 

612 self.assertGreater(len(table1_bad_rows), 0) 

613 self.assertGreater(len(table2_bad_rows), 0) 

614 self.assertEqual(len(table1_good_rows)+len(table1_bad_rows), self.table1Control.shape[0]) 

615 self.assertEqual(len(table2_good_rows)+len(table2_bad_rows), self.table2Control.shape[0]) 

616 

617 if os.path.exists(fileName): 

618 os.unlink(fileName) 

619 

620 def testCustomCompoundCatalogDBObject(self): 

621 """ 

622 Test that CompoundInstanceCatalog behaves properly when passed a 

623 custom CompoundCatalogDBObject 

624 """ 

625 fileName = os.path.join(self.scratch_dir, 'simplest_compound_catalog.txt') 

626 

627 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], [table1DB1, table1DB2, table2DB1], 

628 compoundDBclass=negativeRaCompound) 

629 

630 compoundCat.write_catalog(fileName) 

631 

632 self.assertEqual(len(compoundCat._dbObjectGroupList), 2) 

633 self.assertEqual(len(compoundCat._dbObjectGroupList[0]), 2) 

634 self.assertEqual(len(compoundCat._dbObjectGroupList[1]), 1) 

635 self.assertIn(0, compoundCat._dbObjectGroupList[0]) 

636 self.assertIn(1, compoundCat._dbObjectGroupList[0]) 

637 self.assertIn(2, compoundCat._dbObjectGroupList[1]) 

638 

639 dtype = np.dtype([('id', np.int), 

640 ('raObs', np.float), 

641 ('decObs', np.float), 

642 ('final_mag', np.float)]) 

643 

644 testData = np.genfromtxt(fileName, dtype=dtype) 

645 

646 for line in testData: 

647 if line[0] < 2000: 

648 ix = line[0] - 1000 

649 self.assertAlmostEqual(line[1], -1.0*self.table1Control['ra'][ix], 6) 

650 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

651 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

652 line[3], 6) 

653 elif line[0] < 3000: 

654 ix = line[0]-2000 

655 self.assertAlmostEqual(-2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

656 line[1], 6) 

657 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

658 line[2], 6) 

659 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

660 line[3], 6) 

661 else: 

662 ix = line[0]-3000 

663 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

664 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

665 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

666 

667 if os.path.exists(fileName): 

668 os.unlink(fileName) 

669 

670 def testDefaultCustomCompoundCatalogDBObject(self): 

671 """ 

672 Test that CompoundInstanceCatalog can properly parse multiple CompoundCatalogDBobjects 

673 """ 

674 fileName = os.path.join(self.scratch_dir, 'simplest_compound_catalog.txt') 

675 

676 # negativeDecComopound_table2 should not come into play, since the 

677 # multiple queries are directed at table1 

678 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3], 

679 [table1DB1, table1DB2, table2DB1], 

680 compoundDBclass=[negativeDecCompound_table2, 

681 negativeRaCompound]) 

682 

683 compoundCat.write_catalog(fileName) 

684 

685 self.assertEqual(len(compoundCat._dbObjectGroupList), 2) 

686 self.assertEqual(len(compoundCat._dbObjectGroupList[0]), 2) 

687 self.assertEqual(len(compoundCat._dbObjectGroupList[1]), 1) 

688 self.assertIn(0, compoundCat._dbObjectGroupList[0]) 

689 self.assertIn(1, compoundCat._dbObjectGroupList[0]) 

690 self.assertIn(2, compoundCat._dbObjectGroupList[1]) 

691 

692 dtype = np.dtype([('id', np.int), 

693 ('raObs', np.float), 

694 ('decObs', np.float), 

695 ('final_mag', np.float)]) 

696 

697 testData = np.genfromtxt(fileName, dtype=dtype) 

698 

699 for line in testData: 

700 if line[0] < 2000: 

701 ix = line[0]-1000 

702 self.assertAlmostEqual(line[1], -1.0*self.table1Control['ra'][ix], 6) 

703 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

704 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

705 line[3], 6) 

706 elif line[0] < 3000: 

707 ix = line[0]-2000 

708 self.assertAlmostEqual(-2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

709 line[1], 6) 

710 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

711 line[2], 6) 

712 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

713 line[3], 6) 

714 else: 

715 ix = line[0]-3000 

716 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

717 self.assertAlmostEqual(line[2], self.table2Control['dec'][ix], 6) 

718 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

719 

720 if os.path.exists(fileName): 

721 os.unlink(fileName) 

722 

723 def testCustomCompoundCatalogDBObjectList(self): 

724 """ 

725 Test that CompoundInstanceCatalog behaves properly when there are 

726 two sets of multiple queries, one to table1, one to table2 

727 """ 

728 fileName = os.path.join(self.scratch_dir, 'simplest_compound_catalog.txt') 

729 

730 compoundCat = CompoundInstanceCatalog([Cat1, Cat2, Cat3, Cat4], 

731 [table1DB1, table1DB2, table2DB1, table2DB2], 

732 compoundDBclass=[negativeRaCompound, 

733 negativeDecCompound_table2]) 

734 

735 compoundCat.write_catalog(fileName) 

736 

737 self.assertEqual(len(compoundCat._dbObjectGroupList), 2) 

738 self.assertEqual(len(compoundCat._dbObjectGroupList[0]), 2) 

739 self.assertEqual(len(compoundCat._dbObjectGroupList[1]), 2) 

740 self.assertIn(0, compoundCat._dbObjectGroupList[0]) 

741 self.assertIn(1, compoundCat._dbObjectGroupList[0]) 

742 self.assertIn(2, compoundCat._dbObjectGroupList[1]) 

743 self.assertIn(3, compoundCat._dbObjectGroupList[1]) 

744 

745 dtype = np.dtype([('id', np.int), 

746 ('raObs', np.float), 

747 ('decObs', np.float), 

748 ('final_mag', np.float)]) 

749 

750 testData = np.genfromtxt(fileName, dtype=dtype) 

751 

752 for line in testData: 

753 if line[0] < 2000: 

754 ix = line[0]-1000 

755 self.assertAlmostEqual(line[1], -1.0*self.table1Control['ra'][ix], 6) 

756 self.assertAlmostEqual(line[2], self.table1Control['dec'][ix], 6) 

757 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

758 line[3], 6) 

759 elif line[0] < 3000: 

760 ix = line[0] - 2000 

761 self.assertAlmostEqual(-2.0*self.table1Control['ra'][ix]+self.table1Control['dra'][ix], 

762 line[1], 6) 

763 self.assertAlmostEqual(2.0*self.table1Control['dec'][ix]+self.table1Control['ddec'][ix], 

764 line[2], 6) 

765 self.assertAlmostEqual(self.table1Control['mag'][ix]+self.table1Control['dmag'][ix], 

766 line[3], 6) 

767 elif line[0] < 4000: 

768 ix = line[0] - 3000 

769 self.assertAlmostEqual(line[1], self.table2Control['ra'][ix], 6) 

770 self.assertAlmostEqual(line[2], -1.0*self.table2Control['dec'][ix], 6) 

771 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

772 else: 

773 ix = line[0] - 4000 

774 self.assertAlmostEqual(line[1], 2.0*self.table2Control['ra'][ix], 6) 

775 self.assertAlmostEqual(line[2], -2.0*self.table2Control['dec'][ix], 6) 

776 self.assertAlmostEqual(line[3], self.table2Control['mag'][ix], 6) 

777 

778 if os.path.exists(fileName): 

779 os.unlink(fileName) 

780 

781 

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

783 pass 

784 

785 

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

787 setup_module(None) 

788 unittest.main()