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, nfilters_min=4, min_season_obs=5, 

266 m5mins={'u': 22.7, 'g': 24.1, 'r': 23.7, 'i': 23.1, 'z': 22.2, 'y': 21.4}) 

267 

268 # run the metric 

269 nSL = metric.run(data, slicePoint={'nside': 64, 'ra': 0., 'ebv': 0.}) 

270 

271 # and the result should be 

272 # Changing the refernce value because we have new coadd and mag limits 

273 nSL_ref = 1.42168e-6 # 0.00012650940 

274 

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

276 

277 def testNSNMetric(self): 

278 """ Test the SN NSN metric """ 

279 sims_maf_contrib_dir = os.getenv("SIMS_MAF_CONTRIB_DIR") 

280 if sims_maf_contrib_dir is not None: 

281 

282 day0 = 59000 

283 data = None 

284 

285 diff_season = 280. 

286 nseasons = 1 

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

288 dat = Observations_season(day0, val) 

289 if data is None: 

290 data = dat 

291 else: 

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

293 

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

295 

296 # this is to mimic healpixilization 

297 nside = 128 

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

299 # metric instance 

300 templateDir = None 

301 metric = SNNSNMetric( 

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

303 

304 time_ref = time.time() 

305 

306 res = metric.run(data) 

307 

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

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

310 

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

312 nSN_ref = 2.523 

313 zlim_ref = 0.65 

314 

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

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

317 else: 

318 warnings.warn( 

319 "skipping SN test because no SIMS_MAF_CONTRIB_DIR set") 

320 

321def setup_module(module): 

322 lsst.utils.tests.init() 

323 

324 

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

326 lsst.utils.tests.init() 

327 unittest.main()