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

tests/maf/test_unislicer.py

@@ -0,0 +1,116 @@
+import unittest
+
+import numpy as np
+
+from rubin_sim.maf.slicers import OneDSlicer, UniSlicer
+
+
+def make_data_values(size=100, min=0.0, max=1.0, random=-1):
+    """Generate a simple array of numbers,
+    evenly arranged between min/max, but (optional) random order.
+    """
+    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", "float")])
+    return datavalues
+
+
+class TestUniSlicerSetupAndSlice(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = UniSlicer()
+
+    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, "UniSlicer")
+
+    def test_slicer_nbins(self):
+        self.assertEqual(self.testslicer.nslice, 1)
+
+    def test_setup_slicer_indices(self):
+        """Test slicer returns correct indices (all) after setup.
+        Note this also tests slicing.
+        """
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        dv = make_data_values(nvalues, dvmin, dvmax, random=672)
+        self.testslicer.setup_slicer(dv)
+        # test slicing
+        self.assertEqual(len(self.testslicer.indices), len(dv["testdata"]))
+        np.testing.assert_equal(dv[self.testslicer.indices], dv)
+
+
+class TestUniSlicerIteration(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = UniSlicer()
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_iteration(self):
+        """Test iteration -- which is a one-step identity op for a
+        unislicer.
+        """
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        dv = make_data_values(nvalues, dvmin, dvmax, random=432)
+        self.testslicer.setup_slicer(dv)
+        for i, b in enumerate(self.testslicer):
+            pass
+        self.assertEqual(i, 0)
+
+    def test_get_item(self):
+        """Test that can return an individual indexed values of the slicer."""
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        dv = make_data_values(nvalues, dvmin, dvmax, random=1192)
+        self.testslicer.setup_slicer(dv)
+        self.assertEqual(self.testslicer[0]["slice_point"]["sid"], 0)
+
+
+class TestUniSlicerEqual(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = UniSlicer()
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        dv = make_data_values(nvalues, dvmin, dvmax, random=3482)
+        self.testslicer.setup_slicer(dv)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_equivalence(self):
+        """Test equals method."""
+        # Note that two uni slicers will be considered equal if they are
+        # both the same kind of slicer (unislicer).
+        # They will not necessarily slice data equally though (the indices are
+        #  not necessarily the same!).
+        # These should be the same, even though data is not the same.
+        testslicer2 = UniSlicer()
+        dv2 = make_data_values(100, 0, 1, random=43298)
+        testslicer2.setup_slicer(dv2)
+        self.assertEqual(self.testslicer, testslicer2)
+        # these will not be the same, as different slicer type.
+        testslicer2 = OneDSlicer(slice_col_name="testdata", bins=np.arange(0, 10, 1))
+        testslicer2.setup_slicer(dv2)
+        self.assertNotEqual(self.testslicer, testslicer2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_vectormetrics.py

@@ -0,0 +1,225 @@
+import unittest
+
+import matplotlib
+import numpy as np
+
+import rubin_sim.maf.metric_bundles as metricBundle
+import rubin_sim.maf.metrics as metrics
+import rubin_sim.maf.slicers as slicers
+
+matplotlib.use("Agg")
+
+
+class Test2D(unittest.TestCase):
+    def setUp(self):
+        names = [
+            "night",
+            "fieldId",
+            "fieldRA",
+            "fieldDec",
+            "fiveSigmaDepth",
+            "observationStartMJD",
+            "rotSkyPos",
+        ]
+        types = [int, int, float, float, float, float, float]
+
+        self.m5_1 = 25.0
+        self.m5_2 = 24.0
+
+        self.n1 = 50
+        self.n2 = 49
+
+        # Picking RA and Dec values that will hit nside=16 healpixels
+        self.sim_data = np.zeros(self.n1 + self.n2, dtype=list(zip(names, types)))
+        self.sim_data["night"][0 : self.n1] = 1
+        self.sim_data["fieldId"][0 : self.n1] = 1
+        self.sim_data["fieldRA"][0 : self.n1] = 10.0
+        self.sim_data["fieldDec"][0 : self.n1] = 0.0
+        self.sim_data["fiveSigmaDepth"][0 : self.n1] = self.m5_1
+
+        self.sim_data["night"][self.n1 :] = 2
+        self.sim_data["fieldId"][self.n1 :] = 2
+        self.sim_data["fieldRA"][self.n1 :] = 190.0
+        self.sim_data["fieldDec"][self.n1 :] = -20.0
+        self.sim_data["fiveSigmaDepth"][self.n1 :] = self.m5_2
+
+        self.field_data = np.zeros(
+            2, dtype=list(zip(["fieldId", "fieldRA", "fieldDec"], [int, float, float]))
+        )
+        self.field_data["fieldId"] = [1, 2]
+        self.field_data["fieldRA"] = np.radians([10.0, 190.0])
+        self.field_data["fieldDec"] = np.radians([0.0, -20.0])
+
+        self.sim_data["observationStartMJD"] = self.sim_data["night"]
+
+    def test_user_points2d_slicer(self):
+        metric = metrics.AccumulateCountMetric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.UserPointsSlicer(
+            ra=np.degrees(self.field_data["fieldRA"]),
+            dec=np.degrees(self.field_data["fieldDec"]),
+            lat_lon_deg=True,
+        )
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.fieldData = self.field_data
+        mbg.run_current("", sim_data=self.sim_data)
+        expected = np.array([[self.n1, self.n1], [-666.0, self.n2]])
+        assert np.array_equal(mb.metric_values.data, expected)
+
+    def test_healpix2d_slicer(self):
+        metric = metrics.AccumulateCountMetric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+
+        good = np.where(mb.metric_values.mask[:, -1] == False)[0]
+        expected = np.array([[self.n1, self.n1], [-666.0, self.n2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+    def test_histogram_metric(self):
+        metric = metrics.HistogramMetric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+
+        good = np.where(mb.metric_values.mask[:, -1] == False)[0]
+        expected = np.array([[self.n1, 0.0], [0.0, self.n2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+        # Check that I can run a different statistic
+        metric = metrics.HistogramMetric(col="fiveSigmaDepth", statistic="sum", bins=[0.5, 1.5, 2.5])
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+        expected = np.array([[self.m5_1 * self.n1, 0.0], [0.0, self.m5_2 * self.n2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+    def test_accumulate_metric(self):
+        metric = metrics.AccumulateMetric(col="fiveSigmaDepth", bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+        good = np.where(mb.metric_values.mask[:, -1] == False)[0]
+        expected = np.array([[self.n1 * self.m5_1, self.n1 * self.m5_1], [-666.0, self.n2 * self.m5_2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+    def test_histogram_m5_metric(self):
+        metric = metrics.HistogramM5Metric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+        good = np.where((mb.metric_values.mask[:, 0] == False) | (mb.metric_values.mask[:, 1] == False))[0]
+
+        check_metric = metrics.Coaddm5Metric()
+        temp_slice = np.zeros(self.n1, dtype=list(zip(["fiveSigmaDepth"], [float])))
+        temp_slice["fiveSigmaDepth"] += self.m5_1
+        val1 = check_metric.run(temp_slice)
+        temp_slice = np.zeros(self.n2, dtype=list(zip(["fiveSigmaDepth"], [float])))
+        temp_slice["fiveSigmaDepth"] += self.m5_2
+        val2 = check_metric.run(temp_slice)
+
+        expected = np.array([[val1, -666.0], [-666.0, val2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+    def test_accumulate_m5_metric(self):
+        metric = metrics.AccumulateM5Metric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        mb = metricBundle.MetricBundle(metric, slicer, sql)
+        # Clobber the stacker that gets auto-added
+        mb.stacker_list = []
+        mbg = metricBundle.MetricBundleGroup({0: mb}, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+        good = np.where(mb.metric_values.mask[:, -1] == False)[0]
+
+        check_metric = metrics.Coaddm5Metric()
+        temp_slice = np.zeros(self.n1, dtype=list(zip(["fiveSigmaDepth"], [float])))
+        temp_slice["fiveSigmaDepth"] += self.m5_1
+        val1 = check_metric.run(temp_slice)
+        temp_slice = np.zeros(self.n2, dtype=list(zip(["fiveSigmaDepth"], [float])))
+        temp_slice["fiveSigmaDepth"] += self.m5_2
+        val2 = check_metric.run(temp_slice)
+
+        expected = np.array([[val1, val1], [-666.0, val2]])
+        assert np.array_equal(mb.metric_values.data[good, :], expected)
+
+    def test_accumulate_uniformity_metric(self):
+        names = ["night"]
+        types = ["float"]
+        data_slice = np.zeros(3652, dtype=list(zip(names, types)))
+
+        # Test that a uniform distribution is very close to zero
+        data_slice["night"] = np.arange(1, data_slice.size + 1)
+        metric = metrics.AccumulateUniformityMetric()
+        result = metric.run(data_slice)
+        assert np.max(result) < 1.0 / 365.25
+        assert np.min(result) >= 0
+
+        # Test that if everythin on night 1 or last night, then result is ~1
+        data_slice["night"] = 1
+        result = metric.run(data_slice)
+        assert np.max(result) >= 1.0 - 1.0 / 365.25
+        data_slice["night"] = 3652
+        result = metric.run(data_slice)
+        assert np.max(result) >= 1.0 - 1.0 / 365.25
+
+        # Test if all taken in the middle, result ~0.5
+        data_slice["night"] = 3652 / 2
+        result = metric.run(data_slice)
+        assert np.max(result) >= 0.5 - 1.0 / 365.25
+
+    def test_run_regular_too(self):
+        """
+        Test that a binned slicer and a regular slicer can run together
+        """
+        bundle_list = []
+        metric = metrics.AccumulateM5Metric(bins=[0.5, 1.5, 2.5])
+        slicer = slicers.HealpixSlicer(nside=16)
+        sql = ""
+        bundle_list.append(metricBundle.MetricBundle(metric, slicer, sql))
+        metric = metrics.Coaddm5Metric()
+        slicer = slicers.HealpixSlicer(nside=16)
+        bundle_list.append(metricBundle.MetricBundle(metric, slicer, sql))
+        for bundle in bundle_list:
+            bundle.stacker_list = []
+        bd = metricBundle.make_bundles_dict_from_list(bundle_list)
+        mbg = metricBundle.MetricBundleGroup(bd, None, save_early=False)
+        mbg.set_current("")
+        mbg.run_current("", sim_data=self.sim_data)
+
+        assert np.array_equal(
+            bundle_list[0].metric_values[:, 1].compressed(),
+            bundle_list[1].metric_values.compressed(),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_visitgroupsmetric.py

@@ -0,0 +1,181 @@
+import unittest
+
+import numpy as np
+
+import rubin_sim.maf.metrics as metrics
+
+
+class TestVisitGroupsMetric(unittest.TestCase):
+    def test_pair_fraction_metric(self):
+        metric = metrics.PairFractionMetric(mjd_col="mjd")
+        mjds = np.arange(0, 200, 30) / 60.0 / 24.0
+        data = np.zeros(mjds.size, dtype=[("mjd", float)])
+        data["mjd"] = mjds
+        # These should all have pairs
+        result = metric.run(data)
+        self.assertEqual(result, 1.0)
+
+        # These should have none
+        mjds = np.arange(0, 400, 100) / 60.0 / 24.0
+        data = np.zeros(mjds.size, dtype=[("mjd", float)])
+        data["mjd"] = mjds
+        result = metric.run(data)
+        self.assertEqual(result, 0.0)
+
+        # If those are right, then this should be 50%
+        t1 = np.arange(0, 200, 30) / 60.0 / 24.0
+        t2 = np.arange(0, 400, 100) / 60.0 / 24.0 + 1000
+
+        times = np.append(t1, t2)
+        data = np.zeros(times.size, dtype=[("mjd", float)])
+        data["mjd"] = times
+        result = metric.run(data)
+        expected = np.size(t1) / float(np.size(t1) + np.size(t2))
+        self.assertEqual(result, expected)
+
+    def test_visit_groups(self):
+        """Test visit groups (solar system groups) metric."""
+        # Set up some simple test data.
+        tmin = 15.0 / 60.0 / 24.0
+        tmax = 90.0 / 60.0 / 24.0
+        tstart = 49406.00
+        # The test data needs to have times for all observations:
+        # set up the times in two stages .. the night
+        night = np.array(
+            [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                2,
+                3,
+                3,
+                31,
+                31,
+                32,
+                32,
+                33,
+                33,
+                34,
+                34,
+                34,
+                34,
+                35,
+                35,
+                35,
+                36,
+                36,
+                36,
+                37,
+                37,
+                37,
+                38,
+                38,
+                38,
+            ],
+            "int",
+        )
+        #   .. and the time within the night.
+        expmjd = np.array(
+            [
+                tstart,
+                tstart + tmin / 10.0,
+                tstart + tmin + tmin / 2.0,
+                tstart + tmin * 2 + tmax,
+                tstart + 2 * tmax,
+                tstart + 2 * tmax + tmin / 2.0,  # n0
+                tstart,
+                tstart + tmax,  # n1 .. only 2 obs but should make a pair
+                tstart,  # n2 - only 1 obs, should not make a pair
+                tstart,
+                tstart + tmin,  # n3 .. only 2 obs but should make a pair
+                tstart,
+                tstart + tmin,
+                tstart,
+                tstart + tmin,
+                tstart,
+                tstart + tmin,  # n31/32/33 - a pair on each night
+                tstart,
+                tstart + tmin / 10.0,
+                tstart + tmax * 2,
+                tstart + tmax * 2 + tmin / 10.0,  # n34 .. should make no pairs
+                tstart,
+                tstart + tmin / 10.0,
+                tstart + tmax,  # n35 should make 2.5 (too close at start)
+                # n36 should make 2.5 pairs (too close at end)
+                tstart,
+                tstart + tmax,
+                tstart + tmax + tmin / 10.0,
+                tstart,
+                tstart + tmin,
+                tstart + tmax,  # n37 - 3 (regular 3)
+                tstart,
+                tstart + tmax,
+                tstart + tmax * 2,  # n38 - 3 (three, but long spacing)
+            ],
+            "float",
+        )
+        expmjd = expmjd + night
+        testdata = np.zeros(night.size, dtype=[("expmjd", float), ("night", int)])
+        testdata["expmjd"] = expmjd
+        testdata["night"] = night
+        # Set up metric.
+        testmetric = metrics.VisitGroupsMetric(
+            time_col="expmjd",
+            nights_col="night",
+            delta_t_min=tmin,
+            delta_t_max=tmax,
+            min_n_visits=2,
+            window=5,
+            min_n_nights=3,
+        )
+        # and set up a copy, with a higher number of min visits per night
+        testmetric2 = metrics.VisitGroupsMetric(
+            time_col="expmjd",
+            nights_col="night",
+            delta_t_min=tmin,
+            delta_t_max=tmax,
+            min_n_visits=3,
+            window=5,
+            min_n_nights=3,
+        )
+        # Run metric for expected results.
+        metricval = testmetric.run(testdata)
+        # These are the expected results, based on the times above.
+        expected_nights = np.array([0, 1, 3, 31, 32, 33, 35, 36, 37, 38])
+        expected_numvisits = np.array([5.0, 2, 2, 2, 2, 2, 2.5, 2.5, 3, 3])
+        np.testing.assert_equal(metricval["visits"], expected_numvisits)
+        np.testing.assert_equal(metricval["nights"], expected_nights)
+        # Test reduce methods.
+        self.assertEqual(testmetric.reduce_median(metricval), np.median(expected_numvisits))
+        self.assertEqual(testmetric.reduce_n_nights_with_n_visits(metricval), len(expected_nights))
+        self.assertEqual(testmetric2.reduce_n_nights_with_n_visits(metricval), 3)
+        self.assertEqual(testmetric.reduce_n_visits_in_window(metricval), 11)
+        self.assertEqual(testmetric2.reduce_n_nights_in_window(metricval), 2)
+        self.assertEqual(testmetric.reduce_n_lunations(metricval), 2)
+        # Test with a longer (but simpler) date range.
+        indnight = np.array([0, 1, 2, 3, 4, 5, 31, 32, 33, 34, 61, 62, 63, 121, 122, 123], "int")
+        indtimes = np.array([tstart, tstart + tmin, tstart + tmax], "float")
+        expmjd = []
+        night = []
+        for n in indnight:
+            for t in indtimes:
+                expmjd.append(float(n + t))
+                night.append(n)
+        expmjd = np.array(expmjd)
+        night = np.array(night)
+        testdata = np.zeros(night.size, dtype=[("expmjd", float), ("night", int)])
+        testdata["expmjd"] = expmjd
+        testdata["night"] = night
+
+        metricval = testmetric.run(testdata)
+        self.assertEqual(testmetric.reduce_n_lunations(metricval), 4)
+        self.assertEqual(testmetric.reduce_max_seq_lunations(metricval), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/moving_objects/test_camera.py

@@ -0,0 +1,39 @@
+import unittest
+
+import numpy as np
+
+from rubin_sim.moving_objects import BaseObs
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestCamera(unittest.TestCase):
+    def setUp(self):
+        obj_ra = np.array([10.0, 12.1], float)
+        obj_dec = np.array([-30.0, -30.0], float)
+        obj_mjd = np.array([59580.16, 59580.16], float)
+        self.ephems = np.array(
+            list(zip(obj_ra, obj_dec, obj_mjd)),
+            dtype=([("ra", float), ("dec", float), ("mjd", float)]),
+        )
+        obs_ra = np.array([10.0, 10.0], float)
+        obs_dec = np.array([-30.0, -30.0], float)
+        obs_mjd = np.array([59580.16, 59580.16], float)
+        obs_rot_sky_pos = np.zeros(2)
+        self.obs = np.array(
+            list(zip(obs_ra, obs_dec, obs_rot_sky_pos, obs_mjd)),
+            dtype=([("ra", float), ("dec", float), ("rotSkyPos", float), ("mjd", float)]),
+        )
+
+    def test_camera_fov(self):
+        obs = BaseObs(
+            obs_ra="ra",
+            obs_dec="dec",
+            obs_time_col="mjd",
+            footprint="camera",
+        )
+        idx_obs = obs.sso_in_camera_fov(self.ephems, self.obs)
+        self.assertEqual(idx_obs, [0])
+
+
+if __name__ == "__main__":
+    unittest.main()