Fix exposure calculation to account for edge effects and GTI

src/gdt/core/data_primitives.py

@@ -286,14 +286,14 @@ def high_edges(self):
 
     def index(self, value):
         """Return the index of the interval that contains the value.
-        
+
         Note :
             If the value is precisely on the boundary of two intervals, the
             first interval index will be returned.
-        
+
         Args:
             value (float): The input value
-        
+
         Returns:
             (int)
         """
@@ -668,7 +668,7 @@ def bin(self, method, *args, tstart=None, tstop=None,
         overflow_counts = counts[:, -1]
         deadtime = counts.sum(axis=1) * event_deadtime + \
                    overflow_counts * (overflow_deadtime - event_deadtime)
-        exposure = (hi_edges - lo_edges) - deadtime
+        exposure = (np.minimum(hi_edges, tstop) - np.maximum(lo_edges, tstart)) - deadtime
 
         if self.ebounds is None:
             bins = TimeChannelBins(counts, lo_edges, hi_edges, exposure,

src/gdt/core/tte.py

@@ -331,6 +331,12 @@ def to_phaii(self, bin_method, *args, time_range=None, energy_range=None,
             obj = obj.slice_time(time_range)
 
         # do the time binning to create the TimeEnergyBins or TimeChannelBins
+        # Use GTI start tstart/tstop by default
+        if 'tstart' not in kwargs:
+            kwargs['tstart'] = obj.gti[0].tstart
+        if 'tstop' not in kwargs:
+            kwargs['tstop'] = obj.gti[-1].tstop
+
         bins = obj.data.bin(bin_method, *args, event_deadtime=self._event_deadtime,
                             overflow_deadtime=self._overflow_deadtime, **kwargs)
         if (energy_range is not None) and (self.ebounds is not None):

tests/core/test_primitives.py

@@ -1948,9 +1948,10 @@ def test_times(self):
                               7.790, 9.602, 9.726, 10.45, 10.61])
 
     def test_bin(self):
-        
+
         # full range, no deadtime, bin into 1 s starting at 0
-        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0, 
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0,
+                           tstart = 0., tstop = 11.,
                            overflow_deadtime=0.0)
         self.assertEqual(bins.num_chans, 4)
         self.assertEqual(bins.num_times, 11)
@@ -1961,8 +1962,18 @@ def test_bin(self):
              self.assertListEqual(bins.counts[i].tolist(), counts[i])
         self.assertListEqual(bins.exposure.tolist(), [1.0]*11)
 
+        # By default, tstart and tstop are the time of the first and last event
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0,
+                           overflow_deadtime=0.0)
+
+        exposure = [1.0] * 11
+        exposure[0] -= self.ev.times[0]
+        exposure[-1] -= 11 - self.ev.times[-1]
+        self.assertListEqual(bins.exposure.tolist(), exposure)
+
         # full range, event deadtime, no overflow deadtime
-        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.1, 
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.1,
+                           tstart=0., tstop=11.,
                            overflow_deadtime=0.0)
         self.assertEqual(bins.num_chans, 4)
         self.assertEqual(bins.num_times, 11)
@@ -1971,7 +1982,8 @@ def test_bin(self):
                                                       0.8])        
 
         # full range, event deadtime, and overflow deadtime
-        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.1, 
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.1,
+                           tstart=0., tstop=11.,
                            overflow_deadtime=0.2)
         self.assertEqual(bins.num_chans, 4)
         self.assertEqual(bins.num_times, 11)
@@ -1980,7 +1992,7 @@ def test_bin(self):
                                                       0.8])
 
         # bin starting at tstart
-        bins = self.ev.bin(bin_by_time, 1.0, time_ref=2.0, event_deadtime=0.0, 
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=2.0, event_deadtime=0.0,
                            overflow_deadtime=0.0, tstart=2.0)
         self.assertEqual(bins.num_chans, 4)
         self.assertEqual(bins.num_times, 9)
@@ -1991,7 +2003,7 @@ def test_bin(self):
              self.assertListEqual(bins.counts[i].tolist(), counts[i])
 
         # bin ending at tstop
-        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0, 
+        bins = self.ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0,
                            overflow_deadtime=0.0, tstop=9.0)
         self.assertEqual(bins.num_chans, 4)
         self.assertEqual(bins.num_times, 9)
@@ -2023,7 +2035,8 @@ def test_bin(self):
 
         # no ebounds
         ev = EventList(times=self.ev.times, channels=self.ev.channels)
-        bins = ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0, 
+        bins = ev.bin(bin_by_time, 1.0, time_ref=0.0, event_deadtime=0.0,
+                      tstart=0., tstop=11.,
                       overflow_deadtime=0.0)
         assert isinstance(bins, TimeChannelBins)
         self.assertEqual(bins.num_chans, 4)