rubin-sim 2.6.1.dev2__py3-none-any.whl

tests/maf/test_movieslicer.py

@@ -0,0 +1,216 @@
+import unittest
+import warnings
+
+import numpy as np
+
+from rubin_sim.maf.slicers import MovieSlicer, UniSlicer
+
+
+def make_times(size=100, min=0.0, max=10.0, random=-1):
+    """Generate a simple array of numbers, evenly arranged between min/max."""
+    datavalues = np.arange(0, size, dtype="float")
+    datavalues *= (float(max) - float(min)) / (datavalues.max() - datavalues.min())
+    datavalues += min
+    if random > 0:
+        rng = np.random.RandomState(random)
+        randorder = rng.rand(size)
+        randind = np.argsort(randorder)
+        datavalues = datavalues[randind]
+    datavalues = np.array(list(zip(datavalues)), dtype=[("times", "float")])
+    return datavalues
+
+
+class TestMovieSlicerSetup(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = MovieSlicer(slice_col_name="times", cumulative=False, force_no_ffmpeg=True)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_slicertype(self):
+        """Test instantiation of slicer sets slicer type as expected."""
+        self.assertEqual(self.testslicer.slicer_name, self.testslicer.__class__.__name__)
+        self.assertEqual(self.testslicer.slicer_name, "MovieSlicer")
+
+    def test_setup_slicer_bins(self):
+        """Test setting up slicer using defined bins."""
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        bins = np.arange(dvmin, dvmax, 0.1)
+        dv = make_times(nvalues, dvmin, dvmax, random=987)
+        # Used right bins?
+        self.testslicer = MovieSlicer(
+            slice_col_name="times", bins=bins, cumulative=False, force_no_ffmpeg=True
+        )
+        self.testslicer.setup_slicer(dv)
+        np.testing.assert_equal(self.testslicer.bins, bins)
+        self.assertEqual(self.testslicer.nslice, len(bins) - 1)
+
+    def test_setup_slicer_binsize(self):
+        """Test setting up slicer using bin_size."""
+        dvmin = 0
+        dvmax = 1
+        dv = make_times(1000, dvmin, dvmax, random=1992)
+        bin_size = 0.1
+        for cumulative in [True, False]:
+            self.testslicer = MovieSlicer(
+                slice_col_name="times",
+                bin_size=bin_size,
+                cumulative=cumulative,
+                force_no_ffmpeg=True,
+            )
+            self.testslicer.setup_slicer(dv)
+            # Bins of the right size?
+            bindiff = np.diff(self.testslicer.bins)
+            self.assertAlmostEqual(bindiff.max(), bin_size)
+            self.assertAlmostEqual(bindiff.min(), bin_size)
+        # Test that warning works.
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.testslicer = MovieSlicer(
+                slice_col_name="times",
+                bins=200,
+                bin_size=bin_size,
+                cumulative=False,
+                force_no_ffmpeg=True,
+            )
+            self.testslicer.setup_slicer(dv)
+            # Verify some things
+            self.assertIn("bin_size", str(w[-1].message))
+
+    def test_setup_slicer_nbins_zeros(self):
+        """Test what happens if give slicer test data that is all
+        single-value."""
+        dv = np.zeros(100, float)
+        dv = np.array(list(zip(dv)), dtype=[("times", "float")])
+        nbins = 10
+        self.testslicer = MovieSlicer(
+            slice_col_name="times", bins=nbins, cumulative=False, force_no_ffmpeg=True
+        )
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.testslicer.setup_slicer(dv)
+            self.assertIn("creasing bin_max", str(w[-1].message))
+        self.assertEqual(self.testslicer.nslice, nbins)
+
+    def test_setup_slicer_limits(self):
+        """Test setting up slicer using bin_min/Max."""
+        bin_min = 0
+        bin_max = 1
+        nbins = 10
+        dvmin = -0.5
+        dvmax = 1.5
+        dv = make_times(1000, dvmin, dvmax, random=1772)
+        self.testslicer = MovieSlicer(
+            slice_col_name="times",
+            bin_min=bin_min,
+            bin_max=bin_max,
+            bins=nbins,
+            cumulative=False,
+            force_no_ffmpeg=True,
+        )
+        self.testslicer.setup_slicer(dv)
+        self.assertAlmostEqual(self.testslicer.bins.min(), bin_min)
+        self.assertAlmostEqual(self.testslicer.bins.max(), bin_max)
+
+    def test_indexing(self):
+        """Test iteration and indexing."""
+        dvmin = 0
+        dvmax = 1
+        bins = np.arange(dvmin, dvmax + 0.05, 0.05)
+        self.testslicer = MovieSlicer(
+            slice_col_name="times", bins=bins, cumulative=False, force_no_ffmpeg=True
+        )
+        dv = make_times(1000, dvmin, dvmax, random=908223)
+        self.testslicer.setup_slicer(dv)
+        for i, (s, b) in enumerate(zip(self.testslicer, bins)):
+            self.assertEqual(s["slice_point"]["sid"], i)
+            self.assertEqual(s["slice_point"]["bin_left"], b)
+            self.assertLessEqual(s["slice_point"]["bin_right"], bins[i + 1])
+        for i in [0, len(self.testslicer) // 2, len(self.testslicer) - 1]:
+            self.assertEqual(self.testslicer[i]["slice_point"]["sid"], i)
+            self.assertEqual(self.testslicer[i]["slice_point"]["bin_left"], bins[i])
+
+    def test_equivalence(self):
+        """Test equals method."""
+        # Note that two Movie slicers will be considered equal
+        # if they are both the same kind of
+        # slicer AND have the same bins.
+        # Set up self..
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        bins = np.arange(dvmin, dvmax, 0.01)
+        dv = make_times(nvalues, dvmin, dvmax, random=72031)
+        self.testslicer = MovieSlicer(
+            slice_col_name="times", bins=bins, cumulative=False, force_no_ffmpeg=True
+        )
+        self.testslicer.setup_slicer(dv)
+        # Set up another slicer to match
+        # (same bins, although not the same data).
+        dv2 = make_times(nvalues + 100, dvmin, dvmax, random=56221)
+        testslicer2 = MovieSlicer(slice_col_name="times", bins=bins, cumulative=False, force_no_ffmpeg=True)
+        testslicer2.setup_slicer(dv2)
+        self.assertEqual(self.testslicer, testslicer2)
+        # Set up another slicer that should not match (different bins)
+        dv2 = make_times(nvalues, dvmin + 1, dvmax + 1, random=542093)
+        testslicer2 = MovieSlicer(
+            slice_col_name="times",
+            bins=len(bins),
+            cumulative=False,
+            force_no_ffmpeg=True,
+        )
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+        # Set up a different kind of slicer that should not match.
+        dv2 = make_times(100, 0, 1, random=16)
+        testslicer2 = UniSlicer()
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+
+    def test_slicing(self):
+        """Test slicing."""
+        dvmin = 0
+        dvmax = 1
+        nbins = 100
+        # Test that testbinner raises appropriate error before it's set up
+        # (first time)
+        self.assertRaises(NotImplementedError, self.testslicer._slice_sim_data, 0)
+        for nvalues in (100, 1000):
+            dv = make_times(nvalues, dvmin, dvmax, random=82)
+            # Test differential case.
+            self.testslicer = MovieSlicer(
+                slice_col_name="times",
+                bins=nbins,
+                cumulative=False,
+                force_no_ffmpeg=True,
+            )
+            self.testslicer.setup_slicer(dv)
+            sum = 0
+            for i, s in enumerate(self.testslicer):
+                idxs = s["idxs"]
+                data_slice = dv["times"][idxs]
+                sum += len(idxs)
+                if len(data_slice) > 0:
+                    self.assertEqual(len(data_slice), nvalues / float(nbins))
+                else:
+                    raise ValueError("Data in test case expected to always be > 0 len after slicing")
+            self.assertEqual(sum, nvalues)
+            # And cumulative case.
+            self.testslicer = MovieSlicer(
+                slice_col_name="times",
+                bins=nbins,
+                cumulative=True,
+                force_no_ffmpeg=True,
+            )
+            self.testslicer.setup_slicer(dv)
+            for i, s in enumerate(self.testslicer):
+                idxs = s["idxs"]
+                data_slice = dv["times"][idxs]
+                self.assertGreater(len(data_slice), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_ndslicer.py

@@ -0,0 +1,240 @@
+import itertools
+import unittest
+import warnings
+
+import numpy as np
+import numpy.lib.recfunctions as rfn
+
+from rubin_sim.maf.slicers import NDSlicer, UniSlicer
+
+
+def make_data_values(size=100, min=0.0, max=1.0, nd=3, random=-1):
+    """Generate a simple array of numbers, evenly arranged between min/max,
+    in nd dimensions, but (optional) random order.
+    """
+    data = []
+    for d in range(nd):
+        datavalues = np.arange(0, size, dtype="float")
+        datavalues *= (float(max) - float(min)) / (datavalues.max() - datavalues.min())
+        datavalues += min
+        if random > 0:
+            rng = np.random.RandomState(random)
+            randorder = rng.rand(size)
+            randind = np.argsort(randorder)
+            datavalues = datavalues[randind]
+        datavalues = np.array(list(zip(datavalues)), dtype=[("testdata" + "%d" % (d), "float")])
+        data.append(datavalues)
+    data = rfn.merge_arrays(data, flatten=True, usemask=False)
+    return data
+
+
+class TestNDSlicerSetup(unittest.TestCase):
+    def setUp(self):
+        self.dvmin = 0
+        self.dvmax = 1
+        nvalues = 1000
+        self.nd = 3
+        self.dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=608)
+        self.dvlist = self.dv.dtype.names
+
+    def test_slicertype(self):
+        """Test instantiation of slicer sets slicer type as expected."""
+        testslicer = NDSlicer(self.dvlist)
+        self.assertEqual(testslicer.slicer_name, testslicer.__class__.__name__)
+        self.assertEqual(testslicer.slicer_name, "NDSlicer")
+
+    def test_setup_slicer_bins(self):
+        """Test setting up slicer using defined bins."""
+        # Used right bins?
+        bins = np.arange(self.dvmin, self.dvmax, 0.1)
+        binlist = []
+        for d in range(self.nd):
+            binlist.append(bins)
+        testslicer = NDSlicer(self.dvlist, bins_list=binlist)
+        testslicer.setup_slicer(self.dv)
+        for d in range(self.nd):
+            np.testing.assert_equal(testslicer.bins[d], bins)
+        self.assertEqual(testslicer.nslice, (len(bins) - 1) ** self.nd)
+
+    def test_setup_slicer_nbins(self):
+        """Test setting up slicer using nbins."""
+        for nvalues in (100, 1000):
+            for nbins in (5, 25, 74):
+                dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=-1)
+                # Right number of bins?
+                # expect one more 'bin' to accomodate last right edge,
+                # but nbins accounts for this
+                testslicer = NDSlicer(self.dvlist, bins_list=nbins)
+                testslicer.setup_slicer(dv)
+                self.assertEqual(testslicer.nslice, nbins**self.nd)
+                # Bins of the right size?
+                for i in range(self.nd):
+                    bindiff = np.diff(testslicer.bins[i])
+                    expectedbindiff = (self.dvmax - self.dvmin) / float(nbins)
+                    np.testing.assert_allclose(bindiff, expectedbindiff)
+                # Can we use a list of nbins too and get the
+                # right number of bins?
+                nbins_list = []
+                expectednbins = 1
+                for d in range(self.nd):
+                    nbins_list.append(nbins + d)
+                    expectednbins *= nbins + d
+                testslicer = NDSlicer(self.dvlist, bins_list=nbins_list)
+                testslicer.setup_slicer(dv)
+                self.assertEqual(testslicer.nslice, expectednbins)
+
+    def test_setup_slicer_nbins_zeros(self):
+        """Test handling case of data being single values."""
+        dv = make_data_values(100, 0, 0, self.nd, random=-1)
+        nbins = 10
+        testslicer = NDSlicer(self.dvlist, bins_list=nbins)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            testslicer.setup_slicer(dv)
+            self.assertIn("creasing bin_max", str(w[-1].message))
+        expectednbins = nbins**self.nd
+        self.assertEqual(testslicer.nslice, expectednbins)
+
+    def test_setup_slicer_equivalent(self):
+        """Test setting up slicer using defined bins and nbins is
+        equal where expected.
+        """
+        for nbins in (20, 105):
+            testslicer = NDSlicer(self.dvlist, bins_list=nbins)
+            bins = make_data_values(nbins + 1, self.dvmin, self.dvmax, self.nd, random=-1)
+            bins_list = []
+            for i in bins.dtype.names:
+                bins_list.append(bins[i])
+            for nvalues in (100, 10000):
+                dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=64432)
+                testslicer.setup_slicer(dv)
+                for i in range(self.nd):
+                    np.testing.assert_allclose(testslicer.bins[i], bins_list[i])
+
+
+class TestNDSlicerEqual(unittest.TestCase):
+    def setUp(self):
+        self.dvmin = 0
+        self.dvmax = 1
+        nvalues = 1000
+        self.nd = 3
+        self.dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=20367)
+        self.dvlist = self.dv.dtype.names
+        self.testslicer = NDSlicer(self.dvlist, bins_list=100)
+        self.testslicer.setup_slicer(self.dv)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_equivalence(self):
+        """Test equals method."""
+        # Note that two ND slicers will be considered equal if
+        # they are both the same kind of slicer AND have the same bins in
+        # all dimensions.
+        # Set up another slicer to match
+        # (same bins, although not the same data).
+        dv2 = make_data_values(100, self.dvmin, self.dvmax, self.nd, random=10029)
+        dvlist = dv2.dtype.names
+        testslicer2 = NDSlicer(slice_col_list=dvlist, bins_list=self.testslicer.bins)
+        testslicer2.setup_slicer(dv2)
+        self.assertEqual(self.testslicer, testslicer2)
+        # Set up another slicer that should not match (different bins)
+        dv2 = make_data_values(1000, self.dvmin + 1, self.dvmax + 1, self.nd, random=209837)
+        testslicer2 = NDSlicer(slice_col_list=dvlist, bins_list=100)
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+        # Set up another slicer that should not match (different dimensions)
+        dv2 = make_data_values(1000, self.dvmin, self.dvmax, self.nd - 1, random=50623)
+        testslicer2 = NDSlicer(dv2.dtype.names, bins_list=100)
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+        # Set up a different kind of slicer that should not match.
+        testslicer2 = UniSlicer()
+        dv2 = make_data_values(100, 0, 1, random=22310098)
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+
+
+class TestNDSlicerIteration(unittest.TestCase):
+    def setUp(self):
+        self.dvmin = 0
+        self.dvmax = 1
+        nvalues = 1000
+        self.nd = 3
+        self.dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=11081)
+        self.dvlist = self.dv.dtype.names
+        nvalues = 1000
+        bins = np.arange(self.dvmin, self.dvmax, 0.1)
+        bins_list = []
+        self.iterlist = []
+        for i in range(self.nd):
+            bins_list.append(bins)
+            # (remember iteration doesn't use the very last bin in 'bins')
+            self.iterlist.append(bins[:-1])
+        dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=17)
+        self.testslicer = NDSlicer(self.dvlist, bins_list=bins_list)
+        self.testslicer.setup_slicer(dv)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_iteration(self):
+        """Test iteration."""
+        for s, ib in zip(self.testslicer, itertools.product(*self.iterlist)):
+            self.assertEqual(s["slice_point"]["bin_left"], ib)
+
+    def test_get_item(self):
+        """Test getting indexed binpoint."""
+        for i, s in enumerate(self.testslicer):
+            self.assertEqual(
+                self.testslicer[i]["slice_point"]["bin_left"],
+                s["slice_point"]["bin_left"],
+            )
+        self.assertEqual(self.testslicer[0]["slice_point"]["bin_left"], (0.0, 0.0, 0.0))
+
+
+class TestNDSlicerSlicing(unittest.TestCase):
+    def setUp(self):
+        self.dvmin = 0
+        self.dvmax = 1
+        nvalues = 1000
+        self.nd = 3
+        self.dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=173)
+        self.dvlist = self.dv.dtype.names
+        self.testslicer = NDSlicer(self.dvlist)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_slicing(self):
+        """Test slicing."""
+        # Test get error if try to slice before setup.
+        self.assertRaises(NotImplementedError, self.testslicer._slice_sim_data, 0)
+        nbins = 10
+        bin_size = (self.dvmax - self.dvmin) / (float(nbins))
+        self.testslicer = NDSlicer(self.dvlist, bins_list=nbins)
+        for nvalues in (1000, 10000):
+            dv = make_data_values(nvalues, self.dvmin, self.dvmax, self.nd, random=1735)
+            self.testslicer.setup_slicer(dv)
+            sum = 0
+            for i, s in enumerate(self.testslicer):
+                idxs = s["idxs"]
+                data_slice = dv[idxs]
+                sum += len(idxs)
+                if len(data_slice) > 0:
+                    for i, dvname, b in zip(list(range(self.nd)), self.dvlist, s["slice_point"]["bin_left"]):
+                        self.assertGreaterEqual((data_slice[dvname].min() - b), 0)
+                    if i < self.testslicer.nslice - 1:
+                        self.assertLessEqual((data_slice[dvname].max() - b), bin_size)
+                    else:
+                        self.assertAlmostEqual((data_slice[dvname].max() - b), bin_size)
+                    self.assertEqual(len(data_slice), nvalues / float(nbins))
+            # and check that every data value was assigned somewhere.
+            self.assertEqual(sum, nvalues)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_neodistanceplotter.py

@@ -0,0 +1,41 @@
+import unittest
+
+import numpy as np
+
+import rubin_sim.maf.plots as plots
+
+
+class TestNeoDistancePlotter(unittest.TestCase):
+    def setUp(self):
+        rng = np.random.RandomState(61723009)
+        names = [
+            "eclipLat",
+            "eclipLon",
+            "MaxGeoDist",
+            "NEOHelioX",
+            "NEOHelioY",
+            "filter",
+        ]
+        types = [float] * 5
+        types.append("|S1")
+        npts = 100
+        self.metric_values = np.zeros(npts, list(zip(names, types)))
+        self.metric_values["MaxGeoDist"] = rng.rand(npts) * 2.0
+        self.metric_values["eclipLat"] = rng.rand(npts)
+        self.metric_values["NEOHelioX"] = rng.rand(npts) * 3 - 1.5
+        self.metric_values["NEOHelioY"] = rng.rand(npts) * 3 - 1.5 + 1
+        self.metric_values["filter"] = "g"
+
+    def test_plotter(self):
+        """
+        Just test that it can make a figure without throwing an error.
+        """
+        plotter = plots.NeoDistancePlotter()
+        # Need to wrap in a list because it will usually go through the
+        # UniSlicer, and will thus be an array inside a 1-element masked array
+        fig = plotter([self.metric_values], None, {})
+        self.assertNotEqual(fig, None)
+
+
+if __name__ == "__main__":
+    unittest.main()