Coverage for python/lsst/analysis/tools/analysisMetrics/analysisMetrics.py: 29%

114 statements  

« prev     ^ index     » next       coverage.py v6.4.4, created at 2022-08-18 12:39 -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__ = ( 

24 "StellarLocusBaseMetric", 

25 "WPerpPSFMetric", 

26) 

27 

28from ..actions.keyedData.stellarLocusFit import StellarLocusFitAction 

29from ..actions.scalar.scalarActions import ApproxFloor 

30from ..actions.vector import ( 

31 CoaddPlotFlagSelector, 

32 ExtinctionCorrectedMagDiff, 

33 MagColumnNanoJansky, 

34 SnSelector, 

35 StarSelector, 

36) 

37from ..interfaces import AnalysisMetric 

38 

39 

40class StellarLocusBaseMetric(AnalysisMetric): 

41 # Use this as the Base Class for now StellarLocusBaseMetric 

42 parameterizedBand: bool = False 

43 

44 def setDefaults(self): 

45 super().setDefaults() 

46 self.prep.selectors.flagSelector = CoaddPlotFlagSelector() 

47 

48 self.prep.selectors.snSelector = SnSelector() 

49 self.prep.selectors.snSelector.threshold = 300 

50 

51 self.prep.selectors.starSelector = StarSelector() 

52 

53 self.process.buildActions.x = ExtinctionCorrectedMagDiff() 

54 self.process.buildActions.x.magDiff.returnMillimags = False 

55 self.process.buildActions.y = ExtinctionCorrectedMagDiff() 

56 self.process.buildActions.y.magDiff.returnMillimags = False 

57 

58 

59class GRIStellarPSFMetric(AnalysisMetric): 

60 # Use this as the Base Class for now StellarLocusBaseMetric 

61 parameterizedBand: bool = False 

62 fluxType: str = "psfFlux" 

63 

64 def setDefaults(self): 

65 super().setDefaults() 

66 self.prep.selectors.flagSelector = CoaddPlotFlagSelector() 

67 self.prep.selectors.flagSelector.bands = ["g", "r", "i"] 

68 

69 self.prep.selectors.snSelector = SnSelector() 

70 self.prep.selectors.snSelector.fluxType = "{band}_" + self.fluxType 

71 self.prep.selectors.snSelector.threshold = 300 

72 self.prep.selectors.snSelector.bands = ["r"] 

73 

74 self.prep.selectors.starSelector = StarSelector() 

75 self.prep.selectors.starSelector.vectorKey = "r_extendedness" 

76 

77 self.process.buildActions.x = ExtinctionCorrectedMagDiff() 

78 self.process.buildActions.x.magDiff.col1 = f"g_{self.fluxType}" 

79 self.process.buildActions.x.magDiff.col2 = f"r_{self.fluxType}" 

80 self.process.buildActions.x.magDiff.returnMillimags = False 

81 self.process.buildActions.y = ExtinctionCorrectedMagDiff() 

82 self.process.buildActions.y.magDiff.col1 = f"r_{self.fluxType}" 

83 self.process.buildActions.y.magDiff.col2 = f"i_{self.fluxType}" 

84 self.process.buildActions.y.magDiff.returnMillimags = False 

85 self.process.buildActions.mag = MagColumnNanoJansky(vectorKey="r_psfFlux") 

86 

87 self.process.calculateActions.approxMagDepth = ApproxFloor(vectorKey="mag") 

88 self.process.calculateActions.wPerp_psfFlux = StellarLocusFitAction() 

89 self.process.calculateActions.wPerp_psfFlux.stellarLocusFitDict = { 

90 "xMin": 0.28, 

91 "xMax": 1.0, 

92 "yMin": 0.02, 

93 "yMax": 0.48, 

94 "mHW": 0.52, 

95 "bHW": -0.08, 

96 } 

97 

98 # self.process.calculateActions.xPerp = StellarLocusFitAction() 

99 # self.process.calculateActions.xPerp.stellarLocusFitDict = {} 

100 

101 self.produce.units = { # type: ignore 

102 "wPerp_psfFlux_sigmaMAD": "mag", # TODO need to return mmag from wPerp 

103 } 

104 

105 

106# "xPerp_sigmaMAD": "mag", # TODO need to return mmag from wPerp 

107 

108 

109class GRIStellarCModelMetric(GRIStellarPSFMetric): 

110 fluxType: str = "CModel" 

111 

112 def setDefaults(self): 

113 super().setDefaults() 

114 

115 self.produce.newNames = { 

116 "wPerp_sigmaMAD": "wCmodelPerp_sigmaMAD", # TODO need to return mmag from wPerp 

117 "xPerp_sigmaMAD": "xCmodelPerp_sigmaMAD", # TODO need to return mmag from wPerp 

118 } 

119 

120 

121class RIZStellarPSFMetric(AnalysisMetric): 

122 # Use this as the Base Class for now StellarLocusBaseMetric 

123 parameterizedBand: bool = False 

124 

125 def setDefaults(self): 

126 super().setDefaults() 

127 self.prep.selectors.flagSelector = CoaddPlotFlagSelector() 

128 self.prep.selectors.flagSelector.bands = ["r", "i", "z"] 

129 

130 self.prep.selectors.snSelector = SnSelector() 

131 self.prep.selectors.snSelector.fluxType = "psfFlux" 

132 self.prep.selectors.snSelector.threshold = 300 

133 self.prep.selectors.snSelector.bands = ["i"] 

134 

135 self.prep.selectors.starSelector = StarSelector() 

136 

137 self.process.buildActions.x = ExtinctionCorrectedMagDiff() 

138 self.process.buildActions.x.magDiff.col1 = "r_psfFlux" 

139 self.process.buildActions.x.magDiff.col2 = "i_psfFlux" 

140 self.process.buildActions.x.magDiff.returnMillimags = False 

141 self.process.buildActions.y = ExtinctionCorrectedMagDiff() 

142 self.process.buildActions.y.magDiff.col1 = "i_psfFlux" 

143 self.process.buildActions.y.magDiff.col2 = "z_psfFlux" 

144 self.process.buildActions.y.magDiff.returnMillimags = False 

145 

146 self.process.calculateActions.yPerp = StellarLocusFitAction() 

147 self.process.calculateActions.yerp.stellarLocusFitDict = {} 

148 

149 self.produce.units = { # type: ignore 

150 "yPerp_sigmaMAD": "mag", # TODO need to return mmag from wPerp 

151 } 

152 

153 

154class WPerpPSFMetric(AnalysisMetric): 

155 # Use this as the Base Class for now StellarLocusBaseMetric 

156 parameterizedBand: bool = False 

157 

158 def setDefaults(self): 

159 super().setDefaults() 

160 self.prep.selectors.flagSelector = CoaddPlotFlagSelector() 

161 self.prep.selectors.flagSelector.bands = ["g", "r", "i"] 

162 

163 self.prep.selectors.snSelector = SnSelector() 

164 self.prep.selectors.snSelector.fluxType = "psfFlux" 

165 self.prep.selectors.snSelector.threshold = 300 

166 self.prep.selectors.snSelector.bands = ["r"] 

167 

168 self.prep.selectors.starSelector = StarSelector() 

169 

170 self.process.buildActions.x = ExtinctionCorrectedMagDiff() 

171 self.process.buildActions.x.magDiff.col1 = "g_psfFlux" 

172 self.process.buildActions.x.magDiff.col2 = "r_psfFlux" 

173 self.process.buildActions.x.magDiff.returnMillimags = False 

174 self.process.buildActions.y = ExtinctionCorrectedMagDiff() 

175 self.process.buildActions.y.magDiff.col1 = "r_psfFlux" 

176 self.process.buildActions.y.magDiff.col2 = "i_psfFlux" 

177 self.process.buildActions.y.magDiff.returnMillimags = False 

178 

179 self.process.calculateActions.wPerp = StellarLocusFitAction() 

180 self.process.calculateActions.wPerp.stellarLocusFitDict = { 

181 "xMin": 0.28, 

182 "xMax": 1.0, 

183 "yMin": 0.02, 

184 "yMax": 0.48, 

185 "mHW": 0.52, 

186 "bHW": -0.08, 

187 } 

188 self.produce.units = { # type: ignore 

189 "wPerp_sigmaMAD": "mag", # TODO need to return mmag from wPerp 

190 } 

191 

192 

193class XPerpPSFMetric(AnalysisMetric): 

194 parameterizedBand: bool = False 

195 

196 def setDefaults(self): 

197 super().setDefaults() 

198 self.prep.selectors.flagSelector = CoaddPlotFlagSelector() 

199 self.prep.selectors.flagSelector.bands = ["g", "r", "i"] 

200 

201 self.prep.selectors.snSelector = SnSelector() 

202 self.prep.selectors.snSelector.fluxType = "psfFlux" 

203 self.prep.selectors.snSelector.threshold = 300 

204 self.prep.selectors.snSelector.bands = ["r"] 

205 

206 self.prep.selectors.starSelector = StarSelector() 

207 

208 self.process.buildActions.x = ExtinctionCorrectedMagDiff() 

209 self.process.buildActions.x.magDiff.col1 = "g_psfFlux" 

210 self.process.buildActions.x.magDiff.col2 = "r_psfFlux" 

211 self.process.buildActions.x.magDiff.returnMillimags = False 

212 self.process.buildActions.y = ExtinctionCorrectedMagDiff() 

213 self.process.buildActions.y.magDiff.col1 = "r_psfFlux" 

214 self.process.buildActions.y.magDiff.col2 = "i_psfFlux" 

215 self.process.buildActions.y.magDiff.returnMillimags = False 

216 

217 self.process.calculateActions.xPerp = StellarLocusFitAction() 

218 

219 self.produce.units = { # type: ignore 

220 "wPerp_sigmaMAD": "mag", # TODO need to return mmag from wPerp 

221 }