Coverage for tests/test_seeingModel.py : 20%

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 numpy as np
2import unittest
3import lsst.utils.tests
4from lsst.sims.seeingModel import SeeingModel, SeeingModelConfig
7class TestSeeingModel(unittest.TestCase):
8 def setUp(self):
9 # Set config to known values.
10 config = SeeingModelConfig()
11 config.telescope_seeing = 0.25
12 config.optical_design_seeing = 0.08
13 config.camera_seeing = 0.30
14 config.raw_seeing_wavelength = 500
15 # Define a non-default set of effective wavelengths for testing.
16 filterlist = ['u', 'g', 'r', 'i', 'z']
17 effwavelens = [ 367.06988658, 482.68517118,
18 622.32403587, 754.59752265,
19 869.09018708]
20 config.filter_list = filterlist
21 config.filter_effwavelens = effwavelens
22 config.efd_columns = ['raw_seeing']
23 config.efd_delta_time = 0
24 config.target_columns = ['airmass']
25 self.config = config
27 def test_configure(self):
28 # Configure with defaults.
29 seeingModel = SeeingModel()
30 conf = SeeingModelConfig()
31 self.assertEqual(seeingModel._config, conf)
32 # Test specifying the config.
33 seeingModel = SeeingModel(self.config)
34 self.assertEqual(seeingModel._config.filter_list, self.config.filter_list)
35 # Test specifying an incorrect config.
36 self.assertRaises(RuntimeError, SeeingModel, 0.8)
38 def test_status(self):
39 seeingModel = SeeingModel()
40 confDict = seeingModel.config_info()
41 expected_keys = ['SeeingModel_version', 'SeeingModel_sha', 'efd_columns', 'efd_delta_time',
42 'filter_list', 'filter_effwavelens', 'raw_seeing_wavelength',
43 'telescope_seeing', 'camera_seeing', 'optical_design_seeing',
44 'target_columns']
45 for k in expected_keys:
46 self.assertTrue(k in confDict.keys())
48 def test_efd_requirements(self):
49 seeingModel = SeeingModel(self.config)
50 cols = seeingModel.efd_requirements[0]
51 deltaT = seeingModel.efd_requirements[1]
52 self.assertEqual(self.config.efd_columns, cols)
53 self.assertEqual(self.config.efd_delta_time, deltaT)
55 def test_targetmap_requirements(self):
56 seeingModel = SeeingModel(self.config)
57 self.assertEqual(seeingModel.target_requirements, self.config.target_columns)
59 def test_fwhm_system_zenith(self):
60 # Check calculation is being done as expected.
61 seeingModel = SeeingModel(self.config)
62 self.assertEqual(seeingModel.fwhm_system_zenith, 0.39862262855989494)
64 def test_fwhmGeomEff(self):
65 # Check that the translation between FWHM effective and geometric is done as expected.
66 # (note that fwhmEff_tofwhmGeom & fwhmGeom_to_fwhmEff are static methods)
67 # Document-20160 for reference.
68 fwhm_eff = 1.23
69 fwhm_geom = 0.822 * fwhm_eff + 0.052
70 self.assertEqual(fwhm_geom, SeeingModel.fwhmEff_to_fwhmGeom(fwhm_eff))
71 self.assertEqual(fwhm_eff, SeeingModel.fwhmGeom_to_fwhmEff(fwhm_geom))
73 def test_call(self):
74 # Check the calculation from fwhm_500 to fwhm_eff/fwhm_geom.
75 # Use simple effective wavelengths and airmass values.
76 config = SeeingModelConfig()
77 config.filter_list = ['500', '1000']
78 config.filter_effwavelens = [500.0, 1000.0]
79 wavelens = np.array(config.filter_effwavelens)
80 seeingModel = SeeingModel(config)
81 # Simple fwhm_500 input.
82 fwhm_500 = 1.0
83 # Single airmass.
84 airmass = 1.0
85 efdData = {config.efd_columns[0]: fwhm_500}
86 targetDict = {'airmass': airmass}
87 seeing = seeingModel(efdData, targetDict)
88 fwhm_eff = seeing['fwhmEff']
89 fwhm_geom = seeing['fwhmGeom']
90 # Check shape of returned values.
91 self.assertEqual(fwhm_eff.shape, (len(seeingModel.eff_wavelens),))
92 # Check actual value of seeing in @ wavelen[0] @ zenith after addition of system.
93 fwhm_system = seeingModel.fwhm_system_zenith
94 expected_fwhm_eff = 1.16 * np.sqrt(fwhm_system ** 2 + 1.04 * fwhm_500 ** 2)
95 self.assertAlmostEqual(fwhm_eff[0], expected_fwhm_eff, 15)
96 # Check expected value if we remove the system component.
97 seeingModel.fwhm_system_zenith = 0
98 seeing = seeingModel(efdData, targetDict)
99 expected_fwhm_eff = 1.16 * np.sqrt(1.04) * fwhm_500
100 self.assertAlmostEqual(seeing['fwhmEff'][0], expected_fwhm_eff, 15)
101 # Check scaling with wavelength (remove system component).
102 expected_fwhm_eff = 1.16 * np.sqrt(1.04) * fwhm_500 * np.power(500./wavelens[1], 0.3)
103 self.assertAlmostEqual(seeing['fwhmEff'][1], expected_fwhm_eff, places=15)
104 # Multiple airmasses.
105 airmass = np.array([1.0, 1.5])
106 targetDict = {'airmass': airmass}
107 seeing = seeingModel(efdData, targetDict)
108 self.assertEqual(seeing['fwhmEff'].shape, (len(seeingModel.eff_wavelens), len(airmass)))
109 expected_fwhm_eff = fwhm_500 * 1.16 * np.sqrt(1.04)
110 self.assertEqual(seeing['fwhmEff'][0][0], expected_fwhm_eff)
111 # Check scaling with airmass.
112 expected_fwhm_eff = expected_fwhm_eff * np.power(airmass[1], 0.6)
113 self.assertAlmostEqual(seeing['fwhmEff'][0][1], expected_fwhm_eff, places=15)
116class TestMemory(lsst.utils.tests.MemoryTestCase):
117 pass
119def setup_module(module):
120 lsst.utils.tests.init()
122if __name__ == "__main__": 122 ↛ 123line 122 didn't jump to line 123, because the condition on line 122 was never true
123 lsst.utils.tests.init()
124 unittest.main()