VFATdata.h

Go to the documentation of this file.

#ifndef DataFormats_GEMDigi_VFATdata_h
#define DataFormats_GEMDigi_VFATdata_h
 
#include <cstdint>
 
namespace gem {
  union VFATfirst {
    uint64_t word;
    // v3 dataformat
    struct {
      uint64_t msData1 : 16;  
      uint64_t bc : 16;       
      uint64_t ec : 8;        
      uint64_t header : 8;    
      // is half-full, so it's like a warning
      uint64_t vc : 1;      
      uint64_t unused : 7;  
      uint64_t pos : 8;     
    };
    // v2 dataformat
    struct {
      uint64_t msData1v2 : 16;  
      uint64_t chipID : 12;     
      uint64_t b1110 : 4;       
      uint64_t flag : 4;        
      uint64_t ecV2 : 8;        
      uint64_t b1100 : 4;       
      uint64_t bcV2 : 12;       
      uint64_t b1010 : 4;       
    };
  };
  union VFATsecond {
    uint64_t word;
    struct {
      uint64_t lsData1 : 16;  
      uint64_t msData2 : 48;  
    };
  };
  union VFATthird {
    uint64_t word;
    struct {
      uint64_t crc : 16;      
      uint64_t lsData2 : 48;  
    };
  };
 
  class VFATdata {
  public:
    VFATdata();
    // this constructor only used for packing sim digis
    VFATdata(const int vfatVer,
             const uint16_t BC,
             const uint8_t EC,
             const uint16_t chipID,
             const uint64_t lsDatas,
             const uint64_t msDatas);
    ~VFATdata() {}
 
    void read_fw(uint64_t word) { fw_ = word; }
    uint64_t get_fw() const { return fw_; }
 
    void read_sw(uint64_t word) { sw_ = word; }
    uint64_t get_sw() const { return sw_; }
 
    void read_tw(uint64_t word) { tw_ = word; }
    uint64_t get_tw() const { return tw_; }
 
    // local phi in chamber
    void setPhi(int i) { phiPos_ = i; }
    int phi() const { return phiPos_; }
 
    uint64_t lsData() const { return uint64_t(VFATsecond{sw_}.lsData1) << 48 | VFATthird{tw_}.lsData2; }
    uint64_t msData() const { return uint64_t(VFATfirst{fw_}.msData1) << 48 | VFATsecond{sw_}.msData2; }
 
    uint16_t bc() const {
      if (ver_ == 2)
        return VFATfirst{fw_}.bcV2;
      return VFATfirst{fw_}.bc;
    }
    uint8_t ec() const {
      if (ver_ == 2)
        return VFATfirst{fw_}.ecV2;
      return VFATfirst{fw_}.ec;
    }
    uint16_t vfatId() const {
      if (ver_ == 2)
        return VFATfirst{fw_}.chipID;
      return VFATfirst{fw_}.pos;
    }
 
    void setVersion(int i) { ver_ = i; }
    int version() const { return ver_; }
 
    uint8_t quality();
 
    uint8_t header() const { return VFATfirst{fw_}.header; }
    uint8_t crcCheck() const { return VFATfirst{fw_}.vc; }
    uint8_t position() const { return VFATfirst{fw_}.pos; }
 
    uint8_t b1010() const { return VFATfirst{fw_}.b1010; }
    uint8_t b1100() const { return VFATfirst{fw_}.b1100; }
    uint8_t b1110() const { return VFATfirst{fw_}.b1110; }
    uint8_t flag() const { return VFATfirst{fw_}.flag; }
    uint16_t chipID() const { return VFATfirst{fw_}.chipID; }
    uint16_t crc() const { return VFATthird{tw_}.crc; }
 
    uint16_t crc_cal(uint16_t crc_in, uint16_t dato);
    uint16_t checkCRC();
 
    static const int nChannels = 128;
    static const int sizeChipID = 12;
 
  private:
    int ver_;     
    int phiPos_;  
 
    uint64_t fw_;  // VFAT first word
    uint64_t sw_;  // VFAT second word
    uint64_t tw_;  // VFAT third word
  };
}  // namespace gem
#endif