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

1""" 

2This file defines some test catalog and DBObject classes for use with unit tests. 

3 

4To date (30 October 2014) testPhotometryMixins.py and testCosmologyMixins.py import from this module 

5""" 

6 

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 

23 

24__all__ = ["makeStarDatabase", "makeGalaxyDatabase", 

25 "TestVariabilityMixin", "testDefaults", "cartoonPhotometryStars", 

26 "cartoonPhotometryGalaxies", "testCatalog", "cartoonStars", 

27 "cartoonStarsOnlyI", "cartoonStarsIZ", 

28 "cartoonGalaxies", "cartoonGalaxiesIG", "testStars", "testGalaxies", 

29 "galaxiesWithHoles"] 

30 

31 

32def makeStarDatabase(filename='StellarPhotometryDB.db', size=1000, seedVal=32, 

33 radius=1.0, pointingRA=50.0, pointingDec=-10.0): 

34 

35 star_seds = ['km20_5750.fits_g40_5790','m2.0Full.dat','bergeron_6500_85.dat_6700'] 

36 

37 #Now begin building the database. 

38 #First create the tables. 

39 conn = sqlite3.connect(filename) 

40 c = conn.cursor() 

41 

42 numpy.random.seed(seedVal) 

43 

44 rr = numpy.random.sample(size)*radius 

45 theta = numpy.random.sample(size)*2.0*numpy.pi 

46 

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.") 

53 

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 

61 

62 for i in range(size): 

63 raStar = pointingRA + rr[i]*numpy.cos(theta[i]) 

64 decStar = pointingDec + rr[i]*numpy.sin(theta[i]) 

65 

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]) 

69 

70 c.execute(cmd) 

71 

72 conn.commit() 

73 conn.close() 

74 

75def makeGalaxyDatabase(filename='GalaxyPhotometryDB.db', size=1000, seedVal=32, 

76 radius=1.0, pointingRA=50.0, pointingDec=-10.0): 

77 

78 galaxy_seds = ['Const.80E07.02Z.spec','Inst.80E07.002Z.spec','Burst.19E07.0005Z.spec'] 

79 agn_sed = 'agn.spec' 

80 

81 #Now begin building the database. 

82 #First create the tables. 

83 conn = sqlite3.connect(filename) 

84 c = conn.cursor() 

85 

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)''') 

101 

102 conn.commit() 

103 except: 

104 raise RuntimeError("Error creating galaxy table.") 

105 

106 mjd = 52000.0 

107 

108 numpy.random.seed(seedVal) 

109 

110 rr = numpy.random.sample(size)*radius 

111 theta = numpy.random.sample(size)*2.0*numpy.pi 

112 

113 ra = pointingRA + rr*numpy.cos(theta) 

114 dec = pointingDec + rr*numpy.sin(theta) 

115 

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) 

122 

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 

130 

131 BulgeHalfLightRadius = numpy.random.sample(size)*0.2 

132 DiskHalfLightRadius = numpy.random.sample(size)*0.5 

133 

134 pa_bulge = numpy.random.sample(size)*360.0 

135 pa_disk = numpy.random.sample(size)*360.0 

136 

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 

141 

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 

149 

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) 

159 

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])}} 

166 

167 paramStr = json.dumps(varParam) 

168 

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) 

188 

189 conn.commit() 

190 conn.close() 

191 

192 

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): 

200 

201 if len(varParams) == 0: 

202 return numpy.array([[],[],[],[],[],[]]) 

203 

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 

219 

220 

221class testDefaults(object): 

222 """ 

223 This class just provides default values for quantities that 

224 the astrometry mixins require in order to run 

225 """ 

226 

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 

232 

233 return out 

234 

235 

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 

241 

242 return out 

243 

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 

249 

250 return out 

251 

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 

257 

258 return out 

259 

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. 

264 

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. 

268 

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 """ 

272 

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 """ 

278 

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') 

283 

284 if not hasattr(self, 'cartoonBandpassDict'): 

285 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames,bandpassDir = bandpassDir, 

286 bandpassRoot = 'test_bandpass_') 

287 

288 

289 output = self._quiescentMagnitudeGetter(self.cartoonBandpassDict, self.get_magnitudes._colnames) 

290 

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. 

295 

296 

297 magNormList = self.column_by_name('magNorm') 

298 sedNames = self.column_by_name('sedFilename') 

299 av = self.column_by_name('galacticAv') 

300 

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) 

307 

308 for ss in sublist: 

309 self.sedMasterList.append(ss) 

310 

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]) 

316 

317 self.magnitudeMasterList.append(subList) 

318 

319 return output 

320 

321 

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. 

326 

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. 

330 

331 This allows the unittest to verify the contents of the catalog 

332 (see testAlternateBandpassesGalaxies in testPhotometry.py to see how this works) 

333 """ 

334 

335 @compound('cbulge_u', 'cbulge_g', 'cbulge_r', 'cbulge_i' ,'cbulge_z') 

336 def get_cartoon_bulge_mags(self): 

337 

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') 

342 

343 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames, 

344 bandpassDir=bandpassDir, 

345 bandpassRoot = 'test_bandpass_') 

346 

347 return self._quiescentMagnitudeGetter('bulge', self.cartoonBandpassDict, 

348 self.get_cartoon_bulge_mags._colnames) 

349 

350 

351 @compound('cdisk_u', 'cdisk_g', 'cdisk_r', 'cdisk_i', 'cdisk_z') 

352 def get_cartoon_disk_mags(self): 

353 

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') 

358 

359 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames, 

360 bandpassDir=bandpassDir, 

361 bandpassRoot = 'test_bandpass_') 

362 

363 return self._quiescentMagnitudeGetter('disk', self.cartoonBandpassDict, 

364 self.get_cartoon_disk_mags._colnames) 

365 

366 

367 @compound('cagn_u', 'cagn_g', 'cagn_r', 'cagn_i', 'cagn_z') 

368 def get_cartoon_agn_mags(self): 

369 

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') 

374 

375 self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames, 

376 bandpassDir=bandpassDir, 

377 bandpassRoot = 'test_bandpass_') 

378 

379 return self._quiescentMagnitudeGetter('agn', self.cartoonBandpassDict, 

380 self.get_cartoon_agn_mags._colnames) 

381 

382 

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) 

397 

398 output.append(sub_list) 

399 return numpy.array(output) 

400 

401 

402class testCatalog(InstanceCatalog,AstrometryStars,VariabilityStars,testDefaults): 

403 catalog_type = __file__ + 'MISC' 

404 default_columns=[('expmjd',5000.0,float)] 

405 

406 def db_required_columns(self): 

407 return ['raJ2000'],['varParamStr'] 

408 

409 

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'] 

418 

419 #the lists below will contain the SED objects and the magnitudes 

420 #in a form that unittest can access and validate 

421 

422 sedMasterList = [] 

423 magnitudeMasterList = [] 

424 

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)] 

429 

430class cartoonStarsOnlyI(InstanceCatalog, AstrometryStars ,EBVmixin, VariabilityStars, PhotometryStars): 

431 catalog_type = __file__ + 'cartoonStarsOnlyI' 

432 column_outputs = ['id','raObserved','decObserved','cartoon_i'] 

433 

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)] 

438 

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_') 

449 

450 return self._quiescentMagnitudeGetter(self.cartoonBandpassDict, self.get_magnitudes._colnames) 

451 

452 

453 

454class cartoonStarsIZ(cartoonStarsOnlyI): 

455 catalog_type = 'cartoonStarsIR' 

456 column_outputs = ['id', 'raObserved', 'decObserved', 'cartoon_i', 'cartoon_z'] 

457 

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'] 

472 

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)] 

482 

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

484 

485 

486 def get_galid(self): 

487 return self.column_by_name('id') 

488 

489 

490class cartoonGalaxiesIG(InstanceCatalog, AstrometryGalaxies, EBVmixin, VariabilityGalaxies, cartoonPhotometryGalaxies): 

491 

492 catalog_type = __file__ + 'cartoonGalaxiesIG' 

493 column_outputs=['galid','raObserved','decObserved','ctotal_i','ctotal_g'] 

494 

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)] 

504 

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

506 

507 def get_galid(self): 

508 return self.column_by_name('id') 

509 

510 

511 

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'] 

523 

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

525 

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)] 

531 

532 

533 def get_galid(self): 

534 return self.column_by_name('id') 

535 

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) 

547 

548 

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' 

570 

571 

572 return numpy.array([bulge, disk, agn]) 

573 

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)] 

590 

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 ] 

625 

626 def get_internalAvDisk(self): 

627 return numpy.ones(len(self._current_chunk))*0.1 

628 

629 def get_internalAvBulge(self): 

630 return numpy.ones(len(self._current_chunk))*0.1 

631 

632 def get_galid(self): 

633 return self.column_by_name('id')