fragheader.hpp

Go to the documentation of this file.

// ╭─╮╭─╴╷╭─╮┌─╮
// ╰─╯╵  ╵╰─╯╵ ╵
#pragma once
 
#include <cassert>
#include <vector>
#include <span>
 
namespace itk::fragment {
 
// global timestamp is written to ROB fragment
// all ROD will have relative timestamp with respect to ROB
 
// ROB defines FelixID pattern without V.ElinkID bits
// ROD defines fid by replacing V.ElinkID in FelixID pattern
 
struct FelixPacket {
  uint64_t fid    = 0; 
  uint64_t time   = 0; 
  const uint8_t* data = nullptr;
  size_t   size   = 0;
  uint8_t  status = 0;
}; // Packet
 
 
using uint = uint32_t;
 
// VID - VersionID[8]
// DID - DetectorID[8]
// CID - ConnectorID[16]
// LID - LinkID[14]
// TID - TransportID[14]
// V   - Virtual Link
// EID - ElinkID[19]
// D   - Direction
// SID - StreamID[8]
//  ╭──╮╭──────╮╭──────────────╮╭────────────╮╭────────────╮╭──────╮
//   VID DID     CID             LID           TID           SID     
//  vvvvddddddddccccccccccccccccllllllllllllllttttttttttttttssssssss
//  ╰──╯╰──────╯╰──────────────╯╰────────────╯╰────────────╯╰──────╯
//  ╭──╮╭──────╮╭──────────────╮╷╭─────────────────╮╷╭─────╮╭──────╮
//   VID DID     CID            V EID               D PID    SID    
//  vvvvddddddddccccccccccccccccqeeeeeeeeeeeeeeeeeeerpppppppssssssss
//  ╰──╯╰──────╯╰──────────────╯╵╰─────────────────╯╵╰─────╯╰──────╯
 
struct FelixID {
  union {
    uint64_t felix_id;
    struct {
      uint stream_id        :  8;
      union {
        struct {
          uint transport_id : 14;
          uint link_id      : 14;
        };
        struct {
          uint proto_id     :  7;
          uint direction    :  1;
          uint elink_id     : 19;
          uint virtlink     :  1;
        };
      };
      uint connector_id     : 16;
      uint detector_id      :  8;
      uint version_id       :  4;
    };
  };
} __attribute__((packed, aligned(4))); // FelixID
 
 
 
namespace FLX {
 
struct Header {
  uint32_t fragment_size  : 22 = 0;    
  uint8_t  padding_bytes  :  2 = 0;    
  uint8_t  felix_status   :  8 = 0;    
  uint32_t elink_id       : 20 = 0;    
  uint8_t  format_type    :  4 = 0;    
  uint8_t  swrod_status   :  8 = 0;    
  uint32_t timestamp           = 0;    
} __attribute__((packed, aligned(4)));
 
static constexpr uint32_t HEADER_SIZE = sizeof(Header)/4;
 
static constexpr uint32_t MAX_DATA32_SIZE = (0x1 << 22) - HEADER_SIZE;
 
} // FLX
 
 
namespace SWROD {
 
struct Header {
  uint16_t size          = 0; 
  uint8_t  felix_status  = 0; 
  uint8_t  swrod_status  = 0; 
  uint32_t link_id       = 0; 
} __attribute__((packed, aligned(4)));
 
constexpr uint32_t HEADER_SIZE = sizeof(Header)/4;
 
} // SWROD
 
 
 
namespace ROD { // Read-Out Driver
 
constexpr uint32_t HEADER_MARKER = 0xee1234ee;
 
constexpr uint32_t HEADER_SIZE = 9;
 
static constexpr uint32_t TRAILER_SIZE = 3;
 
struct Header {
  uint32_t header_marker   = HEADER_MARKER; 
  uint32_t header_size     = HEADER_SIZE;   
  uint32_t format_version;   
  uint32_t source_id;        
  uint32_t run_number;       
  uint32_t ext_l1id;         
  uint32_t bcid;             
  uint32_t trigger_type;     
  uint32_t event_type;       
} __attribute__((packed, aligned(4)));
 
static_assert(sizeof(Header) == HEADER_SIZE*4);
 
 
struct Trailer {
  uint32_t status_size = 0;  
  uint32_t data_size   = 0;  
  uint32_t status_pos  = 1;  
} __attribute__((packed, aligned(4)));
 
static_assert(sizeof(Trailer) == TRAILER_SIZE*4);
 
 
} // ROD
 
 
namespace ROB { // Read-Out Buffer
 
enum checksum_t {
  CHECKSUM_NONE    = 0x0,
 
  CHECKSUM_CRC16   = 0x1,
 
  CHECKSUM_ADLER32 = 0x2,
};
 
 
constexpr uint32_t HEADER_MARKER = 0xdd1234dd;
 
struct BaseHeader {
  uint32_t header_marker = HEADER_MARKER; 
  uint32_t fragment_size = 0;           
  uint32_t header_size;                 
  uint32_t format_version;              
  uint32_t source_id;                   
  uint32_t status_size;                 
  uint32_t status[0];                   
};
 
static constexpr uint32_t BASE_HEADER_SIZE = sizeof(BaseHeader)/4;
 
 
template<int n>
struct Header {
  static constexpr uint32_t HEADER_SIZE = sizeof(Header)/4;
 
  uint32_t header_marker = HEADER_MARKER; 
  uint32_t fragment_size = 0;             
  uint32_t header_size   = HEADER_SIZE;   
  uint32_t format_version;        
  uint32_t source_id     = 0;     
  uint32_t status_size   = n;     
  uint32_t status[n];             
  uint32_t checksum_type = 0;     
 
  uint64_t timestamp    = 0x2000000010000000L; 
  uint32_t felix_device = 0xF; 
} __attribute__((packed, aligned(4)));
 
} // ROB
 
} // itk::fragment