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

tests/moving_objects/test_ephemerides.py

@@ -0,0 +1,219 @@
+import os
+import unittest
+
+import numpy as np
+import pandas as pd
+from astropy.time import Time
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.moving_objects import Orbits, PyOrbEphemerides
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestPyOrbEphemerides(unittest.TestCase):
+    def setUp(self):
+        self.testdir = os.path.join(get_data_dir(), "tests", "orbits_testdata")
+        self.orbits = Orbits()
+        self.orbits.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        self.orbits_kep = Orbits()
+        self.orbits_kep.read_orbits(os.path.join(self.testdir, "test_orbitsA.des"))
+        self.ephems = PyOrbEphemerides()
+        self.ephems.set_orbits(self.orbits)
+        self.len_ephems_basic = 11
+        self.len_ephems_full = 34
+
+    def tear_down(self):
+        del self.orbits
+        del self.orbits_kep
+        del self.ephems
+
+    def test_which_pyoorb(self):
+        import pyoorb
+
+        print(pyoorb.__file__)
+
+    def test_set_orbits(self):
+        # Test that we can set orbits.
+        self.ephems.set_orbits(self.orbits)
+        # Test that setting with an empty orbit object fails.
+        # (Avoids hard-to-interpret errors from pyoorb).
+        with self.assertRaises(ValueError):
+            empty_orb = Orbits()
+            empty = pd.DataFrame([], columns=self.orbits.data_cols["KEP"])
+            empty_orb.set_orbits(empty)
+            self.ephems.set_orbits(empty_orb)
+
+    def test_convert_to_oorb_array(self):
+        # Check that orbital elements are converted.
+        self.ephems._convert_to_oorb_elem(self.orbits.orbits, self.orbits.orb_format)
+        self.assertEqual(len(self.ephems.oorb_elem), len(self.orbits))
+        self.assertEqual(self.ephems.oorb_elem[0][7], 2)
+        self.assertEqual(self.ephems.oorb_elem[0][9], 3)
+        self.assertEqual(self.ephems.oorb_elem[0][1], self.orbits.orbits["q"][0])
+        # Test that we can convert KEP orbital elements too.
+        self.ephems._convert_to_oorb_elem(self.orbits_kep.orbits, self.orbits_kep.orb_format)
+        self.assertEqual(len(self.ephems.oorb_elem), len(self.orbits_kep))
+        self.assertEqual(self.ephems.oorb_elem[0][7], 3)
+        self.assertEqual(self.ephems.oorb_elem[0][1], self.orbits_kep.orbits["a"][0])
+
+    def test_convert_from_oorb_array(self):
+        # Check that we can convert orbital elements TO oorb format and back
+        # without losing info
+        # (except ObjId -- we will lose that unless we use updateOrbits.)
+        self.ephems._convert_to_oorb_elem(self.orbits.orbits, self.orbits.orb_format)
+        new_orbits = Orbits()
+        new_orbits.set_orbits(self.orbits.orbits)
+        new_orbits.update_orbits(self.ephems.convert_from_oorb_elem())
+        self.assertEqual(new_orbits, self.orbits)
+
+    def test_convert_times(self):
+        times = np.arange(49353, 49353 + 10, 0.5)
+        eph_times = self.ephems._convert_times(times, "UTC")
+        # Check that shape of eph_times is correct. (times x 2)
+        self.assertEqual(eph_times.shape[0], len(times))
+        self.assertEqual(eph_times.shape[1], 2)
+        # Check that 'timescale' for eph_times is correct.
+        self.assertEqual(eph_times[0][1], 1)
+        eph_times = self.ephems._convert_times(times, "TAI")
+        self.assertEqual(eph_times[0][1], 4)
+
+    def test_oorb_ephemeris(self):
+        self.ephems.set_orbits(self.orbits)
+        times = np.arange(49353, 49353 + 3, 0.25)
+        eph_times = self.ephems._convert_times(times)
+        # Basic ephemerides.
+        oorb_ephs = self.ephems._generate_oorb_ephs_basic(eph_times, obscode=807, eph_mode="N")
+        # Check that it returned the right sort of array.
+        self.assertEqual(
+            oorb_ephs.shape,
+            (len(self.ephems.oorb_elem), len(times), self.len_ephems_basic),
+        )
+        # Full ephemerides
+        oorb_ephs = self.ephems._generate_oorb_ephs_full(eph_times, obscode=807, eph_mode="N")
+        # Check that it returned the right sort of array.
+        self.assertEqual(
+            oorb_ephs.shape,
+            (len(self.ephems.oorb_elem), len(times), self.len_ephems_full),
+        )
+
+    def test_ephemeris(self):
+        # Calculate and convert ephemerides.
+        self.ephems.set_orbits(self.orbits)
+        times = np.arange(49353, 49353 + 2, 0.3)
+        eph_times = self.ephems._convert_times(times)
+        oorb_ephs = self.ephems._generate_oorb_ephs_basic(eph_times, obscode=807)
+        # Group by object, and check grouping.
+        ephs = self.ephems._convert_oorb_ephs_basic(oorb_ephs, by_object=True)
+        self.assertEqual(len(ephs), len(self.orbits))
+        # Group by time, and check grouping.
+        oorb_ephs = self.ephems._generate_oorb_ephs_basic(eph_times, obscode=807)
+        ephs = self.ephems._convert_oorb_ephs_basic(oorb_ephs, by_object=False)
+        self.assertEqual(len(ephs), len(times))
+        # And test all-wrapped-up method:
+        ephs_all = self.ephems.generate_ephemerides(
+            times,
+            obscode=807,
+            eph_mode="N",
+            eph_type="basic",
+            time_scale="UTC",
+            by_object=False,
+        )
+        # See https://rubinobs.atlassian.net/browse/SP-1633
+        # This needs to be fixed, but on a separate ticket
+        # for key in ephs_all.dtype.names:
+        #    np.testing.assert_almost_equal(ephs_all[key], ephs[key])
+
+        # Reset ephems to use KEP Orbits, and calculate new ephemerides.
+        self.ephems.set_orbits(self.orbits_kep)
+        oorb_ephs = self.ephems._generate_oorb_ephs_basic(eph_times, obscode=807, eph_mode="N")
+        ephs_kep = self.ephems._convert_oorb_ephs_basic(oorb_ephs, by_object=True)
+        self.assertEqual(len(ephs_kep), len(self.orbits_kep))
+        oorb_ephs = self.ephems._generate_oorb_ephs_basic(eph_times, obscode=807, eph_mode="N")
+        ephs_kep = self.ephems._convert_oorb_ephs_basic(oorb_ephs, by_object=False)
+        self.assertEqual(len(ephs_kep), len(times))
+        # And test all-wrapped-up method:
+        ephs_all_kep = self.ephems.generate_ephemerides(
+            times,
+            obscode=807,
+            eph_mode="N",
+            eph_type="basic",
+            time_scale="UTC",
+            by_object=False,
+        )
+        # Also https://rubinobs.atlassian.net/browse/SP-1633
+        # for key in ephs_all_kep.dtype.names:
+        #    np.testing.assert_almost_equal(ephs_all_kep[key], ephs_kep[key])
+
+        # Check that ephemerides calculated from the different (COM/KEP)
+        # orbits are almost equal
+        for column in ephs.dtype.names:
+            np.testing.assert_allclose(ephs[column], ephs_kep[column], rtol=1e-5, atol=1e-4)
+        # Check that the wrapped method using KEP elements and the wrapped
+        # method using COM elements match.
+        for column in ephs_all.dtype.names:
+            np.testing.assert_allclose(ephs_all_kep[column], ephs_all[column], rtol=1e-5, atol=1e-4)
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestJPLValues(unittest.TestCase):
+    """Test the oorb generated RA/Dec values against
+    JPL generated RA/Dec values."""
+
+    def setUp(self):
+        # Read orbits.
+        self.orbits = Orbits()
+        self.jpl_dir = os.path.join(get_data_dir(), "tests", "jpl_testdata")
+        self.orbits.read_orbits(os.path.join(self.jpl_dir, "S0_n747.des"), skiprows=1)
+        # Read JPL ephems.
+        self.jpl = pd.read_csv(os.path.join(self.jpl_dir, "807_n747.txt"), sep=r"\s+")
+        # Temp key fix
+        self.jpl["obj_id"] = self.jpl["objId"]
+        # Add times in TAI and UTC, because.
+        t = Time(self.jpl["epoch_mjd"], format="mjd", scale="utc")
+        self.jpl["mjdTAI"] = t.tai.mjd
+        self.jpl["mjdUTC"] = t.utc.mjd
+
+    def tear_down(self):
+        del self.orbits
+        del self.jpl
+
+    def test_ra_dec(self):
+        # We won't compare Vmag, because this also needs information
+        # on trailing losses.
+        times = self.jpl["mjdUTC"].unique()
+        delta_ra = np.zeros(len(times), float)
+        delta_dec = np.zeros(len(times), float)
+        for i, t in enumerate(times):
+            # Find the JPL obj_ids visible at this time.
+            j = self.jpl.query("mjdUTC == @t").sort_values("obj_id")
+            # Set the ephems, using the objects seen at this time.
+            suborbits = self.orbits.orbits.query("obj_id in @j.obj_id").sort_values("obj_id")
+            sub_orbits = Orbits()
+            sub_orbits.set_orbits(suborbits)
+            ephems = PyOrbEphemerides()
+            ephems.set_orbits(sub_orbits)
+            ephs = ephems.generate_ephemerides(
+                [t],
+                time_scale="UTC",
+                obscode=807,
+                eph_mode="N",
+                eph_type="Basic",
+                by_object=False,
+            )
+            delta_ra[i] = np.abs(ephs["ra"] - j["ra_deg"].values).max()
+            delta_dec[i] = np.abs(ephs["dec"] - j["dec_deg"].values).max()
+        # Convert to mas
+        delta_ra *= 3600.0 * 1000.0
+        delta_dec *= 3600.0 * 1000.0
+        # Much of the time we're closer than 1mas,
+        # but there are a few which hit higher values.
+        print("max JPL errors", np.max(delta_ra), np.max(delta_dec))
+        print("std JPL errors", np.std(delta_ra), np.std(delta_dec))
+        self.assertLess(np.max(delta_ra), 25)
+        self.assertLess(np.max(delta_dec), 25)
+        self.assertLess(np.std(delta_ra), 3)
+        self.assertLess(np.std(delta_dec), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/moving_objects/test_orbits.py

@@ -0,0 +1,170 @@
+import os
+import unittest
+
+import numpy as np
+import pandas as pd
+from pandas.testing import assert_frame_equal
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.moving_objects import Orbits
+
+
+class TestOrbits(unittest.TestCase):
+    def setUp(self):
+        self.testdir = os.path.join(get_data_dir(), "tests", "orbits_testdata")
+
+    def test_equal_not_equal(self):
+        orbits = Orbits()
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        self.assertEqual(len(orbits), 4)
+        orbits2 = Orbits()
+        orbits2.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        self.assertEqual(orbits, orbits2)
+        orbits3 = Orbits()
+        orbits3.read_orbits(os.path.join(self.testdir, "test_orbitsA.des"))
+        self.assertNotEqual(orbits, orbits3)
+
+    def test_iteration_and_indexing(self):
+        orbits = Orbits()
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsNEO.s3m"))
+        orbits_single = orbits[0]
+        assert_frame_equal(orbits_single.orbits, orbits.orbits.query("index==0"))
+        orbits_single = orbits[3]
+        assert_frame_equal(orbits_single.orbits, orbits.orbits.query("index==3"))
+        # Test iteration through all orbits.
+        for orb, (i, orbi) in zip(orbits, orbits.orbits.iterrows()):
+            self.assertEqual(orb.orbits.obj_id.values[0], orbi.obj_id)
+            self.assertTrue(isinstance(orb, Orbits))
+            self.assertEqual(orb.orbits.index, i)
+        # Test iteration through a subset of orbits.
+        orbits_sub = Orbits()
+        orbits_sub.set_orbits(orbits.orbits.query("index > 4"))
+        for orb, (i, orbi) in zip(orbits_sub, orbits_sub.orbits.iterrows()):
+            self.assertEqual(orb.orbits.obj_id.values[0], orbi.obj_id)
+            self.assertTrue(isinstance(orb, Orbits))
+            self.assertEqual(orb.orbits.index, i)
+
+    def test_slicing(self):
+        """
+        Test that we can slice a collection of orbits
+        """
+        orbits = Orbits()
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsNEO.s3m"))
+        orbit_slice = orbits[2:6]
+        self.assertEqual(orbit_slice[0], orbits[2])
+        self.assertEqual(orbit_slice[1], orbits[3])
+        self.assertEqual(orbit_slice[2], orbits[4])
+        self.assertEqual(orbit_slice[3], orbits[5])
+        self.assertEqual(len(orbit_slice), 4)
+
+        orbit_slice = orbits[1:7:2]
+        self.assertEqual(orbit_slice[0], orbits[1])
+        self.assertEqual(orbit_slice[1], orbits[3])
+        self.assertEqual(orbit_slice[2], orbits[5])
+        self.assertEqual(len(orbit_slice), 3)
+
+    def test_offset_dataframe(self):
+        """
+        Test that we can slice and iterate through an orbits
+        dataframe that has already been sub-selected from another
+        dataframe.
+        """
+        orbits0 = Orbits()
+        orbits0.read_orbits(os.path.join(self.testdir, "test_orbitsNEO.s3m"))
+
+        orbits_sub = Orbits()
+        orbits_sub.set_orbits(orbits0.orbits.query("index>1"))
+
+        self.assertEqual(len(orbits_sub), 6)
+
+        orbit_slice = orbits_sub[2:6]
+        self.assertEqual(orbit_slice[0], orbits_sub[2])
+        self.assertEqual(orbit_slice[1], orbits_sub[3])
+        self.assertEqual(orbit_slice[2], orbits_sub[4])
+        self.assertEqual(orbit_slice[3], orbits_sub[5])
+        self.assertEqual(len(orbit_slice), 4)
+
+        orbit_slice = orbits_sub[1:5:2]
+        self.assertEqual(orbit_slice[0], orbits_sub[1])
+        self.assertEqual(orbit_slice[1], orbits_sub[3])
+        self.assertEqual(len(orbit_slice), 2)
+
+        for ii, oo in enumerate(orbits_sub):
+            self.assertEqual(oo, orbits0[ii + 2])
+
+    def test_read_orbits(self):
+        orbits = Orbits()
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        self.assertEqual(len(orbits), 4)
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsA.des"))
+        self.assertEqual(len(orbits), 4)
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsCAR.des"))
+        self.assertEqual(len(orbits), 1)
+        with self.assertRaises(ValueError):
+            orbits.read_orbits(os.path.join(self.testdir, "test_orbitsBadMix.des"))
+        with self.assertRaises(ValueError):
+            orbits.read_orbits(os.path.join(self.testdir, "test_orbitsBad.des"))
+
+    def test_set_orbits(self):
+        orbits = Orbits()
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        # Test that we can set the orbits using a dataframe.
+        suborbits = orbits.orbits.head(1)
+        new_orbits = Orbits()
+        new_orbits.set_orbits(suborbits)
+        self.assertEqual(len(new_orbits), 1)
+        self.assertEqual(new_orbits.orb_format, "COM")
+        assert_frame_equal(new_orbits.orbits, suborbits)
+        # Test that we can set the orbits using a Series.
+        for i, sso in suborbits.iterrows():
+            new_orbits = Orbits()
+            new_orbits.set_orbits(sso)
+            self.assertEqual(len(new_orbits), 1)
+            self.assertEqual(new_orbits.orb_format, "COM")
+            assert_frame_equal(new_orbits.orbits, suborbits)
+        # Test that we can set the orbits using a numpy array of many objects.
+        numpyorbits = orbits.orbits.to_records(index=False)
+        new_orbits = Orbits()
+        new_orbits.set_orbits(numpyorbits)
+        self.assertEqual(len(new_orbits), len(orbits))
+        self.assertEqual(new_orbits.orb_format, "COM")
+        assert_frame_equal(new_orbits.orbits, orbits.orbits)
+        # And test that this works for a single row of the numpy array.
+        onenumpyorbits = numpyorbits[0]
+        new_orbits = Orbits()
+        new_orbits.set_orbits(onenumpyorbits)
+        self.assertEqual(len(new_orbits), 1)
+        self.assertEqual(new_orbits.orb_format, "COM")
+        assert_frame_equal(new_orbits.orbits, suborbits)
+        # And test that it fails appropriately when columns are not correct.
+        neworbits = pd.DataFrame(orbits.orbits)
+        newcols = neworbits.columns.values.tolist()
+        newcols[0] = "ssmId"
+        newcols[3] = "ecc"
+        neworbits.columns = newcols
+        new_orbits = Orbits()
+        with self.assertRaises(ValueError):
+            new_orbits.set_orbits(neworbits)
+
+    def test_set_seds(self):
+        """
+        Test that the self-assignment of SEDs works as expected.
+        """
+        orbits = Orbits()
+        # Test with a range of a values.
+        a = np.arange(0, 5, 0.05)
+        orbs = pd.DataFrame(a, columns=["a"])
+        seds = orbits.assign_sed(orbs)
+        self.assertEqual(np.unique(seds[np.where(a < 2)]), "S.dat")
+        self.assertEqual(np.unique(seds[np.where(a > 4)]), "C.dat")
+        # Test when read a values.
+        orbits.read_orbits(os.path.join(self.testdir, "test_orbitsA.des"))
+        sedvals = orbits.assign_sed(orbits.orbits, random_seed=42)
+        orbits2 = Orbits()
+        orbits2.read_orbits(os.path.join(self.testdir, "test_orbitsQ.des"))
+        sedvals2 = orbits2.assign_sed(orbits2.orbits, random_seed=42)
+        np.testing.assert_array_equal(sedvals, sedvals2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/moving_objects/test_sed_data.py

@@ -0,0 +1,61 @@
+import os
+import unittest
+
+from rubin_scheduler.data import get_data_dir
+
+import rubin_sim.phot_utils as phot_utils
+
+
+class SedDataUnitTest(unittest.TestCase):
+
+    def setUp(self) -> None:
+        # Read the lsst bandpasses
+        lsst = {}
+        lsst_filterlist = "ugrizy"
+        for b in lsst_filterlist:
+            lsst[b] = phot_utils.Bandpass()
+            lsst[b].read_throughput(os.path.join(get_data_dir(), "throughputs", "baseline", f"total_{b}.dat"))
+        self.lsst = lsst
+
+    def test_sun(self) -> None:
+        sun = phot_utils.Sed()
+        sun.read_sed_flambda(os.path.join(get_data_dir(), "movingObjects", "kurucz_sun.gz"))
+        expected_mags = {"u": -25.3, "g": -26.5, "r": -27.0, "i": -27.0, "z": -27.1, "y": -27.1}
+        for b in "ugrizy":
+            mag = sun.calc_mag(self.lsst[b])
+            self.assertTrue(abs(mag - expected_mags[b]) < 0.2)
+
+    def test_seds(self):
+        # We have some sample asteroid spectra in rubin_sim_data_dir -
+        # However, those are 'observed' spectra
+        # (already includes a sample solar spectra)
+        ast_templates = [
+            k.replace(".dat.gz", "")
+            for k in os.listdir(os.path.join(get_data_dir(), "movingObjects"))
+            if "kurucz" not in k and "harris" not in k
+        ]
+        # Read the sso seds from disk (using rubin_sim.photUtils.Sed)
+        sso = {}
+        for k in ast_templates:
+            sso[k] = phot_utils.Sed()
+            sso[k].read_sed_flambda(os.path.join(get_data_dir(), "movingObjects", f"{k}.dat.gz"))
+
+        # Calculate the colors for each type:
+        # referenc e bandpass first
+        refband_name = "r"
+        refband = self.lsst[refband_name]
+        # Calculate the reference bandpass magnitudes
+        refmags = {}
+        for k in sso:
+            refmags[k] = sso[k].calc_mag(refband)
+
+        # And now the colors
+        colors = {}
+        for k in sso:
+            colors[k] = {}
+            for f in "ugrizy":
+                colors[k][f"lsst_{f}"] = sso[k].calc_mag(self.lsst[f]) - refmags[k]
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/phot_utils/test_approximatebandpasses.py

@@ -0,0 +1,91 @@
+"""
+Module to test that Approximate Bandpasses are in sync with the official LSST
+Bandpasses from SYSENG
+
+Note: While the LSST bandpasses list throughput values corresponding to
+wavelengths in the range of 300.0-1150.0 nm, the `approximate_baseline`
+directory of throughputs is created by a script manually. It is thus possible
+for this directory to fall out of sync with the SYSENG values in `baseline`.
+This module is intended to test whether this is happening.
+"""
+
+import os
+import unittest
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.phot_utils import Bandpass, PhotometricParameters
+
+
+class ApproximateBandPassTest(unittest.TestCase):
+    """
+    Tests for the approximate Bandpasses in the throughputs directory
+    """
+
+    long_message = True
+
+    def setUp(self):
+        """Setup before tests."""
+        throughputs_dir = os.path.join(get_data_dir(), "throughputs")
+        self.approx_band_pass_dir = os.path.join(throughputs_dir, "approximate_baseline")
+        self.approx_band_pass_dict = {}
+        for kk in ["u", "g", "r", "i", "z", "y"]:
+            self.approx_band_pass_dict[kk] = Bandpass()
+            self.approx_band_pass_dict[kk].read_throughput(
+                os.path.join(self.approx_band_pass_dir, f"total_{kk}.dat")
+            )
+        self.ref_band_pass_dir = os.path.join(throughputs_dir, "baseline")
+        self.ref_band_pass_dict = {}
+        for kk in ["u", "g", "r", "i", "z", "y"]:
+            self.ref_band_pass_dict[kk] = Bandpass()
+            self.ref_band_pass_dict[kk].read_throughput(
+                os.path.join(self.ref_band_pass_dir, f"total_{kk}.dat")
+            )
+        self.error_msg = "The failure of this test indicates that the"
+        " approximate bandpasses in the lsst throughputs directory do not"
+        "sync up with the baseline bandpasses is throughputs. "
+        " This may require running the script :"
+        " throughputs.approximate_baseline/approximateBandpasses.py"
+
+    def test_band_pass_integrals(self):
+        """Test that the ratio of the quantity
+        int dlambda T(lambda) = band flux for a SED proportional to $lambda$
+        for the approximate bandpasses to the SYSENG band passes is 1.0 to an
+        absolute tolerance hard coded to be 1.0e-4
+
+        """
+        phot_params = PhotometricParameters()
+
+        for bn in "ugrizy":
+            ref_band_pass = self.ref_band_pass_dict[bn]
+            approx_band_pass = self.approx_band_pass_dict[bn]
+
+            zp_ref = ref_band_pass.calc_zp_t(phot_params)
+            zp_approx = approx_band_pass.calc_zp_t(phot_params)
+            self.assertAlmostEqual(zp_ref, zp_approx, delta=1.0e-4, msg=self.error_msg)
+
+    def test_bandpasses_indiv(self):
+        """
+        Test that individual transmission values at wavelengths kept in the
+        approximate bandpasses match the individual transmission values in
+        the reference bandpasses
+        """
+        for bn in "ugrizy":
+            approx_band_pass = self.approx_band_pass_dict[bn]
+            ref_band_pass = self.ref_band_pass_dict[bn]
+            refwavelen = ref_band_pass.wavelen
+            approxwavelen = approx_band_pass.wavelen
+            mask = np.zeros(len(refwavelen), dtype=bool)
+            for i, wave in enumerate(refwavelen):
+                if wave in approxwavelen:
+                    mask[i] = True
+            # Assume that the wavelengths are in order
+            np.testing.assert_array_almost_equal(ref_band_pass.sb[mask], approx_band_pass.sb, decimal=3)
+
+        def tearDown(self):
+            pass
+
+
+if __name__ == "__main__":
+    unittest.main()