Coverage for python/lsst/obs/lsst/filters.py: 98%

77 statements  

« prev     ^ index     » next       coverage.py v7.3.1, created at 2023-09-07 11:34 +0000

1# This file is part of obs_lsst. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (http://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 <http://www.gnu.org/licenses/>. 

21 

22__all__ = ( 

23 "LSSTCAM_FILTER_DEFINITIONS", 

24 "LATISS_FILTER_DEFINITIONS", 

25 "LSSTCAM_IMSIM_FILTER_DEFINITIONS", 

26 "TS3_FILTER_DEFINITIONS", 

27 "TS8_FILTER_DEFINITIONS", 

28 "COMCAM_FILTER_DEFINITIONS", 

29 "GENERIC_FILTER_DEFINITIONS", 

30) 

31 

32from lsst.obs.base import FilterDefinition, FilterDefinitionCollection 

33from .translators.lsst import FILTER_DELIMITER 

34 

35 

36def addFilter(filter_dict, band, physical_filter): 

37 """Define a filter in filter_dict, to be converted to a Filter later""" 

38 

39 # index by band but keep distinct physical filters by band 

40 # since there can be many physical filters for a single band 

41 if band not in filter_dict: 

42 filter_dict[band] = {} 

43 

44 filter_dict[band][physical_filter] = dict(physical_filter=physical_filter, 

45 band=band, alias=[], 

46 ) 

47 

48 

49EmptyFilter = FilterDefinition(physical_filter="empty", band="white", 

50 alias={"no_filter", "open"}) 

51 

52# Generic filters used by PhoSim and UCDCam 

53LsstCamFiltersGeneric = FilterDefinitionCollection( 

54 FilterDefinition(physical_filter="u", band="u"), 

55 FilterDefinition(physical_filter="g", band="g"), 

56 FilterDefinition(physical_filter="r", band="r"), 

57 FilterDefinition(physical_filter="i", band="i"), 

58 FilterDefinition(physical_filter="z", band="z"), 

59 FilterDefinition(physical_filter="y", band="y"), 

60) 

61 

62# The LSST Filters from Tony Johnson, 05/09/2023, in DM-38882. 

63LsstCamFiltersBaseline = FilterDefinitionCollection( 

64 FilterDefinition(physical_filter="ph_5", band="white"), # pinhole filter 

65 FilterDefinition(physical_filter="ef_43", band="white"), # "empty" filter 

66 FilterDefinition(physical_filter="u_24", band="u"), 

67 FilterDefinition(physical_filter="g_6", band="g"), 

68 FilterDefinition(physical_filter="r_57", band="r"), 

69 FilterDefinition(physical_filter="i_39", band="i"), 

70 FilterDefinition(physical_filter="z_20", band="z"), 

71 FilterDefinition(physical_filter="y_10", band="y"), 

72) 

73 

74# 

75# Define the filters present in the BOT. 

76# According to Tony Johnson the possible physical filters are 

77# ColorFWheel [SDSSu,SDSSg,SDSSr,SDSSi,SDSSz,SDSSY, 

78# 480nm,650nm,750nm,870nm,950nm,970nm] 

79# SpotProjFWheel [grid,spot,empty3,empty4,empty5,empty6] 

80# NeutralFWheel [ND_OD1.0,ND_OD0.5,ND_OD0.3,empty,ND_OD2.0,ND_OD0.7] 

81# where: 

82# ColorFWheel and SpotProjFWheel are mutually exclusive and 

83# both appear in FILTER, 

84# NeutralFWheel appears in FILTER2 

85# 

86# Experimentally we also see FILTER2 values of: 

87# ['ND_OD0.01', 'ND_OD0.05', 'ND_OD0.4', 'ND_OD3.0', 'ND_OD4.0'] 

88# 

89# The band names are not yet defined, so I'm going to invent them 

90 

91# Map the BOT filters to corresponding band explicitly 

92BOT_filter_map = { 

93 "empty": "white", 

94 "SDSSu": "u", 

95 "SDSSg": "g", 

96 "SDSSr": "r", 

97 "SDSSi": "i", 

98 "SDSSz": "z", 

99 "SDSSY": "y", 

100 "480nm": "g", 

101 "650nm": "r", 

102 "750nm": "i", 

103 "870nm": "z", 

104 "950nm": "y", 

105 "970nm": "y", 

106 "grid": "grid", 

107 "spot": "spot", 

108} 

109 

110BOTFilters_dict = {} 

111for physical_filter, band in BOT_filter_map.items(): 

112 if physical_filter == "empty": 

113 pass # Already defined above 

114 else: 

115 addFilter(BOTFilters_dict, band, physical_filter) 

116 

117 # Empty ND is removed by metadata translator so is not needed here 

118 ndFilters = ["ND_OD0.1", "ND_OD0.3", "ND_OD0.5", "ND_OD0.7", "ND_OD1.0", "ND_OD2.0"] 

119 # We found these additional filters in BOT data files: 

120 ndFilters += ['ND_OD0.01', 'ND_OD0.05', 'ND_OD0.4', 'ND_OD3.0', 'ND_OD4.0'] 

121 

122 for nd in ndFilters: 

123 # fully qualified physical filter 

124 phys_plus_nd = f"{physical_filter}{FILTER_DELIMITER}{nd}" 

125 

126 # When one of the filters is empty we can just use the real filter 

127 # (e.g. "u" not "u~empty"); but we always need at least one "empty" 

128 if band == "white": 

129 # Use the ND on its own 

130 phys_plus_nd = nd 

131 

132 # Use a generic ND modifier for the band 

133 ndband = f"{band}{FILTER_DELIMITER}nd" 

134 

135 addFilter(BOTFilters_dict, band=ndband, physical_filter=phys_plus_nd) 

136 

137BOTFilters = [ 

138 FilterDefinition(band="unknown", physical_filter="unknown"), 

139] 

140for band, physical_filters in BOTFilters_dict.items(): 

141 for physical_filter, filter_defn in physical_filters.items(): 

142 BOTFilters.append(FilterDefinition(**filter_defn)) 

143 

144# 

145# These are the filters used by the CCOB for both TS8 and LSSTCam. 

146# For the testing of LSSTCam at SLAC, they will be combined with the 

147# real LSSTCam filters, so we include those combinations in the CCOB 

148# filter definitions. 

149# 

150CCOB_filter_map = { 

151 "": "white", 

152 "HIGH": "white", 

153 "LOW": "white", 

154 "uv": "u", 

155 "blue": "g", 

156 "red": "r", 

157 "nm750": "i", 

158 "nm850": "z", 

159 "nm960": "y", 

160} 

161 

162CCOBFilters = [] 

163for lsst_filter_def in (EmptyFilter, *LsstCamFiltersBaseline): 

164 lsstcam_filter = lsst_filter_def.physical_filter 

165 if lsstcam_filter == "empty": 

166 lsstcam_filter = "" 

167 lsstcam_band = lsst_filter_def.band 

168 for ccob_filter, ccob_band in CCOB_filter_map.items(): 

169 if lsstcam_band != "white" and ccob_band != "white" and band != ccob_band: 

170 # Skip disallowed filter combinations based on band values. 

171 continue 

172 if ccob_filter == "": 

173 # This would correspond to an entry already in 

174 # LSSTCamFilterBaseline 

175 continue 

176 filters = lsstcam_filter, ccob_filter 

177 physical_filter = FILTER_DELIMITER.join(filters).strip(FILTER_DELIMITER) 

178 if lsstcam_band == "white": 

179 band = ccob_band 

180 else: 

181 band = lsstcam_band 

182 if physical_filter == "": 182 ↛ 183line 182 didn't jump to line 183, because the condition on line 182 was never true

183 physical_filter = "empty" 

184 CCOBFilters.append(FilterDefinition(band=band, physical_filter=physical_filter)) 

185 

186# 

187# The filters that we might see in the real LSSTCam (including in SLAC) 

188# 

189# Note that the filters we'll use on the sky, LsstCamFiltersBaseline, must 

190# come first as we're not allocating enough bits in _computeCoaddExposureId 

191# for all the BOT composite filters (i.e. "u~ND_OD1.0") 

192# 

193LSSTCAM_FILTER_DEFINITIONS = FilterDefinitionCollection( 

194 EmptyFilter, 

195 *LsstCamFiltersBaseline, 

196 *BOTFilters, 

197 *CCOBFilters, 

198) 

199 

200GENERIC_FILTER_DEFINITIONS = FilterDefinitionCollection( 

201 EmptyFilter, 

202 *LsstCamFiltersGeneric, 

203) 

204 

205# 

206# Filters in SLAC's Test Stand 3 

207# 

208TS3Filters = [ 

209 FilterDefinition(band="unknown", physical_filter="unknown"), 

210 FilterDefinition(physical_filter="275CutOn"), 

211 FilterDefinition(physical_filter="550CutOn")] 

212 

213TS3_FILTER_DEFINITIONS = FilterDefinitionCollection( 

214 EmptyFilter, 

215 *LsstCamFiltersGeneric, 

216 *TS3Filters, 

217) 

218# 

219# Filters in SLAC's Test Stand 8 

220# 

221TS8Filters = [ 

222 FilterDefinition(band="unknown", physical_filter="unknown"), 

223 FilterDefinition(physical_filter="275CutOn"), 

224 FilterDefinition(physical_filter="550CutOn")] 

225 

226TS8_FILTER_DEFINITIONS = FilterDefinitionCollection( 

227 EmptyFilter, 

228 *LsstCamFiltersGeneric, 

229 *LsstCamFiltersBaseline, 

230 *TS8Filters, 

231 *CCOBFilters, 

232) 

233 

234 

235# LATISS filters include a grating in the name so we need to construct 

236# filters for each combination of filter+grating. 

237_latiss_filters = ( 

238 FilterDefinition(physical_filter="empty", 

239 band="white", 

240 alias={"no_filter", "open"}), 

241 FilterDefinition(physical_filter="blank_bk7_wg05", 

242 band="white"), 

243 FilterDefinition(physical_filter="KPNO_1111_436nm", 

244 band="g"), 

245 FilterDefinition(physical_filter="KPNO_373A_677nm", 

246 band="r"), 

247 FilterDefinition(physical_filter="KPNO_406_828nm", 

248 band="z"), 

249 FilterDefinition(physical_filter="diffuser", 

250 band="diffuser"), 

251 FilterDefinition(physical_filter="unknown", 

252 band="unknown"), 

253 FilterDefinition(physical_filter="BG40", 

254 band="g", 

255 afw_name="bg"), 

256 FilterDefinition(physical_filter="BG40_65mm_1", 

257 band="g", 

258 afw_name="bg"), 

259 FilterDefinition(physical_filter="BG40_65mm_2", 

260 band="g", 

261 afw_name="bg"), 

262 FilterDefinition(physical_filter="quadnotch1", 

263 band="notch"), 

264 FilterDefinition(physical_filter="RG610", 

265 band="r", 

266 afw_name="rg"), 

267 FilterDefinition(physical_filter="OG550_65mm_1", 

268 band="g", 

269 afw_name="bg"), 

270 FilterDefinition(physical_filter="OG550_65mm_2", 

271 band="g", 

272 afw_name="bg"), 

273 FilterDefinition(physical_filter="FELH0600", 

274 band="r", 

275 afw_name="rg"), 

276 FilterDefinition(physical_filter="SDSSg", 

277 band="g"), 

278 FilterDefinition(physical_filter="SDSSr", 

279 band="r"), 

280 FilterDefinition(physical_filter="SDSSi", 

281 band="i"), 

282 FilterDefinition(physical_filter="SDSSu_65mm", 

283 band="u"), 

284 FilterDefinition(physical_filter="SDSSg_65mm", 

285 band="g"), 

286 FilterDefinition(physical_filter="SDSSr_65mm", 

287 band="r"), 

288 FilterDefinition(physical_filter="SDSSi_65mm", 

289 band="i"), 

290 FilterDefinition(physical_filter="SDSSz_65mm", 

291 band="z"), 

292 FilterDefinition(physical_filter="SDSSy_65mm", 

293 band="y"), 

294 FilterDefinition(physical_filter="collimator", 

295 band="white"), 

296 FilterDefinition(physical_filter="cyl_lens", 

297 band="white"), 

298) 

299 

300# Form a new set of filter definitions from all the explicit gratings 

301_latiss_gratings = ("ronchi90lpmm", 

302 "ronchi170lpmm", 

303 "empty", 

304 "unknown", 

305 "holo4_003", 

306 "blue300lpmm_qn1", 

307 "holo4_001", 

308 "pinhole_1_1000", 

309 "pinhole_1_0500", 

310 "pinhole_1_0200", 

311 "pinhole_1_0100", 

312 "pinhole_2_1_1000", 

313 "pinhole_2_1_0500", 

314 "pinhole_2_1_0200", 

315 "pinhole_2_1_0100", 

316 "pinhole_2_2_1000", 

317 "pinhole_2_2_0500", 

318 "pinhole_2_2_0200", 

319 "pinhole_2_2_0100", 

320 "pinhole_2_3_1000", 

321 "pinhole_2_3_0500", 

322 "pinhole_2_3_0200", 

323 "pinhole_2_3_0100", 

324 "pinhole_2_4_1000", 

325 "pinhole_2_4_0500", 

326 "pinhole_2_4_0200", 

327 "pinhole_2_4_0100", 

328 ) 

329 

330# Include the filters without the grating in case someone wants 

331# to retrieve a filter by an actual filter name 

332_latiss_filter_and_grating = [f for f in _latiss_filters] 

333 

334for filter in _latiss_filters: 

335 for grating in _latiss_gratings: 

336 # The diffuser "filter" was never used with gratings 

337 # so skip it 

338 if filter.physical_filter == "diffuser": 

339 continue 

340 

341 # FilterDefinition is a frozen dataclass 

342 new_name = FILTER_DELIMITER.join([filter.physical_filter, grating]) 

343 

344 # Also need to update aliases 

345 new_aliases = {FILTER_DELIMITER.join([a, grating]) for a in filter.alias} 

346 

347 # For gratings set the band to the band of the filter 

348 combo = FilterDefinition(physical_filter=new_name, 

349 band=filter.band, 

350 afw_name=filter.afw_name, 

351 alias=new_aliases) 

352 _latiss_filter_and_grating.append(combo) 

353 

354 

355LATISS_FILTER_DEFINITIONS = FilterDefinitionCollection(*_latiss_filter_and_grating) 

356 

357 

358LSSTCAM_IMSIM_FILTER_DEFINITIONS = FilterDefinitionCollection( 

359 # These were computed using throughputs 1.4 and 

360 # lsst.sims.photUtils.BandpassSet. 

361 FilterDefinition(physical_filter="u_sim_1.4", 

362 band="u"), 

363 FilterDefinition(physical_filter="g_sim_1.4", 

364 band="g"), 

365 FilterDefinition(physical_filter="r_sim_1.4", 

366 band="r"), 

367 FilterDefinition(physical_filter="i_sim_1.4", 

368 band="i"), 

369 FilterDefinition(physical_filter="z_sim_1.4", 

370 band="z"), 

371 FilterDefinition(physical_filter="y_sim_1.4", 

372 band="y"), 

373 *LsstCamFiltersGeneric, 

374) 

375 

376# ########################################################################### 

377# 

378# ComCam 

379# 

380# See https://jira.lsstcorp.org/browse/DM-21706 

381 

382ComCamFilters_dict = {} 

383for band, sn in [("u", "SN-05"), # incorrect sub thickness 

384 ("u", "SN-02"), # not yet coated 

385 ("u", "SN-06"), # not yet coated 

386 ("g", "SN-07"), # bad cosmetics 

387 ("g", "SN-01"), 

388 ("r", "SN-03"), 

389 ("i", "SN-06"), 

390 ("z", "SN-03"), 

391 ("z", "SN-02"), # failed specs 

392 ("y", "SN-04"), 

393 ]: 

394 physical_filter = f"{band}_{sn[3:]}" 

395 lsstCamFilter = [f for f in LsstCamFiltersBaseline if f.band == band][0] 

396 

397 addFilter(ComCamFilters_dict, band, physical_filter) 

398 

399 

400ComCamFilters = [ 

401 FilterDefinition(band="white", physical_filter="empty"), 

402 FilterDefinition(band="unknown", physical_filter="unknown"), 

403] 

404for band, physical_filters in ComCamFilters_dict.items(): 

405 for physical_filter, filter_defn in physical_filters.items(): 

406 ComCamFilters.append(FilterDefinition(**filter_defn)) 

407 

408COMCAM_FILTER_DEFINITIONS = FilterDefinitionCollection( 

409 *ComCamFilters, 

410)