Coverage for tests/test_deferredCharge.py: 24%

2# LSST Data Management System

6# This product includes software developed by the

7# LSST Project (http://www.lsst.org/).

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 LSST License Statement and

20# the GNU General Public License along with this program. If not,

21# see <https://www.lsstcorp.org/LegalNotices/>.

22#

23"""Test cases for lsst.cp.pipe.deferredCharge."""

25import unittest

26import numpy

28import lsst.utils

29import lsst.utils.tests

31import lsst.cp.pipe as cpPipe

32from lsst.ip.isr import IsrMock, PhotonTransferCurveDataset

35class CpCtiSolveTaskTestCase(lsst.utils.tests.TestCase):

36 """A test case for the deferred charge/CTI solve task."""

38 def setUp(self):

39 self.camera = IsrMock().getCamera()

41 serialOscanMeansA = [

42 7.18039751e-01, 4.56550479e-01, 4.14261669e-01, 2.88099229e-01, -2.34310962e-02,

43 -4.59854975e-02, -1.14491098e-02, 5.19846082e-02, 2.05635265e-01, 1.25147207e-02,

44 9.00449380e-02, -2.39106059e-01, -1.52413145e-01, 4.63459678e-02, 1.85195580e-01,

45 -1.58051759e-01, -8.76842241e-04, -5.09192124e-02, 2.58496821e-01, 2.54267782e-01,

46 -1.37611866e-01, 3.35322201e-01, 1.04846083e-01, -2.16551736e-01, -8.82746354e-02,

47 -1.00256450e-01, 2.73297966e-01, -4.52805981e-02, 3.40960979e-01, 7.80628920e-02,

48 -2.90697180e-02, -6.99492991e-02, -1.06599867e-01, 6.89002723e-02, 1.46290688e-02,

49 1.19647197e-01, -1.54527843e-01, 9.35689881e-02, -1.06599934e-01, -2.13166289e-02,

50 9.35688764e-02, -1.19286761e-01, 1.18098985e-02, -3.69616691e-03, -6.14914447e-02,

51 -5.81059000e-03, 9.42736641e-02, 3.92978266e-02, -1.55937240e-01, 3.76202404e-01,

52 -1.13648064e-01, 1.71803936e-01, 6.17138995e-03, 8.22918862e-02, -2.84214199e-01,

53 -2.99097435e-03, -1.31973490e-01, -2.84214795e-01, -2.99140741e-03, -3.76546055e-01,

54 5.97376414e-02, -1.91883057e-01, -1.34087920e-01, -3.23684871e-01,

55 ]

56 serialOscanMeansB = [

57 1.50365152e+01, 4.43178511e+00, 2.66550946e+00, 1.67382801e+00, 1.10997069e+00,

58 8.89361799e-01, 4.66469795e-01, 6.10956728e-01, 6.67343795e-01, 5.22854805e-01,

59 -1.15006611e-01, 2.67710119e-01, 2.05686077e-01, 1.84541523e-01, 8.65717679e-02,

60 5.51738311e-03, 2.35288814e-01, 3.45944524e-01, 7.81139359e-02, 1.52119964e-01,

61 2.02162191e-01, 3.44150960e-02, -2.86277920e-01, 1.43662184e-01, 3.21276844e-01,

62 -6.21452965e-02, 8.58670697e-02, -1.63320359e-02, -1.07958235e-01, -1.60820082e-01,

63 -2.19705645e-02, -1.55181482e-01, -2.39055425e-01, -2.75705636e-01, 6.33126274e-02,

64 -5.50971478e-02, -2.42579415e-01, -9.87957790e-02, 1.08421087e-01, -1.12892322e-01,

65 1.89090632e-02, -1.53086300e-03, -2.18615308e-01, -2.19320312e-01, 9.22102109e-02,

66 -4.87535410e-02, -1.81964979e-01, -4.17055413e-02, -4.24422681e-01, -1.96061105e-01,

67 -1.35127297e-02, -1.77031055e-01, -2.30597332e-01, -4.01868790e-01, -4.18784261e-01,

68 -3.75085384e-01, -3.49007100e-01, -1.77735761e-01, -7.41272718e-02, -1.92537069e-01,

69 2.46565759e-01, -3.44777972e-01, -2.85573214e-01, -2.34121397e-01,

70 ]

71 serialOscanMeansC = [

72 0.212578110, 0.107817403, -0.122200218, -0.0089812368, -0.067990060, 0.040077099,

73 -0.021402006, 0.090923088, -0.099587158, 0.274797124, -0.016930788, 0.045007070,

74 -0.00379911056, -0.16088248, 0.055911896, 0.0601755001, -0.046872945, 0.210018355,

75 0.081641635, -0.046147249, -0.0059020276, 0.108368757, -0.033966731, -0.0058644798,

76 -0.075746922, -0.203826510, 0.12620401, -0.0156685544, -0.09631182, 0.089754454,

77 0.03789926, 0.0304515115, -0.082173715, -0.061332140, -0.24894494, -0.155137551,

78 -0.073825312, 0.24538413, -0.069597074, 0.192338801, -0.0539746876, -0.184556000,

79 -0.173069382, -0.209975778, 0.086679191, 0.016299034, -0.0094125706, -0.100099911,

80 0.061981365, 0.086250364, 0.209128404, -0.0067993622, 0.171072270, -0.29266333,

81 0.075172274, -0.29375612, -0.13377650, 0.0125964781, -0.124991264, 0.226516831,

82 0.128244484, -0.05019844, -0.149249925, -0.1557398,

83 ]

84 serialOscanMeansD = [

85 4.0867248, 1.43194193, 0.95319573, 0.43219185, 0.53112239, 0.28648, 0.323903486,

86 0.27622156, 0.26031138, 0.144442975, 0.0149878587, 0.062969929, 0.018541051,

87 -0.237687056, 0.22804558, 0.0600504708, 0.140250022, -0.137477808, 0.119911710,

88 0.03770870, -0.20021377, 0.187175400, 0.0168790129, -0.110724371, 0.099311580,

89 0.0079969534, -0.157593577, -0.178876067, -0.214948580, -0.11354382, 0.148154530,

90 -0.056012520, 0.11851939, 0.067902033, 0.18970736, -0.181487703, -0.0101017127,

91 0.100998570, -0.0309096733, -0.034450136, -0.066357072, -0.058662959, 0.146185921,

92 -0.218474021, -0.173691633, 0.055349625, -0.178158524, -0.012917378, -0.166576555,

93 -0.063862754, 0.113169933, -0.33518338, -0.074239500, 0.22262230, -0.066653975,

94 -0.200271016, -0.013275277, 0.100596499, -0.092528954, 0.0339541714, 0.113119135,

95 -0.150720824, 0.038237873, 0.17603852613429813,

96 ]

97 parallelOscanMeans = [

98 7.18039751e-01, 4.56550479e-01, 4.14261669e-01, 2.88099229e-01, -2.34310962e-02,

99 -4.59854975e-02, -1.14491098e-02, 5.19846082e-02, 2.05635265e-01, 1.25147207e-02,

100 ]

101

102 self.inputMeasurements = [

103 {'CTI': {'C:0,0': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

104 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

105 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

106 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

107 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

108 'INPUT_GAIN': 1.5,

109 'INPUT_PTCTURNOFF': numpy.inf},

110 'C:0,1': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

111 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

112 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

113 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

114 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

115 'INPUT_GAIN': 1.5,

116 'INPUT_PTCTURNOFF': numpy.inf},

117 'C:0,2': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

118 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

119 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

120 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

121 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

122 'INPUT_GAIN': 1.5,

123 'INPUT_PTCTURNOFF': numpy.inf},

124 'C:0,3': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

125 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

126 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

127 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

128 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

129 'INPUT_GAIN': 1.5,

130 'INPUT_PTCTURNOFF': numpy.inf},

131 'C:1,0': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

132 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

133 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

134 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

135 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

136 'INPUT_GAIN': 1.5,

137 'INPUT_PTCTURNOFF': numpy.inf},

138 'C:1,1': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

139 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

140 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

141 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

142 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

143 'INPUT_GAIN': 1.5,

144 'INPUT_PTCTURNOFF': numpy.inf},

145 'C:1,2': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

146 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

147 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

148 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

149 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

150 'INPUT_GAIN': 1.5,

151 'INPUT_PTCTURNOFF': numpy.inf},

152 'C:1,3': {'FIRST_COLUMN_MEAN': 117.810165, 'LAST_COLUMN_MEAN': 1.09791130e+02,

153 'IMAGE_MEAN': 117.810165, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansA,

154 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

155 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

156 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

157 'INPUT_GAIN': 1.5,

158 'INPUT_PTCTURNOFF': numpy.inf}}},

159

160 {'CTI': {'C:0,0': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

161 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

162 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

163 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

164 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

165 'INPUT_GAIN': 1.5,

166 'INPUT_PTCTURNOFF': numpy.inf},

167 'C:0,1': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

168 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

169 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

170 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

171 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

172 'INPUT_GAIN': 1.5,

173 'INPUT_PTCTURNOFF': numpy.inf},

174 'C:0,2': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

175 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

176 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

177 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

178 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

179 'INPUT_GAIN': 1.5,

180 'INPUT_PTCTURNOFF': numpy.inf},

181 'C:0,3': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

182 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

183 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

184 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

185 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

186 'INPUT_GAIN': 1.5,

187 'INPUT_PTCTURNOFF': numpy.inf},

188 'C:1,0': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

189 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

190 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

191 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

192 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

193 'INPUT_GAIN': 1.5,

194 'INPUT_PTCTURNOFF': numpy.inf},

195 'C:1,1': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

196 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

197 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

198 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

199 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

200 'INPUT_GAIN': 1.5,

201 'INPUT_PTCTURNOFF': numpy.inf},

202 'C:1,2': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

203 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

204 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

205 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

206 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

207 'INPUT_GAIN': 1.5,

208 'INPUT_PTCTURNOFF': numpy.inf},

209 'C:1,3': {'FIRST_COLUMN_MEAN': 36562.082, 'LAST_COLUMN_MEAN': 3.45901172e+04,

210 'IMAGE_MEAN': 36562.082, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansB,

211 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

212 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

213 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

214 'INPUT_GAIN': 1.5,

215 'INPUT_PTCTURNOFF': numpy.inf}}},

216

217 {'CTI': {'C:0,0': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

218 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

219 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

220 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

221 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

222 'INPUT_GAIN': 1.5,

223 'INPUT_PTCTURNOFF': numpy.inf},

224 'C:0,1': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

225 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

226 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

227 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

228 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

229 'INPUT_GAIN': 1.5,

230 'INPUT_PTCTURNOFF': numpy.inf},

231 'C:0,2': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

232 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

233 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

234 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

235 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

236 'INPUT_GAIN': 1.5,

237 'INPUT_PTCTURNOFF': numpy.inf},

238 'C:0,3': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

239 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

240 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

241 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

242 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

243 'INPUT_GAIN': 1.5,

244 'INPUT_PTCTURNOFF': numpy.inf},

245 'C:1,0': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

246 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

247 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

248 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

249 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

250 'INPUT_GAIN': 1.5,

251 'INPUT_PTCTURNOFF': numpy.inf},

252 'C:1,1': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

253 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

254 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

255 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

256 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

257 'INPUT_GAIN': 1.5,

258 'INPUT_PTCTURNOFF': numpy.inf},

259 'C:1,2': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

260 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

261 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

262 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

263 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

264 'INPUT_GAIN': 1.5,

265 'INPUT_PTCTURNOFF': numpy.inf},

266 'C:1,3': {'FIRST_COLUMN_MEAN': 994.811, 'LAST_COLUMN_MEAN': 936.415,

267 'IMAGE_MEAN': 994.811, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansC,

268 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

269 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

270 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

271 'INPUT_GAIN': 1.5,

272 'INPUT_PTCTURNOFF': numpy.inf}}},

273

274 {'CTI': {'C:0,0': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

275 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

276 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

277 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

278 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

279 'INPUT_GAIN': 1.5,

280 'INPUT_PTCTURNOFF': numpy.inf},

281 'C:0,1': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

282 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

283 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

284 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

285 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

286 'INPUT_GAIN': 1.5,

287 'INPUT_PTCTURNOFF': numpy.inf},

288 'C:0,2': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

289 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

290 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

291 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

292 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

293 'INPUT_GAIN': 1.5,

294 'INPUT_PTCTURNOFF': numpy.inf},

295 'C:0,3': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

296 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

297 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

298 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

299 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

300 'INPUT_GAIN': 1.5,

301 'INPUT_PTCTURNOFF': numpy.inf},

302 'C:1,0': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

303 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

304 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

305 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

306 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

307 'INPUT_GAIN': 1.5,

308 'INPUT_PTCTURNOFF': numpy.inf},

309 'C:1,1': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

310 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

311 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

312 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

313 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

314 'INPUT_GAIN': 1.5,

315 'INPUT_PTCTURNOFF': numpy.inf},

316 'C:1,2': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

317 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

318 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

319 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

320 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

321 'INPUT_GAIN': 1.5,

322 'INPUT_PTCTURNOFF': numpy.inf},

323 'C:1,3': {'FIRST_COLUMN_MEAN': 12215.778, 'LAST_COLUMN_MEAN': 11536.875,

324 'IMAGE_MEAN': 12215.778, 'SERIAL_OVERSCAN_VALUES': serialOscanMeansD,

325 'SERIAL_OVERSCAN_COLUMNS': [x for x in range(0, 64)],

326 'PARALLEL_OVERSCAN_VALUES': parallelOscanMeans,

327 'PARALLEL_OVERSCAN_ROWS': [x for x in range(0, 10)],

328 'INPUT_GAIN': 1.5,

329 'INPUT_PTCTURNOFF': numpy.inf}}}]

330 self.inputDims = [{'detector': 20, 'instrument': 'IsrMock', 'exposure': 2019101200433},

331 {'detector': 20, 'instrument': 'IsrMock', 'exposure': 2019101300154},

332 {'detector': 20, 'instrument': 'IsrMock', 'exposure': 2019101300004},

333 {'detector': 20, 'instrument': 'IsrMock', 'exposure': 2019101200333}]

334

335 self.task = cpPipe.CpCtiSolveTask()

336

337 self.ptc = PhotonTransferCurveDataset()

338 self.ptc.updateMetadata(camera=self.camera, detector=self.camera[20])

339 self.sequencerMetadata = {

340 "SEQNAME": "a_sequencer",

341 "SEQFILE": "a_sequencer_file",

342 "SEQCKSUM": "deadbeef",

343 }

344 self.ptc.updateMetadata(**self.sequencerMetadata, setCalibInfo=True)

345

346 def test_task(self):

347 """A test for the main CpCtiSolveTask.

348

349 This should excercise most of the new code.

350 """

351 results = self.task.run(self.inputMeasurements, self.camera, self.inputDims, self.ptc)

352

353 calib = results.outputCalib

354

355 for key, value in self.sequencerMetadata.items():

356 self.assertEqual(calib.metadata[key], value)

357

358 for key in ["INSTRUME", "DETECTOR", "DET_NAME", "DET_SER"]:

359 self.assertEqual(calib.metadata[key], self.ptc.metadata[key])

360

361 # Check that the signals array is sorted

362 for ampName in calib.signals.keys():

363 assert numpy.all(numpy.diff(calib.signals[ampName]) > 0)

364

365 # Check that the result matches expectation.

366 self.assertAlmostEqual(calib.globalCti['C:0,0'], 1.0e-7, 4)

367 self.assertAlmostEqual(calib.driftScale['C:0,0'], 1.8105e-4, 4)

368 self.assertAlmostEqual(calib.decayTime['C:0,0'], 3.08095, 4)

369

370 # Check that all amps are equal.

371 for ampName in calib.globalCti.keys():

372 self.assertEqual(calib.globalCti['C:0,0'], calib.globalCti[ampName])

373 self.assertEqual(calib.driftScale['C:0,0'], calib.driftScale[ampName])

374 self.assertEqual(calib.decayTime['C:0,0'], calib.decayTime[ampName])

375 self.assertEqual(calib.signals[ampName][-2], calib.serialCtiTurnoff[ampName])

376 self.assertEqual(calib.signals[ampName][-1], calib.parallelCtiTurnoff[ampName])

377 self.assertEqual(

378 (calib.signals[ampName][-1] - calib.signals[ampName][-3]) / 2.0,

379 calib.serialCtiTurnoffSamplingErr[ampName],

380 )

381 self.assertEqual(

382 calib.signals[ampName][-1] - calib.signals[ampName][-2],

383 calib.parallelCtiTurnoffSamplingErr[ampName],

384 )

385

386

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

388 pass

389

390

391def setup_module(module):

392 lsst.utils.tests.init()

393

394

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

396 lsst.utils.tests.init()

397 unittest.main()

Coverage for tests / test_deferredCharge.py: 24%

48 statements