Coverage for tests/testVariabilityMixins.py : 22%

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
21from lsst.sims.catUtils.mixins import Variability
23VARIABILITY_DB = 'VariabilityTestDatabase.db'
24ROOT = os.path.abspath(os.path.dirname(__file__))
27def setup_module(module):
28 lsst.utils.tests.init()
31def makeRRlyTable(size=100, database=VARIABILITY_DB, **kwargs):
32 """
33 Make a test database to serve information to the rrlyrae test
34 """
36 # a haphazard sample of stellar SEDs
37 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750']
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']
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
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)
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()
67def makeCepheidTable(size=100, database=VARIABILITY_DB, **kwargs):
68 """
69 Make a test database to serve information to the cepheid test
70 """
72 # a haphazard sample of stellar SEDs
73 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750']
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']
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
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)
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()
105def makeEbTable(size=100, database=VARIABILITY_DB, **kwargs):
106 """
107 Make a test database to serve information to the Eb test
108 """
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']
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
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)
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()
138def makeMicrolensingTable(size=100, database=VARIABILITY_DB, **kwargs):
139 """
140 Make a test database to serve information to the microlensing test
141 """
143 # a haphazard sample of stellar SEDs
144 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750']
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
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)
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()
173def makeBHMicrolensingTable(size=100, database=VARIABILITY_DB, **kwargs):
174 """
175 Make a test database to serve information to the BHmicrolensing test
176 """
178 # a haphazard sample of stellar SEDs
179 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750']
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']
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
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)
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()
211def makeAmcvnTable(size=100, database=VARIABILITY_DB, **kwargs):
212 """
213 Make a test database to serve information to the AMCVN test
214 """
216 # a haphazard sample of white dwarf SEDs
217 sedFiles = ['bergeron_He_4750_70.dat_4950', 'bergeron_50000_85.dat_54000']
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
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]}}
249 paramStr = json.dumps(varParam)
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()
257def makeAgnTable(size=100, database=VARIABILITY_DB, **kwargs):
258 """
259 Make a test database to serve information to the microlensing test
260 """
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
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)}}
295 paramStr = json.dumps(varParam)
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')
304 c.execute(qstr)
305 conn.commit()
306 conn.close()
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 """
316 # a haphazard sample of stellar SEDs
317 sedFiles = ['kp10_8750.fits_g35_8950', 'kp03_10500.fits_g45_10600', 'km50_6750.fits_g20_6750']
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']
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
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}}
352 if varParam is not None:
353 paramStr = json.dumps(varParam)
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()
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)]
371class hybridDB(variabilityDB):
372 objid = 'hybridTest'
373 tableid = 'hybrid'
374 objectTypeId = 54
377class rrlyDB(variabilityDB):
378 objid = 'rrlyTest'
379 tableid = 'RRly'
380 objectTypeId = 55
383class cepheidDB(variabilityDB):
384 objid = 'cepheidTest'
385 tableid = 'cepheid'
386 objectTypeId = 56
389class ebDB(variabilityDB):
390 objid = 'ebTest'
391 tableid = 'eb'
392 objectTypeId = 57
395class microlensDB(variabilityDB):
396 objid = 'microlensTest'
397 tableid = 'microlensing'
398 objectTypeId = 58
401class BHmicrolensDB(variabilityDB):
402 objid = 'bhmicrolensTest'
403 tableid = 'bhmicrolensing'
404 objectTypeId = 59
407class amcvnDB(variabilityDB):
408 objid = 'amcvnTest'
409 tableid = 'amcvn'
410 objectTypeId = 60
413class agnDB(variabilityDB):
414 objid = 'agnTest'
415 tableid = 'agn'
416 objectTypeId = 61
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)]
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)]
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)]
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)]
446 def get_lsstUdiff(self):
447 lsstUvar = self.column_by_name('lsst_u')
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)
454 return lsstUvar - lsstU
456 def get_agnUdiff(self):
457 lsstU = self.column_by_name('uAgn')
458 lsstUvar = self.column_by_name('uAgn_var')
459 return lsstUvar - lsstU
462class VariabilityTest(unittest.TestCase):
464 longMessage = True
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)
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)
479 def setUp(self):
480 self.obs_metadata = ObservationMetaData(mjd=52000.0)
482 def tearDown(self):
483 del self.obs_metadata
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.
490 This is done by looking for a corresponding catalog in
491 tests/testData and verifying that the two catalogs have identical
492 rows.
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 """
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()
507 with open(cat_name, 'r') as test_file:
508 test_lines = test_file.readlines()
510 for tt in test_lines:
511 self.assertIn(tt, control_lines)
513 for cc in control_lines:
514 self.assertIn(cc, test_lines)
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)
528 myCatalog.write_catalog(cat_name, chunk_size=1000)
529 self.verify_catalogs(cat_name)
531 if os.path.exists(cat_name):
532 os.unlink(cat_name)
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)
539 if os.path.exists(cat_name):
540 os.unlink(cat_name)
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)
546 with self.assertRaises(RuntimeError) as context:
547 myCatalog.write_catalog(cat_name)
549 if os.path.exists(cat_name):
550 os.unlink(cat_name)
552 expectedMessage = "Your InstanceCatalog does not contain a variability method"
553 expectedMessage += " corresponding to 'testVar'"
554 self.assertEqual(context.exception.args[0], expectedMessage)
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 """
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
580 self.assertGreater(n_ceph, 0)
581 self.assertGreater(n_test, 0)
583 n_obj=len(varparams)
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)))
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'])
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))
607 self.assertEqual(n_mags, 6*n_obj*n_time)
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)
616 self.verify_catalogs(cat_name)
617 if os.path.exists(cat_name):
618 os.unlink(cat_name)
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)
627 self.verify_catalogs(cat_name)
628 if os.path.exists(cat_name):
629 os.unlink(cat_name)
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)
638 self.verify_catalogs(cat_name)
639 if os.path.exists(cat_name):
640 os.unlink(cat_name)
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.
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)
656 self.verify_catalogs(cat_name)
657 if os.path.exists(cat_name):
658 os.unlink(cat_name)
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.
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)
674 self.verify_catalogs(cat_name)
675 if os.path.exists(cat_name):
676 os.unlink(cat_name)
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.
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)
692 self.verify_catalogs(cat_name)
693 if os.path.exists(cat_name):
694 os.unlink(cat_name)
696 def testAgn(self):
697 """
698 Just verify that the catalog generation code runs in this case
699 """
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)
712 with open(cat_name,'r') as input_file:
713 lines = input_file.readlines()
714 self.assertGreater(len(lines), 10)
716 if os.path.exists(cat_name):
717 os.unlink(cat_name)
720class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
721 pass
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()