Coverage for python/lsst/analysis/tools/atools/deblenderMetric.py: 26%

58 statements  

« prev     ^ index     » next       coverage.py v7.4.4, created at 2024-03-28 04:17 -0700

1# This file is part of analysis_tools. 

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/>. 

21from __future__ import annotations 

22 

23__all__ = ("ParentDeblenderMetrics", "SkippedDeblenderMetrics", "BlendMetrics", "IsolatedDeblenderMetrics") 

24 

25from ..actions.scalar.scalarActions import CountAction, MeanAction, SumAction 

26from ..actions.vector.selectors import ( 

27 ChildObjectSelector, 

28 FlagSelector, 

29 ParentObjectSelector, 

30 ThresholdSelector, 

31) 

32from ..interfaces import AnalysisTool 

33 

34 

35class ParentDeblenderMetrics(AnalysisTool): 

36 """Calculate metrics based on the performance of the deblender""" 

37 

38 def setDefaults(self): 

39 super().setDefaults() 

40 

41 # Only select parents 

42 self.prep.selectors.parentSelector = ParentObjectSelector() 

43 

44 # Statistics for parent blends 

45 self.process.calculateActions.numParents = CountAction(vectorKey="parentObjectId") 

46 self.process.calculateActions.numDeblendFailed = SumAction(vectorKey="deblend_failed") 

47 self.process.calculateActions.numIncompleteData = SumAction(vectorKey="deblend_incompleteData") 

48 

49 # Total number of detected peaks 

50 self.process.calculateActions.numDetectedPeaks = SumAction(vectorKey="deblend_nPeaks") 

51 # Total number of deblended children 

52 self.process.calculateActions.numDeblendedChildren = SumAction(vectorKey="deblend_nChild") 

53 

54 self.produce.metric.units = { 

55 "numParents": "", 

56 "numDeblendFailed": "", 

57 "numIncompleteData": "", 

58 "numDetectedPeaks": "", 

59 "numDeblendedChildren": "", 

60 } 

61 

62 

63class SkippedDeblenderMetrics(AnalysisTool): 

64 """Calculate metrics based on blends skipped by the deblender""" 

65 

66 def setDefaults(self): 

67 super().setDefaults() 

68 

69 # Only select non-sky object parents that were skipped but did not fail 

70 # This also excludes isolated objects that were skipped 

71 # if isolated objects are not being deblended 

72 self.prep.selectors.parentSelector = ParentObjectSelector() 

73 self.prep.selectors.skippedSelector = FlagSelector() 

74 self.prep.selectors.skippedSelector.selectWhenTrue = ["deblend_skipped"] 

75 self.prep.selectors.skippedSelector.selectWhenFalse = ["deblend_failed", "deblend_isolatedParent"] 

76 

77 # Statistics for skipped blends 

78 self.process.calculateActions.numSkippedBlends = CountAction(vectorKey="parentObjectId") 

79 self.process.calculateActions.numBlendParentTooBig = SumAction(vectorKey="deblend_parentTooBig") 

80 self.process.calculateActions.numBlendTooManyPeaks = SumAction(vectorKey="deblend_tooManyPeaks") 

81 self.process.calculateActions.numBlendTooManyMasked = SumAction(vectorKey="deblend_masked") 

82 

83 # Total number of skipped peaks 

84 self.process.calculateActions.numSkippedPeaks = SumAction(vectorKey="deblend_nPeaks") 

85 

86 self.produce.metric.units = { 

87 "numSkippedBlends": "", 

88 "numBlendParentTooBig": "", 

89 "numBlendTooManyPeaks": "", 

90 "numBlendTooManyMasked": "", 

91 "numSkippedPeaks": "", 

92 } 

93 

94 

95class BlendMetrics(AnalysisTool): 

96 """Calculate metrics based on the performance of the deblender for blends 

97 with multiple children 

98 """ 

99 

100 def setDefaults(self): 

101 super().setDefaults() 

102 

103 # Only select parents that were successfully deblended 

104 # with more than one child 

105 self.prep.selectors.parentSelector = ParentObjectSelector() 

106 self.prep.selectors.blendSelector = ThresholdSelector() 

107 self.prep.selectors.blendSelector.vectorKey = "deblend_nChild" 

108 self.prep.selectors.blendSelector.op = "gt" 

109 self.prep.selectors.blendSelector.threshold = 1 

110 

111 # Statistics for blended parents 

112 self.process.calculateActions.numBlends = CountAction(vectorKey="parentObjectId") 

113 self.process.calculateActions.meanBlendIterations = MeanAction(vectorKey="deblend_iterations") 

114 self.process.calculateActions.meanBlendLogL = MeanAction(vectorKey="deblend_logL") 

115 

116 self.produce.metric.units = { 

117 "numBlends": "", 

118 "meanBlendIterations": "", 

119 "meanBlendLogL": "", 

120 } 

121 

122 

123class IsolatedDeblenderMetrics(AnalysisTool): 

124 """Calculate metrics based on the performance of the deblender for 

125 parents with only a single child peak. 

126 """ 

127 

128 def setDefaults(self): 

129 super().setDefaults() 

130 

131 # Only select parents that were successfully deblended with one child 

132 self.prep.selectors.parentSelector = ParentObjectSelector() 

133 self.prep.selectors.blendSelector = ThresholdSelector() 

134 self.prep.selectors.blendSelector.vectorKey = "deblend_nChild" 

135 self.prep.selectors.blendSelector.op = "eq" 

136 self.prep.selectors.blendSelector.threshold = 1 

137 

138 # Statistics for isolated parent scarlet_lite models 

139 self.process.calculateActions.numIsolated = CountAction(vectorKey="parentObjectId") 

140 self.process.calculateActions.meanIsolatedIterations = MeanAction(vectorKey="deblend_iterations") 

141 self.process.calculateActions.meanIsolatedLogL = MeanAction(vectorKey="deblend_logL") 

142 

143 self.produce.metric.units = { 

144 "numIsolated": "", 

145 "meanIsolatedIterations": "", 

146 "meanIsolatedLogL": "", 

147 } 

148 

149 

150class ChildDeblenderMetrics(AnalysisTool): 

151 """Calculate metrics based on the performance of the deblender for 

152 single sources. 

153 """ 

154 

155 def setDefaults(self): 

156 super().setDefaults() 

157 self.prep.selectors.childSelector = ChildObjectSelector() 

158 self.process.calculateActions.zeroFlux = SumAction(vectorKey="deblend_zeroFlux") 

159 

160 self.produce.metric.units = { 

161 "zeroFlux": "", 

162 }