Coverage for python/lsst/pipe/tasks/processCcd.py: 59%

Shortcuts 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

38 statements  

1# 

2# LSST Data Management System 

3# Copyright 2008-2016 AURA/LSST. 

4# 

5# This product includes software developed by the 

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

7# 

8# This program is free software: you can redistribute it and/or modify 

9# it under the terms of the GNU General Public License as published by 

10# the Free Software Foundation, either version 3 of the License, or 

11# (at your option) any later version. 

12# 

13# This program is distributed in the hope that it will be useful, 

14# but WITHOUT ANY WARRANTY; without even the implied warranty of 

15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

16# GNU General Public License for more details. 

17# 

18# You should have received a copy of the LSST License Statement and 

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

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

21# 

22from lsst.ip.isr import IsrTask 

23import lsst.pex.config as pexConfig 

24import lsst.pipe.base as pipeBase 

25from lsst.utils.timer import timeMethod 

26from .calibrate import CalibrateTask 

27from .characterizeImage import CharacterizeImageTask 

28 

29__all__ = ["ProcessCcdConfig", "ProcessCcdTask"] 

30 

31 

32class ProcessCcdConfig(pexConfig.Config): 

33 """Config for ProcessCcd""" 

34 isr = pexConfig.ConfigurableField( 

35 target=IsrTask, 

36 doc="""Task to perform instrumental signature removal or load a post-ISR image; ISR consists of: 

37 - assemble raw amplifier images into an exposure with image, variance and mask planes 

38 - perform bias subtraction, flat fielding, etc. 

39 - mask known bad pixels 

40 - provide a preliminary WCS 

41 """, 

42 ) 

43 charImage = pexConfig.ConfigurableField( 

44 target=CharacterizeImageTask, 

45 doc="""Task to characterize a science exposure: 

46 - detect sources, usually at high S/N 

47 - estimate the background, which is subtracted from the image and returned as field "background" 

48 - estimate a PSF model, which is added to the exposure 

49 - interpolate over defects and cosmic rays, updating the image, variance and mask planes 

50 """, 

51 ) 

52 doCalibrate = pexConfig.Field( 

53 dtype=bool, 

54 default=True, 

55 doc="Perform calibration?", 

56 ) 

57 calibrate = pexConfig.ConfigurableField( 

58 target=CalibrateTask, 

59 doc="""Task to perform astrometric and photometric calibration: 

60 - refine the WCS in the exposure 

61 - refine the PhotoCalib object in the exposure 

62 - detect sources, usually at low S/N 

63 """, 

64 ) 

65 

66 def setDefaults(self): 

67 self.isr.doWrite = False 

68 self.charImage.doWriteExposure = False 

69 

70## \addtogroup LSST_task_documentation 

71## \{ 

72## \page page_ProcessCcdTask ProcessCcdTask 

73## \ref ProcessCcdTask_ "ProcessCcdTask" 

74## \copybrief ProcessCcdTask 

75## \} 

76 

77 

78class ProcessCcdTask(pipeBase.CmdLineTask): 

79 r"""! 

80 Assemble raw data, fit the PSF, detect and measure, and fit WCS and zero-point 

81 

82 @anchor ProcessCcdTask_ 

83 

84 @section pipe_tasks_processCcd_Contents Contents 

85 

86 - @ref pipe_tasks_processCcd_Purpose 

87 - @ref pipe_tasks_processCcd_Initialize 

88 - @ref pipe_tasks_processCcd_IO 

89 - @ref pipe_tasks_processCcd_Config 

90 - @ref pipe_tasks_processCcd_Debug 

91 - @ref pipe_tasks_processCcd_Example 

92 

93 @section pipe_tasks_processCcd_Purpose Description 

94 

95 Perform the following operations: 

96 - Call isr to unpersist raw data and assemble it into a post-ISR exposure 

97 - Call charImage subtract background, fit a PSF model, repair cosmic rays, 

98 detect and measure bright sources, and measure aperture correction 

99 - Call calibrate to perform deep detection, deblending and single-frame measurement, 

100 refine the WCS and fit the photometric zero-point 

101 

102 @section pipe_tasks_processCcd_Initialize Task initialisation 

103 

104 @copydoc \_\_init\_\_ 

105 

106 @section pipe_tasks_processCcd_IO Invoking the Task 

107 

108 This task is primarily designed to be run from the command line. 

109 

110 The main method is `runDataRef`, which takes a single butler data reference for the raw input data. 

111 

112 @section pipe_tasks_processCcd_Config Configuration parameters 

113 

114 See @ref ProcessCcdConfig 

115 

116 @section pipe_tasks_processCcd_Debug Debug variables 

117 

118 ProcessCcdTask has no debug output, but its subtasks do. 

119 

120 @section pipe_tasks_processCcd_Example A complete example of using ProcessCcdTask 

121 

122 The following commands will process all raw data in obs_test's data repository. 

123 Note: be sure to specify an `--output` that does not already exist: 

124 

125 setup obs_test 

126 setup pipe_tasks 

127 processCcd.py $OBS_TEST_DIR/data/input --output processCcdOut --id 

128 

129 The data is read from the small repository in the `obs_test` package and written `./processCcdOut` 

130 (or whatever output you specified). Specifying `--id` with no values processes all data. 

131 Add the option `--help` to see more options. 

132 """ 

133 ConfigClass = ProcessCcdConfig 

134 RunnerClass = pipeBase.ButlerInitializedTaskRunner 

135 _DefaultName = "processCcd" 

136 

137 def __init__(self, butler=None, psfRefObjLoader=None, astromRefObjLoader=None, photoRefObjLoader=None, 

138 **kwargs): 

139 """! 

140 @param[in] butler The butler is passed to the refObjLoader constructor in case it is 

141 needed. Ignored if the refObjLoader argument provides a loader directly. 

142 @param[in] psfRefObjLoader An instance of LoadReferenceObjectsTasks that supplies an 

143 external reference catalog for image characterization. May be None if the desired 

144 loader can be constructed from the butler argument or all steps requiring a catalog 

145 are disabled. 

146 @param[in] astromRefObjLoader An instance of LoadReferenceObjectsTasks that supplies an 

147 external reference catalog for astrometric calibration. May be None if the desired 

148 loader can be constructed from the butler argument or all steps requiring a reference 

149 catalog are disabled. 

150 @param[in] photoRefObjLoader An instance of LoadReferenceObjectsTasks that supplies an 

151 external reference catalog for photometric calibration. May be None if the desired 

152 loader can be constructed from the butler argument or all steps requiring a reference 

153 catalog are disabled. 

154 @param[in,out] kwargs other keyword arguments for lsst.pipe.base.CmdLineTask 

155 """ 

156 pipeBase.CmdLineTask.__init__(self, **kwargs) 

157 self.makeSubtask("isr") 

158 self.makeSubtask("charImage", butler=butler, refObjLoader=psfRefObjLoader) 

159 self.makeSubtask("calibrate", butler=butler, icSourceSchema=self.charImage.schema, 

160 astromRefObjLoader=astromRefObjLoader, photoRefObjLoader=photoRefObjLoader) 

161 

162 @timeMethod 

163 def runDataRef(self, sensorRef): 

164 """Process one CCD 

165 

166 The sequence of operations is: 

167 - remove instrument signature 

168 - characterize image to estimate PSF and background 

169 - calibrate astrometry and photometry 

170 

171 @param sensorRef: butler data reference for raw data 

172 

173 @return pipe_base Struct containing these fields: 

174 - charRes: object returned by image characterization task; an lsst.pipe.base.Struct 

175 that will include "background" and "sourceCat" fields 

176 - calibRes: object returned by calibration task: an lsst.pipe.base.Struct 

177 that will include "background" and "sourceCat" fields 

178 - exposure: final exposure (an lsst.afw.image.ExposureF) 

179 - background: final background model (an lsst.afw.math.BackgroundList) 

180 """ 

181 self.log.info("Processing %s", sensorRef.dataId) 

182 

183 exposure = self.isr.runDataRef(sensorRef).exposure 

184 

185 charRes = self.charImage.runDataRef( 

186 dataRef=sensorRef, 

187 exposure=exposure, 

188 doUnpersist=False, 

189 ) 

190 exposure = charRes.exposure 

191 

192 if self.config.doCalibrate: 

193 calibRes = self.calibrate.runDataRef( 

194 dataRef=sensorRef, 

195 exposure=charRes.exposure, 

196 background=charRes.background, 

197 doUnpersist=False, 

198 icSourceCat=charRes.sourceCat, 

199 ) 

200 

201 return pipeBase.Struct( 

202 charRes=charRes, 

203 calibRes=calibRes if self.config.doCalibrate else None, 

204 exposure=exposure, 

205 background=calibRes.background if self.config.doCalibrate else charRes.background, 

206 ) 

207 

208 @classmethod 

209 def _makeArgumentParser(cls): 

210 """!Create and return an argument parser 

211 

212 @param[in] cls the class object 

213 @return the argument parser for this task. 

214 

215 This override is used to delay making the data ref list until the dataset type is known; 

216 this is done in @ref parseAndRun. 

217 """ 

218 parser = pipeBase.ArgumentParser(name=cls._DefaultName) 

219 parser.add_id_argument(name="--id", 

220 datasetType=pipeBase.ConfigDatasetType(name="isr.datasetType"), 

221 help="data IDs, e.g. --id visit=12345 ccd=1,2^0,3") 

222 return parser