Coverage for python/lsst/sims/catUtils/utils/CatalogTestUtils.py : 25%

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
1"""
2This file defines some test catalog and DBObject classes for use with unit tests.
4To date (30 October 2014) testPhotometryMixins.py and testCosmologyMixins.py import from this module
5"""
7from builtins import range
8from builtins import object
9import numpy
10import numbers
11import os
12import sqlite3
13import json
14from lsst.utils import getPackageDir
15from lsst.sims.utils import defaultSpecMap
16from lsst.sims.catalogs.definitions import InstanceCatalog
17from lsst.sims.catalogs.decorators import register_method, compound
18from lsst.sims.catUtils.mixins import AstrometryStars, AstrometryGalaxies
19from lsst.sims.photUtils.SignalToNoise import calcSkyCountsPerPixelForM5
20from lsst.sims.photUtils import BandpassDict, SedList
21from lsst.sims.catUtils.mixins import PhotometryGalaxies, PhotometryStars, Variability, \
22 VariabilityStars, VariabilityGalaxies, EBVmixin
24__all__ = ["makeStarDatabase", "makeGalaxyDatabase",
25 "TestVariabilityMixin", "testDefaults", "cartoonPhotometryStars",
26 "cartoonPhotometryGalaxies", "testCatalog", "cartoonStars",
27 "cartoonStarsOnlyI", "cartoonStarsIZ",
28 "cartoonGalaxies", "cartoonGalaxiesIG", "testStars", "testGalaxies",
29 "galaxiesWithHoles"]
32def makeStarDatabase(filename='StellarPhotometryDB.db', size=1000, seedVal=32,
33 radius=1.0, pointingRA=50.0, pointingDec=-10.0):
35 star_seds = ['km20_5750.fits_g40_5790','m2.0Full.dat','bergeron_6500_85.dat_6700']
37 #Now begin building the database.
38 #First create the tables.
39 conn = sqlite3.connect(filename)
40 c = conn.cursor()
42 numpy.random.seed(seedVal)
44 rr = numpy.random.sample(size)*radius
45 theta = numpy.random.sample(size)*2.0*numpy.pi
47 try:
48 c.execute('''CREATE TABLE StarAllForceseek
49 (simobjid int, ra real, decl real, magNorm real,
50 mudecl real, mura real, ebv real, vrad real, varParamStar text, sedFilename text, parallax real)''')
51 except:
52 raise RuntimeError("Error creating StarAllForceseek table.")
54 magnormStar = numpy.random.sample(size)*5.0+17.0
55 magnormStar = numpy.random.sample(size)*4.0 + 17.0
56 mudecl = numpy.random.sample(size)*0.0001
57 mura = numpy.random.sample(size)*0.0001
58 ebv = numpy.random.sample(size)*0.05
59 vrad = numpy.random.sample(size)*1.0
60 parallax = 0.00045+numpy.random.sample(size)*0.00001
62 for i in range(size):
63 raStar = pointingRA + rr[i]*numpy.cos(theta[i])
64 decStar = pointingDec + rr[i]*numpy.sin(theta[i])
66 cmd = '''INSERT INTO StarAllForceseek VALUES (%i, %f, %f, %f, %f, %f, %f, %f, %s, '%s', %f)''' %\
67 (i, raStar, decStar, magnormStar[i], mudecl[i], mura[i],
68 ebv[i], vrad[i], 'NULL', star_seds[i%len(star_seds)], parallax[i])
70 c.execute(cmd)
72 conn.commit()
73 conn.close()
75def makeGalaxyDatabase(filename='GalaxyPhotometryDB.db', size=1000, seedVal=32,
76 radius=1.0, pointingRA=50.0, pointingDec=-10.0):
78 galaxy_seds = ['Const.80E07.02Z.spec','Inst.80E07.002Z.spec','Burst.19E07.0005Z.spec']
79 agn_sed = 'agn.spec'
81 #Now begin building the database.
82 #First create the tables.
83 conn = sqlite3.connect(filename)
84 c = conn.cursor()
86 try:
87 c.execute('''CREATE TABLE galaxy
88 (galtileid int, galid int, ra real, dec real,
89 bra real, bdec real, dra real, ddec real,
90 agnra real, agndec real,
91 magnorm_bulge, magnorm_disk, magnorm_agn,
92 sedname_bulge text, sedname_disk text, sedname_agn text,
93 varParamStr text,
94 a_b real, b_b real, pa_bulge real, bulge_n int,
95 a_d real, b_d real, pa_disk real, disk_n int,
96 ext_model_b text, av_b real, rv_b real,
97 ext_model_d text, av_d real, rv_d real,
98 u_ab real, g_ab real, r_ab real, i_ab real,
99 z_ab real, y_ab real,
100 redshift real, BulgeHalfLightRadius real, DiskHalfLightRadius real)''')
102 conn.commit()
103 except:
104 raise RuntimeError("Error creating galaxy table.")
106 mjd = 52000.0
108 numpy.random.seed(seedVal)
110 rr = numpy.random.sample(size)*radius
111 theta = numpy.random.sample(size)*2.0*numpy.pi
113 ra = pointingRA + rr*numpy.cos(theta)
114 dec = pointingDec + rr*numpy.sin(theta)
116 bra = numpy.radians(ra+numpy.random.sample(size)*0.01*radius)
117 bdec = numpy.radians(dec+numpy.random.sample(size)*0.01*radius)
118 dra = numpy.radians(ra + numpy.random.sample(size)*0.01*radius)
119 ddec = numpy.radians(dec + numpy.random.sample(size)*0.01*radius)
120 agnra = numpy.radians(ra + numpy.random.sample(size)*0.01*radius)
121 agndec = numpy.radians(dec + numpy.random.sample(size)*0.01*radius)
123 magnorm_bulge = numpy.random.sample(size)*4.0 + 17.0
124 magnorm_disk = numpy.random.sample(size)*5.0 + 17.0
125 magnorm_agn = numpy.random.sample(size)*5.0 + 17.0
126 b_b = numpy.random.sample(size)*0.2
127 a_b = b_b+numpy.random.sample(size)*0.05
128 b_d = numpy.random.sample(size)*0.5
129 a_d = b_d+numpy.random.sample(size)*0.1
131 BulgeHalfLightRadius = numpy.random.sample(size)*0.2
132 DiskHalfLightRadius = numpy.random.sample(size)*0.5
134 pa_bulge = numpy.random.sample(size)*360.0
135 pa_disk = numpy.random.sample(size)*360.0
137 av_b = numpy.random.sample(size)*0.4
138 av_d = numpy.random.sample(size)*0.4
139 rv_b = numpy.random.sample(size)*0.1 + 3.0
140 rv_d = numpy.random.sample(size)*0.1 + 3.0
142 u_ab = numpy.random.sample(size)*4.0 + 17.0
143 g_ab = numpy.random.sample(size)*4.0 + 17.0
144 r_ab = numpy.random.sample(size)*4.0 + 17.0
145 i_ab = numpy.random.sample(size)*4.0 + 17.0
146 z_ab = numpy.random.sample(size)*4.0 + 17.0
147 y_ab = numpy.random.sample(size)*4.0 +17.0
148 redshift = numpy.random.sample(size)*2.0
150 t0_mjd = numpy.random.sample(size)*10.0+mjd
151 agn_tau = numpy.random.sample(size)*1000.0 + 1000.0
152 agnSeed = numpy.random.randint(2, 4001, size=size)
153 agn_sfu = numpy.random.sample(size)
154 agn_sfg = numpy.random.sample(size)
155 agn_sfr = numpy.random.sample(size)
156 agn_sfi = numpy.random.sample(size)
157 agn_sfz = numpy.random.sample(size)
158 agn_sfy = numpy.random.sample(size)
160 for i in range(size):
161 varParam = {'varMethodName':'applyAgn',
162 'pars':{'agn_tau':agn_tau[i], 't0_mjd':t0_mjd[i],
163 'agn_sfu':agn_sfu[i], 'agn_sfg':agn_sfg[i], 'agn_sfr':agn_sfr[i],
164 'agn_sfi':agn_sfi[i], 'agn_sfz':agn_sfz[i], 'agn_sfy':agn_sfy[i],
165 'seed':int(agnSeed[i])}}
167 paramStr = json.dumps(varParam)
169 cmd = '''INSERT INTO galaxy VALUES (%i, %i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f,
170 '%s', '%s', '%s', '%s',
171 %f, %f, %f, %i,
172 %f, %f, %f, %i,
173 '%s', %f, %f,
174 '%s', %f, %f,
175 %f, %f, %f, %f, %f, %f,
176 %f, %f, %f)''' %\
177 (i, i, ra[i], dec[i], bra[i], bdec[i], dra[i], ddec[i], agnra[i], agndec[i],
178 magnorm_bulge[i], magnorm_disk[i], magnorm_agn[i],
179 galaxy_seds[(i+1)%len(galaxy_seds)], galaxy_seds[i%len(galaxy_seds)], agn_sed,
180 paramStr,
181 a_b[i], b_b[i], pa_bulge[i], 4,
182 a_d[i], b_d[i], pa_disk[i], 1,
183 'CCM', av_b[i], rv_b[i],
184 'CCM', av_d[i], rv_d[i],
185 u_ab[i], g_ab[i], r_ab[i], i_ab[i], z_ab[i], y_ab[i], redshift[i],
186 BulgeHalfLightRadius[i], DiskHalfLightRadius[i])
187 c.execute(cmd)
189 conn.commit()
190 conn.close()
193class TestVariabilityMixin(Variability):
194 """
195 This is a mixin which provides a dummy variability method for use in unit tests
196 """
197 @register_method('testVar')
198 def applySineVar(self, valid_dexes, varParams, expmjd,
199 variability_cache=None):
201 if len(varParams) == 0:
202 return numpy.array([[],[],[],[],[],[]])
204 period = varParams['period'][valid_dexes]
205 if isinstance(expmjd, numbers.Number):
206 magoff = numpy.zeros((6, self.num_variable_obj(varParams)))
207 phase = expmjd%period
208 amplitude = varParams['amplitude'][valid_dexes]
209 else:
210 magoff = numpy.zeros((6, self.num_variable_obj(varParams), len(expmjd)))
211 phase = numpy.array([expmjd%pp for pp in period])
212 amplitude = numpy.array([[aa]*len(expmjd)
213 for aa in varParams['amplitude'][valid_dexes]])
214 delta = amplitude*numpy.sin(2*numpy.pi*phase.astype(float))
215 delta = delta.astype(float)
216 for ix in range(6):
217 magoff[ix][valid_dexes] += delta
218 return magoff
221class testDefaults(object):
222 """
223 This class just provides default values for quantities that
224 the astrometry mixins require in order to run
225 """
227 def get_proper_motion_ra(self):
228 ra=self.column_by_name('raJ2000')
229 out=numpy.zeros(len(ra))
230 for i in range(len(ra)):
231 out[i]=0.0
233 return out
236 def get_proper_motion_dec(self):
237 ra=self.column_by_name('raJ2000')
238 out=numpy.zeros(len(ra))
239 for i in range(len(ra)):
240 out[i]=0.0
242 return out
244 def get_parallax(self):
245 ra=self.column_by_name('raJ2000')
246 out=numpy.zeros(len(ra))
247 for i in range(len(ra)):
248 out[i]=1.2
250 return out
252 def get_radial_velocity(self):
253 ra=self.column_by_name('raJ2000')
254 out=numpy.zeros(len(ra))
255 for i in range(len(ra)):
256 out[i]=0.0
258 return out
260class cartoonPhotometryStars(PhotometryStars):
261 """
262 This is a class to support loading cartoon bandpasses into photometry so that we can be sure
263 that the photometry mixin is loading the right files and calculating the right magnitudes.
265 In addition to creating a catalog, when the get_magnitude method below is called, it will
266 add sedMasterList and magnitudeMasterList to the catalog instantiation. These are lists
267 containing the magnitudes output to the catalog and the SEDs used to calculate them.
269 Having these variables allows the unittest to verify the output of the catalog
270 (see testAlternateBandpassesStars in testPhotometry.py to see how this works)
271 """
273 @compound('cartoon_u','cartoon_g','cartoon_r','cartoon_i','cartoon_z')
274 def get_magnitudes(self):
275 """
276 Example photometry getter for alternative (i.e. non-LSST) bandpasses
277 """
279 idNames = self.column_by_name('id')
280 columnNames = [name for name in self.get_magnitudes._colnames]
281 bandpassNames = ['u','g','r','i','z']
282 bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests', 'cartoonSedTestData')
284 if not hasattr(self, 'cartoonBandpassDict'):
285 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,bandpassDir = bandpassDir,
286 bandpassRoot = 'test_bandpass_')
289 output = self._quiescentMagnitudeGetter(self.cartoonBandpassDict, self.get_magnitudes._colnames)
291 #############################################################################
292 #Everything below this comment exists solely for the purposes of the unit test
293 #if you need to write a customized getter for photometry that uses non-LSST
294 #bandpasses, you only need to emulate the code above this comment.
297 magNormList = self.column_by_name('magNorm')
298 sedNames = self.column_by_name('sedFilename')
299 av = self.column_by_name('galacticAv')
301 #the two variables below will allow us to get at the SED and magnitude
302 #data from within the unit test class, so that we can be sure
303 #that the mixin loaded the correct bandpasses
304 sublist = SedList(sedNames, magNormList, galacticAvList=av,
305 fileDir=getPackageDir('sims_sed_library'),
306 specMap=defaultSpecMap)
308 for ss in sublist:
309 self.sedMasterList.append(ss)
311 if len(output) > 0:
312 for i in range(len(output[0])):
313 subList = []
314 for j in range(len(output)):
315 subList.append(output[j][i])
317 self.magnitudeMasterList.append(subList)
319 return output
322class cartoonPhotometryGalaxies(PhotometryGalaxies):
323 """
324 This is a class to support loading cartoon bandpasses into photometry so that we can be sure
325 that the photometry mixin is loading the right files and calculating the right magnitudes.
327 In addition to writing the catalog, when the get_magnitudes method below is called, the
328 variables sedMasterDict and mangitudeMasterDict are added to the catalog instantiation.
329 These store the magnitudes calculated for the catalog and the SEDs used to find them.
331 This allows the unittest to verify the contents of the catalog
332 (see testAlternateBandpassesGalaxies in testPhotometry.py to see how this works)
333 """
335 @compound('cbulge_u', 'cbulge_g', 'cbulge_r', 'cbulge_i' ,'cbulge_z')
336 def get_cartoon_bulge_mags(self):
338 if not hasattr(self, 'cartoonBandpassDict'):
339 bandpassNames = ['u','g','r','i','z']
340 bandpassDir = getPackageDir('sims_photUtils')
341 bandpassDir = os.path.join(bandpassDir, 'tests', 'cartoonSedTestData')
343 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,
344 bandpassDir=bandpassDir,
345 bandpassRoot = 'test_bandpass_')
347 return self._quiescentMagnitudeGetter('bulge', self.cartoonBandpassDict,
348 self.get_cartoon_bulge_mags._colnames)
351 @compound('cdisk_u', 'cdisk_g', 'cdisk_r', 'cdisk_i', 'cdisk_z')
352 def get_cartoon_disk_mags(self):
354 if not hasattr(self, 'cartoonBandpassDict'):
355 bandpassNames = ['u','g','r','i','z']
356 bandpassDir = getPackageDir('sims_photUtils')
357 bandpassDir = os.path.join(bandpassDir, 'tests', 'cartoonSedTestData')
359 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,
360 bandpassDir=bandpassDir,
361 bandpassRoot = 'test_bandpass_')
363 return self._quiescentMagnitudeGetter('disk', self.cartoonBandpassDict,
364 self.get_cartoon_disk_mags._colnames)
367 @compound('cagn_u', 'cagn_g', 'cagn_r', 'cagn_i', 'cagn_z')
368 def get_cartoon_agn_mags(self):
370 if not hasattr(self, 'cartoonBandpassDict'):
371 bandpassNames = ['u','g','r','i','z']
372 bandpassDir = getPackageDir('sims_photUtils')
373 bandpassDir = os.path.join(bandpassDir, 'tests', 'cartoonSedTestData')
375 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,
376 bandpassDir=bandpassDir,
377 bandpassRoot = 'test_bandpass_')
379 return self._quiescentMagnitudeGetter('agn', self.cartoonBandpassDict,
380 self.get_cartoon_agn_mags._colnames)
383 @compound('ctotal_u', 'ctotal_g', 'ctotal_r', 'ctotal_i', 'ctotal_z')
384 def get_cartoon_total_mags(self):
385 idList = self.column_by_name('uniqueId')
386 numObj = len(idList)
387 output = []
388 for columnName in self.get_cartoon_total_mags._colnames:
389 if columnName not in self._actually_calculated_columns:
390 sub_list = [numpy.NaN]*numObj
391 else:
392 bandpass = columnName[-1]
393 bulge = self.column_by_name('cbulge_%s' % bandpass)
394 disk = self.column_by_name('cdisk_%s' % bandpass)
395 agn = self.column_by_name('cagn_%s' % bandpass)
396 sub_list = self.sum_magnitudes(bulge=bulge, disk=disk, agn=agn)
398 output.append(sub_list)
399 return numpy.array(output)
402class testCatalog(InstanceCatalog,AstrometryStars,VariabilityStars,testDefaults):
403 catalog_type = __file__ + 'MISC'
404 default_columns=[('expmjd',5000.0,float)]
406 def db_required_columns(self):
407 return ['raJ2000'],['varParamStr']
410class cartoonStars(InstanceCatalog,AstrometryStars,EBVmixin,VariabilityStars,cartoonPhotometryStars,testDefaults):
411 """
412 A catalog of stars relying on the cartoon photometry methods (which use non-LSST bandpasses
413 and output extra data for use by unit tests)
414 """
415 catalog_type = __file__ + 'cartoonStars'
416 column_outputs=['id','raObserved','decObserved','magNorm',\
417 'cartoon_u','cartoon_g','cartoon_r','cartoon_i','cartoon_z']
419 #the lists below will contain the SED objects and the magnitudes
420 #in a form that unittest can access and validate
422 sedMasterList = []
423 magnitudeMasterList = []
425 #I need to give it the name of an actual SED file that spans the expected wavelength range
426 defSedName = 'km30_5250.fits_g00_5370'
427 default_columns = [('sedFilename', defSedName, (str,len(defSedName))), ('glon', 180., float),
428 ('glat', 30., float), ('galacticAv', 0.1, float), ('galacticRv', 3.1, float)]
430class cartoonStarsOnlyI(InstanceCatalog, AstrometryStars ,EBVmixin, VariabilityStars, PhotometryStars):
431 catalog_type = __file__ + 'cartoonStarsOnlyI'
432 column_outputs = ['id','raObserved','decObserved','cartoon_i']
434 #I need to give it the name of an actual SED file that spans the expected wavelength range
435 defSedName = 'km30_5250.fits_g00_5370'
436 default_columns = [('sedFilename', defSedName, (str,len(defSedName))), ('glon', 180., float),
437 ('glat', 30., float), ('galacticAv', 0.1, float), ('galacticRv', 3.1, float)]
439 @compound('cartoon_u','cartoon_g','cartoon_r','cartoon_i','cartoon_z')
440 def get_magnitudes(self):
441 """
442 Example photometry getter for alternative (i.e. non-LSST) bandpasses
443 """
444 if not hasattr(self, 'cartoonBandpassDict'):
445 bandpassNames = ['u','g','r','i','z']
446 bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests', 'cartoonSedTestData')
447 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,bandpassDir = bandpassDir,
448 bandpassRoot = 'test_bandpass_')
450 return self._quiescentMagnitudeGetter(self.cartoonBandpassDict, self.get_magnitudes._colnames)
454class cartoonStarsIZ(cartoonStarsOnlyI):
455 catalog_type = 'cartoonStarsIR'
456 column_outputs = ['id', 'raObserved', 'decObserved', 'cartoon_i', 'cartoon_z']
458class cartoonGalaxies(InstanceCatalog, AstrometryGalaxies, EBVmixin, VariabilityGalaxies, cartoonPhotometryGalaxies, testDefaults):
459 """
460 A catalog of galaxies relying on the cartoon photometry methods (which use non-LSST bandpasses
461 and output extra data for use by unit tests)
462 """
463 catalog_type = __file__ + 'cartoonGalaxies'
464 column_outputs=['galid', 'raObserved', 'decObserved',
465 'ctotal_u', 'ctotal_g', 'ctotal_r', 'ctotal_i', 'ctotal_z',
466 'cbulge_u', 'cbulge_g', 'cbulge_r', 'cbulge_i', 'cbulge_z',
467 'cdisk_u', 'cdisk_g', 'cdisk_r', 'cdisk_i', 'cdisk_z',
468 'cagn_u', 'cagn_g', 'cagn_r', 'cagn_i', 'cagn_z',
469 'sedFilenameBulge', 'magNormBulge', 'internalAvBulge',
470 'sedFilenameDisk', 'magNormDisk', 'internalAvDisk',
471 'sedFilenameAgn', 'magNormAgn', 'redshift']
473 #I need to give it the name of an actual SED file that spans the expected wavelength range
474 defSedName = "Inst.80E09.25Z.spec"
475 default_columns = [('sedFilenameBulge', defSedName, (str,len(defSedName))),
476 ('sedFilenameDisk', defSedName, (str,len(defSedName))),
477 ('sedFilenameAgn', defSedName, (str,len(defSedName))),
478 ('glon', 210., float),
479 ('glat', 70., float),
480 ('internalAvBulge',3.1,float),
481 ('internalAvDisk',3.1,float)]
483 default_formats = {'f' : '%.12f'}
486 def get_galid(self):
487 return self.column_by_name('id')
490class cartoonGalaxiesIG(InstanceCatalog, AstrometryGalaxies, EBVmixin, VariabilityGalaxies, cartoonPhotometryGalaxies):
492 catalog_type = __file__ + 'cartoonGalaxiesIG'
493 column_outputs=['galid','raObserved','decObserved','ctotal_i','ctotal_g']
495 #I need to give it the name of an actual SED file that spans the expected wavelength range
496 defSedName = "Inst.80E09.25Z.spec"
497 default_columns = [('sedFilenameBulge', defSedName, (str,len(defSedName))),
498 ('sedFilenameDisk', defSedName, (str,len(defSedName))),
499 ('sedFilenameAgn', defSedName, (str,len(defSedName))),
500 ('glon', 210., float),
501 ('glat', 70., float),
502 ('internalAvBulge',3.1,float),
503 ('internalAvDisk',3.1,float)]
505 default_formats = {'f' : '%.12f'}
507 def get_galid(self):
508 return self.column_by_name('id')
512class galaxiesWithHoles(InstanceCatalog, PhotometryGalaxies):
513 """
514 This is an InstanceCatalog of galaxies that sets some of the
515 component Seds to 'None' so that we can test how sum_magnitudes
516 handles NaN's in the context of a catalog.
517 """
518 column_outputs = ['raJ2000','decJ2000',
519 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y',
520 'uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge',
521 'uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk',
522 'uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn']
524 default_formats = {'f':'%.12f'}
526 defSedName = "Inst.80E09.25Z.spec"
527 default_columns = [('glon', 210., float),
528 ('glat', 70., float),
529 ('internalAvBulge',3.1,float),
530 ('internalAvDisk',3.1,float)]
533 def get_galid(self):
534 return self.column_by_name('id')
536 @compound('sedFilenameBulge', 'sedFilenameDisk', 'sedFilenameAgn')
537 def get_sedNames(self):
538 ra = self.column_by_name('raJ2000')
539 elements = len(ra)
540 bulge = []
541 disk = []
542 agn = []
543 for ix in range(elements):
544 bulge.append(self.defSedName)
545 disk.append(self.defSedName)
546 agn.append(self.defSedName)
549 for ix in range(elements//8):
550 ibase = ix*8
551 if ibase+1<elements:
552 bulge[ibase+1] = 'None'
553 if ibase+2<elements:
554 disk[ibase+2] = 'None'
555 if ibase+3<elements:
556 agn[ibase+3] = 'None'
557 if ibase+4<elements:
558 bulge[ibase+4] = 'None'
559 disk[ibase+4] = 'None'
560 if ibase+5<elements:
561 bulge[ibase+5] = 'None'
562 agn[ibase+5] = 'None'
563 if ibase+6<elements:
564 disk[ibase+6] = 'None'
565 agn[ibase+6] = 'None'
566 if ibase+7<elements:
567 bulge[ibase+7] = 'None'
568 disk[ibase+7] = 'None'
569 agn[ibase+7] = 'None'
572 return numpy.array([bulge, disk, agn])
574class testStars(InstanceCatalog, EBVmixin, VariabilityStars, TestVariabilityMixin, PhotometryStars,testDefaults):
575 """
576 A generic catalog of stars
577 """
578 catalog_type = __file__ + 'test_stars'
579 column_outputs=['id','raJ2000','decJ2000','magNorm',\
580 'lsst_u','sigma_lsst_u',
581 'lsst_g','sigma_lsst_g',\
582 'lsst_r','sigma_lsst_r',\
583 'lsst_i','sigma_lsst_i',\
584 'lsst_z','sigma_lsst_z',\
585 'lsst_y','sigma_lsst_y',\
586 'EBV','varParamStr']
587 defSedName = 'sed_flat.txt'
588 default_columns = [('sedFilename', defSedName, (str,len(defSedName))), ('glon', 180., float),
589 ('glat', 30., float), ('galacticAv', 0.1, float), ('galacticRv', 3.1, float)]
591class testGalaxies(InstanceCatalog,EBVmixin,VariabilityGalaxies,TestVariabilityMixin,PhotometryGalaxies,testDefaults):
592 """
593 A generic catalog of galaxies
594 """
595 catalog_type = __file__ + 'test_galaxies'
596 column_outputs=['galid','raJ2000','decJ2000',\
597 'redshift',
598 'magNormAgn', 'magNormBulge', 'magNormDisk', \
599 'lsst_u', 'sigma_lsst_u',\
600 'lsst_g', 'sigma_lsst_g',\
601 'lsst_r', 'sigma_lsst_r',\
602 'lsst_i', 'sigma_lsst_i',\
603 'lsst_z', 'sigma_lsst_z',\
604 'lsst_y', 'sigma_lsst_y',\
605 'sedFilenameBulge','uBulge', 'sigma_uBulge', 'gBulge', 'sigma_gBulge', \
606 'rBulge', 'sigma_rBulge', 'iBulge', 'sigma_iBulge', 'zBulge', 'sigma_zBulge',\
607 'yBulge', 'sigma_yBulge', \
608 'sedFilenameDisk','uDisk', 'sigma_uDisk', 'gDisk', 'sigma_gDisk', 'rDisk', 'sigma_rDisk', \
609 'iDisk', 'sigma_iDisk', 'zDisk', 'sigma_zDisk', 'yDisk', 'sigma_yDisk', \
610 'sedFilenameAgn',\
611 'uAgn', 'sigma_uAgn',\
612 'gAgn', 'sigma_gAgn',\
613 'rAgn', 'sigma_rAgn',\
614 'iAgn', 'sigma_iAgn',\
615 'zAgn', 'sigma_zAgn',\
616 'yAgn', 'sigma_yAgn', 'varParamStr']
617 defSedName = "sed_flat.txt"
618 default_columns = [('sedFilename', defSedName, (str, len(defSedName))) ,
619 ('sedFilenameAgn', defSedName, (str, len(defSedName))),
620 ('sedFilenameBulge', defSedName, (str, len(defSedName))),
621 ('sedFilenameDisk', defSedName, (str, len(defSedName))),
622 ('glon', 210., float),
623 ('glat', 70., float),
624 ]
626 def get_internalAvDisk(self):
627 return numpy.ones(len(self._current_chunk))*0.1
629 def get_internalAvBulge(self):
630 return numpy.ones(len(self._current_chunk))*0.1
632 def get_galid(self):
633 return self.column_by_name('id')