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

1from builtins import zip 

2import matplotlib 

3# matplotlib.use("Agg") 

4import numpy as np 

5import unittest 

6#import lsst.sims.maf.metrics as metrics 

7import lsst.utils.tests 

8from lsst.sims.maf.utils.snUtils import Lims, ReferenceData 

9from lsst.sims.maf.metrics import SNCadenceMetric 

10from lsst.sims.maf.metrics import SNSNRMetric 

11from lsst.sims.maf.metrics import SNSLMetric 

12from lsst.sims.maf.metrics import SNNSNMetric 

13 

14import os 

15import warnings 

16import healpy as hp 

17import time 

18 

19m5_ref = dict( 

20 zip('ugrizy', [23.60, 24.83, 24.38, 23.92, 23.35, 22.44])) 

21 

22 

23def Observations_band(day0=59000, daymin=59000, cadence=3., season_length=140., band='r'): 

24 # Define fake data 

25 names = ['observationStartMJD', 'fieldRA', 'fieldDec', 

26 'fiveSigmaDepth', 'visitExposureTime', 'numExposures', 

27 'visitTime', 'season', 'seeingFwhmEff', 'seeingFwhmGeom', 

28 'pixRA', 'pixDec'] 

29 types = ['f8']*len(names) 

30 names += ['night', 'healpixID'] 

31 types += ['i2', 'i2'] 

32 names += ['filter'] 

33 types += ['O'] 

34 

35 daylast = daymin+season_length 

36 cadence = cadence 

37 dayobs = np.arange(daymin, daylast, cadence) 

38 npts = len(dayobs) 

39 data = np.zeros(npts, dtype=list(zip(names, types))) 

40 data['observationStartMJD'] = dayobs 

41 data['night'] = np.floor(data['observationStartMJD']-day0+1) 

42 #data['night'] = 10 

43 data['fiveSigmaDepth'] = m5_ref[band] 

44 data['visitExposureTime'] = 30. 

45 data['numExposures'] = 1 

46 data['visitTime'] = 34 

47 data['filter'] = band 

48 #data['season'] = 1. 

49 data['seeingFwhmEff'] = 0.8 

50 data['seeingFwhmGeom'] = 0.8 

51 data['healpixID'] = 10 

52 data['pixRA'] = 0.0 

53 data['pixDec'] = 0.0 

54 return data 

55 

56 

57def Observations_season(day0=59000, mjdmin=59000, cadence=3.): 

58 bands = 'grizy' 

59 Nvisits = dict(zip(bands, [10, 20, 20, 26, 20])) 

60 rat = 34./3600./24. 

61 shift_visits = {} 

62 shift_visits['g'] = 0 

63 shift_visits['r'] = rat*Nvisits['g'] 

64 shift_visits['i'] = rat*Nvisits['r'] 

65 shift_visits['z'] = rat*Nvisits['i'] 

66 shift_visits['y'] = rat*Nvisits['z'] 

67 

68 # get data 

69 data = None 

70 season_length = 180 

71 shift = 30./(3600.*24) 

72 for band in bands: 

73 

74 mjd = mjdmin+shift_visits[band] 

75 for i in range(Nvisits[band]): 

76 mjd += shift 

77 dat = Observations_band( 

78 daymin=mjd, season_length=season_length, cadence=cadence, band=band) 

79 if data is None: 

80 data = dat 

81 else: 

82 data = np.concatenate((data, dat)) 

83 

84 return data 

85 

86 

87def fakeData(band, season=1): 

88 

89 # Define fake data 

90 names = ['observationStartMJD', 'fieldRA', 'fieldDec', 

91 'fiveSigmaDepth', 'visitExposureTime', 

92 'numExposures', 'visitTime', 'season', 

93 'seeingFwhmEff', 'seeingFwhmGeom', 

94 'airmass', 'sky', 'moonPhase', 'pixRA', 'pixDec'] 

95 

96 types = ['f8']*len(names) 

97 names += ['night'] 

98 types += ['i2'] 

99 names += ['healpixID'] 

100 types += ['i2'] 

101 names += ['filter'] 

102 types += ['O'] 

103 

104 dayobs = [59948.31957176, 59959.2821412, 59970.26134259, 

105 59973.25978009, 59976.26383102, 59988.20670139, 59991.18412037, 

106 60004.1853588, 60032.08975694, 60045.11981481, 60047.98747685, 

107 60060.02083333, 60071.986875, 60075.96452546] 

108 day0 = np.min(dayobs) 

109 npts = len(dayobs) 

110 data = np.zeros(npts, dtype=list(zip(names, types))) 

111 data['observationStartMJD'] = dayobs 

112 data['night'] = np.floor(data['observationStartMJD']-day0+1) 

113 data['fiveSigmaDepth'] = m5_ref[band] 

114 data['visitExposureTime'] = 15. 

115 data['numExposures'] = 2 

116 data['visitTime'] = 2.*15. 

117 data['season'] = season 

118 data['filter'] = band 

119 data['seeingFwhmEff'] = 0. 

120 data['seeingFwhmGeom'] = 0. 

121 data['airmass'] = 1.2 

122 data['sky'] = 20.0 

123 data['moonPhase'] = 0.5 

124 data['pixRA'] = 0.0 

125 data['pixDec'] = 0.0 

126 data['healpixID'] = 1 

127 

128 return data 

129 

130 

131class TestSNmetrics(unittest.TestCase): 

132 

133 def testSNCadenceMetric(self): 

134 """Test the SN cadence metric """ 

135 

136 # Load up the files from sims_maf_contrib if possible 

137 sims_maf_contrib_dir = os.getenv("SIMS_MAF_CONTRIB_DIR") 

138 if sims_maf_contrib_dir is not None: 

139 # Load required SN info to run the metric 

140 band = 'r' 

141 SNR = dict(zip('griz', [30., 40., 30., 20.])) # SNR for WFD 

142 mag_range = [21., 25.5] # WFD mag range 

143 dt_range = [0.5, 30.] # WFD dt range 

144 Li_files = [os.path.join( 

145 sims_maf_contrib_dir, 'data', 'Li_SNCosmo_-2.0_0.2.npy')] 

146 mag_to_flux_files = [os.path.join( 

147 sims_maf_contrib_dir, 'data', 'Mag_to_Flux_SNCosmo.npy')] 

148 lim_sn = Lims(Li_files, mag_to_flux_files, band, SNR[band], 

149 mag_range=mag_range, dt_range=dt_range) 

150 

151 # Define fake data 

152 names = ['observationStartMJD', 'fieldRA', 'fieldDec', 

153 'fiveSigmaDepth', 'visitExposureTime', 'numExposures', 'visitTime'] 

154 types = ['f8']*len(names) 

155 names += ['night'] 

156 types += ['i2'] 

157 names += ['filter'] 

158 types += ['O'] 

159 

160 day0 = 59000 

161 daylast = day0+250 

162 cadence = 5 

163 dayobs = np.arange(day0, daylast, cadence) 

164 npts = len(dayobs) 

165 data = np.zeros(npts, dtype=list(zip(names, types))) 

166 data['observationStartMJD'] = dayobs 

167 data['night'] = np.floor(data['observationStartMJD']-day0) 

168 data['fiveSigmaDepth'] = m5_ref[band] 

169 data['visitExposureTime'] = 15. 

170 data['numExposures'] = 2 

171 data['visitTime'] = 2.*15. 

172 data['filter'] = band 

173 

174 # Run the metric with these fake data 

175 slicePoint = {'nside': 64} 

176 metric = SNCadenceMetric(lim_sn=lim_sn, coadd=False) 

177 result = metric.run(data, slicePoint) 

178 

179 # And the result should be... 

180 result_ref = 0.3743514 

181 

182 assert(np.abs(result-result_ref) < 1.e-5) 

183 else: 

184 warnings.warn( 

185 "skipping SN test because no SIMS_MAF_CONTRIB_DIR set") 

186 

187 def testSNSNRMetric(self): 

188 """Test the SN SNR metric """ 

189 

190 sims_maf_contrib_dir = os.getenv("SIMS_MAF_CONTRIB_DIR") 

191 if sims_maf_contrib_dir is not None: 

192 # Load required SN info to run the metric 

193 band = 'r' 

194 z = 0.3 

195 season = 1. 

196 Li_files = [os.path.join( 

197 sims_maf_contrib_dir, 'data', 'Li_SNCosmo_-2.0_0.2.npy')] 

198 mag_to_flux_files = [os.path.join( 

199 sims_maf_contrib_dir, 'data', 'Mag_to_Flux_SNCosmo.npy')] 

200 

201 names_ref = ['SNCosmo'] 

202 coadd = False 

203 

204 lim_sn = ReferenceData(Li_files, mag_to_flux_files, band, z) 

205 

206 # Define fake data 

207 names = ['observationStartMJD', 'fieldRA', 'fieldDec', 

208 'fiveSigmaDepth', 'visitExposureTime', 'numExposures', 'visitTime', 'season'] 

209 types = ['f8']*len(names) 

210 names += ['night'] 

211 types += ['i2'] 

212 names += ['filter'] 

213 types += ['O'] 

214 

215 dayobs = [59948.31957176, 59959.2821412, 59970.26134259, 

216 59973.25978009, 59976.26383102, 59988.20670139, 59991.18412037, 

217 60004.1853588, 60032.08975694, 60045.11981481, 60047.98747685, 

218 60060.02083333, 60071.986875, 60075.96452546] 

219 day0 = np.min(dayobs) 

220 npts = len(dayobs) 

221 data = np.zeros(npts, dtype=list(zip(names, types))) 

222 

223 data['observationStartMJD'] = dayobs 

224 data['night'] = np.floor(data['observationStartMJD']-day0) 

225 data['fiveSigmaDepth'] = m5_ref[band] 

226 data['visitExposureTime'] = 15. 

227 data['numExposures'] = 2 

228 data['visitTime'] = 2.*15. 

229 data['season'] = season 

230 data['filter'] = band 

231 

232 # Run the metric with these fake data 

233 slicePoint = {'nside': 64} 

234 metric = SNSNRMetric( 

235 lim_sn=lim_sn, coadd=coadd, names_ref=names_ref, season=season, z=z) 

236 

237 result = metric.run(data, slicePoint) 

238 

239 # And the result should be... 

240 result_ref = 0.4830508474576271 

241 

242 assert(np.abs(result-result_ref) < 1.e-5) 

243 else: 

244 warnings.warn( 

245 "skipping SN test because no SIMS_MAF_CONTRIB_DIR set") 

246 

247 def testSNSLMetric(self): 

248 """Test the SN SL metric """ 

249 

250 # load some fake data 

251 data = None 

252 bands = 'griz' 

253 cadence = dict(zip(bands, [2, 1, 2, 1])) 

254 for band in bands: 

255 for i in range(cadence[band]): 

256 fakes = fakeData(band) 

257 if data is None: 

258 data = fakes 

259 else: 

260 data = np.concatenate((data, fakes)) 

261 

262 # metric instance 

263 night_collapse = True 

264 

265 metric = SNSLMetric(night_collapse=night_collapse) 

266 

267 # run the metric 

268 nSL = metric.run(data, slicePoint={'nside': 64}) 

269 

270 # and the result should be 

271 

272 nSL_ref = 0.00012650940 

273 

274 assert(np.abs(nSL-nSL_ref) < 1.e-8) 

275 

276 def testNSNMetric(self): 

277 """ Test the SN NSN metric """ 

278 sims_maf_contrib_dir = os.getenv("SIMS_MAF_CONTRIB_DIR") 

279 if sims_maf_contrib_dir is not None: 

280 

281 day0 = 59000 

282 data = None 

283 

284 diff_season = 280. 

285 nseasons = 1 

286 for val in np.arange(59000, 59000+nseasons*diff_season, diff_season): 

287 dat = Observations_season(day0, val) 

288 if data is None: 

289 data = dat 

290 else: 

291 data = np.concatenate((data, dat)) 

292 

293 #print('data generated', len(data)) 

294 

295 # this is to mimic healpixilization 

296 nside = 128 

297 area = hp.nside2pixarea(nside, degrees=True) 

298 # metric instance 

299 templateDir = None 

300 metric = SNNSNMetric( 

301 pixArea=area, season=[-1], verbose=False, templateDir=templateDir) 

302 

303 time_ref = time.time() 

304 

305 res = metric.run(data) 

306 

307 nSN = res['nSN'].item() 

308 zlim = res['zlim'].item() 

309 

310 #print(time.time()-time_ref, nSN, zlim) 

311 nSN_ref = 2.523 

312 zlim_ref = 0.65 

313 

314 assert(np.isclose(nSN, nSN_ref)) 

315 assert(np.isclose(zlim, zlim_ref)) 

316 else: 

317 warnings.warn( 

318 "skipping SN test because no SIMS_MAF_CONTRIB_DIR set") 

319 

320def setup_module(module): 

321 lsst.utils.tests.init() 

322 

323 

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

325 lsst.utils.tests.init() 

326 unittest.main()