amc13::Packet Class Reference

#include <AMC13Spec.h>

Public Member Functions
void	add (unsigned int amc_no, unsigned int board, unsigned int lv1id, unsigned int orbit, unsigned int bx, const std::vector< uint64_t > &load)
unsigned int	blocks () const
	Packet ()
bool	parse (const uint64_t *start, const uint64_t *data, unsigned int size, unsigned int lv1, unsigned int bx, bool legacy_mc=false, bool mtf7_mode=false)
std::vector< amc::Packet >	payload () const
unsigned int	size () const
bool	write (const edm::Event &ev, unsigned char *ptr, unsigned int skip, unsigned int size) const

Private Attributes
Header	header_
std::vector< amc::Packet >	payload_

Detailed Description

Definition at line 69 of file AMC13Spec.h.

Constructor & Destructor Documentation

amc13::Packet::Packet ( )

inline

Definition at line 71 of file AMC13Spec.h.

{};

Member Function Documentation

void Packet::add	(	unsigned int	amc_no,
		unsigned int	board,
		unsigned int	lv1id,
		unsigned int	orbit,
		unsigned int	bx,
		const std::vector< uint64_t > &	load
	)

Definition at line 61 of file AMC13Spec.cc.

References payload_.

Referenced by l1t::AMCDumpToRaw::formatAMC(), l1t::MP7BufferDumpToRaw::formatAMC(), and counter.Counter::register().

   {
      edm::LogInfo("AMC") << "Adding board " << board << " with payload size " << load.size()
         << " as payload #" << amc_no;
      // Start by indexing with 1
      payload_.push_back(amc::Packet(amc_no, board, lv1id, orbit, bx, load));
   }

unsigned int Packet::blocks

(

)

const

Definition at line 189 of file AMC13Spec.cc.

References amc, bookConverter::max, and payload_.

Referenced by size(), and write().

   {
      unsigned int maxblocks = 0;

      for (const auto& amc: payload_)
         maxblocks = std::max(maxblocks, amc.blocks());

      return maxblocks;
   }

bool Packet::parse	(	const uint64_t *	start,
		const uint64_t *	data,
		unsigned int	size,
		unsigned int	lv1,
		unsigned int	bx,
		bool	legacy_mc = false,
		bool	mtf7_mode = false
	)

Definition at line 70 of file AMC13Spec.cc.

References amc, b, trackerTree::check(), amc13::Header::check(), amc13::Trailer::check(), cms::CRC32Calculator::checksum(), TauDecayModes::dec, amc13::Header::getFormatVersion(), amc13::Header::getNumberOfAMCs(), header_, getRunAppsInfo::headers, i, LogDebug, bookConverter::max, payload_, AlCaHLTBitMon_QueryRunRegistry::string, and lumiQTWidget::t.

Referenced by l1t::L1TRawToDigi::produce().

   {
      // Need at least a header and trailer
      // TODO check if this can be removed
      if (size < 2) {
         edm::LogError("AMC") << "AMC13 packet size too small";
         return false;
      }

      std::map<int, int> amc_index;

      header_ = Header(data++);

      if (!header_.check()) {
         edm::LogError("AMC")
            << "Invalid header for AMC13 packet: "
            << "format version " << header_.getFormatVersion()
            << ", " << header_.getNumberOfAMCs()
            << " AMC packets";
         return false;
      }

      if (size < 2 + header_.getNumberOfAMCs())
         return false;

      // Initial filling of AMC payloads.  First, get the headers.  The
      // first payload follows afterwards.
      for (unsigned int i = 0; i < header_.getNumberOfAMCs(); ++i) {
         payload_.push_back(amc::Packet(data++));
         amc_index[payload_.back().blockHeader().getAMCNumber()] = i;
      }

      unsigned int tot_size = 0; // total payload size
      unsigned int tot_nblocks = 0; // total blocks of payload
      unsigned int maxblocks = 0; // counting the # of amc13 header/trailers (1 ea per block)

      bool check_crc = false;
      for (const auto& amc: payload_) {
         tot_size += amc.blockHeader().getSize();
         tot_nblocks += amc.blockHeader().getBlocks();
         maxblocks = std::max(maxblocks, amc.blockHeader().getBlocks());

         if (amc.blockHeader().validCRC())
            check_crc = true;
      }

      unsigned int words = tot_size + // payload size
                           tot_nblocks + // AMC headers
                           2 * maxblocks; // AMC13 headers

      if (size < words) {
         edm::LogError("L1T")
            << "Encountered AMC 13 packet with "
            << size << " words, "
            << "but expected "
            << words << " words: "
            << tot_size << " payload words, "
            << tot_nblocks << " AMC header words, and 2 AMC 13 header words.";
         return false;
      }

      // Read in the first AMC block and append the payload to the
      // corresponding AMC packet.
      for (auto& amc: payload_) {
         amc.addPayload(data, amc.blockHeader().getBlockSize());
         data += amc.blockHeader().getBlockSize();
      }

      Trailer t(data++);

      int crc = 0;
      if (check_crc) {
         std::string check(reinterpret_cast<const char*>(start), reinterpret_cast<const char*>(data) - 4);
         crc = cms::CRC32Calculator(check).checksum();

         LogDebug("L1T") << "checking data checksum of " << std::hex << crc << std::dec;
      }

      t.check(crc, 0, lv1, bx);

      // Read in remaining AMC blocks
      for (unsigned int b = 1; b < maxblocks; ++b) {
         Header block_h(data++);
         std::vector<amc::BlockHeader> headers;

         for (unsigned int i = 0; i < block_h.getNumberOfAMCs(); ++i)
            headers.push_back(amc::BlockHeader(data++));

         check_crc = false;
         for (const auto& amc: headers) {
            payload_[amc_index[amc.getAMCNumber()]].addPayload(data, amc.getBlockSize());
            data += amc.getBlockSize();

            if (amc.validCRC())
               check_crc = true;
         }

         t = Trailer(data++);

         if (check_crc) {
            std::string check(reinterpret_cast<const char*>(start), reinterpret_cast<const char*>(data) - 4);
            crc = cms::CRC32Calculator(check).checksum();

            LogDebug("L1T") << "checking data checksum of " << std::hex << crc << std::dec;
         } else {
            crc = 0;
         }

         t.check(crc, b, lv1, bx);
      }

      for (auto& amc: payload_) {
    amc.finalize(lv1, bx, legacy_mc, mtf7_mode);
      }

      return true;
   }

std::vector<amc::Packet> amc13::Packet::payload ( ) const

inline

Definition at line 80 of file AMC13Spec.h.

References payload_.

Referenced by l1t::L1TRawToDigi::produce().

{ return payload_; };

unsigned int Packet::size

(

void

)

const

Definition at line 200 of file AMC13Spec.cc.

References amc, blocks(), bookConverter::max, and payload_.

Referenced by l1t::AMCDumpToRaw::formatRaw(), l1t::MP7BufferDumpToRaw::formatRaw(), and write().

   {
      unsigned int words = 0;
      unsigned int blocks = 0;
      unsigned int maxblocks = 0;

      for (const auto& amc: payload_) {
         words += amc.header().getSize();
         blocks += amc.blocks();
         maxblocks = std::max(maxblocks, amc.blocks());
      }

      // Size is total amount of words + # of blocks for AMC headers + # of
      // maxblocks for AMC13 block header, trailer
      return words + blocks + maxblocks * 2;
   }

bool Packet::write	(	const edm::Event &	ev,
		unsigned char *	ptr,
		unsigned int	skip,
		unsigned int	size
	)		const

Definition at line 218 of file AMC13Spec.cc.

References amc, b, blocks(), edm::EventBase::bunchCrossing(), data, edm::EventID::event(), h, edm::EventBase::id(), edm::EventBase::orbitNumber(), payload_, size(), createPayload::skip, and amc13::Trailer::writeCRC().

Referenced by l1t::AMCDumpToRaw::formatRaw(), l1t::MP7BufferDumpToRaw::formatRaw(), and pkg.AbstractPkg::generate().

   {
      if (size < this->size() * 8)
         return false;

      if (size % 8 != 0)
         return false;

      uint64_t * data = reinterpret_cast<uint64_t*>(ptr + skip);

      for (unsigned int b = 0; b < blocks(); ++b) {
         // uint64_t * block_start = data;

         std::vector<uint64_t> block_headers;
         std::vector<uint64_t> block_load;
         for (const auto& amc: payload_) {
            edm::LogInfo("AMC")
               << "Considering block " << b
               << " for payload " << amc.blockHeader().getBoardID()
               << " with size " << amc.size()
               << " and " << amc.blocks() << " blocks";
            if (amc.blocks() < b + 1)
               continue;

            block_headers.push_back(amc.blockHeader(b));
            auto words = amc.block(b);
            block_load.insert(block_load.end(), words.begin(), words.end());
         }

         if (b == 0) {
            amc13::Header h(block_headers.size(), ev.orbitNumber());
            edm::LogInfo("AMC")
               << "Writing header for AMC13 packet: "
               << "format version " << h.getFormatVersion()
               << ", " << h.getNumberOfAMCs()
               << " AMC packets, orbit " << h.getOrbitNumber();
         }

         *(data++) = amc13::Header(block_headers.size(), ev.orbitNumber()).raw();

         block_headers.insert(block_headers.end(), block_load.begin(), block_load.end());
         for (const auto& word: block_headers)
            *(data++) = word;

         *data = Trailer(b, ev.id().event(), ev.bunchCrossing()).raw();
         Trailer::writeCRC(reinterpret_cast<uint64_t*>(ptr), data);
      }

      return true;
   }

Member Data Documentation

Header amc13::Packet::header_

private

Definition at line 80 of file AMC13Spec.h.

Referenced by parse().

std::vector<amc::Packet> amc13::Packet::payload_

private

Definition at line 84 of file AMC13Spec.h.

Referenced by add(), blocks(), parse(), payload(), size(), and write().