Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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__ = ("LsstCam", "LsstCamImSim", "LsstCamPhoSim", "LsstTS8", 

23 "Latiss", "LsstTS3", "LsstUCDCam", "LsstComCam") 

24 

25import os.path 

26 

27import lsst.obs.base.yamlCamera as yamlCamera 

28from lsst.daf.butler.core.utils import getFullTypeName 

29from lsst.utils import getPackageDir 

30from lsst.obs.base import Instrument 

31from lsst.obs.base.gen2to3 import TranslatorFactory 

32from .filters import (LSSTCAM_FILTER_DEFINITIONS, LATISS_FILTER_DEFINITIONS, 

33 LSSTCAM_IMSIM_FILTER_DEFINITIONS, TS3_FILTER_DEFINITIONS, 

34 TS8_FILTER_DEFINITIONS, COMCAM_FILTER_DEFINITIONS, 

35 ) 

36 

37from .translators import LatissTranslator, LsstCamTranslator, \ 

38 LsstUCDCamTranslator, LsstTS3Translator, LsstComCamTranslator, \ 

39 LsstCamPhoSimTranslator, LsstTS8Translator, LsstCamImSimTranslator 

40 

41PACKAGE_DIR = getPackageDir("obs_lsst") 

42 

43 

44class LsstCam(Instrument): 

45 """Gen3 Butler specialization for the LSST Main Camera. 

46 

47 Parameters 

48 ---------- 

49 camera : `lsst.cameraGeom.Camera` 

50 Camera object from which to extract detector information. 

51 filters : `list` of `FilterDefinition` 

52 An ordered list of filters to define the set of PhysicalFilters 

53 associated with this instrument in the registry. 

54 

55 While both the camera geometry and the set of filters associated with a 

56 camera are expected to change with time in general, their Butler Registry 

57 representations defined by an Instrument do not. Instead: 

58 

59 - We only extract names, IDs, and purposes from the detectors in the 

60 camera, which should be static information that actually reflects 

61 detector "slots" rather than the physical sensors themselves. Because 

62 the distinction between physical sensors and slots is unimportant in 

63 the vast majority of Butler use cases, we just use "detector" even 

64 though the concept really maps better to "detector slot". Ideally in 

65 the future this distinction between static and time-dependent 

66 information would be encoded in cameraGeom itself (e.g. by making the 

67 time-dependent Detector class inherit from a related class that only 

68 carries static content). 

69 

70 - The Butler Registry is expected to contain physical_filter entries for 

71 all filters an instrument has ever had, because we really only care 

72 about which filters were used for particular observations, not which 

73 filters were *available* at some point in the past. And changes in 

74 individual filters over time will be captured as changes in their 

75 TransmissionCurve datasets, not changes in the registry content (which 

76 is really just a label). While at present Instrument and Registry 

77 do not provide a way to add new physical_filters, they will in the 

78 future. 

79 """ 

80 filterDefinitions = LSSTCAM_FILTER_DEFINITIONS 

81 instrument = "LSSTCam" 

82 policyName = "lsstCam" 

83 translatorClass = LsstCamTranslator 

84 obsDataPackage = "obs_lsst_data" 

85 

86 @property 

87 def configPaths(self): 

88 return [os.path.join(PACKAGE_DIR, "config"), 

89 os.path.join(PACKAGE_DIR, "config", self.policyName)] 

90 

91 @classmethod 

92 def getName(cls): 

93 # Docstring inherited from Instrument.getName 

94 return cls.instrument 

95 

96 @classmethod 

97 def getCamera(cls): 

98 # Constructing a YAML camera takes a long time but we rely on 

99 # yamlCamera to cache for us. 

100 cameraYamlFile = os.path.join(PACKAGE_DIR, "policy", f"{cls.policyName}.yaml") 

101 camera = yamlCamera.makeCamera(cameraYamlFile) 

102 if camera.getName() != cls.getName(): 

103 raise RuntimeError(f"Expected to read camera geometry for {cls.instrument}" 

104 f" but instead got geometry for {camera.getName()}") 

105 return camera 

106 

107 def getRawFormatter(self, dataId): 

108 # Docstring inherited from Instrument.getRawFormatter 

109 # local import to prevent circular dependency 

110 from .rawFormatter import LsstCamRawFormatter 

111 return LsstCamRawFormatter 

112 

113 def register(self, registry): 

114 # Docstring inherited from Instrument.register 

115 # The maximum values below make Gen3's ObservationDataIdPacker produce 

116 # outputs that match Gen2's ccdExposureId. 

117 obsMax = self.translatorClass.max_detector_exposure_id() 

118 with registry.transaction(): 

119 registry.syncDimensionData( 

120 "instrument", 

121 { 

122 "name": self.getName(), 

123 "detector_max": self.translatorClass.DETECTOR_MAX, 

124 "visit_max": obsMax, 

125 "exposure_max": obsMax, 

126 "class_name": getFullTypeName(self), 

127 } 

128 ) 

129 for detector in self.getCamera(): 

130 registry.syncDimensionData("detector", self.extractDetectorRecord(detector)) 

131 

132 self._registerFilters(registry) 

133 

134 def extractDetectorRecord(self, camGeomDetector): 

135 """Create a Gen3 Detector entry dict from a cameraGeom.Detector. 

136 """ 

137 # All of the LSST instruments have detector names like R??_S??; we'll 

138 # split them up here, and instruments with only one raft can override 

139 # to change the group to something else if desired. 

140 # Long-term, we should get these fields into cameraGeom separately 

141 # so there's no need to specialize at this stage. 

142 # They are separate in ObservationInfo 

143 group, name = camGeomDetector.getName().split("_") 

144 

145 # getType() returns a pybind11-wrapped enum, which unfortunately 

146 # has no way to extract the name of just the value (it's always 

147 # prefixed by the enum type name). 

148 purpose = str(camGeomDetector.getType()).split(".")[-1] 

149 

150 return dict( 

151 instrument=self.getName(), 

152 id=camGeomDetector.getId(), 

153 full_name=camGeomDetector.getName(), 

154 name_in_raft=name, 

155 purpose=purpose, 

156 raft=group, 

157 ) 

158 

159 def makeDataIdTranslatorFactory(self) -> TranslatorFactory: 

160 # Docstring inherited from lsst.obs.base.Instrument. 

161 factory = TranslatorFactory() 

162 factory.addGenericInstrumentRules(self.getName(), detectorKey="detector", exposureKey="expId") 

163 return factory 

164 

165 

166class LsstComCam(LsstCam): 

167 """Gen3 Butler specialization for ComCam data. 

168 """ 

169 

170 filterDefinitions = COMCAM_FILTER_DEFINITIONS 

171 instrument = "LSSTComCam" 

172 policyName = "comCam" 

173 translatorClass = LsstComCamTranslator 

174 

175 def getRawFormatter(self, dataId): 

176 # local import to prevent circular dependency 

177 from .rawFormatter import LsstComCamRawFormatter 

178 return LsstComCamRawFormatter 

179 

180 

181class LsstCamImSim(LsstCam): 

182 """Gen3 Butler specialization for ImSim simulations. 

183 """ 

184 

185 instrument = "LSSTCam-imSim" 

186 policyName = "imsim" 

187 translatorClass = LsstCamImSimTranslator 

188 filterDefinitions = LSSTCAM_IMSIM_FILTER_DEFINITIONS 

189 

190 def getRawFormatter(self, dataId): 

191 # local import to prevent circular dependency 

192 from .rawFormatter import LsstCamImSimRawFormatter 

193 return LsstCamImSimRawFormatter 

194 

195 

196class LsstCamPhoSim(LsstCam): 

197 """Gen3 Butler specialization for Phosim simulations. 

198 """ 

199 

200 instrument = "LSSTCam-PhoSim" 

201 policyName = "phosim" 

202 translatorClass = LsstCamPhoSimTranslator 

203 

204 def getRawFormatter(self, dataId): 

205 # local import to prevent circular dependency 

206 from .rawFormatter import LsstCamPhoSimRawFormatter 

207 return LsstCamPhoSimRawFormatter 

208 

209 

210class LsstTS8(LsstCam): 

211 """Gen3 Butler specialization for raft test stand data. 

212 """ 

213 

214 filterDefinitions = TS8_FILTER_DEFINITIONS 

215 instrument = "LSST-TS8" 

216 policyName = "ts8" 

217 translatorClass = LsstTS8Translator 

218 

219 def getRawFormatter(self, dataId): 

220 # local import to prevent circular dependency 

221 from .rawFormatter import LsstTS8RawFormatter 

222 return LsstTS8RawFormatter 

223 

224 

225class LsstUCDCam(LsstCam): 

226 """Gen3 Butler specialization for UCDCam test stand data. 

227 """ 

228 

229 instrument = "LSST-UCDCam" 

230 policyName = "ucd" 

231 translatorClass = LsstUCDCamTranslator 

232 

233 def getRawFormatter(self, dataId): 

234 # local import to prevent circular dependency 

235 from .rawFormatter import LsstUCDCamRawFormatter 

236 return LsstUCDCamRawFormatter 

237 

238 

239class LsstTS3(LsstCam): 

240 """Gen3 Butler specialization for TS3 test stand data. 

241 """ 

242 

243 filterDefinitions = TS3_FILTER_DEFINITIONS 

244 instrument = "LSST-TS3" 

245 policyName = "ts3" 

246 translatorClass = LsstTS3Translator 

247 

248 def getRawFormatter(self, dataId): 

249 # local import to prevent circular dependency 

250 from .rawFormatter import LsstTS3RawFormatter 

251 return LsstTS3RawFormatter 

252 

253 

254class Latiss(LsstCam): 

255 """Gen3 Butler specialization for AuxTel LATISS data. 

256 """ 

257 filterDefinitions = LATISS_FILTER_DEFINITIONS 

258 instrument = "LATISS" 

259 policyName = "latiss" 

260 translatorClass = LatissTranslator 

261 

262 def extractDetectorRecord(self, camGeomDetector): 

263 # Override to remove group (raft) name, because LATISS only has one 

264 # detector. 

265 record = super().extractDetectorRecord(camGeomDetector) 

266 record["raft"] = None 

267 record["name_in_raft"] = record["full_name"] 

268 return record 

269 

270 def getRawFormatter(self, dataId): 

271 # local import to prevent circular dependency 

272 from .rawFormatter import LatissRawFormatter 

273 return LatissRawFormatter