Coverage for tests/test_gaussianPsfFactory.py: 12%

105 statements  

« prev     ^ index     » next       coverage.py v6.4.2, created at 2022-07-15 11:24 +0000

1# 

2# LSST Data Management System 

3# 

4# Copyright 2008-2016 AURA/LSST. 

5# 

6# This product includes software developed by the 

7# LSST Project (http://www.lsst.org/). 

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 LSST License Statement and 

20# the GNU General Public License along with this program. If not, 

21# see <https://www.lsstcorp.org/LegalNotices/>. 

22# 

23import unittest 

24 

25from lsst.meas.algorithms import GaussianPsfFactory, SigmaPerFwhm, SingleGaussianPsf, DoubleGaussianPsf 

26from lsst.pex.config import Config, FieldValidationError 

27import lsst.utils.tests 

28 

29 

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

31 

32 def testApply(self): 

33 """Test apply and computeSizeAndSigma methods.""" 

34 factory = GaussianPsfFactory() 

35 for fixedSize in (None, 5, 6): 

36 factory.size = fixedSize 

37 for fwhm in (None, 1, 5, 10): 

38 if fwhm is None: 

39 predFwhm = factory.defaultFwhm 

40 else: 

41 predFwhm = fwhm 

42 for sizeFactor in (1, 3, 5): 

43 factory.sizeFactor = sizeFactor 

44 if fixedSize is None: 

45 # predicted size without applying limits = fwhm * sizeFactor, increased to be odd 

46 naiveSize = int(0.5 + (predFwhm * sizeFactor)) 

47 if naiveSize % 2 == 0: 

48 naiveSize += 1 

49 else: 

50 naiveSize = fixedSize 

51 for minSize in (max(1, naiveSize-1), naiveSize, naiveSize + 2): 

52 if minSize <= 0: 

53 continue 

54 factory.minSize = minSize 

55 for maxSize in (naiveSize-1, naiveSize): 

56 if maxSize <= 0: 

57 continue 

58 if maxSize < minSize: 

59 continue 

60 factory.maxSize = maxSize 

61 for addWing in (False, True): 

62 factory.addWing = addWing 

63 size, sigma = factory.computeSizeAndSigma(predFwhm) 

64 self.assertAlmostEqual(sigma, SigmaPerFwhm * predFwhm) 

65 

66 if fixedSize is not None: 

67 self.assertEqual(fixedSize, size) 

68 else: 

69 if minSize is not None: 

70 self.assertLessEqual(minSize, size) 

71 if maxSize is not None: 

72 self.assertGreaterEqual(maxSize, size) 

73 if None not in (minSize, maxSize) and minSize < size < maxSize: 

74 self.assertEqual(naiveSize, size) 

75 self.assertEqual(size % 2, 1) 

76 

77 psfModel = factory.apply(fwhm) 

78 if addWing: 

79 self.assertIsInstance(psfModel, DoubleGaussianPsf) 

80 self.assertAlmostEqual(psfModel.getSigma1(), sigma) 

81 self.assertAlmostEqual( 

82 psfModel.getSigma2(), sigma * factory.wingFwhmFactor) 

83 self.assertAlmostEqual(psfModel.getB(), factory.wingAmplitude) 

84 else: 

85 self.assertIsInstance(psfModel, SingleGaussianPsf) 

86 self.assertAlmostEqual(psfModel.getSigma(), sigma) 

87 

88 psfKernel = psfModel.getKernel() 

89 self.assertEqual(size, psfKernel.getHeight()) 

90 self.assertEqual(size, psfKernel.getWidth()) 

91 

92 def testValidate(self): 

93 """Test the validate method and field-by-field validation.""" 

94 # test field-by-field validation 

95 for fieldName in ( 

96 "size", 

97 "sizeFactor", 

98 "minSize", 

99 "maxSize", 

100 "defaultFwhm", 

101 "wingFwhmFactor", 

102 "wingAmplitude", 

103 ): 

104 for value in (-1, 0): 

105 factory = GaussianPsfFactory() 

106 with self.assertRaises(FieldValidationError): 

107 setattr(factory, fieldName, value) 

108 

109 # test the validate method 

110 for fieldName in ("sizeFactor", "defaultFwhm", "addWing", "wingFwhmFactor", "wingAmplitude"): 

111 factory = GaussianPsfFactory() 

112 setattr(factory, fieldName, None) 

113 with self.assertRaises(Exception): 

114 factory.validate() 

115 

116 for minSize in (None, 5, 9): 

117 for maxSize in (None, 3, 7): 

118 factory = GaussianPsfFactory() 

119 factory.minSize = minSize 

120 factory.maxSize = maxSize 

121 if None not in (minSize, maxSize) and maxSize < minSize: 

122 with self.assertRaises(Exception): 

123 factory.validate() 

124 else: 

125 factory.validate() # should not raise 

126 

127 def testMakeField(self): 

128 """Test the makeField method.""" 

129 for addWing in (False, True): 

130 psfConfig = PsfConfig() 

131 psfConfig.psfModel.defaultFwhm = 2.7 

132 psfConfig.psfModel.sizeFactor = 3.0 

133 psfConfig.psfModel.minSize = 1 

134 psfConfig.psfModel.maxSize = None 

135 psfConfig.psfModel.addWing = addWing 

136 psfModel = psfConfig.psfModel.apply() 

137 if addWing: 

138 self.assertIsInstance(psfModel, DoubleGaussianPsf) 

139 self.assertAlmostEqual(psfModel.getSigma1(), SigmaPerFwhm * psfConfig.psfModel.defaultFwhm) 

140 else: 

141 self.assertIsInstance(psfModel, SingleGaussianPsf) 

142 self.assertAlmostEqual(psfModel.getSigma(), SigmaPerFwhm * psfConfig.psfModel.defaultFwhm) 

143 

144 for fwhm in (None, 2.5): 

145 predFwhm = psfConfig.psfModel.defaultFwhm if fwhm is None else fwhm 

146 psfModel = psfConfig.psfModel.apply(fwhm=fwhm) 

147 if addWing: 

148 self.assertIsInstance(psfModel, DoubleGaussianPsf) 

149 self.assertAlmostEqual(psfModel.getSigma1(), SigmaPerFwhm * predFwhm) 

150 else: 

151 self.assertIsInstance(psfModel, SingleGaussianPsf) 

152 self.assertAlmostEqual(psfModel.getSigma(), SigmaPerFwhm * predFwhm) 

153 

154 

155class PsfConfig(Config): 

156 psfModel = GaussianPsfFactory.makeField("PSF model factory") 

157 

158 

159class TestMemory(lsst.utils.tests.MemoryTestCase): 

160 pass 

161 

162 

163def setup_module(module): 

164 lsst.utils.tests.init() 

165 

166 

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

168 lsst.utils.tests.init() 

169 unittest.main()