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

52 statements  

« prev     ^ index     » next       coverage.py v7.4.1, created at 2024-02-06 12:37 +0000

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 FlagSelector, ParentObjectSelector, ThresholdSelector 

27from ..interfaces import AnalysisTool 

28 

29 

30class ParentDeblenderMetrics(AnalysisTool): 

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

32 

33 def setDefaults(self): 

34 super().setDefaults() 

35 

36 # Only select parents 

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

38 

39 # Statistics for parent blends 

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

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

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

43 

44 # Total number of detected peaks 

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

46 # Total number of deblended children 

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

48 

49 self.produce.metric.units = { 

50 "numParents": "", 

51 "numDeblendFailed": "", 

52 "numIncompleteData": "", 

53 "numDetectedPeaks": "", 

54 "numDeblendedChildren": "", 

55 } 

56 

57 

58class SkippedDeblenderMetrics(AnalysisTool): 

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

60 

61 def setDefaults(self): 

62 super().setDefaults() 

63 

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

65 # This also excludes isolated objects that were skipped 

66 # if isolated objects are not being deblended 

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

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

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

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

71 

72 # Statistics for skipped blends 

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

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

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

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

77 

78 # Total number of skipped peaks 

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

80 

81 self.produce.metric.units = { 

82 "numSkippedBlends": "", 

83 "numBlendParentTooBig": "", 

84 "numBlendTooManyPeaks": "", 

85 "numBlendTooManyMasked": "", 

86 "numSkippedPeaks": "", 

87 } 

88 

89 

90class BlendMetrics(AnalysisTool): 

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

92 with multiple children 

93 """ 

94 

95 def setDefaults(self): 

96 super().setDefaults() 

97 

98 # Only select parents that were successfully deblended 

99 # with more than one child 

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

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

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

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

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

105 

106 # Statistics for blended parents 

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

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

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

110 

111 self.produce.metric.units = { 

112 "numBlends": "", 

113 "meanBlendIterations": "", 

114 "meanBlendLogL": "", 

115 } 

116 

117 

118class IsolatedDeblenderMetrics(AnalysisTool): 

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

120 parents with only a single child peak. 

121 """ 

122 

123 def setDefaults(self): 

124 super().setDefaults() 

125 

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

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

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

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

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

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

132 

133 # Statistics for isolated parent scarlet_lite models 

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

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

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

137 

138 self.produce.metric.units = { 

139 "numIsolated": "", 

140 "meanIsolatedIterations": "", 

141 "meanIsolatedLogL": "", 

142 }