Show message if ADC_Data is clipped (solves #16)

src/damaris/data/ADC_Result.py

@@ -19,6 +19,7 @@ import tables
 #############################################################################
 
 class ADC_Result(Resultable, Drawable, DamarisFFT, Signalpath):
+    default_bit_depth = 14
     """
     Represents the result of an ADC, encapsulating data and metadata
     for processing, visualization, and export.
@@ -50,6 +51,7 @@ class ADC_Result(Resultable, Drawable, DamarisFFT, Signalpath):
         self.ylabel = "Samples [Digits]"
         self.lock=threading.RLock()
         self.nChannels = 0
+        self.is_clipped = False
 
         # using no argument for initialization
         if (x is None) and (y is None) and (index is None) and (sampl_freq is None) and (desc is None) and (job_id is None) and (job_date is None):
@@ -107,6 +109,44 @@ class ADC_Result(Resultable, Drawable, DamarisFFT, Signalpath):
         return self.cont_data
 
 
+    def check_clipping(self, bit_depth=None):
+        """
+        Check if any data in y is clipped.
+        For a 14-bit ADC, clipping occurs at 2**13 (8192) or 2**13-1 (8191).
+        In general, for a bit_depth-bit signed ADC, limits are 2**(bit_depth-1) and -(2**(bit_depth-1)).
+        """
+        if not self.contains_data():
+            return False
+
+        if bit_depth is None:
+            # try to get bit_depth from description
+            if hasattr(self, "description") and self.description is not None:
+                if "adc_bit_depth" in self.description:
+                    try:
+                        bit_depth = int(self.description["adc_bit_depth"])
+                    except (ValueError, TypeError):
+                        bit_depth = ADC_Result.default_bit_depth
+                else:
+                    bit_depth = ADC_Result.default_bit_depth
+            else:
+                bit_depth = ADC_Result.default_bit_depth
+
+        limit_pos = 2**(bit_depth-1) - 1
+        limit_neg = -2**(bit_depth-1)
+
+        self.lock.acquire()
+        try:
+            self.is_clipped = False
+            for ch_data in self.y:
+                if numpy.any(ch_data >= limit_pos) or numpy.any(ch_data <= limit_neg):
+                    self.is_clipped = True
+                    break
+        finally:
+            self.lock.release()
+
+        return self.is_clipped
+
+
     def add_sample_space(self, samples):
         "Adds space for n samples, where n can also be negative (deletes space). New space is filled up with \"0\""
 
@@ -575,4 +615,5 @@ def read_from_hdf(hdf_node):
     for ch in range(adc_data.shape[1]):
         adc.y.append(adc_data[:,ch])
 
+    adc.check_clipping()
     return adc

src/damaris/data/Accumulation.py

@@ -61,6 +61,7 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
         self.xlabel = "Time / s"
         self.ylabel = "Avg. Samples [Digits]"
         self.lock=threading.RLock()
+        self.is_clipped = False
 
         self.common_descriptions=None
         self.time_period=[]
@@ -616,6 +617,7 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, y_2 = tmp_ysquare, n = self.n, index = self.index, sampl_freq = self.sampling_rate, error = self.use_error)
                 else:
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, n = self.n, index = self.index, sampl_freq = self.sampling_rate, error = self.use_error)
+                r.is_clipped = self.is_clipped
                 r.job_id = self.job_id
                 r.job_ids = self.job_ids.copy()
                 r.time_period = self.time_period[:] if self.time_period is not None else None
@@ -645,6 +647,8 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                     r = Accumulation(x = numpy.array(other.x, dtype="float32"), y = tmp_y, y_2 = tmp_ysquare, n = 1, index = other.index, sampl_freq = other.sampling_rate, error = True)
                 else:
                     r = Accumulation(x = numpy.array(other.x, dtype="float32"), y = tmp_y, index = other.index, sampl_freq = other.sampling_rate, n = 1, error = False)
+                if hasattr(other, "is_clipped"):
+                    r.is_clipped = other.is_clipped
                 r.time_period=[other.job_date,other.job_date]
                 r.job_id = other.job_id
                 r.common_descriptions=other.description.copy()
@@ -678,6 +682,7 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, y_2 = tmp_ysquare, n = self.n + 1, index = self.index, sampl_freq = self.sampling_rate, error = True)
                 else:
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, n = self.n + 1, index = self.index, sampl_freq = self.sampling_rate, error = False)
+                r.is_clipped = self.is_clipped or (hasattr(other, "is_clipped") and other.is_clipped)
                 r.time_period=[min(self.time_period[0],other.job_date),
                                max(self.time_period[1],other.job_date)]
                 r.job_id = other.job_id
@@ -744,13 +749,14 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
 
                 for i in range(self.get_number_of_channels()):
                     tmp_y.append(self.y[i] + other.y[i])
-                    tmp_ysquare.append(self.y_square[i] + other.y_square[i])
+                    if self.uses_statistics():
+                        tmp_ysquare.append(self.y_square[i] + other.y_square[i])
 
                 if self.uses_statistics():
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, y_2 = tmp_ysquare, n = other.n + self.n, index = self.index, sampl_freq = self.sampling_rate, error = True)
                 else:
                     r = Accumulation(x = numpy.array(self.x, dtype="float32"), y = tmp_y, n = other.n + self.n, index = self.index, sampl_freq = self.sampling_rate, error = False)
-
+                r.is_clipped = self.is_clipped or (hasattr(other, "is_clipped") and other.is_clipped)
                 r.time_period=[min(self.time_period[0],other.time_period[0]),
                                max(self.time_period[1],other.time_period[1])]
                 r.job_id = other.job_id
@@ -954,6 +960,8 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                 self.set_title(self.__title_pattern % self.n)
                 self.lock.release()
 
+                if hasattr(other, "is_clipped"):
+                    self.is_clipped = other.is_clipped
                 self.time_period=[other.job_date,other.job_date]
                 self.job_id = other.job_id      # added by Oleg Petrov
                 self.job_ids[other.job_id] = other.get_job_date()
@@ -982,6 +990,8 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                         self.y_square[i] += numpy.array(other.y[i], dtype="float32") ** 2
 
                 self.n += 1
+                if hasattr(other, "is_clipped"):
+                    self.is_clipped = self.is_clipped or other.is_clipped
                 self.time_period=[min(self.time_period[0],other.job_date),
                                   max(self.time_period[1],other.job_date)]
 
@@ -1020,6 +1030,8 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                         self.y_square.append(self.y[i] ** 2)
 
                 self.set_title(self.__title_pattern % self.n)
+                if hasattr(other, "is_clipped"):
+                    self.is_clipped = other.is_clipped
                 self.common_descriptions=other.common_desriptions.copy()
                 self.time_period=other.time_period[:]
                 self.job_id = other.job_id      # added by Oleg Petrov
@@ -1049,6 +1061,8 @@ class Accumulation(Errorable, Drawable, DamarisFFT, Signalpath):
                         self.y_square[i] += other.y_square[i]
 
                 self.n += other.n
+                if hasattr(other, "is_clipped"):
+                    self.is_clipped = self.is_clipped or other.is_clipped
                 self.time_period=[min(self.time_period[0],other.time_period[0]),
                                   max(self.time_period[1],other.time_period[1])]
                 self.job_id = other.job_id