CSCALCTHeader.h

Go to the documentation of this file.

#ifndef CSCALCTHeader_h
#define CSCALCTHeader_h

#include <bitset>
#include <vector>
#include <iosfwd>
#ifndef LOCAL_UNPACK
#include <atomic>
#endif
#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
#include "DataFormats/CSCDigi/interface/CSCALCTStatusDigi.h"
#include "EventFilter/CSCRawToDigi/interface/CSCALCTHeader2006.h"
#include "EventFilter/CSCRawToDigi/interface/CSCALCTHeader2007.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"
#include <boost/dynamic_bitset.hpp>

class CSCALCTHeader {
 public:
  explicit CSCALCTHeader(int chamberType); 

  explicit CSCALCTHeader(const unsigned short * buf);

  CSCALCTHeader(const CSCALCTStatusDigi & digi);

  static void setDebug(bool value){debug = value;};

  void setEventInformation(const CSCDMBHeader &);
  unsigned short int nLCTChipRead()   const;
  
  std::vector<CSCALCTDigi> ALCTDigis() const;
  

  enum FIFO_MODE {NO_DUMP, FULL_DUMP, LOCAL_DUMP};
  unsigned short int FIFOMode()       const {return header2006.fifoMode;} 
  unsigned short int NTBins()         const {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.nTBins;
      case 2007:
        return header2007.rawBins;
      default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"trying to access NTBINs: ALCT firmware version is bad/not defined!";
        return 0;
      }
  }
  unsigned short int BoardID()        const {return header2006.boardID;}
  unsigned short int ExtTrig()        const {return header2006.extTrig;}
  unsigned short int CSCID()          const {return header2006.cscID;}
  unsigned short int BXNCount()       const {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.bxnCount;
      case 2007:
        return header2007.bxnCount;
      default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"trying to access BXNcount: ALCT firmware version is bad/not defined!";
        return 0;
      }
  }

  void setBXNCount(unsigned int bxn)       {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        header2006.bxnCount = bxn % 0xFFF;
    break;
      case 2007:
        header2007.bxnCount = bxn % 0xFFF;
    break;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"trying to set BXNcount: ALCT firmware version is bad/not defined!";
    break;
      }
  }


  unsigned short int L1Acc()          const {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return header2006.l1Acc;
      case 2007:
        return header2007.l1aCounter;
      default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"trying to access L1Acc: ALCT firmware version is bad/not defined!";
        return 0;
      }
  }

  void setL1Acc(unsigned int l1a)       {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        header2006.l1Acc = l1a % 0xF;
        break;
      case 2007:
        header2007.l1aCounter = l1a % 0xFFF;
        break;
      default:
        edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"trying to set L1Acc: ALCT firmware version is bad/not defined!";
        break;
      }
  }

  unsigned short int L1AMatch()        const {return header2006.l1aMatch;}
  unsigned short int ActiveFEBs()      const {return header2006.activeFEBs;}
  unsigned short int Promote1()        const {return header2006.promote1;}
  unsigned short int Promote2()        const {return header2006.promote2;}
  unsigned short int LCTChipRead()     const {return header2006.lctChipRead;}
  unsigned short int alctFirmwareVersion() const {return firmwareVersion;}
  void setDAVForChannel(int wireGroup) {
     if(firmwareVersion == 2006) {
       header2006.setDAV((wireGroup-1)/16);
     }
  }
  CSCALCTHeader2007 alctHeader2007()   const {return header2007;}
  CSCALCTHeader2006 alctHeader2006()   const {return header2006;}

  unsigned short int * data() {return theOriginalBuffer;}
 
  int sizeInWords() {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
        return 8;
      case 2007:
        return sizeInWords2007_;
      default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"SizeInWords(): ALCT firmware version is bad/not defined!";
        return 0;
      }
  }
  
  bool check() const {
#ifdef LOCAL_UNPACK
    switch (firmwareVersion) {
#else
    switch (firmwareVersion.load()) {
#endif
      case 2006:
    return header2006.flag_0 == 0xC;
      case 2007:
        return header2007.flag1 == 0xDB0A;
      default:
    edm::LogError("CSCALCTHeader|CSCRawToDigi")
          <<"check(): ALCT firmware version is bad/not defined!";
        return false;
      }
  }
 
  void add(const std::vector<CSCALCTDigi> & digis);

  boost::dynamic_bitset<> pack();

  static void selfTest(int firmware);  

 private:
  CSCALCTHeader2006 header2006;
  CSCALCTHeader2007 header2007;
  std::vector<CSCALCT> theALCTs;   
  CSCALCTs2006 alcts2006;
  CSCVirtexID virtexID;
  CSCConfigurationRegister configRegister;
  std::vector<CSCCollisionMask> collisionMasks;
  std::vector<CSCHotChannelMask> hotChannelMasks;
  
  //raw data also stored in this buffer
  //maximum header size is 116 words
  unsigned short int theOriginalBuffer[116];
 
#ifdef LOCAL_UNPACK
 static bool debug;
 static unsigned short int firmwareVersion;  
#else 
  static std::atomic<bool> debug;
  static std::atomic<unsigned short int> firmwareVersion;
#endif

  unsigned short int sizeInWords2007_, bxn0, bxn1;
};

std::ostream & operator<<(std::ostream & os, const CSCALCTHeader & header);

#endif