UCTDAQRawData.h

Go to the documentation of this file.

#ifndef UCTDAQRawData_hh
#define UCTDAQRawData_hh

#include <cstdint>
#include <iostream>
#include <iomanip>

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
using namespace edm;

class UCTDAQRawData {
public:

  UCTDAQRawData(const uint64_t *d) : myDataPtr(d) {
    if(d != nullptr) {
      if((d[0] & 0x5000000000000000) != 0x5000000000000000) {
    LogError("UCTDAQRawData") << "CDF Header does not seem to be correct" 
          << std::showbase << std::internal 
          << std::setfill('0') << std::setw(10)
          << std::hex
          << d[0]
          << "; but continuing!"
          << std::endl;
      }
    }
  }
  
  virtual ~UCTDAQRawData() {;}
  
  // Access functions for convenience
  
  const uint64_t *dataPtr() const {return myDataPtr;}

  const uint64_t *cdfHeader() const {return &myDataPtr[0];}

  uint32_t FOV() {return ((myDataPtr[0] & 0x00000000000000F0) >> 4);}
  uint32_t sourceID() {return ((myDataPtr[0] & 0x00000000000FFF00) >> 8);}
  uint32_t BXID() {return ((myDataPtr[0] & 0x00000000FFF00000) >> 20);}
  uint32_t L1ID() {return ((myDataPtr[0] & 0x00FFFFFF00000000) >> 32);}
  uint32_t eventType() {return ((myDataPtr[0] & 0x0F00000000000000) >> 56);}
  uint32_t orbitNumber() {
    return ((myDataPtr[1] & 0x0000000FFFFFFFF0) >> 4);
  }
  uint32_t nAMCs() {return ((myDataPtr[1] & 0x00F0000000000000) >> 52);}
  uint32_t uFOV() {return ((myDataPtr[1] & 0xF000000000000000) >> 60);}

  uint32_t boardID(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return myDataPtr[2+amc] & 0x000000000000FFFF;
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch board ID for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return 0xDEADBEEF;
  }

  uint32_t amcNo(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x00000000000F0000) >> 16);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch amc no for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return 0xDEADBEEF;
  }

  uint32_t amcBlkNo(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x000000000FF00000) >> 20);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch amc block no for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return 0xDEADBEEF;
  }

  uint32_t amcSize(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x00FFFFFF00000000) >> 32);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch amc size for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return 0xDEADBEEF;
  }

  bool crcError(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x0100000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch crcError-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool isValid(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x0200000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch isValid-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool isPresent(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x0400000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch isPresent-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool isEnabled(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x0800000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch isEnabled-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool isSegmented(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x1000000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch isSegmented-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool more(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x2000000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch more-bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  bool lengthError(uint32_t amc = 0) {
    if(amc < nAMCs()) {
      return ((myDataPtr[2+amc] & 0x4000000000000000) != 0);
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch length error bit for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return false;
  }
  
  const uint32_t *amcPayload(uint32_t amc) {
    if(amc < nAMCs()) {
      // Number of 64-bit words to skip
      uint32_t skip = 2 + nAMCs();
      for(uint32_t i = 0; i < amc; i++) {
    skip += amcSize(i);
      }
      return (uint32_t *) &myDataPtr[skip];
    }
    LogError("UCTDAQRawData") << "UCTDAQRawData: Failed to fetch payload location for AMC = " << amc << "; Max AMC = " << nAMCs() << std::endl;
    return nullptr;
  }

  const uint64_t *amc13TrailerPtr() {
    uint32_t skip = 2;
    for(uint32_t i = 0; i < nAMCs(); i++) {
      skip += (1 + amcSize(i));
    }
    return &myDataPtr[skip];
  }

  uint32_t amc13BXID() {
    const uint64_t *data = amc13TrailerPtr();
    return (data[0] & 0x0000000000000FFF);
  }

  uint32_t amc13L1ID() {
    const uint64_t *data = amc13TrailerPtr();
    return ((data[0] & 0x00000000000FF000) >> 12);
  }

  uint32_t amc13BlockNo() {
    const uint64_t *data = amc13TrailerPtr();
    return ((data[0] & 0x000000000FF00000) >> 20);
  }

  uint32_t amc13CRC32() {
    const uint64_t *data = amc13TrailerPtr();
    return ((data[0] & 0xFFFFFFFF00000000) >> 32);
  }

  const uint64_t *cdfTrailerPtr() {
    uint32_t skip = 2;
    for(uint32_t i = 0; i < nAMCs(); i++) {
      skip += (1 + amcSize(i));
    }
    skip++;
    const uint64_t *data = &myDataPtr[skip];
    if((data[0] & 0xF000000000000000) != 0xA000000000000000) {
      LogError("UCTDAQRawData") << "CDF Trailer seems to be wrong : " 
        << std::showbase << std::internal 
        << std::setfill('0') << std::setw(10)
        << std::hex
        << data[1]
        << std::endl;
    }
    return data;
  }

  bool crcModified() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x0000000000000004) == 1);
  }

  bool isLastTrailerWord() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x0000000000000008) == 1);
  }

  uint32_t ttsBits() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x00000000000000F0) >> 4);
  }

  uint32_t eventStatus() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x0000000000000F00) >> 8);
  }

  bool isWrongFEDID() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x0000000000004000) == 1);
  }

  bool isSLinkErrorDetectedByFRL() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x0000000000008000) == 1);
  }

  uint32_t crc16() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x00000000FFFF0000) >> 16);
  }

  uint32_t eventLength() {
    const uint64_t *data = cdfTrailerPtr();
    return ((data[0] & 0x00FFFFFF00000000) >> 32);
  }

  void print() {
    using namespace std;
    LogDebug("UCTDAQRawData") << "Common cDAQ/AMC13 Data Header:" << endl;
    LogDebug("UCTDAQRawData") << "Framework Version = " << internal << setfill('0') << setw(3) << hex << FOV() << endl;
    LogDebug("UCTDAQRawData") << "sourceID......... = " << dec << sourceID() << endl;
    LogDebug("UCTDAQRawData") << "BXID............. = " << dec << BXID() << endl;
    LogDebug("UCTDAQRawData") << "L1ID............. = " << internal << setfill('0') << setw(8) << hex << L1ID() << endl;
    LogDebug("UCTDAQRawData") << "eventType........ = " << internal << setfill('0') << setw(3) << hex << eventType() << endl;
    LogDebug("UCTDAQRawData") << "orbitNo.......... = " << dec << orbitNumber() << endl;
    LogDebug("UCTDAQRawData") << "uFOV............. = " << internal << setfill('0') << setw(8) << hex << uFOV() << endl;
    LogDebug("UCTDAQRawData") << "# of CTP7s....... = " << dec << nAMCs() << endl;
    LogDebug("UCTDAQRawData") << "Phi SlotNo BlockNo     Size CRC? Valid? Present? Enabled? Segmented? More? LengthError?" << endl;
    for(uint32_t i = 0; i < nAMCs(); i++) {
      LogDebug("UCTDAQRawData") << dec << setfill(' ') << setw(3) << boardID(i) << " " 
       << dec << setfill(' ') << setw(6) << amcNo(i) << " " 
       << dec << setfill(' ') << setw(7) << amcBlkNo(i) << " "
       << dec << setfill(' ') << setw(8) << amcSize(i) << " " 
       << "   " << crcError(i) << " " 
       << "     " << isValid(i) << " "
       << "       " << isPresent(i) << " "
       << "       " << isEnabled(i) << " " 
       << "         " << isSegmented(i) << " "
       << "    " << more(i) << " " 
       << "           " << lengthError(i) << endl;
    }
    LogDebug("UCTDAQRawData") << "AMC13 Trailer:" << endl;
    LogDebug("UCTDAQRawData") << "AMC13 BXID....... = " << dec << amc13BXID() << endl;
    LogDebug("UCTDAQRawData") << "AMC13 L1ID....... = " << dec << amc13L1ID() << endl;
    LogDebug("UCTDAQRawData") << "AMC13 BlockNo.... = " << dec << amc13BlockNo() << endl;
    LogDebug("UCTDAQRawData") << "AMC13 CRC32...... = " << internal << setfill('0') << setw(10) << hex << amc13BXID() << endl;
    LogDebug("UCTDAQRawData") << "Common DAQ Trailer:" << endl;
    LogDebug("UCTDAQRawData") << "CRC Modified?.... = " << crcModified() << endl;
    LogDebug("UCTDAQRawData") << "Last Trailer Word?= " << isLastTrailerWord() << endl;
    LogDebug("UCTDAQRawData") << "ttsBits.......... = " << internal << setfill('0') << setw(3) << hex << ttsBits() << endl;
    LogDebug("UCTDAQRawData") << "Event Status..... = " << internal << setfill('0') << setw(3) << hex << eventStatus() << endl;
    LogDebug("UCTDAQRawData") << "Wrong FED ID?.... = " << isWrongFEDID() << endl;
    LogDebug("UCTDAQRawData") << "SLink Error?..... = " << isSLinkErrorDetectedByFRL() << endl;
    LogDebug("UCTDAQRawData") << "CRC 16........... = " << internal << setfill('0') << setw(6) << hex << crc16() << endl;
    LogDebug("UCTDAQRawData") << "Event Length..... = " << dec << eventLength() << endl;
  }
  
private:

  // No copy constructor and equality operator are needed
  
  UCTDAQRawData(const UCTDAQRawData&) = delete;
  const UCTDAQRawData& operator=(const UCTDAQRawData& i) = delete;
  
  // RawData data
  
  const uint64_t* myDataPtr;
  
};

#endif