Coverage for tests/test_extended_psf.py: 17%

87 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-06-23 10:59 +0000

1# This file is part of pipe_tasks. 

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 

23import numpy as np 

24import tempfile 

25 

26from lsst.afw import image as afwImage 

27from lsst.pipe.tasks import extended_psf 

28import lsst.utils.tests 

29 

30np.random.seed(51778) 

31 

32 

33def make_extended_psf(n_extended_psf=1): 

34 e_psf_images = [afwImage.MaskedImageF(25, 25) for _ in range(n_extended_psf)] 

35 for e_psf_im in e_psf_images: 

36 e_psf_im.image.array += np.random.rand(25, 25) 

37 e_psf_im.mask.array += np.random.choice(3, size=(25, 25)) 

38 return e_psf_images 

39 

40 

41class ExtendedPsfTestCase(lsst.utils.tests.TestCase): 

42 """Test ExtendedPsf. 

43 """ 

44 def setUp(self): 

45 self.default_e_psf = make_extended_psf(1)[0] 

46 self.constant_e_psf = extended_psf.ExtendedPsf(self.default_e_psf) 

47 self.regions = ["NW", "SW", "E"] 

48 self.region_detectors = [list(range(10)), list(range(10, 20)), list(range(20, 40))] 

49 self.regional_e_psfs = make_extended_psf(3) 

50 

51 def tearDown(self): 

52 del self.default_e_psf 

53 del self.regions 

54 del self.region_detectors 

55 del self.regional_e_psfs 

56 

57 def test_constant_psf(self): 

58 # When calling a constant ExtendedPsf, the same PSF is returned whether 

59 # a detector ID is given or not. 

60 cons_psf0 = self.constant_e_psf() 

61 cons_psf1 = self.constant_e_psf(detector=11) 

62 self.assertMaskedImagesAlmostEqual(cons_psf0, self.default_e_psf) 

63 self.assertMaskedImagesAlmostEqual(cons_psf1, self.default_e_psf) 

64 

65 def test_regional_psf_addition(self): 

66 # Start with either an empty instance, or one containing a default 

67 # extended PSF. 

68 starts_empty_e_psf = extended_psf.ExtendedPsf() 

69 with_default_e_psf = extended_psf.ExtendedPsf(self.default_e_psf) 

70 self.assertEqual(len(starts_empty_e_psf), 0) 

71 self.assertEqual(len(with_default_e_psf), 1) 

72 # Add a couple of regional PSFs. 

73 for j in range(2): 

74 starts_empty_e_psf.add_regional_extended_psf(self.regional_e_psfs[j], self.regions[j], 

75 self.region_detectors[j]) 

76 with_default_e_psf.add_regional_extended_psf(self.regional_e_psfs[j], self.regions[j], 

77 self.region_detectors[j]) 

78 self.assertEqual(len(starts_empty_e_psf), 2) 

79 self.assertEqual(len(with_default_e_psf), 3) 

80 # Ensure we recover the correct regional PSF. 

81 for j in range(2): 

82 for det in self.region_detectors[j]: 

83 # Try it by calling the class directly. 

84 reg_psf0, reg_psf1 = starts_empty_e_psf(det), with_default_e_psf(det) 

85 self.assertMaskedImagesAlmostEqual(reg_psf0, self.regional_e_psfs[j]) 

86 self.assertMaskedImagesAlmostEqual(reg_psf1, self.regional_e_psfs[j]) 

87 # Try it by passing on a detector number to the 

88 # get_regional_extended_psf method. 

89 reg_psf0 = starts_empty_e_psf.get_regional_extended_psf(detector=det) 

90 reg_psf1 = with_default_e_psf.get_regional_extended_psf(detector=det) 

91 self.assertMaskedImagesAlmostEqual(reg_psf0, self.regional_e_psfs[j]) 

92 self.assertMaskedImagesAlmostEqual(reg_psf1, self.regional_e_psfs[j]) 

93 # Try it by passing on a region name. 

94 reg_psf0 = starts_empty_e_psf.get_regional_extended_psf(region_name=self.regions[j]) 

95 reg_psf1 = with_default_e_psf.get_regional_extended_psf(region_name=self.regions[j]) 

96 self.assertMaskedImagesAlmostEqual(reg_psf0, self.regional_e_psfs[j]) 

97 self.assertMaskedImagesAlmostEqual(reg_psf1, self.regional_e_psfs[j]) 

98 # Ensure we recover the original default PSF. 

99 self.assertMaskedImagesAlmostEqual(with_default_e_psf(), self.default_e_psf) 

100 

101 def test_IO(self): 

102 # Test IO with a constant extended PSF. 

103 with tempfile.NamedTemporaryFile() as f: 

104 self.constant_e_psf.writeFits(f.name) 

105 read_e_psf = extended_psf.ExtendedPsf.readFits(f.name) 

106 self.assertMaskedImagesAlmostEqual(self.constant_e_psf(), read_e_psf()) 

107 # Test IO with per-region extended PSFs (with default). 

108 per_region_e_psf0 = extended_psf.ExtendedPsf(self.default_e_psf) 

109 for j in range(3): 

110 per_region_e_psf0.add_regional_extended_psf(self.regional_e_psfs[j], self.regions[j], 

111 self.region_detectors[j]) 

112 with tempfile.NamedTemporaryFile() as f: 

113 per_region_e_psf0.writeFits(f.name) 

114 read_e_psf0 = extended_psf.ExtendedPsf.readFits(f.name) 

115 self.assertEqual(per_region_e_psf0.detectors_focal_plane_regions, 

116 read_e_psf0.detectors_focal_plane_regions) 

117 # Check default extended PSF. 

118 self.assertMaskedImagesAlmostEqual(per_region_e_psf0(), read_e_psf0()) 

119 # And per-region extended PSFs. 

120 for j in range(3): 

121 for det in self.region_detectors[j]: 

122 reg_psf0, read_reg_psf0 = per_region_e_psf0(det), read_e_psf0(det) 

123 self.assertMaskedImagesAlmostEqual(reg_psf0, read_reg_psf0) 

124 # Test IO with a single per-region extended PSF. 

125 per_region_e_psf1 = extended_psf.ExtendedPsf() 

126 per_region_e_psf1.add_regional_extended_psf(self.regional_e_psfs[1], self.regions[1], 

127 self.region_detectors[1]) 

128 with tempfile.NamedTemporaryFile() as f: 

129 per_region_e_psf1.writeFits(f.name) 

130 read_e_psf1 = extended_psf.ExtendedPsf.readFits(f.name) 

131 self.assertEqual(per_region_e_psf0.detectors_focal_plane_regions, 

132 read_e_psf0.detectors_focal_plane_regions) 

133 for det in self.region_detectors[1]: 

134 reg_psf1, read_reg_psf1 = per_region_e_psf1(det), read_e_psf1(det) 

135 self.assertMaskedImagesAlmostEqual(reg_psf1, read_reg_psf1) 

136 

137 

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

139 pass 

140 

141 

142def setup_module(module): 

143 lsst.utils.tests.init() 

144 

145 

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

147 lsst.utils.tests.init() 

148 unittest.main()