Add comparison to non-bandpass-aware thinning

Author: rmjarvis

tests/test_sed.py

@@ -1204,23 +1204,39 @@ def test_thin_bandpass():
     print('in band: ',len(combined_in_band), combined_in_band)
 
     thin_s = s.thin(rel_err=1.e-3, preserve_range=True, bandpass=bp)
-    thin_flux = thin_s.calculateFlux(bp)
-    thin_err = abs((thin_flux - flux) / flux)
-    print('thinned', len(thin_s.wave_list), thin_s.wave_list)
-    assert thin_err < 1.e-3
     np.testing.assert_allclose([thin_s.blue_limit, thin_s.red_limit],
                                [bp.blue_limit, bp.red_limit])
     assert len(thin_s.wave_list) < len(combined_in_band)
     assert len(thin_s.wave_list) < len(s.wave_list)
+    thin_flux = thin_s.calculateFlux(bp)
+    thin_err = abs((thin_flux - flux) / flux)
+    print('thinned', len(thin_s.wave_list), thin_s.wave_list)
+    print('thin_err = ',thin_err)
+    assert thin_err < 1.e-3
 
     # trim_zeros=False should retain the original redshifted SED support.
     thin_s2 = s.thin(rel_err=1.e-3, preserve_range=True, trim_zeros=False, bandpass=bp)
     print('trim_zeros=False', len(thin_s2.wave_list), thin_s2.wave_list)
+    np.testing.assert_allclose([thin_s2.blue_limit, thin_s2.red_limit],
+                               [s.blue_limit, s.red_limit])
     thin_flux2 = thin_s2.calculateFlux(bp)
     thin_err2 = abs((thin_flux2 - flux) / flux)
+    print('thin_err2 = ',thin_err2)
     assert thin_err2 < 1.e-3
-    np.testing.assert_allclose([thin_s2.blue_limit, thin_s2.red_limit],
+
+    # Compare the thinned error when not using bp in the thin call.
+    thin_s3 = s.thin(rel_err=1.e-3, preserve_range=True, trim_zeros=False)
+    print('trim_zeros=False, no bandpass', len(thin_s3.wave_list), thin_s3.wave_list)
+    np.testing.assert_allclose([thin_s3.blue_limit, thin_s3.red_limit],
                                [s.blue_limit, s.red_limit])
+    thin_flux3 = thin_s3.calculateFlux(bp)
+    thin_err3 = abs((thin_flux3 - flux) / flux)
+    print('thin_err3 = ',thin_err3)
+    # There are no hard guarantees about this result, but it should normally also be < rel_err.
+    assert thin_err3 < 1.e-3
+    # It would also be expected in practice that the bandpass-aware thinning does a better
+    # job, but there are no guarantees about that either.  It turns out to be true here.
+    assert thin_err2 < thin_err3
 
 @timer
 def test_broadcast():