Coverage for tests/testPhotometricIndices.py : 21%

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
1import os
2import numpy as np
3import unittest
4import tempfile
5import lsst.utils.tests
7from lsst.utils import getPackageDir
8from lsst.sims.utils import ObservationMetaData
9from lsst.sims.catalogs.db import fileDBObject
10from lsst.sims.catalogs.definitions import InstanceCatalog
11from lsst.sims.catUtils.mixins import (PhotometryStars, PhotometrySSM,
12 PhotometryGalaxies)
14ROOT = os.path.abspath(os.path.dirname(__file__))
17def setup_module(module):
18 lsst.utils.tests.init()
21class baselineStarCatalog(InstanceCatalog, PhotometryStars):
22 catalog_type = __file__ + 'baseline_star_catalog'
24 column_outputs = ['raJ2000', 'decJ2000',
25 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y',
26 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r',
27 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y']
29 default_formats = {'f': '%.13f'}
32class uStarCatalog(InstanceCatalog, PhotometryStars):
33 column_outputs = ['raJ2000', 'decJ2000', 'lsst_u', 'sigma_lsst_u']
35 default_formats = {'f': '%.13f'}
38class gzStarCatalog(InstanceCatalog, PhotometryStars):
39 column_outputs = ['raJ2000', 'decJ2000', 'lsst_g', 'lsst_z',
40 'sigma_lsst_g', 'sigma_lsst_z']
42 default_formats = {'f': '%.13f'}
45class gzUncertaintyStarCatalog(InstanceCatalog, PhotometryStars):
46 column_outputs = ['raJ2000', 'decJ2000', 'sigma_lsst_g', 'sigma_lsst_z']
48 default_formats = {'f': '%.13f'}
51class IndexTestCaseStars(unittest.TestCase):
52 """
53 This unit test suite will test that the 'indices' framework for making
54 sure that an InstanceCatalog only calculates the magnitudes requested
55 works in the case of stars.
56 """
58 @classmethod
59 def setUpClass(cls):
61 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'],
62 m5 = [22.0, 23.0, 24.0, 25.0, 26.0, 27.0])
64 baselineDtype = np.dtype([(name, np.float) for name in baselineStarCatalog.column_outputs])
66 dbdtype = np.dtype([
67 ('id', np.int),
68 ('raJ2000', np.float),
69 ('decJ2000', np.float),
70 ('sedFilename', str, 100),
71 ('magNorm', np.float),
72 ('galacticAv', np.float)
73 ])
75 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData')
76 inputFile = os.path.join(inputDir, 'IndicesTestCatalogStars.txt')
78 cls.db = fileDBObject(inputFile, runtable='test',
79 idColKey='id', dtype=dbdtype)
81 cat = baselineStarCatalog(cls.db, obs_metadata=cls.obs)
82 cls.catName = tempfile.mktemp(dir=ROOT, prefix='indicesStarControlCat-', suffix='.txt')
83 cat.write_catalog(cls.catName)
84 cls.controlData = np.genfromtxt(cls.catName, dtype=baselineDtype, delimiter=',')
85 os.unlink(cls.catName)
87 def test_u_star_catalog(self):
88 """
89 Test that a catalog which only cares about u does not calculate any other magnitudes.
90 """
91 dtype = np.dtype([(name, np.float) for name in uStarCatalog.column_outputs])
93 cat = uStarCatalog(self.db, obs_metadata=self.obs)
94 with lsst.utils.tests.getTempFilePath('.txt') as catName:
95 cat.write_catalog(catName)
96 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
97 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10)
98 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10)
99 np.testing.assert_array_almost_equal(self.controlData['lsst_u'], testData['lsst_u'], 10)
100 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_u'], testData['sigma_lsst_u'], 10)
102 self.assertNotIn('lsst_g', cat._actually_calculated_columns)
103 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns)
104 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
105 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
106 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
107 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
108 self.assertNotIn('lsst_z', cat._actually_calculated_columns)
109 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns)
110 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
111 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
113 def test_gz_star_catalog(self):
114 """
115 Test that a catalog which only cares about g and z does not calculate any other magnitudes
116 """
117 dtype = np.dtype([(name, np.float) for name in gzStarCatalog.column_outputs])
119 cat = gzStarCatalog(self.db, obs_metadata=self.obs)
120 with lsst.utils.tests.getTempFilePath('.txt') as catName:
121 cat.write_catalog(catName)
122 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
123 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10)
124 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10)
125 np.testing.assert_array_almost_equal(self.controlData['lsst_g'], testData['lsst_g'], 10)
126 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10)
127 np.testing.assert_array_almost_equal(self.controlData['lsst_z'], testData['lsst_z'], 10)
128 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10)
130 self.assertNotIn('lsst_u', cat._actually_calculated_columns)
131 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns)
132 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
133 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
134 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
135 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
136 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
137 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
139 def test_gz_uncertainty_star_catalog(self):
140 """
141 Test that a catalog which only cares about g and z uncertainties
142 does not calculate any other magnitudes
143 """
144 dtype = np.dtype([(name, np.float) for name in gzUncertaintyStarCatalog.column_outputs])
146 cat = gzUncertaintyStarCatalog(self.db, obs_metadata=self.obs)
147 with lsst.utils.tests.getTempFilePath('.txt') as catName:
148 cat.write_catalog(catName)
149 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
150 np.testing.assert_array_almost_equal(self.controlData['raJ2000'], testData['raJ2000'], 10)
151 np.testing.assert_array_almost_equal(self.controlData['decJ2000'], testData['decJ2000'], 10)
152 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10)
153 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10)
155 self.assertNotIn('lsst_u', cat._actually_calculated_columns)
156 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns)
157 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
158 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
159 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
160 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
161 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
162 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
163 self.assertIn('lsst_g', cat._actually_calculated_columns)
164 self.assertIn('lsst_z', cat._actually_calculated_columns)
167class baselineSSMCatalog(InstanceCatalog, PhotometrySSM):
168 column_outputs = ['lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y',
169 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r',
170 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y']
172 default_formats = {'f': '%.13f'}
175class uSSMCatalog(InstanceCatalog, PhotometrySSM):
176 column_outputs = ['lsst_u', 'sigma_lsst_u']
178 default_formats = {'f': '%.13f'}
181class gzSSMCatalog(InstanceCatalog, PhotometrySSM):
182 column_outputs = ['lsst_g', 'lsst_z',
183 'sigma_lsst_g', 'sigma_lsst_z']
185 default_formats = {'f': '%.13f'}
188class gzUncertaintySSMCatalog(InstanceCatalog, PhotometrySSM):
189 column_outputs = ['sigma_lsst_g', 'sigma_lsst_z']
191 default_formats = {'f': '%.13f'}
194class IndexTestCaseSSM(unittest.TestCase):
195 """
196 This unit test suite will test that the 'indices' framework for making
197 sure that an InstanceCatalog only calculates the magnitudes requested
198 works in the case of solar system objects.
199 """
201 @classmethod
202 def setUpClass(cls):
204 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'],
205 m5 = [22.0, 23.0, 24.0, 25.0, 26.0, 27.0])
207 baselineDtype = np.dtype([(name, np.float) for name in baselineSSMCatalog.column_outputs])
209 dbdtype = np.dtype([
210 ('id', np.int),
211 ('sedFilename', str, 100),
212 ('magNorm', np.float),
213 ('velRA', np.float),
214 ('velDec', np.float)
215 ])
217 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData')
218 inputFile = os.path.join(inputDir, 'SSMphotometryCatalog.txt')
220 cls.db = fileDBObject(inputFile, runtable='test',
221 idColKey='id', dtype=dbdtype)
223 cat = baselineSSMCatalog(cls.db, obs_metadata=cls.obs)
224 catName = tempfile.mktemp(prefix='IndexTestCase_setUpClass')
225 cat.write_catalog(catName)
226 cls.controlData = np.genfromtxt(catName, dtype=baselineDtype, delimiter=',')
227 os.unlink(catName)
229 def test_u_ssm_catalog(self):
230 """
231 Test that a catalog which only cares about u does not calculate any other magnitudes.
232 """
233 dtype = np.dtype([(name, np.float) for name in uSSMCatalog.column_outputs])
235 cat = uSSMCatalog(self.db, obs_metadata=self.obs)
236 with lsst.utils.tests.getTempFilePath('.txt') as catName:
237 cat.write_catalog(catName)
238 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
239 np.testing.assert_array_almost_equal(self.controlData['lsst_u'], testData['lsst_u'], 10)
240 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_u'], testData['sigma_lsst_u'], 10)
242 self.assertNotIn('lsst_g', cat._actually_calculated_columns)
243 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns)
244 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
245 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
246 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
247 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
248 self.assertNotIn('lsst_z', cat._actually_calculated_columns)
249 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns)
250 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
251 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
253 def test_gz_ssm_catalog(self):
254 """
255 Test that a catalog which only cares about g and z does not calculate any other magnitudes
256 """
257 dtype = np.dtype([(name, np.float) for name in gzSSMCatalog.column_outputs])
259 cat = gzSSMCatalog(self.db, obs_metadata=self.obs)
260 with lsst.utils.tests.getTempFilePath('.txt') as catName:
261 cat.write_catalog(catName)
262 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
263 np.testing.assert_array_almost_equal(self.controlData['lsst_g'], testData['lsst_g'], 10)
264 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10)
265 np.testing.assert_array_almost_equal(self.controlData['lsst_z'], testData['lsst_z'], 10)
266 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10)
268 self.assertNotIn('lsst_u', cat._actually_calculated_columns)
269 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns)
270 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
271 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
272 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
273 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
274 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
275 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
277 def test_gz_uncertainty_ssm_catalog(self):
278 """
279 Test that a catalog which only cares about g and z uncertainties
280 does not calculate any other magnitudes
281 """
282 dtype = np.dtype([(name, np.float) for name in gzUncertaintySSMCatalog.column_outputs])
284 cat = gzUncertaintySSMCatalog(self.db, obs_metadata=self.obs)
285 with lsst.utils.tests.getTempFilePath('.txt') as catName:
286 cat.write_catalog(catName)
287 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
288 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_g'], testData['sigma_lsst_g'], 10)
289 np.testing.assert_array_almost_equal(self.controlData['sigma_lsst_z'], testData['sigma_lsst_z'], 10)
291 self.assertNotIn('lsst_u', cat._actually_calculated_columns)
292 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns)
293 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
294 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
295 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
296 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
297 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
298 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
299 self.assertIn('lsst_g', cat._actually_calculated_columns)
300 self.assertIn('lsst_z', cat._actually_calculated_columns)
302class baselineGalaxyCatalog(InstanceCatalog, PhotometryGalaxies):
303 column_outputs = ['uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge',
304 'uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk',
305 'uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn',
306 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y',
307 'sigma_uBulge', 'sigma_gBulge', 'sigma_rBulge',
308 'sigma_iBulge', 'sigma_zBulge', 'sigma_yBulge',
309 'sigma_uDisk', 'sigma_gDisk', 'sigma_rDisk',
310 'sigma_iDisk', 'sigma_zDisk', 'sigma_yDisk',
311 'sigma_uAgn', 'sigma_gAgn', 'sigma_rAgn',
312 'sigma_iAgn', 'sigma_zAgn', 'sigma_yAgn',
313 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r',
314 'sigma_lsst_i', 'sigma_lsst_z', 'sigma_lsst_y']
316 default_formats = {'f': '%.13f'}
319class uGalaxyCatalog(InstanceCatalog, PhotometryGalaxies):
320 column_outputs = ['uBulge', 'uDisk', 'uAgn', 'lsst_u',
321 'sigma_uBulge', 'sigma_uDisk', 'sigma_uAgn',
322 'sigma_lsst_u']
324 default_formats = {'f': '%.13f'}
327class gzGalaxyCatalog(InstanceCatalog, PhotometryGalaxies):
328 column_outputs = ['gBulge', 'gDisk', 'gAgn', 'lsst_g',
329 'zBulge', 'zDisk', 'zAgn', 'lsst_z',
330 'sigma_gBulge', 'sigma_gDisk', 'sigma_gAgn',
331 'sigma_lsst_g',
332 'sigma_zBulge', 'sigma_zDisk', 'sigma_zAgn',
333 'sigma_lsst_z']
335 default_formats = {'f': '%.13f'}
338class IndexTestCaseGalaxies(unittest.TestCase):
339 """
340 This unit test suite will test that the 'indices' framework for making
341 sure that an InstanceCatalog only calculates the magnitudes requested
342 works in the case of galaxies.
343 """
345 @classmethod
346 def setUpClass(cls):
348 cls.obs = ObservationMetaData(bandpassName=['u', 'g', 'r', 'i', 'z', 'y'],
349 m5=[24.0, 25.0, 26.0, 27.0, 28.0, 29.0])
351 dtype = np.dtype([
352 ('id', np.int),
353 ('sedFilenameBulge', str, 100),
354 ('magNormBulge', np.float),
355 ('sedFilenameDisk', str, 100),
356 ('magNormDisk', np.float),
357 ('sedFilenameAgn', str, 100),
358 ('magNormAgn', np.float),
359 ('internalAvBulge', np.float),
360 ('internalAvDisk', np.float),
361 ('galacticAv', np.float),
362 ('redshift', np.float)
363 ])
365 inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData')
366 inputFile = os.path.join(inputDir, 'IndicesTestCatalogGalaxies.txt')
367 cls.db = fileDBObject(inputFile, dtype=dtype, runtable='test',
368 idColKey='id')
370 cls.db.objectTypeId = 44
372 cat = baselineGalaxyCatalog(cls.db, obs_metadata=cls.obs)
373 dtype = np.dtype([(name, np.float) for name in cat.column_outputs])
374 catName = tempfile.mktemp(dir=ROOT, prefix='', suffix='.txt')
375 cat.write_catalog(catName)
376 cls.controlData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
377 os.remove(catName)
379 def test_u_catalog(self):
380 """
381 Test that a catalog which only requests u band magnitudes does not
382 calculate anything it shouldn't
383 """
384 cat = uGalaxyCatalog(self.db, obs_metadata=self.obs)
385 dtype = np.dtype([(name, np.float) for name in cat.column_outputs])
386 with lsst.utils.tests.getTempFilePath('.txt') as catName:
387 cat.write_catalog(catName)
389 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
391 for name in ('uBulge', 'uDisk', 'uAgn', 'lsst_u',
392 'sigma_uBulge', 'sigma_uDisk', 'sigma_uAgn', 'sigma_lsst_u'):
394 np.testing.assert_array_almost_equal(testData[name],
395 self.controlData[name], 10)
397 self.assertNotIn('gBulge', cat._actually_calculated_columns)
398 self.assertNotIn('rBulge', cat._actually_calculated_columns)
399 self.assertNotIn('iBulge', cat._actually_calculated_columns)
400 self.assertNotIn('zBulge', cat._actually_calculated_columns)
401 self.assertNotIn('yBulge', cat._actually_calculated_columns)
402 self.assertNotIn('gDisk', cat._actually_calculated_columns)
403 self.assertNotIn('rDisk', cat._actually_calculated_columns)
404 self.assertNotIn('iDisk', cat._actually_calculated_columns)
405 self.assertNotIn('zDisk', cat._actually_calculated_columns)
406 self.assertNotIn('yDisk', cat._actually_calculated_columns)
407 self.assertNotIn('gAgn', cat._actually_calculated_columns)
408 self.assertNotIn('rAgn', cat._actually_calculated_columns)
409 self.assertNotIn('iAgn', cat._actually_calculated_columns)
410 self.assertNotIn('zAgn', cat._actually_calculated_columns)
411 self.assertNotIn('yAgn', cat._actually_calculated_columns)
412 self.assertNotIn('lsst_g', cat._actually_calculated_columns)
413 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
414 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
415 self.assertNotIn('lsst_z', cat._actually_calculated_columns)
416 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
417 self.assertNotIn('sigma_gBulge', cat._actually_calculated_columns)
418 self.assertNotIn('sigma_rBulge', cat._actually_calculated_columns)
419 self.assertNotIn('sigma_iBulge', cat._actually_calculated_columns)
420 self.assertNotIn('sigma_zBulge', cat._actually_calculated_columns)
421 self.assertNotIn('sigma_yBulge', cat._actually_calculated_columns)
422 self.assertNotIn('sigma_gDisk', cat._actually_calculated_columns)
423 self.assertNotIn('sigma_rDisk', cat._actually_calculated_columns)
424 self.assertNotIn('sigma_iDisk', cat._actually_calculated_columns)
425 self.assertNotIn('sigma_zDisk', cat._actually_calculated_columns)
426 self.assertNotIn('sigma_yDisk', cat._actually_calculated_columns)
427 self.assertNotIn('sigma_gAgn', cat._actually_calculated_columns)
428 self.assertNotIn('sigma_rAgn', cat._actually_calculated_columns)
429 self.assertNotIn('sigma_iAgn', cat._actually_calculated_columns)
430 self.assertNotIn('sigma_zAgn', cat._actually_calculated_columns)
431 self.assertNotIn('sigma_yAgn', cat._actually_calculated_columns)
432 self.assertNotIn('sigma_lsst_g', cat._actually_calculated_columns)
433 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
434 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
435 self.assertNotIn('sigma_lsst_z', cat._actually_calculated_columns)
436 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
438 def test_gz_catalog(self):
439 """
440 Test that a catalog which only requests g and z band magnitudes does not
441 calculate anything it shouldn't
442 """
443 cat = gzGalaxyCatalog(self.db, obs_metadata=self.obs)
444 dtype = np.dtype([(name, np.float) for name in cat.column_outputs])
445 with lsst.utils.tests.getTempFilePath('.txt') as catName:
446 cat.write_catalog(catName)
448 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
450 for name in ('gBulge', 'gDisk', 'gAgn', 'lsst_g',
451 'zBulge', 'zDisk', 'zAgn', 'lsst_z',
452 'sigma_gBulge', 'sigma_gDisk', 'sigma_gAgn',
453 'sigma_lsst_g',
454 'sigma_zBulge', 'sigma_zDisk', 'sigma_zAgn',
455 'sigma_lsst_z'):
457 np.testing.assert_array_almost_equal(testData[name],
458 self.controlData[name], 10)
460 self.assertNotIn('uBulge', cat._actually_calculated_columns)
461 self.assertNotIn('rBulge', cat._actually_calculated_columns)
462 self.assertNotIn('iBulge', cat._actually_calculated_columns)
463 self.assertNotIn('yBulge', cat._actually_calculated_columns)
464 self.assertNotIn('uDisk', cat._actually_calculated_columns)
465 self.assertNotIn('rDisk', cat._actually_calculated_columns)
466 self.assertNotIn('iDisk', cat._actually_calculated_columns)
467 self.assertNotIn('yDisk', cat._actually_calculated_columns)
468 self.assertNotIn('uAgn', cat._actually_calculated_columns)
469 self.assertNotIn('rAgn', cat._actually_calculated_columns)
470 self.assertNotIn('iAgn', cat._actually_calculated_columns)
471 self.assertNotIn('yAgn', cat._actually_calculated_columns)
472 self.assertNotIn('lsst_u', cat._actually_calculated_columns)
473 self.assertNotIn('lsst_r', cat._actually_calculated_columns)
474 self.assertNotIn('lsst_i', cat._actually_calculated_columns)
475 self.assertNotIn('lsst_y', cat._actually_calculated_columns)
476 self.assertNotIn('sigma_uBulge', cat._actually_calculated_columns)
477 self.assertNotIn('sigma_rBulge', cat._actually_calculated_columns)
478 self.assertNotIn('sigma_iBulge', cat._actually_calculated_columns)
479 self.assertNotIn('sigma_yBulge', cat._actually_calculated_columns)
480 self.assertNotIn('sigma_uDisk', cat._actually_calculated_columns)
481 self.assertNotIn('sigma_rDisk', cat._actually_calculated_columns)
482 self.assertNotIn('sigma_iDisk', cat._actually_calculated_columns)
483 self.assertNotIn('sigma_yDisk', cat._actually_calculated_columns)
484 self.assertNotIn('sigma_uAgn', cat._actually_calculated_columns)
485 self.assertNotIn('sigma_rAgn', cat._actually_calculated_columns)
486 self.assertNotIn('sigma_iAgn', cat._actually_calculated_columns)
487 self.assertNotIn('sigma_yAgn', cat._actually_calculated_columns)
488 self.assertNotIn('sigma_lsst_u', cat._actually_calculated_columns)
489 self.assertNotIn('sigma_lsst_r', cat._actually_calculated_columns)
490 self.assertNotIn('sigma_lsst_i', cat._actually_calculated_columns)
491 self.assertNotIn('sigma_lsst_y', cat._actually_calculated_columns)
493class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
494 pass
496if __name__ == "__main__": 496 ↛ 497line 496 didn't jump to line 497, because the condition on line 496 was never true
497 lsst.utils.tests.init()
498 unittest.main()