VFATdata.h

Go to the documentation of this file.

#ifndef EventFilter_GEMRawToDigi_VFATdata_h
#define EventFilter_GEMRawToDigi_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;  
      uint64_t crcCheck : 8;  
      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_}.crcCheck;    }
    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
  };
}
#endif