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 

3matplotlib.use("Agg") 

4import numpy as np 

5import unittest 

6import lsst.sims.maf.metrics as metrics 

7import lsst.utils.tests 

8 

9 

10class TestTechnicalMetrics(unittest.TestCase): 

11 

12 def testNChangesMetric(self): 

13 """ 

14 Test the NChanges metric. 

15 """ 

16 filters = np.array(['u', 'u', 'g', 'g', 'r']) 

17 visitTimes = np.arange(0, filters.size, 1) 

18 data = np.core.records.fromarrays([visitTimes, filters], 

19 names=['observationStartMJD', 'filter']) 

20 metric = metrics.NChangesMetric() 

21 result = metric.run(data) 

22 self.assertEqual(result, 2) 

23 filters = np.array(['u', 'g', 'u', 'g', 'r']) 

24 data = np.core.records.fromarrays([visitTimes, filters], 

25 names=['observationStartMJD', 'filter']) 

26 metric = metrics.NChangesMetric() 

27 result = metric.run(data) 

28 self.assertEqual(result, 4) 

29 

30 def testMinTimeBetweenStatesMetric(self): 

31 """ 

32 Test the minTimeBetweenStates metric. 

33 """ 

34 filters = np.array(['u', 'g', 'g', 'r']) 

35 visitTimes = np.array([0, 5, 6, 7]) # days 

36 data = np.core.records.fromarrays([visitTimes, filters], 

37 names=['observationStartMJD', 'filter']) 

38 metric = metrics.MinTimeBetweenStatesMetric() 

39 result = metric.run(data) # minutes 

40 self.assertEqual(result, 2*24.0*60.0) 

41 data['filter'] = np.array(['u', 'u', 'u', 'u']) 

42 result = metric.run(data) 

43 self.assertEqual(result, metric.badval) 

44 

45 def testNStateChangesFasterThanMetric(self): 

46 """ 

47 Test the NStateChangesFasterThan metric. 

48 """ 

49 filters = np.array(['u', 'g', 'g', 'r']) 

50 visitTimes = np.array([0, 5, 6, 7]) # days 

51 data = np.core.records.fromarrays([visitTimes, filters], 

52 names=['observationStartMJD', 'filter']) 

53 metric = metrics.NStateChangesFasterThanMetric(cutoff=3*24*60) 

54 result = metric.run(data) # minutes 

55 self.assertEqual(result, 1) 

56 

57 def testMaxStateChangesWithinMetric(self): 

58 """ 

59 Test the MaxStateChangesWithin metric. 

60 """ 

61 filters = np.array(['u', 'g', 'r', 'u', 'g', 'r']) 

62 visitTimes = np.array([0, 1, 1, 4, 6, 7]) # days 

63 data = np.core.records.fromarrays([visitTimes, filters], 

64 names=['observationStartMJD', 'filter']) 

65 metric = metrics.MaxStateChangesWithinMetric(timespan=1*24*60) 

66 result = metric.run(data) # minutes 

67 self.assertEqual(result, 2) 

68 filters = np.array(['u', 'g', 'g', 'u', 'g', 'r', 'g', 'r']) 

69 visitTimes = np.array([0, 1, 1, 4, 4, 7, 8, 8]) # days 

70 data = np.core.records.fromarrays([visitTimes, filters], 

71 names=['observationStartMJD', 'filter']) 

72 metric = metrics.MaxStateChangesWithinMetric(timespan=1*24*60) 

73 result = metric.run(data) # minutes 

74 self.assertEqual(result, 3) 

75 

76 filters = np.array(['u', 'g']) 

77 visitTimes = np.array([0, 1]) # days 

78 data = np.core.records.fromarrays([visitTimes, filters], 

79 names=['observationStartMJD', 'filter']) 

80 metric = metrics.MaxStateChangesWithinMetric(timespan=1*24*60) 

81 result = metric.run(data) # minutes 

82 self.assertEqual(result, 1) 

83 

84 filters = np.array(['u', 'u']) 

85 visitTimes = np.array([0, 1]) # days 

86 data = np.core.records.fromarrays([visitTimes, filters], 

87 names=['observationStartMJD', 'filter']) 

88 metric = metrics.MaxStateChangesWithinMetric(timespan=1*24*60) 

89 result = metric.run(data) # minutes 

90 self.assertEqual(result, 0) 

91 

92 def testTeffMetric(self): 

93 """ 

94 Test the Teff (time_effective) metric. 

95 """ 

96 filters = np.array(['g', 'g', 'g', 'g', 'g']) 

97 m5 = np.zeros(len(filters), float) + 25.0 

98 data = np.core.records.fromarrays([m5, filters], 

99 names=['fiveSigmaDepth', 'filter']) 

100 metric = metrics.TeffMetric(fiducialDepth={'g': 25}, teffBase=30.0) 

101 result = metric.run(data) 

102 self.assertEqual(result, 30.0*m5.size) 

103 filters = np.array(['g', 'g', 'g', 'u', 'u']) 

104 m5 = np.zeros(len(filters), float) + 25.0 

105 m5[3:5] = 20.0 

106 data = np.core.records.fromarrays([m5, filters], 

107 names=['fiveSigmaDepth', 'filter']) 

108 metric = metrics.TeffMetric(fiducialDepth={'u': 20, 'g': 25}, teffBase=30.0) 

109 result = metric.run(data) 

110 self.assertEqual(result, 30.0*m5.size) 

111 

112 def testOpenShutterFractionMetric(self): 

113 """ 

114 Test the open shutter fraction metric. 

115 """ 

116 nvisit = 10 

117 exptime = 30. 

118 slewtime = 30. 

119 visitExpTime = np.ones(nvisit, dtype='float')*exptime 

120 visitTime = np.ones(nvisit, dtype='float')*(exptime+0.0) 

121 slewTime = np.ones(nvisit, dtype='float')*slewtime 

122 data = np.core.records.fromarrays([visitExpTime, visitTime, slewTime], 

123 names=['visitExposureTime', 'visitTime', 'slewTime']) 

124 metric = metrics.OpenShutterFractionMetric() 

125 result = metric.run(data) 

126 self.assertEqual(result, .5) 

127 

128 def testBruteOSFMetric(self): 

129 """ 

130 Test the open shutter fraction metric. 

131 """ 

132 nvisit = 10 

133 exptime = 30. 

134 slewtime = 30. 

135 visitExpTime = np.ones(nvisit, dtype='float')*exptime 

136 visitTime = np.ones(nvisit, dtype='float')*(exptime+0.0) 

137 slewTime = np.ones(nvisit, dtype='float')*slewtime 

138 mjd = np.zeros(nvisit) + np.add.accumulate(visitExpTime) + np.add.accumulate(slewTime) 

139 mjd = mjd/60./60./24. 

140 data = np.core.records.fromarrays([visitExpTime, visitTime, slewTime, mjd], 

141 names=['visitExposureTime', 'visitTime', 'slewTime', 

142 'observationStartMJD']) 

143 metric = metrics.BruteOSFMetric() 

144 result = metric.run(data) 

145 self.assertGreater(result, 0.5) 

146 self.assertLess(result, 0.6) 

147 

148 def testCompletenessMetric(self): 

149 """ 

150 Test the completeness metric. 

151 """ 

152 # Generate some test data. 

153 data = np.zeros(600, dtype=list(zip(['filter'], ['<U1']))) 

154 data['filter'][:100] = 'u' 

155 data['filter'][100:200] = 'g' 

156 data['filter'][200:300] = 'r' 

157 data['filter'][300:400] = 'i' 

158 data['filter'][400:550] = 'z' 

159 data['filter'][550:600] = 'y' 

160 slicePoint = [0] 

161 # Test completeness metric when requesting all filters. 

162 metric = metrics.CompletenessMetric(u=100, g=100, r=100, i=100, z=100, y=100) 

163 completeness = metric.run(data, slicePoint) 

164 print('xxx-metric.reduceu(completeness)=', metric.reduceu(completeness)) 

165 print('xxx-metric.reduceg(completeness)=', metric.reduceg(completeness)) 

166 assert(metric.reduceu(completeness) == 1) 

167 assert(metric.reduceg(completeness) == 1) 

168 assert(metric.reducer(completeness) == 1) 

169 assert(metric.reducei(completeness) == 1) 

170 assert(metric.reducez(completeness) == 1.5) 

171 assert(metric.reducey(completeness) == 0.5) 

172 assert(metric.reduceJoint(completeness) == 0.5) 

173 # Test completeness metric when requesting only some filters. 

174 metric = metrics.CompletenessMetric(u=0, g=100, r=100, i=100, z=100, y=100) 

175 completeness = metric.run(data, slicePoint) 

176 assert(metric.reduceu(completeness) == 1) 

177 assert(metric.reduceg(completeness) == 1) 

178 assert(metric.reducer(completeness) == 1) 

179 assert(metric.reducei(completeness) == 1) 

180 assert(metric.reducez(completeness) == 1.5) 

181 assert(metric.reducey(completeness) == 0.5) 

182 assert(metric.reduceJoint(completeness) == 0.5) 

183 # Test completeness metric when some filters not observed at all. 

184 metric = metrics.CompletenessMetric(u=100, g=100, r=100, i=100, z=100, y=100) 

185 data['filter'][550:600] = 'z' 

186 data['filter'][:100] = 'g' 

187 completeness = metric.run(data, slicePoint) 

188 assert(metric.reduceu(completeness) == 0) 

189 assert(metric.reduceg(completeness) == 2) 

190 assert(metric.reducer(completeness) == 1) 

191 assert(metric.reducei(completeness) == 1) 

192 assert(metric.reducez(completeness) == 2) 

193 assert(metric.reducey(completeness) == 0) 

194 assert(metric.reduceJoint(completeness) == 0) 

195 # And test that if you forget to set any requested visits, that you get the useful error message 

196 self.assertRaises(ValueError, metrics.CompletenessMetric, 'filter') 

197 

198 

199class TestMemory(lsst.utils.tests.MemoryTestCase): 

200 pass 

201 

202 

203def setup_module(module): 

204 lsst.utils.tests.init() 

205 

206 

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

208 lsst.utils.tests.init() 

209 unittest.main()