AMCSpec.cc

Go to the documentation of this file.

#include <iomanip>
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/CRC32Calculator.h"
 
#include "EventFilter/L1TRawToDigi/interface/AMCSpec.h"
 
#define EDM_ML_DEBUG 1
 
namespace amc {
  BlockHeader::BlockHeader(unsigned int amc_no, unsigned int board_id, unsigned int size, unsigned int block) {
    // Determine size
    unsigned int max_block_no = 0;
    if (size >= 0x13ff)
      max_block_no = (size - 1023) / 4096;
 
    if (block != max_block_no)
      size = split_block_size;
    else if (block != 0)
      size -= split_block_size * max_block_no;
 
    data_ = (static_cast<uint64_t>(size & Size_mask) << Size_shift) |
            (static_cast<uint64_t>(block & BlkNo_mask) << BlkNo_shift) |
            (static_cast<uint64_t>(amc_no & AmcNo_mask) << AmcNo_shift) |
            (static_cast<uint64_t>(board_id & BoardID_mask) << BoardID_shift) | (1llu << Enabled_bit_shift) |
            (1llu << Present_bit_shift);
 
    if (block == getBlocks() - 1) {
      // Last block
      data_ |= (1llu << CRC_bit_shift) | (1llu << Valid_bit_shift) | (1llu << Length_bit_shift);
    }
 
    if (block == 0 && getBlocks() == 1) {
      // Bits already zeroed - only one block
    } else if (block == 0) {
      // First of many blocks
      data_ |= 1llu << More_bit_shift;
    } else if (block == getBlocks() - 1) {
      // Last of many blocks
      data_ |= 1llu << Segmented_bit_shift;
    } else {
      // Intermediate of many blocks
      data_ |= (1llu << More_bit_shift) | (1llu << Segmented_bit_shift);
    }
  }
 
  unsigned int BlockHeader::getBlocks() const {
    // The first block of a segmented event has a size of 1023, all
    // following have a max size of 4096.  Segmentation only happens
    // for AMC payloads >= 0x13ff 64 bit words.
    unsigned int size = getSize();
    if (size >= 0x13ff)
      return (size - 1023) / 4096 + 1;
    return 1;
  }
 
  unsigned int BlockHeader::getBlockSize() const {
    // More and not Segmented means the first of multiple blocks.  For
    // these, getSize() returns the total size of the AMC packet, not the
    // size of the first block.
    if (getMore() && !getSegmented())
      return split_block_size;
    return getSize();
  }
 
  Header::Header(unsigned int amc_no,
                 unsigned int lv1_id,
                 unsigned int bx_id,
                 unsigned int size,
                 unsigned int or_n,
                 unsigned int board_id,
                 unsigned int user)
      : data0_((uint64_t(amc_no & AmcNo_mask) << AmcNo_shift) | (uint64_t(lv1_id & LV1ID_mask) << LV1ID_shift) |
               (uint64_t(bx_id & BX_mask) << BX_shift) | (uint64_t(size & Size_mask) << Size_shift)),
        data1_((uint64_t(or_n & OrN_mask) << OrN_shift) | (uint64_t(board_id & BoardID_mask) << BoardID_shift) |
               (uint64_t(user & User_mask) << User_shift)) {}
 
  Trailer::Trailer(unsigned int crc, unsigned int lv1_id, unsigned int size)
      : data_((uint64_t(crc & CRC_mask) << CRC_shift) | (uint64_t(lv1_id & LV1ID_mask) << LV1ID_shift) |
              (uint64_t(size & Size_mask) << Size_shift)) {}
 
  bool Trailer::check(unsigned int crc, unsigned int lv1_id, unsigned int size, bool mtf7_mode) const {
    if ((crc != getCRC() || size != getSize() || (lv1_id & LV1ID_mask) != getLV1ID()) && !mtf7_mode) {
      edm::LogWarning("L1T") << "Found AMC trailer with:"
                             << "\n\tLV1 ID " << getLV1ID() << ", size " << getSize() << ", CRC " << std::hex
                             << std::setw(8) << std::setfill('0') << getCRC() << std::dec << "\nBut expected:"
                             << "\n\tLV1 ID " << (lv1_id & LV1ID_mask) << ", size " << size << ", CRC " << std::hex
                             << std::setw(8) << std::setfill('0') << crc;
      return false;
    }
    return true;
  }
 
  void Trailer::writeCRC(const uint64_t *start, uint64_t *end) {
    std::string dstring(reinterpret_cast<const char *>(start), reinterpret_cast<const char *>(end) + 4);
    auto crc = cms::CRC32Calculator(dstring).checksum();
 
    *end = ((*end) & ~(uint64_t(CRC_mask) << CRC_shift)) | (static_cast<uint64_t>(crc & CRC_mask) << CRC_shift);
  }
 
  Packet::Packet(unsigned int amc,
                 unsigned int board,
                 unsigned int lv1id,
                 unsigned int orbit,
                 unsigned int bx,
                 const std::vector<uint64_t> &load,
                 unsigned int user)
      : block_header_(amc, board, load.size() + 3),  // add 3 words for header (2) and trailer (1)
        header_(amc, lv1id, bx, load.size() + 3, orbit, board, user),
        trailer_(0, lv1id, load.size() + 3) {
    auto hdata = header_.raw();
    payload_.reserve(load.size() + 3);
    payload_.insert(payload_.end(), hdata.begin(), hdata.end());
    payload_.insert(payload_.end(), load.begin(), load.end());
    payload_.insert(payload_.end(), trailer_.raw());
 
    auto ptr = payload_.data();
    Trailer::writeCRC(ptr, ptr + payload_.size() - 1);
  }
 
  void Packet::addPayload(const uint64_t *data, unsigned int size) {
    payload_.insert(payload_.end(), data, data + size);
  }
 
  void Packet::finalize(unsigned int lv1, unsigned int bx, bool legacy_mc, bool mtf7_mode) {
    if (legacy_mc) {
      header_ =
          Header(block_header_.getAMCNumber(), lv1, bx, block_header_.getSize(), 0, block_header_.getBoardID(), 0);
 
      payload_.insert(payload_.begin(), {0, 0});
      payload_.insert(payload_.end(), {0});
    } else {
      header_ = Header(payload_.data());
      trailer_ = Trailer(&payload_.back());
 
      std::string check(reinterpret_cast<const char *>(payload_.data()), payload_.size() * 8 - 4);
      auto crc = cms::CRC32Calculator(check).checksum();
 
      trailer_.check(crc, lv1, header_.getSize(), mtf7_mode);
    }
  }
 
  std::vector<uint64_t> Packet::block(unsigned int id) const {
    if (id == 0 and id == block_header_.getBlocks() - 1) {
      return payload_;
    } else if (id == block_header_.getBlocks() - 1) {
      return std::vector<uint64_t>(payload_.begin() + id * split_block_size, payload_.end());
    } else {
      return std::vector<uint64_t>(payload_.begin() + id * split_block_size,
                                   payload_.begin() + (id + 1) * split_block_size);
    }
  }
 
  std::unique_ptr<uint64_t[]> Packet::data() {
    // Remove 3 words: 2 for the header, 1 for the trailer
    std::unique_ptr<uint64_t[]> res(new uint64_t[payload_.size() - 3]);
    for (unsigned int i = 0; i < payload_.size() - 3; ++i)
      res.get()[i] = payload_[i + 2];
    return res;
  }
}  // namespace amc