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

tests/moving_objects/test_chebyfits.py

@@ -0,0 +1,188 @@
+import os
+import shutil
+import tempfile
+import unittest
+import warnings
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.moving_objects import ChebyFits, Orbits
+
+ROOT = os.path.abspath(os.path.dirname(__file__))
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestChebyFits(unittest.TestCase):
+    def setUp(self):
+        self.testdir = os.path.join(get_data_dir(), "tests", "orbits_testdata")
+        self.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix="TestChebyFits-")
+        self.orbits = Orbits()
+        self.orbits.read_orbits(os.path.join(self.testdir, "test_orbitsMBA.s3m"))
+        self.cheb = ChebyFits(
+            self.orbits,
+            54800,
+            30,
+            ngran=64,
+            sky_tolerance=2.5,
+            n_decimal=10,
+            n_coeff_position=14,
+        )
+        self.assertEqual(self.cheb.ngran, 64)
+
+    def tearDown(self):
+        del self.orbits
+        del self.cheb
+        if os.path.exists(self.scratch_dir):
+            shutil.rmtree(self.scratch_dir)
+
+    def test_precompute_multipliers(self):
+        # Precompute multipliers is done as an automatic step in __init__.
+        # After setting up self.cheb, these multipliers should all exist.
+        for key in self.cheb.n_coeff:
+            self.assertTrue(key in self.cheb.multipliers)
+
+    def test_set_segment_length(self):
+        # Expect MBAs with standard ngran and tolerance to have
+        # length ~2.0 days.
+        self.cheb.calc_segment_length()
+        self.assertAlmostEqual(self.cheb.length, 2.0)
+        # Test that we can set it to other values which fit into
+        # the 30 day window.
+        self.cheb.calc_segment_length(length=1.5)
+        self.assertEqual(self.cheb.length, 1.5)
+        # Test that we if we try to set it to a value which does not
+        # fit into the 30 day window,
+        # that the actual value used is different - and smaller.
+        self.cheb.calc_segment_length(length=1.9)
+        self.assertTrue(self.cheb.length < 1.9)
+        # Test that we get a warning about the residuals if we try
+        # to set the length to be too long.
+        with warnings.catch_warnings(record=True) as w:
+            self.cheb.calc_segment_length(length=5.0)
+            self.assertTrue(len(w), 1)
+        # Now check granularity works for other orbit types
+        # (which would have other standard lengths).
+        # Check for multiple orbit types.
+        for orbit_file in [
+            "test_orbitsMBA.s3m",
+            "test_orbitsOuter.s3m",
+            "test_orbitsNEO.s3m",
+        ]:
+            self.orbits.read_orbits(os.path.join(self.testdir, orbit_file))
+            t_start = self.orbits.orbits["epoch"].iloc[0]
+            cheb = ChebyFits(self.orbits, t_start, 30, ngran=64, n_decimal=2)
+            # And that we should converge for a variety of other tolerances.
+            for sky_tolerance in (2.5, 5.0, 10.0, 100.0, 1000.0, 20000.0):
+                cheb.sky_tolerance = sky_tolerance
+                cheb.calc_segment_length()
+                pos_resid, ratio = cheb._test_residuals(cheb.length)
+                self.assertTrue(pos_resid < sky_tolerance)
+                self.assertEqual((cheb.length * 100) % 1, 0)
+                # print('final', orbit_file, sky_tolerance, pos_resid,
+                # cheb.length, ratio)
+        # And check for challenging 'impactors'.
+        for orbit_file in ["test_orbitsImpactors.s3m"]:
+            self.orbits.read_orbits(os.path.join(self.testdir, orbit_file))
+            t_start = self.orbits.orbits["epoch"].iloc[0]
+            cheb = ChebyFits(self.orbits, t_start, 30, ngran=64, n_decimal=10)
+            # And that we should converge for a variety of other tolerances.
+            for sky_tolerance in (2.5, 10.0, 100.0):
+                cheb.sky_tolerance = sky_tolerance
+                cheb.calc_segment_length()
+                pos_resid, ratio = cheb._test_residuals(cheb.length)
+                self.assertTrue(pos_resid < sky_tolerance)
+                # print('final', orbit_file, sky_tolerance, pos_resid,
+                # cheb.length, ratio)
+
+    @unittest.skip("Skipping because it has a strange platform-dependent failure")
+    def test_segments(self):
+        # Test that we can create segments.
+        self.cheb.calc_segment_length(length=1.0)
+        times = self.cheb.make_all_times()
+        self.cheb.generate_ephemerides(times)
+        self.cheb.calc_segments()
+        # We expect calculated coefficients to have the following keys:
+        coeff_keys = [
+            "obj_id",
+            "t_start",
+            "t_end",
+            "ra",
+            "dec",
+            "geo_dist",
+            "vmag",
+            "elongation",
+        ]
+        for k in coeff_keys:
+            self.assertTrue(k in self.cheb.coeffs.keys())
+        # And in this case, we had a 30 day timespan with 1 day segments
+        # (one day segments should be more than enough to meet
+        # 2.5mas tolerance, so not subdivided)
+        self.assertEqual(len(self.cheb.coeffs["t_start"]), 30 * len(self.orbits))
+        # And we used 14 coefficients for ra and dec.
+        self.assertEqual(len(self.cheb.coeffs["ra"][0]), 14)
+        self.assertEqual(len(self.cheb.coeffs["dec"][0]), 14)
+
+    def test_write(self):
+        # Test that we can write the output to files.
+        self.cheb.calc_segment_length()
+        self.cheb.generate_ephemerides(self.cheb.make_all_times())
+        self.cheb.calc_segments()
+        coeff_name = os.path.join(self.scratch_dir, "coeff1.txt")
+        resid_name = os.path.join(self.scratch_dir, "resid1.txt")
+        failed_name = os.path.join(self.scratch_dir, "failed1.txt")
+        self.cheb.write(coeff_name, resid_name, failed_name)
+        self.assertTrue(os.path.isfile(coeff_name))
+        self.assertTrue(os.path.isfile(resid_name))
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestRun(unittest.TestCase):
+    def setUp(self):
+        self.testdir = os.path.join(get_data_dir(), "tests", "orbits_testdata")
+        self.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix="TestChebyFits-")
+        self.orbits = Orbits()
+        self.orbits.read_orbits(os.path.join(self.testdir, "test_orbitsMBA.s3m"))
+
+    def tearDown(self):
+        del self.orbits
+        if os.path.exists(self.scratch_dir):
+            shutil.rmtree(self.scratch_dir)
+
+    def test_run_through(self):
+        # Set up chebyshev fitter.
+        t_start = self.orbits.orbits.epoch.iloc[0]
+        interval = 30
+        cheb = ChebyFits(self.orbits, t_start, interval, ngran=64, sky_tolerance=2.5, n_decimal=10)
+        # Set granularity. Use an value that will be too long,
+        # to trigger recursion below.
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            cheb.calc_segment_length(length=10.0)
+        # Run through segments.
+        cheb.calc_segments()
+        self.assertEqual(len(np.unique(cheb.coeffs["obj_id"])), len(self.orbits))
+        # Write outputs.
+        coeff_name = os.path.join(self.scratch_dir, "coeff2.txt")
+        resid_name = os.path.join(self.scratch_dir, "resid2.txt")
+        failed_name = os.path.join(self.scratch_dir, "failed2.txt")
+        cheb.write(coeff_name, resid_name, failed_name)
+        # Test that the segments for each individual object fit
+        # together start/end.
+        for k in cheb.coeffs:
+            cheb.coeffs[k] = np.array(cheb.coeffs[k])
+        for obj_id in np.unique(cheb.coeffs["obj_id"]):
+            condition = cheb.coeffs["obj_id"] == obj_id
+            te_prev = t_start
+            for ts, te in zip(cheb.coeffs["t_start"][condition], cheb.coeffs["t_end"][condition]):
+                # Test that the start of the current interval =
+                # the end of the previous interval.
+                self.assertEqual(te_prev, ts)
+                te_prev = te
+        # Test that the end of the last interval is equal to the end
+        # of the total interval
+        self.assertEqual(te, t_start + interval)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/moving_objects/test_chebyshevutils.py

@@ -0,0 +1,76 @@
+import unittest
+
+import numpy as np
+
+from rubin_sim.moving_objects import chebeval, chebfit, make_cheb_matrix
+
+
+class TestChebgrid(unittest.TestCase):
+    def test_raise_error(self):
+        x = np.linspace(-1, 1, 9)
+        y = np.sin(x)
+        dy = np.cos(x)
+        p, resid, rms, maxresid = chebfit(x, y, dy, n_poly=4)
+        with self.assertRaises(RuntimeError):
+            chebeval(np.linspace(-1, 1, 17), p, interval=[1, 2, 3])
+
+    def test_eval(self):
+        x = np.linspace(-1, 1, 9)
+        y = np.sin(x)
+        dy = np.cos(x)
+        p, resid, rms, maxresid = chebfit(x, y, dy, n_poly=4)
+        yy_w_vel, vv = chebeval(np.linspace(-1, 1, 17), p)
+        yy_wout_vel, vv = chebeval(np.linspace(-1, 1, 17), p, do_velocity=False)
+        self.assertTrue(np.allclose(yy_wout_vel, yy_w_vel))
+        # Test that we get a nan for a value outside the range of the
+        # 'interval', if mask=True
+        yy_w_vel, vv = chebeval(np.linspace(-2, 1, 17), p, mask=True)
+        self.assertTrue(
+            np.isnan(yy_w_vel[0]),
+            msg="Expected NaN for masked/out of range value, but got %.2e" % (yy_w_vel[0]),
+        )
+
+    def test_ends_locked(self):
+        x = np.linspace(-1, 1, 9)
+        y = np.sin(x)
+        dy = np.cos(x)
+        for polynomial in range(4, 10):
+            p, resid, rms, maxresid = chebfit(x, y, dy, n_poly=4)
+            yy, vv = chebeval(np.linspace(-1, 1, 17), p)
+            self.assertAlmostEqual(yy[0], y[0], places=13)
+            self.assertAlmostEqual(yy[-1], y[-1], places=13)
+            self.assertAlmostEqual(vv[0], dy[0], places=13)
+            self.assertAlmostEqual(vv[-1], dy[-1], places=13)
+
+    def test_accuracy(self):
+        """If n_poly is  greater than number of values being fit,
+        then fit should be exact."""
+        x = np.linspace(0, np.pi, 9)
+        y = np.sin(x)
+        dy = np.cos(x)
+        p, resid, rms, maxresid = chebfit(x, y, dy, n_poly=16)
+        yy, vv = chebeval(x, p, interval=np.array([0, np.pi]))
+        self.assertTrue(np.allclose(yy, y, rtol=1e-13))
+        self.assertTrue(np.allclose(vv, dy, rtol=1e-13))
+        self.assertLess(np.sum(resid), 1e-13)
+
+    def test_accuracy_prefit_c1c2(self):
+        """If n_poly is  greater than number of values being fit,
+        then fit should be exact."""
+        NPOINTS = 8
+        NPOLY = 16
+        x = np.linspace(0, np.pi, NPOINTS + 1)
+        y = np.sin(x)
+        dy = np.cos(x)
+        xmatrix, dxmatrix = make_cheb_matrix(NPOINTS + 1, NPOLY)
+        p, resid, rms, maxresid = chebfit(
+            x, y, dy, x_multiplier=xmatrix, dx_multiplier=dxmatrix, n_poly=NPOLY
+        )
+        yy, vv = chebeval(x, p, interval=np.array([0, np.pi]))
+        self.assertTrue(np.allclose(yy, y, rtol=1e-13))
+        self.assertTrue(np.allclose(vv, dy, rtol=1e-13))
+        self.assertLess(np.sum(resid), 1e-13)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/moving_objects/test_chebyvalues.py

@@ -0,0 +1,245 @@
+import os
+import shutil
+import tempfile
+import unittest
+import warnings
+
+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 ChebyFits, ChebyValues, Orbits, PyOrbEphemerides
+
+ROOT = os.path.abspath(os.path.dirname(__file__))
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestChebyValues(unittest.TestCase):
+    def setUp(self):
+        self.testdatadir = os.path.join(get_data_dir(), "tests", "orbits_testdata")
+        self.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix="TestChebyValues-")
+        self.coeff_file = os.path.join(self.scratch_dir, "test_coeffs")
+        self.resid_file = os.path.join(self.scratch_dir, "test_resids")
+        self.failed_file = os.path.join(self.scratch_dir, "test_failed")
+        self.orbits = Orbits()
+        self.orbits.read_orbits(os.path.join(self.testdatadir, "test_orbitsNEO.s3m"), skiprows=1)
+        self.pyephems = PyOrbEphemerides()
+        self.pyephems.set_orbits(self.orbits)
+        self.t_start = self.orbits.orbits.epoch.iloc[0]
+        self.interval = 30
+        self.n_coeffs = 14
+        self.n_decimal = 13
+
+        self.cheby_fits = ChebyFits(
+            self.orbits,
+            self.t_start,
+            self.interval,
+            ngran=64,
+            sky_tolerance=2.5,
+            n_decimal=self.n_decimal,
+            n_coeff_position=self.n_coeffs,
+            obscode=807,
+            time_scale="TAI",
+        )
+        self.set_length = 0.5
+        self.cheby_fits.calc_segment_length(length=self.set_length)
+        self.cheby_fits.calc_segments()
+        self.cheby_fits.write(self.coeff_file, self.resid_file, self.failed_file, append=False)
+        self.coeff_keys = [
+            "obj_id",
+            "t_start",
+            "t_end",
+            "ra",
+            "dec",
+            "geo_dist",
+            "vmag",
+            "elongation",
+        ]
+
+    def tearDown(self):
+        del self.orbits
+        del self.cheby_fits
+        if os.path.exists(self.scratch_dir):
+            shutil.rmtree(self.scratch_dir)
+
+    def test_set_coeff(self):
+        # Test setting coefficients directly from chebyFits outputs.
+        cheby_values = ChebyValues()
+        cheby_values.set_coefficients(self.cheby_fits)
+        for k in self.coeff_keys:
+            self.assertTrue(k in cheby_values.coeffs)
+            self.assertTrue(isinstance(cheby_values.coeffs[k], np.ndarray))
+        self.assertEqual(len(np.unique(cheby_values.coeffs["obj_id"])), len(self.orbits))
+        # This will only be true for carefully selected length/orbit type,
+        # where subdivision did not occur.
+        # For the test MBAs, a len=1day will work.
+        # For the test NEOs, a len=0.25 day will work (with 2.5mas skyTol).
+        # self.assertEqual(len(cheby_values.coeffs['tStart']),
+        #            (self.interval / self.set_length) * len(self.orbits))
+        self.assertEqual(len(cheby_values.coeffs["ra"][0]), self.n_coeffs)
+        self.assertTrue("meanRA" in cheby_values.coeffs)
+        self.assertTrue("meanDec" in cheby_values.coeffs)
+
+    def test_read_coeffs(self):
+        # Test reading the coefficients from disk.
+        cheby_values = ChebyValues()
+        cheby_values.read_coefficients(self.coeff_file)
+        cheby_values2 = ChebyValues()
+        cheby_values2.set_coefficients(self.cheby_fits)
+        for k in cheby_values.coeffs:
+            if k == "obj_id":
+                # Can't test strings with np.test.assert_almost_equal.
+                np.testing.assert_equal(cheby_values.coeffs[k], cheby_values2.coeffs[k])
+            else:
+                # All of these will only be accurate to 2 less decimal places
+                # than they are print out with in chebyFits. Since vmag,
+                # delta and elongation only use 7
+                # decimal places, this means we can test to 5 decimal
+                # places for those.
+                np.testing.assert_allclose(cheby_values.coeffs[k], cheby_values2.coeffs[k], rtol=0, atol=1e-5)
+
+    def test_get_ephemerides(self):
+        # Test that get_ephemerides works and is accurate.
+        cheby_values = ChebyValues()
+        cheby_values.set_coefficients(self.cheby_fits)
+
+        # Multiple times, all objects, all within interval.
+        tstep = self.interval / 10.0
+        time = np.arange(self.t_start, self.t_start + self.interval, tstep)
+        # Test for a single time, but all the objects.
+        ephemerides = cheby_values.get_ephemerides(time)
+        pyephemerides = self.pyephems.generate_ephemerides(
+            time, obscode=807, time_scale="TAI", by_object=True
+        )
+        # Looks like there's some weird hardware dependent issue
+        # where cheby_fits is failing to fit some orbits.
+
+        # RA and Dec should agree to 2.5mas (sky_tolerance above)
+        pos_residuals = np.sqrt(
+            (ephemerides["ra"] - pyephemerides["ra"]) ** 2
+            + ((ephemerides["dec"] - pyephemerides["dec"]) * np.cos(np.radians(ephemerides["dec"]))) ** 2
+        )
+        pos_residuals *= 3600.0 * 1000.0
+        if not np.all(np.isfinite(ephemerides["ra"])):
+            warnings.warn("NaN values from ChebyValues.get_ephemerides, skipping some tests")
+        else:
+            # Let's just look at the max residuals in all quantities.
+            for k in ("ra", "dec", "dradt", "ddecdt", "geo_dist"):
+                resids = np.abs(ephemerides[k] - pyephemerides[k])
+                if k != "geo_dist":
+                    resids *= 3600.0 * 1000.0
+                print("max diff", k, np.max(resids))
+            resids = np.abs(ephemerides["elongation"] - pyephemerides["solarelon"])
+            print("max diff elongation", np.max(resids))
+            resids = np.abs(ephemerides["vmag"] - pyephemerides["magV"])
+            print("max diff vmag", np.max(resids))
+            self.assertLessEqual(np.nanmax(pos_residuals), 2.5)
+            # Test for single time, but for a subset of the objects.
+            obj_ids = self.orbits.orbits.obj_id.head(3).values
+            ephemerides = cheby_values.get_ephemerides(time, obj_ids)
+            self.assertEqual(len(ephemerides["ra"]), 3)
+            # Test for time outside of segment range.
+            obj_ids = self.orbits.orbits.obj_id.head(3).values
+            ephemerides = cheby_values.get_ephemerides(
+                self.t_start + self.interval * 2, obj_ids, extrapolate=False
+            )
+            self.assertTrue(
+                np.isnan(ephemerides["ra"][0]),
+                msg=f"Expected Nan for out of range ephemeris, got {ephemerides['ra'][0]}",
+            )
+
+
+@unittest.skip("Temporary skip until ephemerides replaced")
+class TestJPLValues(unittest.TestCase):
+    # Test the interpolation-generated RA/Dec values against JPL
+    # generated RA/Dec values.
+    # The resulting errors should be similar to the errors reported
+    # from testEphemerides when testing against JPL 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_table(os.path.join(self.jpl_dir, "807_n747.txt"), sep=r"\s+")
+        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
+        self.jpl = self.jpl.to_records(index=False)
+        # Generate interpolation coefficients for the time period
+        # in the JPL catalog.
+        self.scratch_dir = tempfile.mkdtemp(dir=ROOT, prefix="TestJPLValues-")
+        self.coeff_file = os.path.join(self.scratch_dir, "test_coeffs")
+        self.resid_file = os.path.join(self.scratch_dir, "test_resids")
+        self.failed_file = os.path.join(self.scratch_dir, "test_failed")
+        t_start = self.jpl["mjdTAI"].min() - 0.2
+        t_end = self.jpl["mjdTAI"].max() + 0.2 - self.jpl["mjdTAI"].min()
+        self.cheby_fits = ChebyFits(
+            self.orbits,
+            t_start,
+            t_end,
+            ngran=64,
+            sky_tolerance=2.5,
+            n_decimal=14,
+            obscode=807,
+        )
+        self.cheby_fits.calc_segment_length()
+        self.cheby_fits.calc_segments()
+
+        self.coeff_keys = [
+            "obj_id",
+            "t_start",
+            "t_end",
+            "ra",
+            "dec",
+            "geo_dist",
+            "vmag",
+            "elongation",
+        ]
+        self.cheby_values = ChebyValues()
+        self.cheby_values.set_coefficients(self.cheby_fits)
+
+    def tearDown(self):
+        del self.orbits
+        del self.jpl
+        if os.path.exists(self.scratch_dir):
+            shutil.rmtree(self.scratch_dir)
+
+    def test_ra_dec(self):
+        # We won't compare Vmag, because this also needs
+        # information on trailing losses.
+        times = np.unique(self.jpl["mjdTAI"])
+        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[np.where(self.jpl["mjdTAI"] == t)]
+            ephs = self.cheby_values.get_ephemerides(t, obj_ids=j["obj_id"])
+            ephorder = np.argsort(ephs["obj_id"])
+            # Sometimes I've had to reorder both, sometimes just the ephs. ??
+            jorder = np.argsort(j["obj_id"])
+            jorder = np.arange(0, len(jorder))
+            d_ra = np.abs(ephs["ra"][ephorder][:, 0] - j["ra_deg"][jorder]) * 3600.0 * 1000.0
+            d_dec = np.abs(ephs["dec"][ephorder][:, 0] - j["dec_deg"][jorder]) * 3600.0 * 1000.0
+            delta_ra[i] = d_ra.max()
+            delta_dec[i] = d_dec.max()
+        # Should be (given OOrb direct prediction):
+        # Much of the time we're closer than 1mas, but there are a
+        # few which hit higher values.
+        # This is consistent with the errors/values reported by oorb
+        # directly in testEphemerides.
+
+        #    # XXX--units?
+        print("max JPL errors", delta_ra.max(), delta_dec.max())
+        print("std of 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()