Coverage for tests/test_filters.py: 22%

98 statements  

« prev     ^ index     » next       coverage.py v7.1.0, created at 2023-02-05 18:01 -0800

1# This file is part of obs_base. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# This program is free software: you can redistribute it and/or modify 

10# it under the terms of the GNU General Public License as published by 

11# the Free Software Foundation, either version 3 of the License, or 

12# (at your option) any later version. 

13# 

14# This program is distributed in the hope that it will be useful, 

15# but WITHOUT ANY WARRANTY; without even the implied warranty of 

16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

17# GNU General Public License for more details. 

18# 

19# You should have received a copy of the GNU General Public License 

20# along with this program. If not, see <https://www.gnu.org/licenses/>. 

21 

22import unittest 

23 

24import lsst.utils.tests 

25import lsst.afw.image 

26from lsst.obs.base import FilterDefinition, FilterDefinitionCollection 

27import lsst.pex.exceptions 

28 

29 

30class TestFilterDefinitionCollection(lsst.utils.tests.TestCase): 

31 def setUp(self): 

32 self.filters1 = FilterDefinitionCollection(FilterDefinition(physical_filter='abc', lambdaEff=123), 

33 FilterDefinition(physical_filter='def', 

34 band='d', 

35 doc="This is a test filter.", 

36 lambdaEff=456)) 

37 self.filters2 = FilterDefinitionCollection(FilterDefinition(physical_filter='abc', lambdaEff=321), 

38 FilterDefinition(physical_filter='def', 

39 band='dd', 

40 lambdaEff=654)) 

41 FilterDefinitionCollection.reset() 

42 

43 def test_singleton(self): 

44 self.filters1.defineFilters() 

45 self.assertEqual(lsst.afw.image.Filter('abc').getFilterProperty().getLambdaEff(), 123) 

46 self.assertEqual(lsst.afw.image.Filter('def').getFilterProperty().getLambdaEff(), 456) 

47 self.filters1.defineFilters() # this should not change anything 

48 self.assertEqual(lsst.afw.image.Filter('abc').getFilterProperty().getLambdaEff(), 123) 

49 self.assertEqual(lsst.afw.image.Filter('def').getFilterProperty().getLambdaEff(), 456) 

50 with self.assertRaises(RuntimeError): 

51 self.filters2.defineFilters() 

52 # the defined filters should be unchanged 

53 self.assertEqual(lsst.afw.image.Filter('abc').getFilterProperty().getLambdaEff(), 123) 

54 self.assertEqual(lsst.afw.image.Filter('def').getFilterProperty().getLambdaEff(), 456) 

55 

56 def test_reset(self): 

57 self.filters1.defineFilters() 

58 with self.assertRaises(RuntimeError): 

59 self.filters2.defineFilters() 

60 self.filters1.reset() 

61 # The new filters can be defiend and should replace the old ones. 

62 self.filters2.defineFilters() 

63 self.assertEqual(lsst.afw.image.Filter('abc').getFilterProperty().getLambdaEff(), 321) 

64 self.assertEqual(lsst.afw.image.Filter('def').getFilterProperty().getLambdaEff(), 654) 

65 

66 def test_findAll(self): 

67 self.assertEqual(set(self.filters1.findAll('r')), set()) 

68 matches = self.filters1.findAll('abc') 

69 self.assertEqual(len(matches), 1) 

70 match = list(matches)[0] 

71 self.assertEqual(match.physical_filter, 'abc') 

72 

73 def test_physical_to_band(self): 

74 """Test that the physical_to_band dict returns expected values. 

75 """ 

76 self.assertIsNone(self.filters1.physical_to_band['abc']) 

77 self.assertEqual(self.filters1.physical_to_band['def'], 'd') 

78 self.assertIsNone(self.filters2.physical_to_band['abc']) 

79 self.assertEqual(self.filters2.physical_to_band['def'], 'dd') 

80 

81 

82class TestFilterDefinition(lsst.utils.tests.TestCase): 

83 def setUp(self): 

84 lsst.afw.image.utils.resetFilters() 

85 self.filter_g = FilterDefinition(band="g", 

86 physical_filter="HSC-G", 

87 lambdaEff=1234, 

88 alias={'ABCDEFG'}) 

89 self.filter_g2 = FilterDefinition(band="g", 

90 physical_filter="HSC-G2", 

91 afw_name='g2', 

92 lambdaEff=1235, 

93 alias={'HIJK'}) 

94 

95 self.physical_only = FilterDefinition(physical_filter="physical", lambdaEff=0) 

96 self.afw_name = FilterDefinition(physical_filter="afw_name", 

97 lambdaEff=5, afw_name="afw only") 

98 self.abstract = FilterDefinition(physical_filter="abstract", lambdaEff=42, 

99 band="abstract only") 

100 

101 def testDefineFilters(self): 

102 """Test that a filter is properly defined in afw.""" 

103 # the filter should not exist until we define it 

104 with self.assertRaises(lsst.pex.exceptions.NotFoundError): 

105 lsst.afw.image.Filter('g') 

106 with self.assertRaises(lsst.pex.exceptions.NotFoundError): 

107 lsst.afw.image.Filter('g2') 

108 with self.assertRaises(lsst.pex.exceptions.NotFoundError): 

109 lsst.afw.image.Filter('HSC-G') 

110 

111 self.filter_g.defineFilter() 

112 filter = lsst.afw.image.Filter('g') 

113 filter_alias = lsst.afw.image.Filter('HSC-G') 

114 self.assertEqual(filter.getName(), 'g') 

115 # afw Filter stores the aliased name as the CannonicalName 

116 self.assertEqual(filter_alias.getCanonicalName(), 'g') 

117 self.assertEqual(filter, filter_alias) 

118 self.assertEqual(['ABCDEFG', 'HSC-G'], sorted(filter.getAliases())) 

119 

120 self.filter_g2.defineFilter() 

121 filter2 = lsst.afw.image.Filter('g2') 

122 filter2_alias = lsst.afw.image.Filter('HSC-G2') 

123 self.assertEqual(filter2.getName(), 'g2') 

124 self.assertEqual(filter2_alias.getCanonicalName(), 'g2') 

125 self.assertEqual(filter2, filter2_alias) 

126 self.assertEqual(['HIJK', 'HSC-G2'], sorted(filter2.getAliases())) 

127 

128 def test_physical_only(self): 

129 """physical_filter is the only name this filter has. 

130 """ 

131 self.physical_only.defineFilter() 

132 filter = lsst.afw.image.Filter('physical') 

133 self.assertEqual(filter.getName(), 'physical') 

134 self.assertEqual([], sorted(filter.getAliases())) 

135 self.assertEqual(self.physical_only.makeFilterLabel(), 

136 lsst.afw.image.FilterLabel(physical='physical')) 

137 

138 def test_afw_name(self): 

139 """afw_name is the Filter name, physical_filter is an alias. 

140 """ 

141 self.afw_name.defineFilter() 

142 filter = lsst.afw.image.Filter('afw only') 

143 filter_alias = lsst.afw.image.Filter('afw_name') 

144 self.assertEqual(filter.getName(), 'afw only') 

145 self.assertEqual(filter_alias.getCanonicalName(), 'afw only') 

146 self.assertEqual(['afw_name'], sorted(filter.getAliases())) 

147 self.assertEqual(self.afw_name.makeFilterLabel(), 

148 lsst.afw.image.FilterLabel(physical='afw_name')) 

149 

150 def test_abstract_only(self): 

151 """band is the Filter name, physical_filter is an alias. 

152 """ 

153 self.abstract.defineFilter() 

154 filter = lsst.afw.image.Filter('abstract only') 

155 filter_alias = lsst.afw.image.Filter('abstract') 

156 self.assertEqual(filter.getName(), 'abstract only') 

157 self.assertEqual(filter_alias.getCanonicalName(), 'abstract only') 

158 self.assertEqual(['abstract'], sorted(filter.getAliases())) 

159 self.assertEqual(self.abstract.makeFilterLabel(), 

160 lsst.afw.image.FilterLabel(band='abstract only', physical='abstract')) 

161 

162 

163class MemoryTester(lsst.utils.tests.MemoryTestCase): 

164 pass 

165 

166 

167def setup_module(module): 

168 lsst.utils.tests.init() 

169 

170 

171if __name__ == '__main__': 171 ↛ 172line 171 didn't jump to line 172, because the condition on line 171 was never true

172 lsst.utils.tests.init() 

173 unittest.main()