Coverage for tests/testMovieSlicer.py : 17%

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
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
27class TestMovieSlicerSetup(unittest.TestCase):
29 def setUp(self):
30 self.testslicer = MovieSlicer(sliceColName='times', cumulative=False, forceNoFfmpeg=True)
32 def tearDown(self):
33 del self.testslicer
34 self.testslicer = None
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')
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)
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))
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)
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)
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])
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)
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)
182class TestMemory(lsst.utils.tests.MemoryTestCase):
183 pass
186def setup_module(module):
187 lsst.utils.tests.init()
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()