Coverage for tests/test_filters.py: 24%

98 statements  

« prev     ^ index     » next       coverage.py v6.4, created at 2022-06-02 03:54 -0700

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.afw.image 

25import lsst.pex.exceptions 

26import lsst.utils.tests 

27from lsst.obs.base import FilterDefinition, FilterDefinitionCollection 

28 

29 

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

31 def setUp(self): 

32 self.filters1 = FilterDefinitionCollection( 

33 FilterDefinition(physical_filter="abc", lambdaEff=123), 

34 FilterDefinition(physical_filter="def", band="d", doc="This is a test filter.", lambdaEff=456), 

35 ) 

36 self.filters2 = FilterDefinitionCollection( 

37 FilterDefinition(physical_filter="abc", lambdaEff=321), 

38 FilterDefinition(physical_filter="def", band="dd", lambdaEff=654), 

39 ) 

40 FilterDefinitionCollection.reset() 

41 

42 def test_singleton(self): 

43 self.filters1.defineFilters() 

44 self.assertEqual(lsst.afw.image.Filter("abc").getFilterProperty().getLambdaEff(), 123) 

45 self.assertEqual(lsst.afw.image.Filter("def").getFilterProperty().getLambdaEff(), 456) 

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

47 self.assertEqual(lsst.afw.image.Filter("abc").getFilterProperty().getLambdaEff(), 123) 

48 self.assertEqual(lsst.afw.image.Filter("def").getFilterProperty().getLambdaEff(), 456) 

49 with self.assertRaises(RuntimeError): 

50 self.filters2.defineFilters() 

51 # the defined filters should be unchanged 

52 self.assertEqual(lsst.afw.image.Filter("abc").getFilterProperty().getLambdaEff(), 123) 

53 self.assertEqual(lsst.afw.image.Filter("def").getFilterProperty().getLambdaEff(), 456) 

54 

55 def test_reset(self): 

56 self.filters1.defineFilters() 

57 with self.assertRaises(RuntimeError): 

58 self.filters2.defineFilters() 

59 self.filters1.reset() 

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

61 self.filters2.defineFilters() 

62 self.assertEqual(lsst.afw.image.Filter("abc").getFilterProperty().getLambdaEff(), 321) 

63 self.assertEqual(lsst.afw.image.Filter("def").getFilterProperty().getLambdaEff(), 654) 

64 

65 def test_findAll(self): 

66 self.assertEqual(set(self.filters1.findAll("r")), set()) 

67 matches = self.filters1.findAll("abc") 

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

69 match = list(matches)[0] 

70 self.assertEqual(match.physical_filter, "abc") 

71 

72 def test_physical_to_band(self): 

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

74 self.assertIsNone(self.filters1.physical_to_band["abc"]) 

75 self.assertEqual(self.filters1.physical_to_band["def"], "d") 

76 self.assertIsNone(self.filters2.physical_to_band["abc"]) 

77 self.assertEqual(self.filters2.physical_to_band["def"], "dd") 

78 

79 

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

81 def setUp(self): 

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

83 self.filter_g = FilterDefinition(band="g", physical_filter="HSC-G", lambdaEff=1234, alias={"ABCDEFG"}) 

84 self.filter_g2 = FilterDefinition( 

85 band="g", physical_filter="HSC-G2", afw_name="g2", lambdaEff=1235, alias={"HIJK"} 

86 ) 

87 

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

89 self.afw_name = FilterDefinition(physical_filter="afw_name", lambdaEff=5, afw_name="afw only") 

90 self.abstract = FilterDefinition(physical_filter="abstract", lambdaEff=42, band="abstract only") 

91 

92 def testDefineFilters(self): 

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

94 # the filter should not exist until we define it 

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

96 lsst.afw.image.Filter("g") 

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

98 lsst.afw.image.Filter("g2") 

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

100 lsst.afw.image.Filter("HSC-G") 

101 

102 self.filter_g.defineFilter() 

103 filter = lsst.afw.image.Filter("g") 

104 filter_alias = lsst.afw.image.Filter("HSC-G") 

105 self.assertEqual(filter.getName(), "g") 

106 # afw Filter stores the aliased name as the CannonicalName 

107 self.assertEqual(filter_alias.getCanonicalName(), "g") 

108 self.assertEqual(filter, filter_alias) 

109 self.assertEqual(["ABCDEFG", "HSC-G"], sorted(filter.getAliases())) 

110 

111 self.filter_g2.defineFilter() 

112 filter2 = lsst.afw.image.Filter("g2") 

113 filter2_alias = lsst.afw.image.Filter("HSC-G2") 

114 self.assertEqual(filter2.getName(), "g2") 

115 self.assertEqual(filter2_alias.getCanonicalName(), "g2") 

116 self.assertEqual(filter2, filter2_alias) 

117 self.assertEqual(["HIJK", "HSC-G2"], sorted(filter2.getAliases())) 

118 

119 def test_physical_only(self): 

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

121 self.physical_only.defineFilter() 

122 filter = lsst.afw.image.Filter("physical") 

123 self.assertEqual(filter.getName(), "physical") 

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

125 self.assertEqual( 

126 self.physical_only.makeFilterLabel(), lsst.afw.image.FilterLabel(physical="physical") 

127 ) 

128 

129 def test_afw_name(self): 

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

131 self.afw_name.defineFilter() 

132 filter = lsst.afw.image.Filter("afw only") 

133 filter_alias = lsst.afw.image.Filter("afw_name") 

134 self.assertEqual(filter.getName(), "afw only") 

135 self.assertEqual(filter_alias.getCanonicalName(), "afw only") 

136 self.assertEqual(["afw_name"], sorted(filter.getAliases())) 

137 self.assertEqual(self.afw_name.makeFilterLabel(), lsst.afw.image.FilterLabel(physical="afw_name")) 

138 

139 def test_abstract_only(self): 

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

141 self.abstract.defineFilter() 

142 filter = lsst.afw.image.Filter("abstract only") 

143 filter_alias = lsst.afw.image.Filter("abstract") 

144 self.assertEqual(filter.getName(), "abstract only") 

145 self.assertEqual(filter_alias.getCanonicalName(), "abstract only") 

146 self.assertEqual(["abstract"], sorted(filter.getAliases())) 

147 self.assertEqual( 

148 self.abstract.makeFilterLabel(), 

149 lsst.afw.image.FilterLabel(band="abstract only", physical="abstract"), 

150 ) 

151 

152 

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

154 pass 

155 

156 

157def setup_module(module): 

158 lsst.utils.tests.init() 

159 

160 

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

162 lsst.utils.tests.init() 

163 unittest.main()