Implemented DigiEventCircular ascii function

hexsample/digi.py

@@ -26,7 +26,7 @@
 from loguru import logger
 import numpy as np
 
-from hexsample.hexagon import HexagonalGrid, HexagonalLayout
+#from hexsample.readout import HexagonalReadoutCircular
 from hexsample.pprint import AnsiFontEffect, ansi_format, space, line
 from hexsample.roi import Padding, RegionOfInterest
 
@@ -289,64 +289,41 @@ class DigiEventCircular(DigiEventBase):
     column: int
     row: int
 
-
-    '''
-    def get_neighbors(self):
-        """This function returns the offset coordinates of the signal pixel, that
-        is the highest pixel of the event (as first element), and its neighbors
-        (starting from the upper left, proceiding clockwisely). 
-        The order of the coordinates corresponds in the arrays of pha to the right 
-        value, in order to properly reconstruct the event.
-        """
-        # Identifying the 6 neighbours of the central pixel and saving the signal pixels
-        # prepending the cooridnates of the highest one... 
-        neighbors_coords = list(self.grid.neighbors(self.column, self.row)) #returns a list of tuples
-        # ...and prepending the highest pha pixel to the list...
-        neighbors_coords.insert(0, (self.column, self.row))
-        # ...dividing column and row coordinates in different arrays...
-        columns, rows = zip(*neighbors_coords)
-        columns, rows = np.array(columns), np.array(rows)
-        return columns, rows
-    '''
-    '''
-    def as_dict(self) -> dict:
-        """Return the pixel content of the event in the form of a {(col, row): pha}
-        value.
-
-        This is useful to address the pixel content at a given coordinate. We refrain,
-        for the moment, from implementing a __call__() hook on top of this, as the
-        semantics would be fundamentally different from that implemented with a
-        rectangular ROI, where the access happen in ROI coordinates, and not in chip
-        coordinates, but we might want to come back to this.
+    def __post_init__(self) -> None:
+        """Post-initialization code.
         """
-        columns, rows = self.get_neighbors()
-        return {(col, row): pha for col, row, pha in zip(columns, rows, self.pha)}
-    '''
+        if not len(self.pha) == 7:
+            raise RuntimeError(f'{self.__class__.__name__} has {len(self.pha)} PHA values'
+                f'instead of {7}.')
+
 
-    '''
     def ascii(self, pha_width: int = 5) -> str:
-        """Ascii representation.
+        """Ascii representation. 
+        In the specific case of this class, the ascii representation is simply a px 
+        (that is the highest PHA pixel), because the neighbor position is not accessible
+        by the DigiEvent.
         """
-        columns, rows = self.get_neighbors()
-        pha_dict = self.as_dict()
         fmt = f'%{pha_width}d'
-        cols = np.arange(columns.min(), columns.max() + 1)
+        cols = np.arange(self.column - 1, self.column + 2)
         num_cols = cols[-1] - cols[0] + 1
-        rows = np.arange(rows.min(), rows.max() + 1)
+        rows = np.arange(self.row - 1, self.row + 2)
         big_space = space(2 * pha_width + 1)
         text = f'\n{big_space}'
         text += ''.join([fmt % col for col in cols])
         text += f'\n{big_space}+{line(pha_width * num_cols)}\n'
-        for row in rows:
-            text += f'    {fmt % row}  |'
+        for r in rows:
+            text += f'    {fmt % r}  |'
             for col in cols:
                 try:
-                    pha = fmt % pha_dict[(col, row)]
+                    if col == self.column and r ==self.row:
+                        pha = fmt % max(self.pha)
+                    else:
+                        pha = ' ' * pha_width
                 except KeyError:
                     pha = ' ' * pha_width
                 text += pha
             text += f'\n{big_space}|\n'
         return text
-    '''
+
 
 

hexsample/readout.py

@@ -456,6 +456,7 @@ def read(self, timestamp: float, x: np.ndarray, y: np.ndarray, trg_threshold: fl
         # See: https://stackoverflow.com/questions/70094914/max-on-collections-counter
         coord_max = max(sparse_signal, key=sparse_signal.get)
         col_max, row_max = coord_max
+        print(coord_max)
         #... and converting it in ADC channel coordinates (value from 0 to 6)...
         adc_max = self.adc_channel(*coord_max)
         # ... creating a 7-elements array containing the PHA of the ADC channels from 0 to 6
@@ -476,4 +477,4 @@ def read(self, timestamp: float, x: np.ndarray, y: np.ndarray, trg_threshold: fl
         # Do not forget to update the trigger_id!
         self.trigger_id += 1
         #The pha array is always in the order [pha(adc0), pha(adc1), pha(adc2), pha(adc3), pha(adc4), pha(adc5), pha(adc6)]
-        return DigiEventCircular(self.trigger_id, seconds, microseconds, livetime, pha, *coords)
+        return DigiEventCircular(self.trigger_id, seconds, microseconds, livetime, pha, *coord_max)

tests/test_digi.py

@@ -119,7 +119,7 @@ def test_digitization_circular(layout: HexagonalLayout = HexagonalLayout.ODD_R,
     x = np.append(x, np.full(num_pairs, x2))
     y = np.append(y, np.full(num_pairs, y2))
     event = readout.read(0., x, y, 100.) #this is a DigiEventCircular
-    #print(event.ascii())
+    print(event.ascii())
 
 def test_digi_event_rectangular(min_col: int = 106, max_col: int = 113, min_row: int = 15,
     max_row: int = 22, padding: Padding = Padding(1, 2, 3, 4)):