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 unittest 

5import numpy as np 

6import sqlite3 

7import json 

8import tempfile 

9import shutil 

10import lsst.utils.tests 

11from lsst.utils import getPackageDir 

12from lsst.sims.utils.CodeUtilities import sims_clean_up 

13from lsst.sims.utils import ObservationMetaData 

14from lsst.sims.catalogs.db import CatalogDBObject 

15from lsst.sims.catalogs.definitions import InstanceCatalog 

16from lsst.sims.catUtils.mixins import PhotometryStars, PhotometryGalaxies 

17from lsst.sims.catUtils.mixins import VariabilityStars, VariabilityGalaxies 

18from lsst.sims.catUtils.mixins import ExtraGalacticVariabilityModels 

19from lsst.sims.catUtils.utils import TestVariabilityMixin 

20 

21from lsst.sims.catUtils.mixins import Variability 

22 

23VARIABILITY_DB = 'VariabilityTestDatabase.db' 

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

25 

26 

27def setup_module(module): 

28 lsst.utils.tests.init() 

29 

30 

31def makeRRlyTable(size=100, database=VARIABILITY_DB, **kwargs): 

32 """ 

33 Make a test database to serve information to the rrlyrae test 

34 """ 

35 

36 # a haphazard sample of stellar SEDs 

37 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750'] 

38 

39 # a haphazard sample of RRLyrae light curves 

40 lcFiles = ['rrly_lc/RRc/959802_per.txt', 'rrly_lc/RRc/1078860_per.txt', 'rrly_lc/RRab/98874_per.txt', 

41 'rrly_lc/RRab/3879827_per.txt'] 

42 

43 conn = sqlite3.connect(database) 

44 c = conn.cursor() 

45 try: 

46 c.execute('''CREATE TABLE RRly 

47 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

48 conn.commit() 

49 except: 

50 return 

51 

52 rng = np.random.RandomState(32) 

53 mjDisplacement = (rng.random_sample(size)-50.0)*50.0 

54 for i in range(size): 

55 sedFile = sedFiles[rng.randint(0, len(sedFiles))] 

56 varParam = {'varMethodName': 'applyRRly', 

57 'pars': {'tStartMjd': 48000.0+mjDisplacement[i], 

58 'filename': lcFiles[rng.randint(0, len(lcFiles))]}} 

59 paramStr = json.dumps(varParam) 

60 

61 qstr = '''INSERT INTO RRly VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

62 c.execute(qstr) 

63 conn.commit() 

64 conn.close() 

65 

66 

67def makeCepheidTable(size=100, database=VARIABILITY_DB, **kwargs): 

68 """ 

69 Make a test database to serve information to the cepheid test 

70 """ 

71 

72 # a haphazard sample of stellar SEDs 

73 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750'] 

74 

75 # a haphazard sample of cepheid light curves 

76 lcFiles = ['cepheid_lc/classical_longPer_specfile', 'cepheid_lc/classical_medPer_specfile', 

77 'cepheid_lc/classical_shortPer_specfile', 'cepheid_lc/classical_shortPer_specfile', 

78 'cepheid_lc/popII_longPer_specfile', 'cepheid_lc/popII_shortPer_specfile'] 

79 

80 conn = sqlite3.connect(database) 

81 c = conn.cursor() 

82 try: 

83 c.execute('''CREATE TABLE cepheid 

84 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

85 conn.commit() 

86 except: 

87 return 

88 

89 rng = np.random.RandomState(32) 

90 periods = rng.random_sample(size)*50.0 

91 mjDisplacement = (rng.random_sample(size)-0.5)*50.0 

92 for i in range(size): 

93 sedFile = sedFiles[rng.randint(0, len(sedFiles))] 

94 varParam = {'varMethodName': 'applyCepheid', 

95 'pars': {'period': periods[i], 'lcfile': lcFiles[rng.randint(0, len(lcFiles))], 

96 't0': 48000.0+mjDisplacement[i]}} 

97 paramStr = json.dumps(varParam) 

98 

99 qstr = '''INSERT INTO cepheid VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

100 c.execute(qstr) 

101 conn.commit() 

102 conn.close() 

103 

104 

105def makeEbTable(size=100, database=VARIABILITY_DB, **kwargs): 

106 """ 

107 Make a test database to serve information to the Eb test 

108 """ 

109 

110 # a haphazard sample of eclipsing binary light curves 

111 lcFiles = ['eb_lc/EB.2294.inp', 'eb_lc/EB.1540.inp', 'eb_lc/EB.2801.inp'] 

112 

113 conn = sqlite3.connect(database) 

114 c = conn.cursor() 

115 try: 

116 c.execute('''CREATE TABLE eb 

117 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

118 conn.commit() 

119 except: 

120 return 

121 

122 rng = np.random.RandomState(32) 

123 periods = rng.random_sample(size)*50.0 

124 mjDisplacement = (rng.random_sample(size)-0.5)*50.0 

125 for i in range(size): 

126 sedFile = 'sed_flat_norm.txt' 

127 varParam = {'varMethodName': 'applyEb', 

128 'pars': {'period': periods[i], 'lcfile': lcFiles[rng.randint(0, len(lcFiles))], 

129 't0': 48000.0+mjDisplacement[i]}} 

130 paramStr = json.dumps(varParam) 

131 

132 qstr = '''INSERT INTO eb VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

133 c.execute(qstr) 

134 conn.commit() 

135 conn.close() 

136 

137 

138def makeMicrolensingTable(size=100, database=VARIABILITY_DB, **kwargs): 

139 """ 

140 Make a test database to serve information to the microlensing test 

141 """ 

142 

143 # a haphazard sample of stellar SEDs 

144 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750'] 

145 

146 # there are two microlensing methods; they should be equivalent 

147 method = ['applyMicrolensing', 'applyMicrolens'] 

148 conn = sqlite3.connect(database) 

149 c = conn.cursor() 

150 try: 

151 c.execute('''CREATE TABLE microlensing 

152 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

153 conn.commit() 

154 except: 

155 return 

156 

157 rng = np.random.RandomState(32) 

158 that = rng.random_sample(size)*40.0+40.0 

159 umin = rng.random_sample(size) 

160 mjDisplacement = rng.random_sample(size)*50.0 

161 for i in range(size): 

162 sedFile = sedFiles[0] 

163 varParam = {'varMethodName': method[i%len(method)], 

164 'pars': {'that': that[i], 'umin': umin[i], 't0': 52000.0+mjDisplacement[i]}} 

165 paramStr = json.dumps(varParam) 

166 

167 qstr = '''INSERT INTO microlensing VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

168 c.execute(qstr) 

169 conn.commit() 

170 conn.close() 

171 

172 

173def makeBHMicrolensingTable(size=100, database=VARIABILITY_DB, **kwargs): 

174 """ 

175 Make a test database to serve information to the BHmicrolensing test 

176 """ 

177 

178 # a haphazard sample of stellar SEDs 

179 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750'] 

180 

181 # a sample of black hole microlensing light curves that do not repeat time steps 

182 # (repeating time steps causes the scipy spline interpolation routine to return Nan) 

183 lcFiles = ['microlens/bh_binary_source/lc_14_25_75_8000_0_0.05_316', 

184 'microlens/bh_binary_source/lc_14_25_4000_8000_0_phi1.09_0.005_100', 

185 'microlens/bh_binary_source/lc_14_25_75_8000_0_tets2.09_0.005_316'] 

186 

187 conn = sqlite3.connect(database) 

188 c = conn.cursor() 

189 try: 

190 c.execute('''CREATE TABLE bhmicrolensing 

191 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

192 conn.commit() 

193 except: 

194 return 

195 

196 rng = np.random.RandomState(32) 

197 mjDisplacement = rng.random_sample(size)*5.0*365.25 

198 for i in range(size): 

199 sedFile = sedFiles[rng.randint(0, len(sedFiles))] 

200 varParam = {'varMethodName': 'applyBHMicrolens', 

201 'pars': {'filename': lcFiles[rng.randint(0, len(lcFiles))], 

202 't0': 52000.0-mjDisplacement[i]}} 

203 paramStr = json.dumps(varParam) 

204 

205 qstr = '''INSERT INTO bhmicrolensing VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

206 c.execute(qstr) 

207 conn.commit() 

208 conn.close() 

209 

210 

211def makeAmcvnTable(size=100, database=VARIABILITY_DB, **kwargs): 

212 """ 

213 Make a test database to serve information to the AMCVN test 

214 """ 

215 

216 # a haphazard sample of white dwarf SEDs 

217 sedFiles = ['bergeron_He_4750_70.dat_4950', 'bergeron_50000_85.dat_54000'] 

218 

219 conn = sqlite3.connect(database) 

220 c = conn.cursor() 

221 try: 

222 c.execute('''CREATE TABLE amcvn 

223 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

224 conn.commit() 

225 except: 

226 return 

227 

228 rng = np.random.RandomState(32) 

229 doesBurst = rng.randint(0, 2, size=size) 

230 burst_freq = rng.randint(10, 150, size=size) 

231 burst_scale = 115.0 

232 amp_burst = rng.random_sample(size)*8.0 

233 color_excess_during_burst = rng.random_sample(size)*0.2-0.4 

234 amplitude = rng.random_sample(size)*0.2 

235 period = rng.random_sample(size)*200.0 

236 mjDisplacement = rng.random_sample(size)*500.0 

237 for i in range(size): 

238 sedFile = sedFiles[rng.randint(0, len(sedFiles))] 

239 varParam = {'varMethodName': 'applyAmcvn', 

240 'pars': {'does_burst': int(doesBurst[i]), # have to cast to int from np.int for json 

241 'burst_freq': int(burst_freq[i]), 

242 'burst_scale': burst_scale, 

243 'amp_burst': amp_burst[i], 

244 'color_excess_during_burst': color_excess_during_burst[i], 

245 'amplitude': amplitude[i], 

246 'period': period[i], 

247 't0': 51500.0-mjDisplacement[i]}} 

248 

249 paramStr = json.dumps(varParam) 

250 

251 qstr = '''INSERT INTO amcvn VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

252 c.execute(qstr) 

253 conn.commit() 

254 conn.close() 

255 

256 

257def makeAgnTable(size=100, database=VARIABILITY_DB, **kwargs): 

258 """ 

259 Make a test database to serve information to the microlensing test 

260 """ 

261 

262 # a haphazard sample of galaxy SEDs 

263 sedFiles = ['Exp.31E06.0005Z.spec', 'Inst.79E06.1Z.spec', 'Const.50E07.0005Z.spec'] 

264 conn = sqlite3.connect(database) 

265 c = conn.cursor() 

266 try: 

267 c.execute('''CREATE TABLE agn 

268 (galid int, varsimobjid int, 

269 internalAvBulge real, internalAvDisk real, redshift real, 

270 variability text, 

271 sedFilenameBulge text, sedFilenameDisk text, sedFilenameAgn text)''') 

272 conn.commit() 

273 except: 

274 return 

275 

276 rng = np.random.RandomState(32) 

277 agn_tau = rng.random_sample(size)*100.0+100.0 

278 agn_sfu = rng.random_sample(size)*2.0 

279 agn_sfg = rng.random_sample(size)*2.0 

280 agn_sfr = rng.random_sample(size)*2.0 

281 agn_sfi = rng.random_sample(size)*2.0 

282 agn_sfz = rng.random_sample(size)*2.0 

283 agn_sfy = rng.random_sample(size)*2.0 

284 mjDisplacement = rng.random_sample(size)*5.0 

285 avBulge = rng.random_sample(size)*0.5+2.6 

286 avDisk = rng.random_sample(size)*0.5+2.6 

287 redshift = rng.random_sample(size)*0.5 

288 for i in range(size): 

289 varParam = {'varMethodName': 'applyAgn', 

290 'pars': {'agn_tau': agn_tau[i], 'agn_sfu': agn_sfu[i], 'agn_sfg': agn_sfg[i], 

291 'agn_sfr': agn_sfr[i], 'agn_sfi': agn_sfi[i], 'agn_sfz': agn_sfz[i], 

292 'agn_sfy': agn_sfy[i], 't0_mjd': 48000.0+mjDisplacement[i], 

293 'seed': rng.randint(0, 200000)}} 

294 

295 paramStr = json.dumps(varParam) 

296 

297 qstr = '''INSERT INTO agn VALUES (%i, %i, %f, %f, %f, '%s', '%s', '%s', '%s')''' % \ 

298 (i, i, avBulge[i], avDisk[i], redshift[i], 

299 paramStr, 

300 sedFiles[rng.randint(0, len(sedFiles))], 

301 sedFiles[rng.randint(0, len(sedFiles))], 

302 'agn.spec') 

303 

304 c.execute(qstr) 

305 conn.commit() 

306 conn.close() 

307 

308 

309def makeHybridTable(size=100, database='VariabilityTestDatabase.db', **kwargs): 

310 """ 

311 Make a test database that contains a mix of Cepheid variables 

312 and 'testVar' variables (variables that use the applySineVar 

313 method defined in the TestVariabilityMixin) 

314 """ 

315 

316 # a haphazard sample of stellar SEDs 

317 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750'] 

318 

319 # a haphazard sample of cepheid light curves 

320 lcFiles = ['cepheid_lc/classical_longPer_specfile', 'cepheid_lc/classical_medPer_specfile', 

321 'cepheid_lc/classical_shortPer_specfile', 'cepheid_lc/classical_shortPer_specfile', 

322 'cepheid_lc/popII_longPer_specfile', 'cepheid_lc/popII_shortPer_specfile'] 

323 

324 conn = sqlite3.connect(database) 

325 c = conn.cursor() 

326 try: 

327 c.execute('''CREATE TABLE hybrid 

328 (varsimobjid int, variability text, sedfilename text, parallax real, ebv real)''') 

329 conn.commit() 

330 except: 

331 return 

332 

333 rng = np.random.RandomState(32) 

334 periods = rng.random_sample(size)*50.0 

335 mjDisplacement = (rng.random_sample(size)-0.5)*50.0 

336 for i in range(size): 

337 sedFile = sedFiles[rng.randint(0, len(sedFiles))] 

338 if i%3 == 0: 

339 # just to make sure that Variability mixins no how to andle 

340 # objects with no variability 

341 varParam = None 

342 paramStr = None 

343 elif i%2 == 0: 

344 varParam = {'varMethodName': 'applyCepheid', 

345 'pars': {'period': periods[i], 

346 'lcfile': lcFiles[rng.randint(0, len(lcFiles))], 

347 't0': 48000.0+mjDisplacement[i]}} 

348 else: 

349 varParam = {'varMethodName': 'testVar', 

350 'pars': {'period': rng.random_sample()*100.0, 'amplitude': 2.0}} 

351 

352 if varParam is not None: 

353 paramStr = json.dumps(varParam) 

354 

355 qstr = '''INSERT INTO hybrid VALUES (%i, '%s', '%s', 0.01, 0.7)''' % (i, paramStr, sedFile) 

356 c.execute(qstr) 

357 conn.commit() 

358 conn.close() 

359 

360 

361class variabilityDB(CatalogDBObject): 

362 driver = 'sqlite' 

363 database = VARIABILITY_DB 

364 idColKey = 'varsimobjid' 

365 columns = [('id', 'varsimobjid', int), 

366 ('sedFilename', 'sedfilename', str, 40), 

367 ('varParamStr', 'variability', str, 600)] 

368 

369 

370 

371class hybridDB(variabilityDB): 

372 objid = 'hybridTest' 

373 tableid = 'hybrid' 

374 objectTypeId = 54 

375 

376 

377class rrlyDB(variabilityDB): 

378 objid = 'rrlyTest' 

379 tableid = 'RRly' 

380 objectTypeId = 55 

381 

382 

383class cepheidDB(variabilityDB): 

384 objid = 'cepheidTest' 

385 tableid = 'cepheid' 

386 objectTypeId = 56 

387 

388 

389class ebDB(variabilityDB): 

390 objid = 'ebTest' 

391 tableid = 'eb' 

392 objectTypeId = 57 

393 

394 

395class microlensDB(variabilityDB): 

396 objid = 'microlensTest' 

397 tableid = 'microlensing' 

398 objectTypeId = 58 

399 

400 

401class BHmicrolensDB(variabilityDB): 

402 objid = 'bhmicrolensTest' 

403 tableid = 'bhmicrolensing' 

404 objectTypeId = 59 

405 

406 

407class amcvnDB(variabilityDB): 

408 objid = 'amcvnTest' 

409 tableid = 'amcvn' 

410 objectTypeId = 60 

411 

412 

413class agnDB(variabilityDB): 

414 objid = 'agnTest' 

415 tableid = 'agn' 

416 objectTypeId = 61 

417 

418 

419class StellarVariabilityCatalog(InstanceCatalog, PhotometryStars, VariabilityStars): 

420 catalog_type = __file__ + 'stellarVariabilityCatalog' 

421 column_outputs = ['varsimobjid', 'sedFilename', 'delta_lsst_u'] 

422 default_columns = [('magNorm', 14.0, float)] 

423 

424 

425class StellarVariabilityCatalogWithTest(InstanceCatalog, PhotometryStars, 

426 VariabilityStars, TestVariabilityMixin): 

427 catalog_type = __file__ + 'testVariabilityCatalog' 

428 column_outputs = ['varsimobjid', 'sedFilename', 'delta_lsst_u'] 

429 default_columns = [('magNorm', 14.0, float)] 

430 

431 

432class OtherVariabilityCatalogWithTest(InstanceCatalog, PhotometryStars, 

433 TestVariabilityMixin, VariabilityStars): 

434 catalog_type = __file__ + 'other_variability_catalog' 

435 column_outputs = ['varsimobjid', 'sedFilename', 'delta_lsst_u'] 

436 default_columns = [('magNorm', 14.0, float)] 

437 

438 

439class GalaxyVariabilityCatalog(InstanceCatalog, PhotometryGalaxies, VariabilityGalaxies): 

440 catalog_type = __file__ + 'galaxyVariabilityCatalog' 

441 column_outputs = ['varsimobjid', 'sedFilenameAgn', 'lsstUdiff', 'delta_uAgn'] 

442 default_columns = [('magNormAgn', 14.0, float), 

443 ('magNormDisk', 14.0, float), 

444 ('magNormBulge', 14.0, float)] 

445 

446 def get_lsstUdiff(self): 

447 lsstUvar = self.column_by_name('lsst_u') 

448 

449 bulge = self.column_by_name('uBulge') 

450 disk = self.column_by_name('uDisk') 

451 agn = self.column_by_name('uAgn') - self.column_by_name('delta_uAgn') 

452 lsstU = self.sum_magnitudes(bulge=bulge, disk=disk, agn=agn) 

453 

454 return lsstUvar - lsstU 

455 

456 def get_agnUdiff(self): 

457 lsstU = self.column_by_name('uAgn') 

458 lsstUvar = self.column_by_name('uAgn_var') 

459 return lsstUvar - lsstU 

460 

461 

462class VariabilityTest(unittest.TestCase): 

463 

464 longMessage = True 

465 

466 @classmethod 

467 def setUpClass(cls): 

468 cls.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix='VariabilityTest-') 

469 cls.variability_db = os.path.join(cls.scratch_dir, VARIABILITY_DB) 

470 

471 @classmethod 

472 def tearDownClass(cls): 

473 sims_clean_up() 

474 if os.path.exists(cls.variability_db): 

475 os.unlink(cls.variability_db) 

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

477 shutil.rmtree(cls.scratch_dir, ignore_errors=True) 

478 

479 def setUp(self): 

480 self.obs_metadata = ObservationMetaData(mjd=52000.0) 

481 

482 def tearDown(self): 

483 del self.obs_metadata 

484 

485 def verify_catalogs(self, cat_name): 

486 """ 

487 Verify that a catalog generated by the unit tests below contains 

488 the rows it ought to. 

489 

490 This is done by looking for a corresponding catalog in 

491 tests/testData and verifying that the two catalogs have identical 

492 rows. 

493 

494 Parameters 

495 ---------- 

496 cat_name is the full path to the test-generated catalog. The 

497 comparison catalog will be found in tests/testData 

498 """ 

499 

500 control_dir = os.path.join(getPackageDir('sims_catUtils'), 

501 'tests', 'testData') 

502 _, control_name = os.path.split(cat_name) 

503 control_name = os.path.join(control_dir, control_name) 

504 with open(control_name, 'r') as control_file: 

505 control_lines = control_file.readlines() 

506 

507 with open(cat_name, 'r') as test_file: 

508 test_lines = test_file.readlines() 

509 

510 for tt in test_lines: 

511 self.assertIn(tt, control_lines) 

512 

513 for cc in control_lines: 

514 self.assertIn(cc, test_lines) 

515 

516 def testHybridVariability(self): 

517 """ 

518 Test that we can generate a catalog which inherits from multiple variability mixins 

519 (in this case, TestVariability and VariabilityStars). This is to make sure that 

520 the register_method and register_class decorators do not mangle inheritance of 

521 methods from mixins. 

522 """ 

523 cat_name = os.path.join(self.scratch_dir, 'hybridTestCatalog.dat') 

524 makeHybridTable(database=self.variability_db) 

525 myDB = CatalogDBObject.from_objid('hybridTest', database=self.variability_db) 

526 myCatalog = StellarVariabilityCatalogWithTest(myDB, obs_metadata=self.obs_metadata) 

527 

528 myCatalog.write_catalog(cat_name, chunk_size=1000) 

529 self.verify_catalogs(cat_name) 

530 

531 if os.path.exists(cat_name): 

532 os.unlink(cat_name) 

533 

534 # make sure order of mixin inheritance does not matter 

535 myCatalog = OtherVariabilityCatalogWithTest(myDB, obs_metadata=self.obs_metadata) 

536 myCatalog.write_catalog(cat_name, chunk_size=1000) 

537 self.verify_catalogs(cat_name) 

538 

539 if os.path.exists(cat_name): 

540 os.unlink(cat_name) 

541 

542 # make sure that, if a catalog does not contain a variability method, 

543 # an error is thrown; verify that it contains the correct error message 

544 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

545 

546 with self.assertRaises(RuntimeError) as context: 

547 myCatalog.write_catalog(cat_name) 

548 

549 if os.path.exists(cat_name): 

550 os.unlink(cat_name) 

551 

552 expectedMessage = "Your InstanceCatalog does not contain a variability method" 

553 expectedMessage += " corresponding to 'testVar'" 

554 self.assertEqual(context.exception.args[0], expectedMessage) 

555 

556 def testApplyVariabilityWithManyMJD(self): 

557 """ 

558 Use the hybrid variability catalog class from testHybridVariability to 

559 verify that, if we pass an array of expmjd into applyVariability, we get 

560 the expected result out. 

561 """ 

562 

563 makeHybridTable(database=self.variability_db) 

564 hybrid_db = hybridDB(database=self.variability_db) 

565 hybrid_cat = StellarVariabilityCatalogWithTest(hybrid_db, obs_metadata=self.obs_metadata, 

566 column_outputs=['varParamStr']) 

567 rng = np.random.RandomState(88) 

568 mjd_arr = rng.random_sample(14)*3653.0+59580.0 

569 n_time = len(mjd_arr) 

570 varparams =[] 

571 n_ceph = 0 

572 n_test = 0 

573 for line in hybrid_cat.iter_catalog(): 

574 varparams.append(line[-1]) 

575 if 'Cepheid' in line[-1]: 

576 n_ceph += 1 

577 if 'testVar' in line[-1]: 

578 n_test +=1 

579 

580 self.assertGreater(n_ceph, 0) 

581 self.assertGreater(n_test, 0) 

582 

583 n_obj=len(varparams) 

584 

585 new_hybrid_cat = StellarVariabilityCatalogWithTest(hybrid_db, obs_metadata=self.obs_metadata) 

586 delta_mag_vector = new_hybrid_cat.applyVariability(varparams, expmjd=mjd_arr) 

587 self.assertEqual(delta_mag_vector.shape, (6, len(varparams), len(mjd_arr))) 

588 

589 n_mags = 0 

590 for i_time, mjd in enumerate(mjd_arr): 

591 obs = ObservationMetaData(mjd=mjd) 

592 control_hybrid_cat = StellarVariabilityCatalogWithTest(hybrid_db, obs_metadata=obs, 

593 column_outputs=['delta_lsst_u', 

594 'delta_lsst_g', 

595 'delta_lsst_r', 

596 'delta_lsst_i', 

597 'delta_lsst_z', 

598 'delta_lsst_y']) 

599 

600 for i_obj, star_obj in enumerate(control_hybrid_cat.iter_catalog()): 

601 for i_band in range(6): 

602 n_mags += 1 

603 self.assertEqual(delta_mag_vector[i_band][i_obj][i_time], 

604 star_obj[-6+i_band], 

605 msg = 'failed on time %d; obj %d; band %d' % (i_time, i_obj, i_band)) 

606 

607 self.assertEqual(n_mags, 6*n_obj*n_time) 

608 

609 def testRRlyrae(self): 

610 cat_name = os.path.join(self.scratch_dir, 'rrlyTestCatalog.dat') 

611 makeRRlyTable(database=self.variability_db) 

612 myDB = CatalogDBObject.from_objid('rrlyTest', database=self.variability_db) 

613 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

614 myCatalog.write_catalog(cat_name, chunk_size=1000) 

615 

616 self.verify_catalogs(cat_name) 

617 if os.path.exists(cat_name): 

618 os.unlink(cat_name) 

619 

620 def testCepheids(self): 

621 cat_name = os.path.join(self.scratch_dir, 'cepheidTestCatalog.dat') 

622 makeCepheidTable(database=self.variability_db) 

623 myDB = CatalogDBObject.from_objid('cepheidTest', database=self.variability_db) 

624 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

625 myCatalog.write_catalog(cat_name, chunk_size=1000) 

626 

627 self.verify_catalogs(cat_name) 

628 if os.path.exists(cat_name): 

629 os.unlink(cat_name) 

630 

631 def testEb(self): 

632 cat_name = os.path.join(self.scratch_dir, 'ebTestCatalog.dat') 

633 makeEbTable(database=self.variability_db) 

634 myDB = CatalogDBObject.from_objid('ebTest', database=self.variability_db) 

635 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

636 myCatalog.write_catalog(cat_name, chunk_size=1000) 

637 

638 self.verify_catalogs(cat_name) 

639 if os.path.exists(cat_name): 

640 os.unlink(cat_name) 

641 

642 def testMicrolensing(self): 

643 # Note: this test assumes that the parameters for the microlensing variability 

644 # model occur in a standard varParamStr column in the database. 

645 # Actually, the current database of microlensing events simply store the variability 

646 # parameters as independent columns in the database. 

647 # The varParamStr formalism is how the applyMicrolensing methods are written, however, 

648 # so that is what we will test. 

649 

650 cat_name = os.path.join(self.scratch_dir, 'microlensTestCatalog.dat') 

651 makeMicrolensingTable(database=self.variability_db) 

652 myDB = CatalogDBObject.from_objid('microlensTest', database=self.variability_db) 

653 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

654 myCatalog.write_catalog(cat_name, chunk_size=1000) 

655 

656 self.verify_catalogs(cat_name) 

657 if os.path.exists(cat_name): 

658 os.unlink(cat_name) 

659 

660 def testBHMicrolensing(self): 

661 # Note: this test assumes that the parameters for the BHmicrolensing variability 

662 # model occur in a standard varParamStr column in the database. 

663 # Actually, the current database of BHmicrolensing events simply store the variability 

664 # parameters as independent columns in the database. 

665 # The varParamStr formalism is how the applyBHMicrolens method is written, however, 

666 # so that is what we will test. 

667 

668 cat_name = os.path.join(self.scratch_dir, 'bhmicrolensTestCatalog.dat') 

669 makeBHMicrolensingTable(database=self.variability_db) 

670 myDB = CatalogDBObject.from_objid('bhmicrolensTest', database=self.variability_db) 

671 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

672 myCatalog.write_catalog(cat_name, chunk_size=1000) 

673 

674 self.verify_catalogs(cat_name) 

675 if os.path.exists(cat_name): 

676 os.unlink(cat_name) 

677 

678 def testAmcvn(self): 

679 # Note: this test assumes that the parameters for the Amcvn variability 

680 # model occur in a standard varParamStr column in the database. 

681 # Actually, the current database of Amcvn events simply store the variability 

682 # parameters as independent columns in the database. 

683 # The varParamStr formalism is how the applyAmcvn method is written, however, 

684 # so that is what we will test. 

685 

686 cat_name = os.path.join(self.scratch_dir, 'amcvnTestCatalog.dat') 

687 makeAmcvnTable(database=self.variability_db) 

688 myDB = CatalogDBObject.from_objid('amcvnTest', database=self.variability_db) 

689 myCatalog = StellarVariabilityCatalog(myDB, obs_metadata=self.obs_metadata) 

690 myCatalog.write_catalog(cat_name, chunk_size=1000) 

691 

692 self.verify_catalogs(cat_name) 

693 if os.path.exists(cat_name): 

694 os.unlink(cat_name) 

695 

696 def testAgn(self): 

697 """ 

698 Just verify that the catalog generation code runs in this case 

699 """ 

700 

701 cat_name = os.path.join(self.scratch_dir, 'agnTestCatalog.dat') 

702 makeAgnTable(database=self.variability_db) 

703 myDB = CatalogDBObject.from_objid('agnTest', database=self.variability_db) 

704 obs = ObservationMetaData(pointingRA=self.obs_metadata.pointingRA, 

705 pointingDec=self.obs_metadata.pointingDec, 

706 boundType=self.obs_metadata.boundType, 

707 boundLength=self.obs_metadata.boundLength, 

708 mjd=60000.0) 

709 myCatalog = GalaxyVariabilityCatalog(myDB, obs_metadata=obs) 

710 myCatalog.write_catalog(cat_name, chunk_size=1000) 

711 

712 with open(cat_name,'r') as input_file: 

713 lines = input_file.readlines() 

714 self.assertGreater(len(lines), 10) 

715 

716 if os.path.exists(cat_name): 

717 os.unlink(cat_name) 

718 

719 

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

721 pass 

722 

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

724 lsst.utils.tests.init() 

725 unittest.main()