events.h

#ifndef TOFEVENTS_H_INCLUDED
#define TOFEVENTS_H_INCLUDED
 
#include <tuple>
#include <array>
#include <format>
 
#include "tof_typedefs.h"
#include "packets/monitoring.h"
#include "packets/tof_packet.h"
#include "events/tof_event_header.hpp"
#include "calibration.h"
#include "version.h"
 
class RBCalibration;
 
#define NCHN 9
#define NWORDS 1024
#define N_LTBS 25
#define N_CHN_PER_LTB 16
 
struct RBEventHeader;
struct RBEvent;
struct MasterTriggerEvent;
struct TofHit;
 
/*********************************************************/
 
static const f32 C_LIGHT_PADDLE = 15.4; 
 
/*********************************************************/
  
static const u8 EVENTSTATUS_UNKNOWN                 =   0;
static const u8 EVENTSTATUS_CRC32WRONG              =  10;
static const u8 EVENTSTATUS_TAILWRONG               =  11;
static const u8 EVENTSTATUS_CHIDWRONG               =  12;
static const u8 EVENTSTATUS_CELLSYNCERR             =  13;
static const u8 EVENTSTATUS_CHNSYNCERR              =  14;
static const u8 EVENTSTATUS_CELLANDCHNSYNCERR       =  15;
static const u8 EVENTSTATUS_ANYDATAMANGLING         =  16;
static const u8 EVENTSTATUS_INCOMPLETEREADOUT       =  21;
static const u8 EVENTSTATUS_INCOMPATIBLEDATA        =  22;
static const u8 EVENTSTATUS_EVENTTIMEOUT            =  23;
static const u8 EVENTSTATUS_GOODNOCRCORERRBITCHECK  =  39;
static const u8 EVENTSTATUS_GOODNOCRCCHECK          =  40;
static const u8 EVENTSTATUS_GOODNOERRBITCHECK       =  41;
static const u8 EVENTSTATUS_PERFECT                 =  42;
 
enum class EventStatus : u8 {
  Unknown                = EVENTSTATUS_UNKNOWN,
  Crc32Wrong             = EVENTSTATUS_CRC32WRONG,
  TailWrong              = EVENTSTATUS_TAILWRONG,
  ChannelIDWrong         = EVENTSTATUS_CHIDWRONG, 
  CellSyncErrors         = EVENTSTATUS_CELLSYNCERR,
  ChnSyncErrors          = EVENTSTATUS_CHNSYNCERR,
  CellAndChnSyncErrors   = EVENTSTATUS_CELLANDCHNSYNCERR,
  AnyDataMangling        = EVENTSTATUS_ANYDATAMANGLING,
  IncompatibleData       = EVENTSTATUS_INCOMPATIBLEDATA,
  EventTimeOut           = EVENTSTATUS_EVENTTIMEOUT,
  GoodNoCRCOrErrBitCheck = EVENTSTATUS_GOODNOCRCORERRBITCHECK,
  GoodNoCRCCheck         = EVENTSTATUS_GOODNOCRCCHECK,
  GoodNoErrBitCheck      = EVENTSTATUS_GOODNOERRBITCHECK,
  IncompleteReadout      = EVENTSTATUS_INCOMPLETEREADOUT,
  Perfect                = EVENTSTATUS_PERFECT,
  
};
 
std::ostream& operator<<(std::ostream& os, const EventStatus& status);
 
template <>
struct std::formatter<EventStatus> : std::formatter<std::string> {
  // Parse format specifiers (default implementation)
  constexpr auto parse(std::format_parse_context& ctx) {
      return ctx.begin();
  }
  
  auto format(const EventStatus& status, auto& ctx) {
      std::ostringstream oss;
      oss << status;  // Use the << operator to convert enum to string
      return std::format_to(ctx.out(), "{}", oss.str());
  }
};
 
 
/*********************************************************/
 
static const u8 TRIGGERTYPE_UNKNOWN      = 0;
static const u8 TRIGGERTYPE_GAPS         = 4;
static const u8 TRIGGERTYPE_ANY          = 1;
static const u8 TRIGGERTYPE_TRACK        = 2;
static const u8 TRIGGERTYPE_TRACKCENTRAL = 3;
static const u8 TRIGGERTYPE_POISSON      = 100;
static const u8 TRIGGERTYPE_FORCED       = 101;
 
 
/************************************
 *
 * GAPS Trigger types/sources. Description
 * can be found elsewhere. More than oen
 * of them can be active at the same time
 *
 */
enum class TriggerType : u8 {
  Unknown      = TRIGGERTYPE_UNKNOWN,
  Gaps         = TRIGGERTYPE_GAPS,
  Any          = TRIGGERTYPE_ANY,
  Track        = TRIGGERTYPE_TRACK,
  TrackCentral = TRIGGERTYPE_TRACKCENTRAL,
  Poisson      = TRIGGERTYPE_POISSON,
  Forced       = TRIGGERTYPE_FORCED, 
};
 
std::ostream& operator<<(std::ostream& os, const TriggerType& t_type);
 
/*********************************************************/
 
static const u8 LTBTHRESHOLD_NOHIT   = 0;
static const u8 LTBTHRESHOLD_HIT     = 1;
static const u8 LTBTHRESHOLD_BETA    = 2;
static const u8 LTBTHRESHOLD_VETO    = 3;
static const u8 LTBTHRESHOLD_UNKNOWN = 255;
 
enum class LTBThreshold : u8 {
  NoHit   = LTBTHRESHOLD_NOHIT,
  Hit     = LTBTHRESHOLD_HIT,
  Beta    = LTBTHRESHOLD_BETA,
  Veto    = LTBTHRESHOLD_VETO,
  Unknown = LTBTHRESHOLD_UNKNOWN,
};
 
std::ostream& operator<<(std::ostream& os, const LTBThreshold& thresh);
 
/*********************************************************/
 
struct RBEventHeader {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
  static const u16 SIZE = 30; // size in bytes with HEAD and TAIL
 
  u8   rb_id                 ;
  u32  event_id              ;
  u8   status_byte           ;
  u16  channel_mask          ;
  u16  stop_cell             ;
  u16  ch9_amp               ;
  u16  ch9_freq              ;
  u16  ch9_phase             ; 
  u16  fpga_temp             ;
  u32  timestamp32           ;
  u16  timestamp16           ;
  
  RBEventHeader();
 
  static RBEventHeader from_bytestream(const Vec<u8> &bytestream,
                                       u64 &pos);
 
  Vec<u8> get_channels()    const;
  u8      get_nchan()       const;
  Vec<u8> get_active_data_channels() const;
  bool    has_ch9()            const;
  u8      get_n_datachan()     const;
  f32     get_fpga_temp()      const;
  bool    is_event_fragment()  const;
  bool    drs_lost_trigger()   const;
  bool    lost_lock()          const;
  bool    lost_lock_last_sec() const;
  bool    is_locked()          const;
  bool    is_locked_last_sec() const;
 
  std::array<f32, 3> get_sine_fit() const;
    
  u64  get_timestamp48()    const;
 
  std::string to_string() const;
};
 
struct RBEvent {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
 
  // data type will be an enum
  u8 data_type;
  EventStatus status;
  RBEventHeader header;
  Vec<Vec<u16>> adc; 
  Vec<TofHit> hits;
 
  RBEvent();
 
  const Vec<u16>& get_channel_by_label(u8 channel) const;
  const Vec<u16>& get_channel_by_id(u8 channel) const;
 
  const Vec<u16>& get_channel_adc(u8 channel) const; 
 
  static f32 calc_baseline(const Vec<f32> &volts, usize min_bin, usize max_bin); 
 
  static RBEvent from_bytestream(const Vec<u8> &bytestream,
                                 u64 &pos);
 
  std::string to_string() const;
 
  private:
 
    bool channel_check(u8 channel) const;
    Vec<u16> _empty_channel = Vec<u16>();
};
 
struct RBMissingHit {
  
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
  static const usize SIZE = 15; // bytes
  
  u32 event_id     ;  
  u8  ltb_hit_index;  
  u8  ltb_id       ;  
  u8  ltb_dsi      ;  
  u8  ltb_j        ;  
  u8  ltb_ch       ;  
  u8  rb_id        ;  
  u8  rb_ch        ;  
 
  static RBMissingHit from_bytestream(const Vec<u8> &bytestream,
                                      u64 &pos);
};
 
/*********************************************************/
 
static const u8 EVENT_QUALITY_UNKNOWN         =  0;
static const u8 EVENT_QUALITY_SILVER          =  10;
static const u8 EVENT_QUALITY_GOLD            =  20;
static const u8 EVENT_QUALITY_DIAMOND         =  30;
static const u8 EVENT_QUALITY_FOURLEAFCLOVER  =  40;
 
 
enum class EventQuality : u8 {
  Unknown        = EVENT_QUALITY_UNKNOWN,
  Silver         = EVENT_QUALITY_SILVER,
  Gold           = EVENT_QUALITY_GOLD,
  Diamond        = EVENT_QUALITY_DIAMOND,
  FourLeafClover = EVENT_QUALITY_FOURLEAFCLOVER
};
 
std::ostream& operator<<(std::ostream& os, const EventQuality& qual);
 
/*********************************************************/
 
static const u8 COMPRESSION_LEVEL_UNKNOWN         =  0;
static const u8 COMPRESSION_LEVEL_NONE            =  10;
 
enum class CompressionLevel : u8 {
  Unknown        = COMPRESSION_LEVEL_UNKNOWN,
  None           = COMPRESSION_LEVEL_NONE,
};
 
std::ostream& operator<<(std::ostream& os, const CompressionLevel& level);
 
 
struct MasterTriggerEvent {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
  static const usize SIZE = 45; // size in bytes
  EventStatus event_status;
  u32 event_id            ; 
  u32 timestamp           ; 
  u32 tiu_timestamp       ; 
  u32 tiu_gps32           ; 
  u32 tiu_gps16           ; 
  u32 crc                 ;
  u16 trigger_source      ;
  u32 dsi_j_mask          ;
  Vec<u16> channel_mask   ;
  u64 mtb_link_mask       ;
  
  MasterTriggerEvent();
  
  u64 get_timestamp_gps48() const;
 
  u64 get_timestamp_abs48() const;
  
  Vec<u8> get_rb_link_ids() const;
  
  Vec<std::tuple<u8, u8, u8, LTBThreshold>> get_trigger_hits() const;
 
 
  Vec<TriggerType> get_trigger_sources() const; 
  static MasterTriggerEvent from_bytestream(const Vec<u8> &bytestream,
                                            u64 &pos);
  std::string to_string() const;
 
};
 
 
struct TofEvent {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
 
  EventStatus status;
  TofEventHeader header;
  MasterTriggerEvent mt_event;
 
 
  Vec<RBEvent>      rb_events;
  Vec<RBMissingHit> missing_hits;
 
  TofEvent();
 
  static TofEvent from_bytestream(const Vec<u8> &bytestream,
                                  u64 &pos);
 
  static TofEvent from_tofpacket(const TofPacket &packet);
 
  static u32 get_n_rbmissinghits(u32 mask);
  static u32 get_n_rbevents(u32 mask);
 
  std::string to_string() const;
 
  const RBEvent& get_rbevent(u8 board_id) const; 
 
  Vec<u8> get_rbids() const;
 
  private:
    bool passed_consistency_check();
 
    RBEvent _empty_event = RBEvent();
};
 
/***********************************************
 * Reconstructed waveform peak information
 * 
 * There should be one TofHit per reconstructed
 * peak
 * 
 *
 */
struct TofHit  {
  static const u16 HEAD = 0xF0F0;
  static const u16 TAIL = 0xF0F;
 
  u8   paddle_id;
  // deprecated
  bool broken;
 
  // new variables for V1
  Gaps::ProtocolVersion version;
  f32 baseline_a;
  f32 baseline_a_rms;
  f32 baseline_b;
  f32 baseline_b_rms;
  f32 phase;
 
  u32 timestamp32;
  u16 timestamp16;
  // don't serialize
  f32 paddle_len;  
 
  u8 ctr_etx;
  u16 tail = 0xF0F; 
 
  f32 get_time_a()       const;
  f32 get_time_b()       const;
  f32 get_peak_a()       const;
  f32 get_peak_b()       const;
  f32 get_charge_a()     const;
  f32 get_charge_b()     const;
  f32 get_charge_min_i() const;
  f32 get_x_pos()        const;
  f32 get_t_avg()        const;
  f32 get_t0()           const;
  f64 get_timestamp48()  const;
 
  void set_paddle_len(f32 paddle_len);
 
  static TofHit from_bytestream(const Vec<u8> &bytestream, 
                                       u64 &pos);
 
  // easier print out
  std::string to_string() const;
  
  private:
    // we keep this private, since 
    // the user should use the getters
    // to get the values converted 
    // back to f32
    // deprecated, but kept for compatibility
    u16 time_a;
    u16 time_b;
    u16 peak_a;
    u16 peak_b;
    u16 charge_a;
    u16 charge_b;
    u16 charge_min_i;
    u16 x_pos;
    u16 t_average;
    
    f32 time_a_f32;
    f32 time_b_f32;
    f32 peak_a_f32;
    f32 peak_b_f32;
    f32 charge_a_f32;
    f32 charge_b_f32;
};
 
/************************
 * A part of a TofEvent 
 * - a single waveform 
 *
 * That is a waveform for 
 * a specific channel for a 
 * specific id.
 *
 * Each paddle has 2 waveforms
 *
 *
 */ 
struct RBWaveform {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
 
  u32       event_id  ; 
  u8        rb_id     ; 
  u8        rb_channel; 
  u16       stop_cell ;
  Vec<u16>  adc       ; 
  
  static RBWaveform from_bytestream(const Vec<u8> &bytestream, 
                                    u64 &pos);
  
  std::string to_string() const;
};
 
 
struct TofEventSummary {
  static const u16 HEAD = 0xAAAA;
  static const u16 TAIL = 0x5555;
 
  Gaps::ProtocolVersion version ;
  EventStatus status            ; 
  u8          quality           ; 
  u16         trigger_sources   ; 
  u8          n_trigger_paddles ; 
  u32         event_id          ; 
  // flight computer event variable packet
  u8          n_hits_umb        ;
  u8          n_hits_cbe        ;
  u8          n_hits_cor        ;
  f32         tot_edep_umb      ;
  f32         tot_edep_cbe      ;
  f32         tot_edep_cor      ;
 
  u32         timestamp32       ; 
  u16         timestamp16       ; 
  u16         primary_beta      ; 
  u16         primary_charge    ; 
  u32         dsi_j_mask        ;
  Vec<u16>    channel_mask      ;
  u64         mtb_link_mask     ;
  Vec<TofHit> hits              ;
  
  static TofEventSummary from_bytestream(const Vec<u8> &stream, 
                                         u64 &pos);
  // combined timestamp
  u64  get_timestamp48()    const;
 
  Vec<u8> get_rb_link_ids() const;
  
  Vec<std::tuple<u8, u8, u8, LTBThreshold>> get_trigger_hits() const;
 
 
  Vec<TriggerType> get_trigger_sources() const; 
  
  std::string to_string() const;
};
 
std::ostream& operator<<(std::ostream& os, const TofHit& pad);
 
std::ostream& operator<<(std::ostream& os, const MasterTriggerEvent& mt);
 
std::ostream& operator<<(std::ostream& os, const TofEvent& et);
 
std::ostream& operator<<(std::ostream& os, const RBEvent& re);
 
std::ostream& operator<<(std::ostream& os, const RBEventHeader& rh);
 
std::ostream& operator<<(std::ostream& os, const RBWaveform& rh);
 
std::ostream& operator<<(std::ostream& os, const TofEventSummary& tes);
 
#endif