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 str 

2from builtins import zip 

3import matplotlib 

4matplotlib.use("Agg") 

5import numpy as np 

6import warnings 

7import unittest 

8from lsst.sims.maf.slicers.movieSlicer import MovieSlicer 

9from lsst.sims.maf.slicers.uniSlicer import UniSlicer 

10import lsst.utils.tests 

11 

12 

13def makeTimes(size=100, min=0., max=10., random=-1): 

14 """Generate a simple array of numbers, evenly arranged between min/max.""" 

15 datavalues = np.arange(0, size, dtype='float') 

16 datavalues *= (float(max) - float(min)) / (datavalues.max() - datavalues.min()) 

17 datavalues += min 

18 if random > 0: 

19 rng = np.random.RandomState(random) 

20 randorder = rng.rand(size) 

21 randind = np.argsort(randorder) 

22 datavalues = datavalues[randind] 

23 datavalues = np.array(list(zip(datavalues)), dtype=[('times', 'float')]) 

24 return datavalues 

25 

26 

27class TestMovieSlicerSetup(unittest.TestCase): 

28 

29 def setUp(self): 

30 self.testslicer = MovieSlicer(sliceColName='times', cumulative=False, forceNoFfmpeg=True) 

31 

32 def tearDown(self): 

33 del self.testslicer 

34 self.testslicer = None 

35 

36 def testSlicertype(self): 

37 """Test instantiation of slicer sets slicer type as expected.""" 

38 self.assertEqual(self.testslicer.slicerName, self.testslicer.__class__.__name__) 

39 self.assertEqual(self.testslicer.slicerName, 'MovieSlicer') 

40 

41 def testSetupSlicerBins(self): 

42 """Test setting up slicer using defined bins.""" 

43 dvmin = 0 

44 dvmax = 1 

45 nvalues = 1000 

46 bins = np.arange(dvmin, dvmax, 0.1) 

47 dv = makeTimes(nvalues, dvmin, dvmax, random=987) 

48 # Used right bins? 

49 self.testslicer = MovieSlicer(sliceColName='times', bins=bins, cumulative=False, forceNoFfmpeg=True) 

50 self.testslicer.setupSlicer(dv) 

51 np.testing.assert_equal(self.testslicer.bins, bins) 

52 self.assertEqual(self.testslicer.nslice, len(bins)-1) 

53 

54 def testSetupSlicerBinsize(self): 

55 """Test setting up slicer using binsize.""" 

56 dvmin = 0 

57 dvmax = 1 

58 dv = makeTimes(1000, dvmin, dvmax, random=1992) 

59 binsize = 0.1 

60 for cumulative in ([True, False]): 

61 self.testslicer = MovieSlicer(sliceColName='times', binsize=binsize, cumulative=cumulative, 

62 forceNoFfmpeg=True) 

63 self.testslicer.setupSlicer(dv) 

64 # Bins of the right size? 

65 bindiff = np.diff(self.testslicer.bins) 

66 self.assertAlmostEqual(bindiff.max(), binsize) 

67 self.assertAlmostEqual(bindiff.min(), binsize) 

68 # Test that warning works. 

69 with warnings.catch_warnings(record=True) as w: 

70 warnings.simplefilter("always") 

71 self.testslicer = MovieSlicer(sliceColName='times', bins=200, binsize=binsize, 

72 cumulative=False, forceNoFfmpeg=True) 

73 self.testslicer.setupSlicer(dv) 

74 # Verify some things 

75 self.assertIn("binsize", str(w[-1].message)) 

76 

77 def testSetupSlicerNbinsZeros(self): 

78 """Test what happens if give slicer test data that is all single-value.""" 

79 dv = np.zeros(100, float) 

80 dv = np.array(list(zip(dv)), dtype=[('times', 'float')]) 

81 nbins = 10 

82 self.testslicer = MovieSlicer(sliceColName='times', bins=nbins, cumulative=False, forceNoFfmpeg=True) 

83 with warnings.catch_warnings(record=True) as w: 

84 warnings.simplefilter("always") 

85 self.testslicer.setupSlicer(dv) 

86 self.assertIn("creasing binMax", str(w[-1].message)) 

87 self.assertEqual(self.testslicer.nslice, nbins) 

88 

89 def testSetupSlicerLimits(self): 

90 """Test setting up slicer using binMin/Max.""" 

91 binMin = 0 

92 binMax = 1 

93 nbins = 10 

94 dvmin = -.5 

95 dvmax = 1.5 

96 dv = makeTimes(1000, dvmin, dvmax, random=1772) 

97 self.testslicer = MovieSlicer(sliceColName='times', 

98 binMin=binMin, binMax=binMax, bins=nbins, 

99 cumulative=False, forceNoFfmpeg=True) 

100 self.testslicer.setupSlicer(dv) 

101 self.assertAlmostEqual(self.testslicer.bins.min(), binMin) 

102 self.assertAlmostEqual(self.testslicer.bins.max(), binMax) 

103 

104 def testIndexing(self): 

105 """Test iteration and indexing.""" 

106 dvmin = 0 

107 dvmax = 1 

108 bins = np.arange(dvmin, dvmax+0.05, 0.05) 

109 self.testslicer = MovieSlicer(sliceColName='times', bins=bins, 

110 cumulative=False, forceNoFfmpeg=True) 

111 dv = makeTimes(1000, dvmin, dvmax, random=908223) 

112 self.testslicer.setupSlicer(dv) 

113 for i, (s, b) in enumerate(zip(self.testslicer, bins)): 

114 self.assertEqual(s['slicePoint']['sid'], i) 

115 self.assertEqual(s['slicePoint']['binLeft'], b) 

116 self.assertLessEqual(s['slicePoint']['binRight'], bins[i+1]) 

117 for i in ([0, len(self.testslicer)//2, len(self.testslicer)-1]): 

118 self.assertEqual(self.testslicer[i]['slicePoint']['sid'], i) 

119 self.assertEqual(self.testslicer[i]['slicePoint']['binLeft'], bins[i]) 

120 

121 def testEquivalence(self): 

122 """Test equals method.""" 

123 # Note that two Movie slicers will be considered equal if they are both the same kind of 

124 # slicer AND have the same bins. 

125 # Set up self.. 

126 dvmin = 0 

127 dvmax = 1 

128 nvalues = 1000 

129 bins = np.arange(dvmin, dvmax, 0.01) 

130 dv = makeTimes(nvalues, dvmin, dvmax, random=72031) 

131 self.testslicer = MovieSlicer(sliceColName='times', bins=bins, cumulative=False, forceNoFfmpeg=True) 

132 self.testslicer.setupSlicer(dv) 

133 # Set up another slicer to match (same bins, although not the same data). 

134 dv2 = makeTimes(nvalues+100, dvmin, dvmax, random=56221) 

135 testslicer2 = MovieSlicer(sliceColName='times', bins=bins, cumulative=False, forceNoFfmpeg=True) 

136 testslicer2.setupSlicer(dv2) 

137 self.assertEqual(self.testslicer, testslicer2) 

138 # Set up another slicer that should not match (different bins) 

139 dv2 = makeTimes(nvalues, dvmin+1, dvmax+1, random=542093) 

140 testslicer2 = MovieSlicer(sliceColName='times', bins=len(bins), cumulative=False, forceNoFfmpeg=True) 

141 testslicer2.setupSlicer(dv2) 

142 self.assertNotEqual(self.testslicer, testslicer2) 

143 # Set up a different kind of slicer that should not match. 

144 dv2 = makeTimes(100, 0, 1, random=16) 

145 testslicer2 = UniSlicer() 

146 testslicer2.setupSlicer(dv2) 

147 self.assertNotEqual(self.testslicer, testslicer2) 

148 

149 def testSlicing(self): 

150 """Test slicing.""" 

151 dvmin = 0 

152 dvmax = 1 

153 nbins = 100 

154 # Test that testbinner raises appropriate error before it's set up (first time) 

155 self.assertRaises(NotImplementedError, self.testslicer._sliceSimData, 0) 

156 for nvalues in (100, 1000): 

157 dv = makeTimes(nvalues, dvmin, dvmax, random=82) 

158 # Test differential case. 

159 self.testslicer = MovieSlicer(sliceColName='times', bins=nbins, cumulative=False, 

160 forceNoFfmpeg=True) 

161 self.testslicer.setupSlicer(dv) 

162 sum = 0 

163 for i, s in enumerate(self.testslicer): 

164 idxs = s['idxs'] 

165 dataslice = dv['times'][idxs] 

166 sum += len(idxs) 

167 if len(dataslice) > 0: 

168 self.assertEqual(len(dataslice), nvalues/float(nbins)) 

169 else: 

170 raise ValueError('Data in test case expected to always be > 0 len after slicing') 

171 self.assertEqual(sum, nvalues) 

172 # And cumulative case. 

173 self.testslicer = MovieSlicer(sliceColName='times', bins=nbins, cumulative=True, 

174 forceNoFfmpeg=True) 

175 self.testslicer.setupSlicer(dv) 

176 for i, s in enumerate(self.testslicer): 

177 idxs = s['idxs'] 

178 dataslice = dv['times'][idxs] 

179 self.assertGreater(len(dataslice), 0) 

180 

181 

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

183 pass 

184 

185 

186def setup_module(module): 

187 lsst.utils.tests.init() 

188 

189 

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

191 lsst.utils.tests.init() 

192 unittest.main()