Coverage for tests/test_extended_psf.py: 16%

94 statements  

« prev     ^ index     » next       coverage.py v7.5.1, created at 2024-05-07 03:40 -0700

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 = [] 

49 for i in range(3): 

50 self.det = extended_psf.DetectorsInRegion() 

51 r0 = 10*i 

52 r1 = 10*(i+1) 

53 self.det.detectors = list(range(r0, r1)) 

54 self.region_detectors.append(self.det) 

55 self.regional_e_psfs = make_extended_psf(3) 

56 

57 def tearDown(self): 

58 del self.default_e_psf 

59 del self.regions 

60 del self.region_detectors 

61 del self.det 

62 del self.regional_e_psfs 

63 

64 def test_constant_psf(self): 

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

66 # a detector ID is given or not. 

67 cons_psf0 = self.constant_e_psf() 

68 cons_psf1 = self.constant_e_psf(detector=11) 

69 self.assertMaskedImagesAlmostEqual(cons_psf0, self.default_e_psf) 

70 self.assertMaskedImagesAlmostEqual(cons_psf1, self.default_e_psf) 

71 

72 def test_regional_psf_addition(self): 

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

74 # extended PSF. 

75 starts_empty_e_psf = extended_psf.ExtendedPsf() 

76 with_default_e_psf = extended_psf.ExtendedPsf(self.default_e_psf) 

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

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

79 # Add a couple of regional PSFs. 

80 for j in range(2): 

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

82 self.region_detectors[j]) 

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

84 self.region_detectors[j]) 

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

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

87 # Ensure we recover the correct regional PSF. 

88 for j in range(2): 

89 for det in self.region_detectors[j].detectors: 

90 # Try it by calling the class directly. 

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

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

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

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

95 # get_extended_psf method. 

96 reg_psf0 = starts_empty_e_psf.get_extended_psf(region_name=det) 

97 reg_psf1 = with_default_e_psf.get_extended_psf(region_name=det) 

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

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

100 # Try it by passing on a region name. 

101 reg_psf0 = starts_empty_e_psf.get_extended_psf(region_name=self.regions[j]) 

102 reg_psf1 = with_default_e_psf.get_extended_psf(region_name=self.regions[j]) 

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

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

105 # Ensure we recover the original default PSF. 

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

107 

108 def test_IO(self): 

109 # Test IO with a constant extended PSF. 

110 with tempfile.NamedTemporaryFile() as f: 

111 self.constant_e_psf.writeFits(f.name) 

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

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

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

115 per_region_e_psf0 = extended_psf.ExtendedPsf(self.default_e_psf) 

116 for j in range(3): 

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

118 self.region_detectors[j]) 

119 with tempfile.NamedTemporaryFile() as f: 

120 per_region_e_psf0.writeFits(f.name) 

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

122 self.assertEqual(per_region_e_psf0.detectors_focal_plane_regions, 

123 read_e_psf0.detectors_focal_plane_regions) 

124 # Check default extended PSF. 

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

126 # And per-region extended PSFs. 

127 for j in range(3): 

128 for det in self.region_detectors[j].detectors: 

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

130 self.assertMaskedImagesAlmostEqual(reg_psf0, read_reg_psf0) 

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

132 per_region_e_psf1 = extended_psf.ExtendedPsf() 

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

134 self.region_detectors[1]) 

135 with tempfile.NamedTemporaryFile() as f: 

136 per_region_e_psf1.writeFits(f.name) 

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

138 self.assertEqual(per_region_e_psf0.detectors_focal_plane_regions, 

139 read_e_psf0.detectors_focal_plane_regions) 

140 for det in self.region_detectors[1].detectors: 

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

142 self.assertMaskedImagesAlmostEqual(reg_psf1, read_reg_psf1) 

143 

144 

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

146 pass 

147 

148 

149def setup_module(module): 

150 lsst.utils.tests.init() 

151 

152 

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

154 lsst.utils.tests.init() 

155 unittest.main()