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 ProcessCcdTask 

73## \ref ProcessCcdTask_ "ProcessCcdTask" 

74## \copybrief ProcessCcdTask 

75## \} 

76 

77 

78class ProcessCcdTask(pipeBase.CmdLineTask): 

79 r"""!Assemble raw data, fit the PSF, detect and measure, and fit WCS and zero-point 

80 

81 @anchor ProcessCcdTask_ 

82 

83 @section pipe_tasks_processCcd_Contents Contents 

84 

85 - @ref pipe_tasks_processCcd_Purpose 

86 - @ref pipe_tasks_processCcd_Initialize 

87 - @ref pipe_tasks_processCcd_IO 

88 - @ref pipe_tasks_processCcd_Config 

89 - @ref pipe_tasks_processCcd_Debug 

90 - @ref pipe_tasks_processCcd_Example 

91 

92 @section pipe_tasks_processCcd_Purpose Description 

93 

94 Perform the following operations: 

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

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

97 detect and measure bright sources, and measure aperture correction 

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

99 refine the WCS and fit the photometric zero-point 

100 

101 @section pipe_tasks_processCcd_Initialize Task initialisation 

102 

103 @copydoc \_\_init\_\_ 

104 

105 @section pipe_tasks_processCcd_IO Invoking the Task 

106 

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

108 

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

110 

111 @section pipe_tasks_processCcd_Config Configuration parameters 

112 

113 See @ref ProcessCcdConfig 

114 

115 @section pipe_tasks_processCcd_Debug Debug variables 

116 

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

118 

119 @section pipe_tasks_processCcd_Example A complete example of using ProcessCcdTask 

120 

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

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

123 

124 setup obs_test 

125 setup pipe_tasks 

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

127 

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

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

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

131 """ 

132 ConfigClass = ProcessCcdConfig 

133 RunnerClass = pipeBase.ButlerInitializedTaskRunner 

134 _DefaultName = "processCcd" 

135 

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

137 **kwargs): 

138 """! 

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

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

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

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

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

144 are disabled. 

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

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

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

148 catalog are disabled. 

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

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

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

152 catalog are disabled. 

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

154 """ 

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

156 self.makeSubtask("isr") 

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

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

159 astromRefObjLoader=astromRefObjLoader, photoRefObjLoader=photoRefObjLoader) 

160 

161 @timeMethod 

162 def runDataRef(self, sensorRef): 

163 """Process one CCD 

164 

165 The sequence of operations is: 

166 - remove instrument signature 

167 - characterize image to estimate PSF and background 

168 - calibrate astrometry and photometry 

169 

170 @param sensorRef: butler data reference for raw data 

171 

172 @return pipe_base Struct containing these fields: 

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

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

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

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

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

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

179 """ 

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

181 

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

183 

184 charRes = self.charImage.runDataRef( 

185 dataRef=sensorRef, 

186 exposure=exposure, 

187 doUnpersist=False, 

188 ) 

189 exposure = charRes.exposure 

190 

191 if self.config.doCalibrate: 

192 calibRes = self.calibrate.runDataRef( 

193 dataRef=sensorRef, 

194 exposure=charRes.exposure, 

195 background=charRes.background, 

196 doUnpersist=False, 

197 icSourceCat=charRes.sourceCat, 

198 ) 

199 

200 return pipeBase.Struct( 

201 charRes=charRes, 

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

203 exposure=exposure, 

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

205 ) 

206 

207 @classmethod 

208 def _makeArgumentParser(cls): 

209 """!Create and return an argument parser 

210 

211 @param[in] cls the class object 

212 @return the argument parser for this task. 

213 

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

215 this is done in @ref parseAndRun. 

216 """ 

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

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

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

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

221 return parser