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

tests/maf/test_maps.py

@@ -0,0 +1,199 @@
+import os
+import unittest
+import warnings
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+import rubin_sim.maf.maps as maps
+import rubin_sim.maf.slicers as slicers
+
+
+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,
+    (optional) random order.
+    """
+    datavalues = np.arange(0, size, dtype="float")
+    datavalues *= (float(max) - float(min)) / (datavalues.max() - datavalues.min())
+    datavalues += min
+    rot_vals = datavalues * 0
+    if random > 0:
+        rng = np.random.RandomState(random)
+        randorder = rng.rand(size)
+        randind = np.argsort(randorder)
+        datavalues = datavalues[randind]
+    ids = np.arange(size)
+    datavalues = np.array(
+        list(zip(datavalues, datavalues, ids, rot_vals)),
+        dtype=[
+            ("fieldRA", "float"),
+            ("fieldDec", "float"),
+            ("fieldId", "int"),
+            ("rotSkyPos", "float"),
+        ],
+    )
+    return datavalues
+
+
+def make_field_data(seed):
+    rng = np.random.RandomState(seed)
+    names = ["fieldId", "fieldRA", "fieldDec"]
+    types = [int, float, float]
+    field_data = np.zeros(100, dtype=list(zip(names, types)))
+    field_data["fieldId"] = np.arange(100)
+    field_data["fieldRA"] = rng.rand(100)
+    field_data["fieldDec"] = rng.rand(100)
+    return field_data
+
+
+class TestMaps(unittest.TestCase):
+    def test_dust_map(self):
+        map_path = os.path.join(get_data_dir(), "tests")
+        nside = 8
+        if os.path.isfile(os.path.join(map_path, f"dust_nside_{nside}.npz")):
+            data = make_data_values(random=981)
+            dustmap = maps.DustMap(nside=nside, map_path=map_path)
+
+            slicer1 = slicers.HealpixSlicer(lat_lon_deg=False, nside=nside, use_camera=False)
+            slicer1.setup_slicer(data)
+            result1 = dustmap.run(slicer1.slice_points)
+            assert "ebv" in list(result1.keys())
+
+            field_data = make_field_data(2234)
+
+            slicer2 = slicers.UserPointsSlicer(
+                field_data["fieldRA"], field_data["fieldDec"], lat_lon_deg=False
+            )
+            result2 = dustmap.run(slicer2.slice_points)
+            assert "ebv" in list(result2.keys())
+
+            # Check interpolation works
+            dustmap = maps.DustMap(interp=True, nside=nside, map_path=map_path)
+            result3 = dustmap.run(slicer2.slice_points)
+            assert "ebv" in list(result3.keys())
+
+            # Check warning gets raised
+            dustmap = maps.DustMap(nside=4, map_path=map_path)
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                dustmap.run(slicer1.slice_points)
+                self.assertIn("nside", str(w[-1].message))
+        else:
+            warnings.warn("Did not find dustmaps, not running testMaps.py")
+
+    def test_dust_map3_d(self):
+        nside = 8
+        map_file = os.path.join(get_data_dir(), "tests", f"test_ebv3d_nside{nside}.fits")
+        if os.path.isfile(map_file):
+            data = make_data_values(random=981)
+            dustmap = maps.DustMap3D(nside=nside, map_file=map_file, interp=False)
+
+            slicer1 = slicers.HealpixSlicer(lat_lon_deg=False, nside=nside, use_camera=False)
+            slicer1.setup_slicer(data)
+            result1 = dustmap.run(slicer1.slice_points)
+            assert "ebv3d_ebvs" in list(result1.keys())
+            assert "ebv3d_dists" in list(result1.keys())
+
+            field_data = make_field_data(2234)
+
+            slicer2 = slicers.UserPointsSlicer(
+                field_data["fieldRA"], field_data["fieldDec"], lat_lon_deg=False
+            )
+            result2 = dustmap.run(slicer2.slice_points)
+            assert "ebv3d_ebvs" in list(result2.keys())
+            assert "ebv3d_dists" in list(result2.keys())
+
+            # Check interpolation works
+            dustmap = maps.DustMap3D(interp=True, nside=nside, map_file=map_file, dist_pc=2000, d_mag=10)
+            result3 = dustmap.run(slicer2.slice_points)
+            assert "ebv3d_ebvs" in list(result3.keys())
+            assert "ebv3d_dists" in list(result3.keys())
+            assert "ebv3d_ebv_at_2000.0" in list(result3.keys())
+            assert "ebv3d_dist_at_10.0" in list(result3.keys())
+
+            # Check that we can call the distance at magnitude method
+            _ = dustmap.distance_at_dmag(5, result3["ebv3d_dists"], result3["ebv3d_ebvs"], "r")
+            # And call it without running the map
+            # (and thus reading more info) first
+            _ = maps.DustMap3D().distance_at_dmag(5, result3["ebv3d_dists"], result3["ebv3d_ebvs"], "r")
+            # And call it as a static method at one point on the sky
+            _ = maps.DustMap3D().distance_at_dmag(
+                5, result3["ebv3d_dists"][0, :], result3["ebv3d_ebvs"][0, :], "r"
+            )
+
+            # Check warning gets raised
+            dustmap = maps.DustMap3D(nside=4, map_file=map_file)
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                dustmap.run(slicer1.slice_points)
+                self.assertIn("nside", str(w[-1].message))
+        else:
+            warnings.warn("Did not find dustmaps, not running testMaps.py")
+
+    def test_star_map(self):
+        map_path = os.path.join(get_data_dir(), "tests")
+
+        if os.path.isfile(os.path.join(map_path, "starDensity_r_nside_64.npz")):
+            data = make_data_values(random=887)
+            # check that it works if nside does not match map nside of 64
+            nsides = [32, 64, 128]
+            for nside in nsides:
+                starmap = maps.StellarDensityMap(map_dir=map_path)
+                slicer1 = slicers.HealpixSlicer(nside=nside, lat_lon_deg=False, use_camera=False)
+                slicer1.setup_slicer(data)
+                result1 = starmap.run(slicer1.slice_points)
+                assert "starMapBins_r" in list(result1.keys())
+                assert "starLumFunc_r" in list(result1.keys())
+                assert np.max(result1["starLumFunc_r"] > 0)
+
+            field_data = make_field_data(22)
+
+            slicer2 = slicers.UserPointsSlicer(
+                field_data["fieldRA"], field_data["fieldDec"], lat_lon_deg=False
+            )
+            result2 = starmap.run(slicer2.slice_points)
+            assert "starMapBins_r" in list(result2.keys())
+            assert "starLumFunc_r" in list(result2.keys())
+            assert np.max(result2["starLumFunc_r"] > 0)
+
+        else:
+            warnings.warn("Did not find stellar density map, skipping test.")
+
+    @unittest.skipUnless(
+        os.path.isdir(os.path.join(get_data_dir(), "maps")),
+        "Skip the galplane priority map data unless maps data present, required for setup",
+    )
+    def test_galplane_priority_maps(self):
+        map_path = os.path.join(get_data_dir(), "maps")
+        nside = 64
+        data = make_data_values(random=981)
+        galplane_map = maps.GalacticPlanePriorityMap(nside=nside, map_path=map_path, interp=False)
+
+        # Set up basic case - healpix
+        slicer1 = slicers.HealpixSlicer(lat_lon_deg=False, nside=nside, use_camera=False)
+        slicer1.setup_slicer(data)
+        result1 = galplane_map.run(slicer1.slice_points)
+        key = maps.gp_priority_map_components_to_keys("sum", "combined_map")
+        assert key in list(result1.keys())
+
+        # Set up more advanced case - random ra/dec
+        field_data = make_field_data(2234)
+        slicer2 = slicers.UserPointsSlicer(field_data["fieldRA"], field_data["fieldDec"], lat_lon_deg=False)
+        result2 = galplane_map.run(slicer2.slice_points)
+        assert key in list(result2.keys())
+
+        # Check interpolation works
+        galplane_map = maps.GalacticPlanePriorityMap(interp=True, nside=nside, map_path=map_path)
+        result3 = galplane_map.run(slicer2.slice_points)
+        assert key in list(result3.keys())
+
+        # Check warning gets raised
+        galplane_map = maps.GalacticPlanePriorityMap(nside=4, map_path=map_path)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            galplane_map.run(slicer1.slice_points)
+            self.assertIn("nside", str(w[-1].message))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_metricbundle.py

@@ -0,0 +1,69 @@
+import glob
+import os
+import shutil
+import tempfile
+import unittest
+
+from rubin_scheduler.data import get_data_dir
+from rubin_scheduler.utils.code_utilities import sims_clean_up
+
+import rubin_sim.maf.db as db
+import rubin_sim.maf.maps as maps
+import rubin_sim.maf.metric_bundles as metric_bundles
+import rubin_sim.maf.metrics as metrics
+import rubin_sim.maf.slicers as slicers
+import rubin_sim.maf.stackers as stackers
+
+TEST_DB = "example_v3.4_0yrs.db"
+
+
+class TestMetricBundle(unittest.TestCase):
+    @classmethod
+    def tearDown_class(cls):
+        sims_clean_up()
+
+    def setUp(self):
+        self.out_dir = tempfile.mkdtemp(prefix="TMB")
+
+    def test_out(self):
+        """
+        Check that the metric bundle can generate the expected output
+        """
+        nside = 8
+        slicer = slicers.HealpixSlicer(nside=nside)
+        metric = metrics.MeanMetric(col="airmass")
+        sql = "filter='r'"
+        stacker1 = stackers.HourAngleStacker()
+        stacker2 = stackers.GalacticStacker()
+        map = maps.GalCoordsMap()
+
+        metric_b = metric_bundles.MetricBundle(
+            metric, slicer, sql, stacker_list=[stacker1, stacker2], maps_list=[map]
+        )
+        database = os.path.join(get_data_dir(), "tests", TEST_DB)
+
+        results_db = db.ResultsDb(out_dir=self.out_dir)
+
+        bgroup = metric_bundles.MetricBundleGroup(
+            {0: metric_b}, database, out_dir=self.out_dir, results_db=results_db
+        )
+        bgroup.run_all()
+        bgroup.plot_all()
+        bgroup.write_all()
+
+        out_thumbs = glob.glob(os.path.join(self.out_dir, "thumb*"))
+        out_npz = glob.glob(os.path.join(self.out_dir, "*.npz"))
+        out_pdf = glob.glob(os.path.join(self.out_dir, "*.pdf"))
+
+        # By default, make 2 plots for healpix
+        assert len(out_thumbs) == 2
+        assert len(out_pdf) == 2
+        assert len(out_npz) == 1
+
+    def tearDown(self):
+        if os.path.isdir(self.out_dir):
+            shutil.rmtree(self.out_dir)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_mometrics.py

@@ -0,0 +1,422 @@
+import unittest
+
+import numpy as np
+import pandas as pd
+
+import rubin_sim.maf.metrics as metrics
+
+
+class TestMoMetrics1(unittest.TestCase):
+    def setUp(self):
+        # Set up some sso_obs data to test the metrics on.
+        # Note that sso_obs is a numpy recarray.
+        # The expected set of columns in sso_obs is:
+        # cols = ['observationStartMJD', 'night', 'fieldRA', 'fieldDec',
+        #        'rotSkyPos', 'filter',
+        #        'visitExposureTime', 'seeingFwhmGeom', 'fiveSigmaDepth',
+        #        'solarElong',
+        #        'delta', 'ra', 'dec', 'magV', 'time', 'dradt', 'ddecdt',
+        #        'phase', 'solarelon',
+        #        'velocity', 'magFilter', 'dmagColor', 'dmagTrail',
+        #        'dmagDetect']
+        # And stackers will often add
+        # addCols = ['appMag', 'magLimit', 'snr', 'vis']
+
+        # Test metrics using sso_obs for a particular object.
+        times = np.array(
+            [0.1, 0.2, 0.3, 1.1, 1.3, 5.1, 7.1, 7.2, 7.3, 10.1, 10.2, 10.3, 13.1, 13.5],
+            dtype="float",
+        )
+        sso_obs = np.recarray(
+            [len(times)],
+            dtype=(
+                [
+                    ("time", "<f8"),
+                    ("ra", "<f8"),
+                    ("dec", "<f8"),
+                    ("appMag", "<f8"),
+                    ("observationStartMJD", "<f8"),
+                    ("night", "<f8"),
+                    ("magLimit", "<f8"),
+                    ("SNR", "<f8"),
+                    ("vis", "<f8"),
+                ]
+            ),
+        )
+
+        sso_obs["time"] = times
+        sso_obs["observationStartMJD"] = times
+        sso_obs["night"] = np.floor(times)
+        sso_obs["ra"] = np.arange(len(times))
+        sso_obs["dec"] = np.arange(len(times))
+        sso_obs["appMag"] = np.zeros(len(times), dtype="float") + 24.0
+        sso_obs["magLimit"] = np.zeros(len(times), dtype="float") + 25.0
+        sso_obs["SNR"] = np.zeros(len(times), dtype="float") + 5.0
+        sso_obs["vis"] = np.zeros(len(times), dtype="float") + 1
+        sso_obs["vis"][0:5] = 0
+        self.sso_obs = sso_obs
+        self.orb = None
+        self.hval = 8.0
+
+    def testn_obs_metric(self):
+        n_obs_metric = metrics.NObsMetric(snr_limit=5)
+        n_obs = n_obs_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(n_obs, len(self.sso_obs["time"]))
+        n_obs_metric = metrics.NObsMetric(snr_limit=10)
+        n_obs = n_obs_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(n_obs, 0)
+        n_obs_metric = metrics.NObsMetric(snr_limit=None)
+        n_obs = n_obs_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(n_obs, len(self.sso_obs["time"]) - 5)
+
+    def testn_obs_no_singles_metric(self):
+        n_obs_no_singles_metric = metrics.NObsNoSinglesMetric(snr_limit=5)
+        n_obs = n_obs_no_singles_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(n_obs, len(self.sso_obs["time"]) - 1)
+
+    def test_n_nights_metric(self):
+        n_nights_metric = metrics.NNightsMetric(snr_limit=5)
+        nnights = n_nights_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(nnights, len(np.unique(self.sso_obs["night"])))
+        n_nights_metric = metrics.NNightsMetric(snr_limit=None)
+        nnights = n_nights_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(nnights, len(np.unique(self.sso_obs["night"])) - 2)
+
+    def test_arc_metric(self):
+        arc_metric = metrics.ObsArcMetric(snr_limit=5)
+        arc = arc_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(
+            arc,
+            self.sso_obs["observationStartMJD"][-1] - self.sso_obs["observationStartMJD"][0],
+        )
+        arc_metric = metrics.ObsArcMetric(snr_limit=None)
+        arc = arc_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(
+            arc,
+            self.sso_obs["observationStartMJD"][-1] - self.sso_obs["observationStartMJD"][5],
+        )
+
+    def test_activity_over_period_metric(self):
+        # cometary orbit format ok
+        orb = np.recarray(
+            1,
+            dtype=(
+                [
+                    ("objId", (str, 20)),
+                    ("q", float),
+                    ("e", float),
+                    ("inc", float),
+                    ("Omega", float),
+                    ("argPeri", float),
+                    ("tPeri", float),
+                    ("epoch", float),
+                    ("H", float),
+                    ("g", float),
+                ]
+            ),
+        )
+
+        orb["objId"] = "NESC00001HYj"
+        orb["q"] = 1.00052
+        orb["e"] = 0.028514
+        orb["inc"] = 0.502477
+        orb["Omega"] = 50.989131
+        orb["argPeri"] = 55.091685
+        orb["tPeri"] = 61046.627194 - 59850
+        orb["epoch"] = 60973.799216 - 59850
+        orb["H"] = 35.526041
+        orb["g"] = 0.15
+        o = pd.DataFrame(orb)
+        activity_period_metric = metrics.ActivityOverPeriodMetric(bin_size=360, snr_limit=5)
+        activity = activity_period_metric.run(self.sso_obs, o.iloc[0], self.hval)
+        self.assertEqual(activity, 1.0)
+        activity_period_metric = metrics.ActivityOverPeriodMetric(bin_size=720, snr_limit=5)
+        activity = activity_period_metric.run(self.sso_obs, o.iloc[0], self.hval)
+        self.assertEqual(activity, 1.0)
+        activity_period_metric = metrics.ActivityOverPeriodMetric(bin_size=10, snr_limit=5)
+        activity = activity_period_metric.run(self.sso_obs, o.iloc[0], self.hval)
+        self.assertLess(activity, 0.03)
+        # different type of orbit - currently should fail quietly
+        orb = np.recarray(
+            1,
+            dtype=(
+                [
+                    ("objId", (str, 20)),
+                    ("a", float),
+                    ("e", float),
+                    ("inc", float),
+                    ("Omega", float),
+                    ("argPeri", float),
+                    ("meanAnomaly", float),
+                    ("epoch", float),
+                    ("H", float),
+                    ("g", float),
+                ]
+            ),
+        )
+        orb["objId"] = "NESC00001HYj"
+        orb["a"] = 1.029886
+        orb["e"] = 0.028514
+        orb["inc"] = 0.502477
+        orb["Omega"] = 50.989131
+        orb["argPeri"] = 55.091685
+        orb["meanAnomaly"] = 291.321814
+        orb["epoch"] = 60973.799216 - 59850
+        orb["H"] = 35.526041
+        orb["g"] = 0.15
+        o = pd.DataFrame(orb)
+        activity_period_metric = metrics.ActivityOverPeriodMetric(bin_size=360, snr_limit=5)
+        activity = activity_period_metric.run(self.sso_obs, o.iloc[0], self.hval)
+        self.assertEqual(activity, 1.0)
+        activity_period_metric = metrics.ActivityOverPeriodMetric(bin_size=180, snr_limit=5)
+        activity = activity_period_metric.run(self.sso_obs, o.iloc[0], self.hval)
+        self.assertEqual(activity, 0.5)
+
+    def tearDown(self):
+        del self.sso_obs
+        del self.orb
+        del self.hval
+
+
+class TestDiscoveryMetrics(unittest.TestCase):
+    def setUp(self):
+        rng = np.random.RandomState(61331)
+        # Test metrics using sso_obs for a particular object.
+        times = np.array(
+            [0.1, 0.2, 0.9, 1.1, 1.3, 5.1, 7.1, 7.2, 7.5, 10.1, 10.2, 13.1, 13.5],
+            dtype="float",
+        )
+        sso_obs = np.recarray(
+            [len(times)],
+            dtype=(
+                [
+                    ("time", "<f8"),
+                    ("ra", "<f8"),
+                    ("dec", "<f8"),
+                    ("ec_lon", "<f8"),
+                    ("ec_lat", "<f8"),
+                    ("solar_elong", "<f8"),
+                    ("appMag", "<f8"),
+                    ("observationStartMJD", "<f8"),
+                    ("night", "<f8"),
+                    ("magLimit", "<f8"),
+                    ("velocity", "<f8"),
+                    ("SNR", "<f8"),
+                    ("vis", "<f8"),
+                    ("magFilter", "<f8"),
+                    ("fiveSigmaDepth", "<f8"),
+                    ("seeingFwhmGeom", "<f8"),
+                    ("visitExposureTime", "<f8"),
+                    ("dmagDetect", "<f8"),
+                ]
+            ),
+        )
+
+        sso_obs["time"] = times
+        sso_obs["observationStartMJD"] = times
+        sso_obs["night"] = np.floor(times)
+        sso_obs["ra"] = np.arange(len(times))
+        sso_obs["dec"] = np.arange(len(times)) + 5
+        sso_obs["ec_lon"] = sso_obs["ra"] + 10
+        sso_obs["ec_lat"] = sso_obs["dec"] + 20
+        sso_obs["solar_elong"] = sso_obs["ra"] + 30
+        sso_obs["appMag"] = np.zeros(len(times), dtype="float") + 24.0
+        sso_obs["magFilter"] = np.zeros(len(times), dtype="float") + 24.0
+        sso_obs["fiveSigmaDepth"] = np.zeros(len(times), dtype="float") + 25.0
+        sso_obs["dmagDetect"] = np.zeros(len(times), dtype="float")
+        sso_obs["magLimit"] = np.zeros(len(times), dtype="float") + 25.0
+        sso_obs["SNR"] = np.zeros(len(times), dtype="float") + 5.0
+        sso_obs["vis"] = np.zeros(len(times), dtype="float") + 1
+        sso_obs["vis"][0:5] = 0
+        sso_obs["velocity"] = rng.rand(len(times))
+        sso_obs["seeingFwhmGeom"] = np.ones(len(times), "float")
+        sso_obs["visitExposureTime"] = np.ones(len(times), "float") * 24.0
+        self.sso_obs = sso_obs
+        self.orb = np.recarray([len(times)], dtype=([("H", "<f8")]))
+        self.orb["H"] = np.zeros(len(times), dtype="float") + 8
+        self.hval = 8
+
+    def test_discovery_metric(self):
+        disc_metric = metrics.DiscoveryMetric(
+            n_obs_per_night=2,
+            t_min=0.0,
+            t_max=0.3,
+            n_nights_per_window=3,
+            t_window=9,
+            snr_limit=5,
+        )
+        metric_value = disc_metric.run(self.sso_obs, self.orb, self.hval)
+        child = metrics.DiscoveryNObsMetric(disc_metric)
+        n_obs = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        self.assertEqual(n_obs, 8)
+        # child = metrics.DiscoveryNObsMetric(disc_metric, i=1)
+        # n_obs = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        # self.assertEqual(n_obs, 7)
+        child = metrics.DiscoveryNChancesMetric(disc_metric)
+        nchances = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        self.assertEqual(nchances, 2)
+        child = metrics.DiscoveryTimeMetric(disc_metric)
+        time = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        self.assertEqual(time, self.sso_obs["observationStartMJD"][0])
+        # child = metrics.DiscoveryTimeMetric(disc_metric, i=1)
+        # time = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        # self.assertEqual(time, self.sso_obs["observationStartMJD"][3])
+        child = metrics.DiscoveryRadecMetric(disc_metric)
+        ra, dec = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        self.assertEqual(ra, 0)
+        self.assertEqual(dec, 5)
+        child = metrics.DiscoveryEclonlatMetric(disc_metric)
+        lon, lat, solar_elong = child.run(self.sso_obs, self.orb, self.hval, metric_value)
+        self.assertEqual(lon, 10)
+        self.assertEqual(lat, 25)
+
+        disc_metric3 = metrics.MagicDiscoveryMetric(n_obs=5, t_window=2, snr_limit=5)
+        magic = disc_metric3.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(magic, 1)
+        disc_metric3 = metrics.MagicDiscoveryMetric(n_obs=3, t_window=1, snr_limit=5)
+        magic = disc_metric3.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(magic, 2)
+        disc_metric3 = metrics.MagicDiscoveryMetric(n_obs=4, t_window=4, snr_limit=5)
+        magic = disc_metric3.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(magic, 4)
+
+    def test_high_velocity_metric(self):
+        rng = np.random.RandomState(8123)
+        vel_metric = metrics.HighVelocityMetric(psf_factor=1.0, snr_limit=5)
+        metric_value = vel_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(metric_value, 0)
+        self.sso_obs["velocity"][0:2] = 1.5
+        metric_value = vel_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(metric_value, 2)
+        vel_metric = metrics.HighVelocityMetric(psf_factor=2.0, snr_limit=5)
+        metric_value = vel_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(metric_value, 0)
+        self.sso_obs["velocity"][0:2] = rng.rand(1)
+
+    def test_high_velocity_nights_metric(self):
+        vel_metric = metrics.HighVelocityNightsMetric(psf_factor=1.0, n_obs_per_night=1, snr_limit=5)
+        metric_value = vel_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(metric_value, 0)
+        self.sso_obs["velocity"][0:2] = 1.5
+        metric_value = vel_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(metric_value, self.sso_obs["observationStartMJD"][0])
+        self.sso_obs["velocity"][0:2] = np.random.rand(1)
+
+
+class TestKnownObjectMetrics(unittest.TestCase):
+    def setUp(self):
+        self.t1 = 53371
+        self.t2 = 57023
+        self.t3 = 59580
+        times = np.arange(self.t1 - 365 * 2, self.t3 + 365 * 3, 1)
+        cols = ["MJD(UTC)", "RA", "Dec", "magV", "Elongation", "appMagV"]
+        dtype = []
+        for c in cols:
+            dtype.append((c, "<f8"))
+        sso_obs = np.recarray([len(times)], dtype=dtype)
+
+        sso_obs["MJD(UTC)"] = times
+        sso_obs["RA"] = np.arange(len(times))
+        sso_obs["Dec"] = np.arange(len(times))
+        sso_obs["magV"] = np.zeros(len(times), dtype="float") + 20.0
+        sso_obs["Elongation"] = np.zeros(len(times), dtype=float) + 180.0
+        self.hval = 0.0
+        sso_obs["appMagV"] = sso_obs["magV"] + self.hval
+        self.orb = None
+        self.sso_obs = sso_obs
+
+    def test_known_objects_metric(self):
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=1.0,
+            v_mag_thresh1=20.5,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=20.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=20.5,
+            eff4=1.0,
+            v_mag_thresh4=22,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, self.sso_obs["MJD(UTC)"].min())
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=1.0,
+            v_mag_thresh1=15.0,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=20.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=20.5,
+            eff4=1.0,
+            v_mag_thresh4=22,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, self.t1)
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=0.0,
+            v_mag_thresh1=20.5,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=20.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=20.5,
+            eff4=1.0,
+            v_mag_thresh4=22,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, self.t1)
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=1.0,
+            v_mag_thresh1=10,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=10.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=20.5,
+            eff4=1.0,
+            v_mag_thresh4=22,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, self.t2)
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=1.0,
+            v_mag_thresh1=10,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=10.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=10.5,
+            eff4=1.0,
+            v_mag_thresh4=22,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, self.t3)
+        known_object_metric = metrics.KnownObjectsMetric(
+            t_switch1=self.t1,
+            eff1=1.0,
+            v_mag_thresh1=10,
+            t_switch2=self.t2,
+            eff2=1.0,
+            v_mag_thresh2=10.5,
+            t_switch3=self.t3,
+            eff3=1.0,
+            v_mag_thresh3=10.5,
+            eff4=1.0,
+            v_mag_thresh4=10.5,
+        )
+        m_val = known_object_metric.run(self.sso_obs, self.orb, self.hval)
+        self.assertEqual(m_val, known_object_metric.badval)
+
+
+if __name__ == "__main__":
+    unittest.main()