Coverage for tests/test_buildSingleKernelVisitor.py: 11%

192 statements  

« prev     ^ index     » next       coverage.py v7.3.2, created at 2023-11-01 10:57 +0000

1import unittest 

2 

3 

4import lsst.utils.tests 

5import lsst.afw.image as afwImage 

6import lsst.afw.math as afwMath 

7import lsst.geom as geom 

8import lsst.ip.diffim as ipDiffim 

9import lsst.utils.logging as logUtils 

10import lsst.pex.config as pexConfig 

11 

12logUtils.trace_set_at("lsst.ip.diffim", 4) 

13 

14 

15class DiffimTestCases(unittest.TestCase): 

16 

17 def setUp(self): 

18 self.config = ipDiffim.PsfMatchConfigDF() 

19 

20 self.ps = pexConfig.makePropertySet(self.config) 

21 

22 self.ps["useRegularization"] = False 

23 self.ps["checkConditionNumber"] = False # I am making shady kernels by hand 

24 self.ps["useCoreStats"] = False # I am making off-center resids 

25 self.kList = ipDiffim.makeKernelBasisList(self.config) 

26 self.size = 51 

27 

28 def makeCandidate(self, kSum, x, y): 

29 mi1 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size)) 

30 mi1.getVariance().set(1.0) # avoid NaNs 

31 mi1[self.size//2, self.size//2, afwImage.LOCAL] = (1, 0x0, 1) 

32 mi2 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size)) 

33 mi2.getVariance().set(1.0) # avoid NaNs 

34 mi2[self.size//2, self.size//2, afwImage.LOCAL] = (kSum, 0x0, kSum) 

35 kc = ipDiffim.makeKernelCandidate(x, y, mi1, mi2, self.ps) 

36 

37 return kc 

38 

39 def testWithOneBasis(self): 

40 self.runWithOneBasis(False) 

41 self.runWithOneBasis(True) 

42 

43 def runWithOneBasis(self, useRegularization): 

44 kc1 = self.makeCandidate(1, 0.0, 0.0) 

45 kc2 = self.makeCandidate(2, 0.0, 0.0) 

46 kc3 = self.makeCandidate(3, 0.0, 0.0) 

47 

48 if useRegularization: 

49 hMat = ipDiffim.makeRegularizationMatrix(self.ps) 

50 bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps, hMat) 

51 else: 

52 bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

53 

54 bskv.processCandidate(kc1) 

55 bskv.processCandidate(kc2) 

56 bskv.processCandidate(kc3) 

57 

58 # Initialized 

59 self.assertEqual(kc1.isInitialized(), True) 

60 self.assertEqual(kc2.isInitialized(), True) 

61 self.assertEqual(kc3.isInitialized(), True) 

62 

63 # Is a solution 

64 try: 

65 kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT) 

66 kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT) 

67 kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT) 

68 except Exception as e: 

69 print(e) 

70 self.fail() 

71 

72 # Its not the Pca one 

73 try: 

74 kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA) 

75 kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA) 

76 kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA) 

77 except Exception: 

78 pass 

79 else: 

80 self.fail() 

81 

82 # Processed all of them 

83 self.assertEqual(bskv.getNProcessed(), 3) 

84 

85 # Rejected none 

86 self.assertEqual(bskv.getNRejected(), 0) 

87 

88 # Skips built candidates 

89 bskv.reset() 

90 bskv.setSkipBuilt(True) 

91 bskv.processCandidate(kc1) 

92 bskv.processCandidate(kc2) 

93 bskv.processCandidate(kc3) 

94 # Processed none of them 

95 self.assertEqual(bskv.getNProcessed(), 0) 

96 

97 def testWithThreeBases(self): 

98 kc1 = self.makeCandidate(1, 0.0, 0.0) 

99 kc2 = self.makeCandidate(2, 0.0, 0.0) 

100 kc3 = self.makeCandidate(3, 0.0, 0.0) 

101 bskv1 = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

102 bskv1.processCandidate(kc1) 

103 bskv1.processCandidate(kc2) 

104 bskv1.processCandidate(kc3) 

105 self.assertEqual(bskv1.getNProcessed(), 3) 

106 

107 # make sure orig solution is the current one 

108 soln1_1 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId() 

109 soln2_1 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId() 

110 soln3_1 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId() 

111 self.assertEqual(soln1_1, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

112 self.assertEqual(soln2_1, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

113 self.assertEqual(soln3_1, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

114 

115 # do pca basis; visit manually since visitCandidates is still broken 

116 imagePca = ipDiffim.KernelPcaD() 

117 kpv = ipDiffim.KernelPcaVisitorF(imagePca) 

118 kpv.processCandidate(kc1) 

119 kpv.processCandidate(kc2) 

120 kpv.processCandidate(kc3) 

121 kpv.subtractMean() 

122 imagePca.analyze() 

123 eigenKernels = [] 

124 eigenKernels.append(kpv.getEigenKernels()[0]) 

125 self.assertEqual(len(eigenKernels), 1) # the other eKernels are 0.0 and you can't get their coeffs! 

126 

127 # do twice to mimic a Pca loop 

128 bskv2 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.ps) 

129 bskv2.setSkipBuilt(False) 

130 bskv2.processCandidate(kc1) 

131 bskv2.processCandidate(kc2) 

132 bskv2.processCandidate(kc3) 

133 self.assertEqual(bskv2.getNProcessed(), 3) 

134 

135 soln1_2 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

136 soln2_2 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

137 soln3_2 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

138 # pca is recent 

139 self.assertEqual(soln1_2, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

140 self.assertEqual(soln2_2, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

141 self.assertEqual(soln3_2, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

142 # orig is still orig 

143 self.assertEqual(soln1_1, kc1.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()) 

144 self.assertEqual(soln2_1, kc2.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()) 

145 self.assertEqual(soln3_1, kc3.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()) 

146 # pca is not orig 

147 self.assertNotEqual(soln1_2, soln1_1) 

148 self.assertNotEqual(soln2_2, soln2_1) 

149 self.assertNotEqual(soln3_2, soln3_1) 

150 

151 # do twice to mimic a Pca loop 

152 bskv3 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.ps) 

153 bskv3.setSkipBuilt(False) 

154 bskv3.processCandidate(kc1) 

155 bskv3.processCandidate(kc2) 

156 bskv3.processCandidate(kc3) 

157 self.assertEqual(bskv3.getNProcessed(), 3) 

158 

159 soln1_3 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

160 soln2_3 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

161 soln3_3 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId() 

162 # pca is recent 

163 self.assertEqual(soln1_3, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

164 self.assertEqual(soln2_3, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

165 self.assertEqual(soln3_3, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId()) 

166 # pca is not previous pca 

167 self.assertNotEqual(soln1_2, soln1_3) 

168 self.assertNotEqual(soln2_2, soln2_3) 

169 self.assertNotEqual(soln3_2, soln3_3) 

170 

171 def testRejection(self): 

172 # we need to construct a candidate whose shape does not 

173 # match the underlying basis 

174 # 

175 # so lets just make a kernel list with all the power in 

176 # the center, but the candidate requires some off center 

177 # power 

178 kc1 = self.makeCandidate(1, 0.0, 0.0) 

179 kc2 = self.makeCandidate(2, 0.0, 0.0) 

180 kc3 = self.makeCandidate(3, 0.0, 0.0) 

181 bskv1 = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

182 bskv1.processCandidate(kc1) 

183 bskv1.processCandidate(kc2) 

184 bskv1.processCandidate(kc3) 

185 

186 imagePca = ipDiffim.KernelPcaD() 

187 kpv = ipDiffim.KernelPcaVisitorF(imagePca) 

188 kpv.processCandidate(kc1) 

189 kpv.processCandidate(kc2) 

190 kpv.processCandidate(kc3) 

191 kpv.subtractMean() 

192 imagePca.analyze() 

193 eigenKernels = [] 

194 eigenKernels.append(kpv.getEigenKernels()[0]) 

195 self.assertEqual(len(eigenKernels), 1) 

196 

197 # bogus candidate 

198 mi1 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size)) 

199 mi1.getVariance().set(0.1) 

200 mi1[self.size//2, self.size//2, afwImage.LOCAL] = (1, 0x0, 1) 

201 mi2 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size)) 

202 mi2.getVariance().set(0.1) 

203 # make it high enough to make the mean resids large 

204 mi2[self.size//3, self.size//3, afwImage.LOCAL] = (self.size**2, 0x0, 1) 

205 kc4 = ipDiffim.makeKernelCandidate(0, 0, mi1, mi2, self.ps) 

206 self.assertEqual(kc4.getStatus(), afwMath.SpatialCellCandidate.UNKNOWN) 

207 

208 # process with eigenKernels 

209 bskv2 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.ps) 

210 bskv2.setSkipBuilt(False) 

211 bskv2.processCandidate(kc1) 

212 bskv2.processCandidate(kc2) 

213 bskv2.processCandidate(kc3) 

214 bskv2.processCandidate(kc4) 

215 

216 self.assertEqual(bskv2.getNProcessed(), 4) 

217 self.assertEqual(bskv2.getNRejected(), 1) 

218 

219 self.assertEqual(kc1.getStatus(), afwMath.SpatialCellCandidate.GOOD) 

220 self.assertEqual(kc2.getStatus(), afwMath.SpatialCellCandidate.GOOD) 

221 self.assertEqual(kc3.getStatus(), afwMath.SpatialCellCandidate.GOOD) 

222 self.assertEqual(kc4.getStatus(), afwMath.SpatialCellCandidate.BAD) 

223 

224 def testVisit(self, nCell=3): 

225 bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

226 

227 sizeCellX = self.ps["sizeCellX"] 

228 sizeCellY = self.ps["sizeCellY"] 

229 

230 kernelCellSet = afwMath.SpatialCellSet(geom.Box2I(geom.Point2I(0, 0), 

231 geom.Extent2I(sizeCellX * nCell, 

232 sizeCellY * nCell)), 

233 sizeCellX, 

234 sizeCellY) 

235 nTot = 0 

236 for candX in range(nCell): 

237 for candY in range(nCell): 

238 if candX == nCell // 2 and candY == nCell // 2: 

239 kc = self.makeCandidate(100.0, 

240 candX * sizeCellX + sizeCellX // 2, 

241 candY * sizeCellY + sizeCellY // 2) 

242 else: 

243 kc = self.makeCandidate(1.0, 

244 candX * sizeCellX + sizeCellX // 2, 

245 candY * sizeCellY + sizeCellY // 2) 

246 kernelCellSet.insertCandidate(kc) 

247 nTot += 1 

248 

249 kernelCellSet.visitCandidates(bskv, 1) 

250 self.assertEqual(bskv.getNProcessed(), nTot) 

251 self.assertEqual(bskv.getNRejected(), 0) 

252 

253 for cell in kernelCellSet.getCellList(): 

254 for cand in cell.begin(False): 

255 self.assertEqual(cand.getStatus(), afwMath.SpatialCellCandidate.GOOD) 

256 

257 def tearDown(self): 

258 del self.config 

259 del self.ps 

260 del self.kList 

261 

262 

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

264 pass 

265 

266 

267def setup_module(module): 

268 lsst.utils.tests.init() 

269 

270 

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

272 lsst.utils.tests.init() 

273 unittest.main()