L1TMP7ZeroSupp Class Reference

#include <L1TMP7ZeroSupp.h>

Inheritance diagram for L1TMP7ZeroSupp:

Public Member Functions
	L1TMP7ZeroSupp (const edm::ParameterSet &ps)
	~L1TMP7ZeroSupp () override
Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default
	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete
	~DQMEDAnalyzer () override=default

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
void	bookHistograms (DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override
void	dqmBeginRun (const edm::Run &r, const edm::EventSetup &c) override

Private Types
enum	binlabels {   EVTS =0, EVTSGOOD, EVTSBAD, BLOCKS,   ZSBLKSGOOD, ZSBLKSBAD, ZSBLKSBADFALSEPOS, ZSBLKSBADFALSENEG,   BXBLOCKS, ZSBXBLKSGOOD, ZSBXBLKSBAD, ZSBXBLKSBADFALSEPOS,   ZSBXBLKSBADFALSENEG, NBINLABELS }
enum	ratioBinlabels {   REVTS =0, RBLKS, RBLKSFALSEPOS, RBLKSFALSENEG,   RBXBLKS, RBXBLKSFALSEPOS, RBXBLKSFALSENEG, RNBINLABELS }

Private Member Functions
void	bookCapIdHistograms (DQMStore::IBooker &ibooker, const unsigned int &id)

Private Attributes
int	amc13HeaderSize_
int	amc13TrailerSize_
int	amcHeaderSize_
int	amcTrailerSize_
MonitorElement *	capIds_
bool	checkOnlyCapIdsWithMasks_
int	dataInvFlagMask_
std::vector< unsigned int >	definedMaskCapIds_
std::map< unsigned int, MonitorElement * >	errorSummaryDenMap_
std::map< unsigned int, MonitorElement * >	errorSummaryNumMap_
edm::EDGetTokenT< FEDRawDataCollection >	fedDataToken_
std::vector< int >	fedIds_
std::vector< std::vector< int > >	masks_
int	maxFedReadoutSize_
std::string	monitorDir_
int	newZsFlagMask_
std::map< unsigned int, MonitorElement * >	readoutSizeNoZSMap_
std::map< unsigned int, MonitorElement * >	readoutSizeZSExpectedMap_
std::map< unsigned int, MonitorElement * >	readoutSizeZSMap_
int	slinkHeaderSize_
int	slinkTrailerSize_
bool	verbose_
std::map< unsigned int, MonitorElement * >	zeroSuppValMap_
bool	zsEnabled_
int	zsFlagMask_

Static Private Attributes
static const unsigned int	maxMasks_ = 16

Detailed Description

Definition at line 22 of file L1TMP7ZeroSupp.h.

Member Enumeration Documentation

enum L1TMP7ZeroSupp::binlabels

private

Enumerator
EVTS
EVTSGOOD
EVTSBAD
BLOCKS
ZSBLKSGOOD
ZSBLKSBAD
ZSBLKSBADFALSEPOS
ZSBLKSBADFALSENEG
BXBLOCKS
ZSBXBLKSGOOD
ZSBXBLKSBAD
ZSBXBLKSBADFALSEPOS
ZSBXBLKSBADFALSENEG
NBINLABELS

Definition at line 41 of file L1TMP7ZeroSupp.h.

{EVTS=0, EVTSGOOD, EVTSBAD, BLOCKS, ZSBLKSGOOD, ZSBLKSBAD, ZSBLKSBADFALSEPOS, ZSBLKSBADFALSENEG, BXBLOCKS, ZSBXBLKSGOOD, ZSBXBLKSBAD, ZSBXBLKSBADFALSEPOS, ZSBXBLKSBADFALSENEG, NBINLABELS};

enum L1TMP7ZeroSupp::ratioBinlabels

private

Enumerator
REVTS
RBLKS
RBLKSFALSEPOS
RBLKSFALSENEG
RBXBLKS
RBXBLKSFALSEPOS
RBXBLKSFALSENEG
RNBINLABELS

Definition at line 42 of file L1TMP7ZeroSupp.h.

{REVTS=0, RBLKS, RBLKSFALSEPOS, RBLKSFALSENEG, RBXBLKS, RBXBLKSFALSEPOS, RBXBLKSFALSENEG, RNBINLABELS};

Constructor & Destructor Documentation

L1TMP7ZeroSupp::L1TMP7ZeroSupp

(

const edm::ParameterSet &

ps

)

Definition at line 5 of file L1TMP7ZeroSupp.cc.

References gather_cfg::cout, TauDecayModes::dec, definedMaskCapIds_, edm::ParameterSet::exists(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, masks_, maxMasks_, AlCaHLTBitMon_QueryRunRegistry::string, verbose_, and ~L1TMP7ZeroSupp().

    : fedDataToken_(consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("rawData"))),
      zsEnabled_(ps.getUntrackedParameter<bool>("zsEnabled")),
      fedIds_(ps.getParameter<std::vector<int>>("fedIds")),
      slinkHeaderSize_(ps.getUntrackedParameter<int>("lenSlinkHeader")),
      slinkTrailerSize_(ps.getUntrackedParameter<int>("lenSlinkTrailer")),
      amc13HeaderSize_(ps.getUntrackedParameter<int>("lenAMC13Header")),
      amc13TrailerSize_(ps.getUntrackedParameter<int>("lenAMC13Trailer")),
      amcHeaderSize_(ps.getUntrackedParameter<int>("lenAMCHeader")),
      amcTrailerSize_(ps.getUntrackedParameter<int>("lenAMCTrailer")),
      newZsFlagMask_(ps.getUntrackedParameter<int>("newZsFlagMask")),
      zsFlagMask_(ps.getUntrackedParameter<int>("zsFlagMask")),
      dataInvFlagMask_(ps.getUntrackedParameter<int>("dataInvFlagMask")),
      maxFedReadoutSize_(ps.getUntrackedParameter<int>("maxFEDReadoutSize")),
      checkOnlyCapIdsWithMasks_(ps.getUntrackedParameter<bool>("checkOnlyCapIdsWithMasks")),
      monitorDir_(ps.getUntrackedParameter<std::string>("monitorDir")),
      verbose_(ps.getUntrackedParameter<bool>("verbose"))
{
  std::vector<int> onesMask(6, 0xffffffff);
  masks_.reserve(maxMasks_);
  for (unsigned int i = 0; i < maxMasks_; ++i) {
    std::string maskCapIdStr{"maskCapId"+std::to_string(i)};
    masks_.push_back(ps.getUntrackedParameter<std::vector<int>>(maskCapIdStr, onesMask));
    // which masks are defined?
    if (ps.exists(maskCapIdStr)) {
      definedMaskCapIds_.push_back(i);
    }
  }
  if (verbose_) {
    // check masks
    std::cout << "masks" << std::endl;
    for (unsigned int i = 0; i < maxMasks_; ++i) {
      std::cout << "caption ID" << i << ":" << std::endl;
      for (const auto& maskIt: masks_.at(i)) {
        std::cout << std::hex << std::setw(8) << std::setfill('0') << maskIt << std::dec << std::endl;
      }
    }
    std::cout << "----------" << std::endl;
  }
}

L1TMP7ZeroSupp::~L1TMP7ZeroSupp ( )

overridedefault

Referenced by L1TMP7ZeroSupp().

Member Function Documentation

void L1TMP7ZeroSupp::analyze ( const edm::Event &  e, const edm::EventSetup &  c  )

overrideprotected

Definition at line 145 of file L1TMP7ZeroSupp.cc.

References amc13HeaderSize_, amc13TrailerSize_, amcHeaderSize_, amcTrailerSize_, groupFilesInBlocks::block, BLOCKS, BXBLOCKS, FEDHeader::bxID(), capIds_, FEDHeader::check(), FEDTrailer::check(), checkOnlyCapIdsWithMasks_, gather_cfg::cout, FEDTrailer::crc(), FEDRawData::data(), data, dataInvFlagMask_, TauDecayModes::dec, definedMaskCapIds_, end, errorSummaryDenMap_, errorSummaryNumMap_, EVTS, EVTSBAD, EVTSGOOD, FEDTrailer::evtStatus(), FEDRawDataCollection::FEDData(), fedDataToken_, l1t::stage2::layer2::fedId, fedIds_, MonitorElement::Fill(), FEDTrailer::fragmentLength(), edm::Event::getByToken(), RecoTauValidation_cfi::header, triggerObjects_cff::id, edm::HandleBase::isValid(), FEDHeader::lvl1ID(), masks_, maxMasks_, newZsFlagMask_, amc13::Packet::parse(), jets_cff::payload, amc13::Packet::payload(), RBLKS, RBLKSFALSENEG, RBLKSFALSEPOS, RBXBLKS, RBXBLKSFALSENEG, RBXBLKSFALSEPOS, readoutSizeNoZSMap_, readoutSizeZSExpectedMap_, readoutSizeZSMap_, REVTS, FEDRawData::size(), slinkHeaderSize_, slinkTrailerSize_, FEDHeader::sourceID(), command_line::start, FEDHeader::triggerType(), FEDTrailer::ttsBits(), verbose_, FEDHeader::version(), zeroSuppValMap_, ZSBLKSBAD, ZSBLKSBADFALSENEG, ZSBLKSBADFALSEPOS, ZSBLKSGOOD, ZSBXBLKSBAD, ZSBXBLKSBADFALSENEG, ZSBXBLKSBADFALSEPOS, ZSBXBLKSGOOD, zsEnabled_, and zsFlagMask_.

                                                                      {

  if (verbose_) edm::LogInfo("L1TDQM") << "L1TMP7ZeroSupp: analyze..." << std::endl;

  edm::Handle<FEDRawDataCollection> feds;
  e.getByToken(fedDataToken_, feds);

  if (!feds.isValid()) {
    edm::LogError("L1TDQM") << "Cannot analyse: no FEDRawDataCollection found";
    return;
  }

  zeroSuppValMap_[maxMasks_]->Fill(EVTS);
  errorSummaryDenMap_[maxMasks_]->Fill(REVTS);
  for (const auto &id: definedMaskCapIds_) {
    zeroSuppValMap_[id]->Fill(EVTS);
    errorSummaryDenMap_[id]->Fill(REVTS);
  }

  std::map<unsigned int, bool> evtGood;
  evtGood[maxMasks_] = true;
  for (const auto &id: definedMaskCapIds_) {
    evtGood[id] = true;
  }
  unsigned valid_count = 0;
  for (const auto& fedId: fedIds_) {
    const FEDRawData& l1tRcd = feds->FEDData(fedId);

    unsigned int fedDataSize = l1tRcd.size();
    std::map<unsigned int, unsigned int> readoutSizeNoZSMap;
    std::map<unsigned int, unsigned int> readoutSizeZSMap;
    std::map<unsigned int, unsigned int> readoutSizeZSExpectedMap;
    readoutSizeNoZSMap[maxMasks_] = 0;
    readoutSizeZSMap[maxMasks_] = 0;
    readoutSizeZSExpectedMap[maxMasks_] = 0;
    for (const auto &id: definedMaskCapIds_) {
      readoutSizeNoZSMap[id] = 0;
      readoutSizeZSMap[id] = 0;
      readoutSizeZSExpectedMap[id] = 0;
    }

    edm::LogInfo("L1TDQM") << "Found FEDRawDataCollection with ID " << fedId << " and size " << l1tRcd.size();

    if ((int) l1tRcd.size() < slinkHeaderSize_ + slinkTrailerSize_ + amc13HeaderSize_ + amc13TrailerSize_ + amcHeaderSize_ + amcTrailerSize_) {
      if (l1tRcd.size() > 0) {
        edm::LogError("L1TDQM") << "Cannot analyse: invalid L1T raw data (size = " << l1tRcd.size() << ") for ID " << fedId << ".";
      }
      continue;
    } else {
      valid_count++;
    }

    const unsigned char *data = l1tRcd.data();
    FEDHeader header(data);

    if (header.check()) {
      edm::LogInfo("L1TDQM") << "Found SLink header:" << " Trigger type " << header.triggerType() << " L1 event ID " << header.lvl1ID() << " BX Number " << header.bxID() << " FED source " << header.sourceID() << " FED version " << header.version();
    } else {
      edm::LogWarning("L1TDQM") << "Did not find a SLink header!";
    }

    FEDTrailer trailer(data + (l1tRcd.size() - slinkTrailerSize_));

    if (trailer.check()) {
      edm::LogInfo("L1TDQM") << "Found SLink trailer:" << " Length " << trailer.fragmentLength() << " CRC " << trailer.crc() << " Status " << trailer.evtStatus() << " Throttling bits " << trailer.ttsBits();
    } else {
      edm::LogWarning("L1TDQM") << "Did not find a SLink trailer!";
    }

    amc13::Packet packet;
    if (!packet.parse(
             (const uint64_t*) data,
             (const uint64_t*) (data + slinkHeaderSize_),
             (l1tRcd.size() - slinkHeaderSize_ - slinkTrailerSize_) / 8,
             header.lvl1ID(),
             header.bxID())) {
       edm::LogError("L1TDQM") << "Could not extract AMC13 Packet.";
       return;
    }

    for (auto& amc: packet.payload()) {
      if (amc.size() == 0)
        continue;

      auto payload64 = amc.data();
      auto start = (const uint32_t*) payload64.get();
      // Want to have payload size in 32 bit words, but AMC measures
      // it in 64 bit words -> factor 2.
      const uint32_t * end = start + (amc.size() * 2);

      auto payload = std::make_unique<l1t::MP7Payload>(start, end, false);

      // getBlock() returns a non-null unique_ptr on success
      std::unique_ptr<l1t::Block> block;
      while ((block = payload->getBlock()) != nullptr) {
        if (verbose_) {
          std::cout << ">>> check zero suppression for block <<<" << std::endl
                    << "hdr:  " << std::hex << std::setw(8) << std::setfill('0') << block->header().raw() << std::dec
                    << " (ID " << block->header().getID() << ", size " << block->header().getSize()
                    << ", CapID 0x" << std::hex << std::setw(2) << std::setfill('0') << block->header().getCapID()
                    << ", flags 0x" << std::hex << std::setw(2) << std::setfill('0') << block->header().getFlags()
                    << ")" << std::dec << std::endl;
          for (const auto& word: block->payload()) {
            std::cout << "data: " << std::hex << std::setw(8) << std::setfill('0') << word << std::dec << std::endl;
          }
        }

        unsigned int blockCapId = block->header().getCapID();
        unsigned int blockSize = block->header().getSize() * 4; // times 4 to get the size in byte
        unsigned int blockHeaderSize = sizeof(block->header().raw());
        unsigned int blockHeaderFlags = block->header().getFlags();
        bool newZsFlagSet = ((blockHeaderFlags & newZsFlagMask_) != 0); // use the per-BX ZS
        bool blockZsFlagSet = newZsFlagSet ? true : ((blockHeaderFlags & zsFlagMask_) != 0); // ZS validation flag for whole block
        bool dataInvertFlagSet = newZsFlagSet && ((blockHeaderFlags & dataInvFlagMask_) != 0); // invert the data before applying the mask

        capIds_->Fill(blockCapId);

        bool capIdDefined = false;
        if (zeroSuppValMap_.find(blockCapId) != zeroSuppValMap_.end()) {
          capIdDefined = true;
        }

        // Only check blocks with a CapId that has a defined ZS mask.
        if (checkOnlyCapIdsWithMasks_ and not capIdDefined) {
          continue;
        }

        // fill the denominator histograms
        zeroSuppValMap_[maxMasks_]->Fill(BLOCKS);
        errorSummaryDenMap_[maxMasks_]->Fill(RBLKS);
        errorSummaryDenMap_[maxMasks_]->Fill(RBLKSFALSEPOS);
        errorSummaryDenMap_[maxMasks_]->Fill(RBLKSFALSENEG);
        if (capIdDefined) {
          zeroSuppValMap_[blockCapId]->Fill(BLOCKS);
          errorSummaryDenMap_[blockCapId]->Fill(RBLKS);
          errorSummaryDenMap_[blockCapId]->Fill(RBLKSFALSEPOS);
          errorSummaryDenMap_[blockCapId]->Fill(RBLKSFALSENEG);
        }

        auto totalBlockSize = blockHeaderSize;
        if (!newZsFlagSet) {
          totalBlockSize += blockSize;
        }
        auto totalBlockSizeExpected = totalBlockSize;
        auto totalBlockSizeNoZS = blockHeaderSize + blockSize;

        auto bxBlocks = block->getBxBlocks(6, newZsFlagSet); // 6 32 bit MP7 payload words per BX

        // check all BX blocks
        bool allToSuppress = true;
        for (const auto& bxBlock: bxBlocks) {
          bool toSuppress = false;
          bool bxZsFlagSet = ((bxBlock.header().getFlags() & zsFlagMask_) != 0); // ZS validation flag

          // check if this bxblock should be suppressed
          unsigned int wordcounter = 0;
          unsigned int wordsum = 0;
          for (const auto& word: bxBlock.payload()) {
            if (dataInvertFlagSet) {
              wordsum += masks_[blockCapId].at(wordcounter%6) & (~word);
            } else {
              wordsum += masks_[blockCapId].at(wordcounter%6) & word;
            }
            if (verbose_) {
              std::cout << "word: " << std::hex << std::setw(8) << std::setfill('0') << word << std::dec
                        << ", maskword" << wordcounter%6 << ": " << std::hex << std::setw(8) << std::setfill('0')
                        << masks_[blockCapId].at(wordcounter%6) << std::dec << ", wordsum: " << wordsum << std::endl;
            }
            if (wordsum > 0) {
              if (verbose_) {
                std::cout << "wordsum not 0: this BX block should be kept" << std::endl;
              }
              break;
            }
            ++wordcounter;
          }
          // the sum of payload words must be 0 for correct ZS
          if (wordsum == 0 && zsEnabled_) {
            toSuppress = true;
            if (verbose_) {
              std::cout << "wordsum == 0: this BX block should be zero suppressed" << std::endl;
            }
          }
          // update the overall block status
          allToSuppress = allToSuppress && toSuppress;

          // only fill the BX related things for the per-BX ZS
          if (newZsFlagSet) {
            // the ZS flag of the block is the AND of all BX block ZS flags
            blockZsFlagSet = blockZsFlagSet && bxZsFlagSet;

            // fill the BX related bins of the denominator histogram
            zeroSuppValMap_[maxMasks_]->Fill(BXBLOCKS);
            errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKS);
            errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKSFALSEPOS);
            errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKSFALSENEG);
            if (capIdDefined) {
              zeroSuppValMap_[blockCapId]->Fill(BXBLOCKS);
              errorSummaryDenMap_[blockCapId]->Fill(RBXBLKS);
              errorSummaryDenMap_[blockCapId]->Fill(RBXBLKSFALSEPOS);
              errorSummaryDenMap_[blockCapId]->Fill(RBXBLKSFALSENEG);
            }

            unsigned int totalBxBlockSize = bxBlock.getSize() * 4 + sizeof(bxBlock.header().raw());  // times 4 to get the size in byte
            // check if zero suppression flag agrees for the BX block
            if (toSuppress && bxZsFlagSet) {
              if (verbose_) std::cout << "GOOD BX block with ZS flag true" << std::endl;
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSGOOD);
              if (capIdDefined) {
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSGOOD);
              }
            } else if (!toSuppress && !bxZsFlagSet) {
              if (verbose_) std::cout << "GOOD BX block with ZS flag false" << std::endl;
              totalBlockSize += totalBxBlockSize;
              totalBlockSizeExpected += totalBxBlockSize;
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSGOOD);
              if (capIdDefined) {
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSGOOD);
              }
            } else if (!toSuppress && bxZsFlagSet) {
              if (verbose_) std::cout << "BAD BX block with ZS flag true" << std::endl;
              totalBlockSizeExpected += totalBxBlockSize;
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBAD);
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBADFALSEPOS);
              errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKS);
              errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKSFALSEPOS);
              evtGood[maxMasks_] = false;
              if (capIdDefined) {
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBAD);
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBADFALSEPOS);
                errorSummaryNumMap_[blockCapId]->Fill(RBXBLKS);
                errorSummaryNumMap_[blockCapId]->Fill(RBXBLKSFALSEPOS);
                evtGood[blockCapId] = false;
              }
            } else {
              if (verbose_) std::cout << "BAD BX block with ZS flag false" << std::endl;
              totalBlockSize += totalBxBlockSize;
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBAD);
              zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBADFALSENEG);
              errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKS);
              errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKSFALSENEG);
              evtGood[maxMasks_] = false;
              if (capIdDefined) {
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBAD);
                zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBADFALSENEG);
                errorSummaryNumMap_[blockCapId]->Fill(RBXBLKS);
                errorSummaryNumMap_[blockCapId]->Fill(RBXBLKSFALSENEG);
                evtGood[blockCapId] = false;
              }
            }
          }
        }

        readoutSizeNoZSMap[maxMasks_] += totalBlockSizeNoZS;
        if (capIdDefined) {
          readoutSizeNoZSMap[blockCapId] += totalBlockSizeNoZS;
        }

        // check if zero suppression flag agrees for the whole block
        if (allToSuppress && blockZsFlagSet) {
          if (verbose_) std::cout << "GOOD block with ZS flag true" << std::endl;
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSGOOD);
          if (capIdDefined) {
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSGOOD);
          }
        } else if (!allToSuppress && !blockZsFlagSet) {
          if (verbose_) std::cout << "GOOD block with ZS flag false" << std::endl;
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSGOOD);
          readoutSizeZSMap[maxMasks_] += totalBlockSize;
          readoutSizeZSExpectedMap[maxMasks_] += totalBlockSizeExpected;
          if (capIdDefined) {
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSGOOD);
            readoutSizeZSMap[blockCapId] += totalBlockSize;
            readoutSizeZSExpectedMap[blockCapId] += totalBlockSizeExpected;
          }
        } else if (!allToSuppress && blockZsFlagSet) {
          if (verbose_) std::cout << "BAD block with ZS flag true" << std::endl;
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBAD);
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBADFALSEPOS);
          errorSummaryNumMap_[maxMasks_]->Fill(RBLKS);
          errorSummaryNumMap_[maxMasks_]->Fill(RBLKSFALSEPOS);
          readoutSizeZSExpectedMap[maxMasks_] += totalBlockSizeExpected;
          evtGood[maxMasks_] = false;
          if (capIdDefined) {
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBAD);
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBADFALSEPOS);
            errorSummaryNumMap_[blockCapId]->Fill(RBLKS);
            errorSummaryNumMap_[blockCapId]->Fill(RBLKSFALSEPOS);
            readoutSizeZSExpectedMap[blockCapId] += totalBlockSizeExpected;
            evtGood[blockCapId] = false;
          }
        } else {
          if (verbose_) std::cout << "BAD block with ZS flag false" << std::endl;
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBAD);
          zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBADFALSENEG);
          errorSummaryNumMap_[maxMasks_]->Fill(RBLKS);
          errorSummaryNumMap_[maxMasks_]->Fill(RBLKSFALSENEG);
          readoutSizeZSMap[maxMasks_] += totalBlockSize;
          evtGood[maxMasks_] = false;
          if (capIdDefined) {
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBAD);
            zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBADFALSENEG);
            errorSummaryNumMap_[blockCapId]->Fill(RBLKS);
            errorSummaryNumMap_[blockCapId]->Fill(RBLKSFALSENEG);
            readoutSizeZSMap[blockCapId] += totalBlockSize;
            evtGood[blockCapId] = false;
          }
        }
      }
    }
    if (verbose_) {
      std::cout << "FED data size: " << fedDataSize << " bytes" << std::endl;
      std::cout << "Payload size no ZS: " << readoutSizeNoZSMap[maxMasks_] << " bytes" << std::endl;
      std::cout << "Payload size ZS: " << readoutSizeZSMap[maxMasks_] << " bytes" << std::endl;
      std::cout << "Payload size expected ZS: " << readoutSizeZSExpectedMap[maxMasks_] << " bytes" << std::endl;
      std::cout << "Filled readout size ZS with headers: " << readoutSizeZSMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_] << " bytes" << std::endl;
      std::cout << "Filled expected readout size ZS with headers: " << readoutSizeZSExpectedMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_] << " bytes" << std::endl;
    }
    readoutSizeNoZSMap_[maxMasks_]->Fill(fedDataSize);
    readoutSizeZSMap_[maxMasks_]->Fill(readoutSizeZSMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_]);
    readoutSizeZSExpectedMap_[maxMasks_]->Fill(readoutSizeZSExpectedMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_]);
    for (const auto &id: definedMaskCapIds_) {
      readoutSizeNoZSMap_[id]->Fill(readoutSizeNoZSMap[id]);
      readoutSizeZSMap_[id]->Fill(readoutSizeZSMap[id]);
      readoutSizeZSExpectedMap_[id]->Fill(readoutSizeZSExpectedMap[id]);
    }
  }

  if (evtGood[maxMasks_]) {
    zeroSuppValMap_[maxMasks_]->Fill(EVTSGOOD);
  } else {
    zeroSuppValMap_[maxMasks_]->Fill(EVTSBAD);
    errorSummaryNumMap_[maxMasks_]->Fill(REVTS);
  }
  for (const auto &id: definedMaskCapIds_) {
    if (evtGood[id]) {
      zeroSuppValMap_[id]->Fill(EVTSGOOD);
    } else {
      zeroSuppValMap_[id]->Fill(EVTSBAD);
      errorSummaryNumMap_[id]->Fill(REVTS);
    }
  }
}

void L1TMP7ZeroSupp::bookCapIdHistograms ( DQMStore::IBooker &  ibooker, const unsigned int &  id  )

private

Definition at line 89 of file L1TMP7ZeroSupp.cc.

References BLOCKS, DQMStore::IBooker::book1D(), BXBLOCKS, errorSummaryDenMap_, errorSummaryNumMap_, EVTS, EVTSBAD, EVTSGOOD, triggerObjects_cff::id, maxFedReadoutSize_, maxMasks_, NBINLABELS, RBLKS, RBLKSFALSENEG, RBLKSFALSEPOS, RBXBLKS, RBXBLKSFALSENEG, RBXBLKSFALSEPOS, readoutSizeNoZSMap_, readoutSizeZSExpectedMap_, readoutSizeZSMap_, REVTS, RNBINLABELS, AlCaHLTBitMon_QueryRunRegistry::string, zeroSuppValMap_, ZSBLKSBAD, ZSBLKSBADFALSENEG, ZSBLKSBADFALSEPOS, ZSBLKSGOOD, ZSBXBLKSBAD, ZSBXBLKSBADFALSENEG, ZSBXBLKSBADFALSEPOS, and ZSBXBLKSGOOD.

Referenced by bookHistograms().

                                                                                         {
  std::string summaryTitleText = "Zero suppression validation summary";
  std::string sizeTitleText;
  if (id == maxMasks_) {
    sizeTitleText = "FED readout ";
  } else {
    summaryTitleText = summaryTitleText+", caption id "+std::to_string(id);
    sizeTitleText = "cumulated caption id "+std::to_string(id)+" block ";
  }

  zeroSuppValMap_[id] = ibooker.book1D("zeroSuppVal", summaryTitleText, NBINLABELS, 0, NBINLABELS);
  zeroSuppValMap_[id]->setAxisTitle("ZS status", 1);
  zeroSuppValMap_[id]->setBinLabel(EVTS+1, "events", 1);
  zeroSuppValMap_[id]->setBinLabel(EVTSGOOD+1, "good events", 1);
  zeroSuppValMap_[id]->setBinLabel(EVTSBAD+1, "bad events", 1);
  zeroSuppValMap_[id]->setBinLabel(BLOCKS+1, "blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBLKSGOOD+1, "good blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBAD+1, "bad blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBADFALSEPOS+1, "false pos.", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBADFALSENEG+1, "false neg.", 1);
  zeroSuppValMap_[id]->setBinLabel(BXBLOCKS+1, "BX blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSGOOD+1, "good BX blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBAD+1, "bad BX blocks", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBADFALSEPOS+1, "BX false pos.", 1);
  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBADFALSENEG+1, "BX false neg.", 1);

  errorSummaryNumMap_[id] = ibooker.book1D("errorSummaryNum", summaryTitleText, RNBINLABELS, 0, RNBINLABELS);
  errorSummaryNumMap_[id]->setBinLabel(REVTS+1, "bad events", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBLKS+1, "bad blocks", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBLKSFALSEPOS+1, "false pos.", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBLKSFALSENEG+1, "false neg.", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBXBLKS+1, "bad BX blocks", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBXBLKSFALSEPOS+1, "BX false pos.", 1);
  errorSummaryNumMap_[id]->setBinLabel(RBXBLKSFALSENEG+1, "BX false neg.", 1);

  errorSummaryDenMap_[id] = ibooker.book1D("errorSummaryDen", "denominators", RNBINLABELS, 0, RNBINLABELS);
  errorSummaryDenMap_[id]->setBinLabel(REVTS+1, "# events", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBLKS+1, "# blocks", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBLKSFALSEPOS+1, "# blocks", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBLKSFALSENEG+1, "# blocks", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBXBLKS+1, "# BX blocks", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBXBLKSFALSEPOS+1, "# BX blocks", 1);
  errorSummaryDenMap_[id]->setBinLabel(RBXBLKSFALSENEG+1, "# BX blocks", 1);
  // Setting canExtend to false is needed to get the correct behaviour when running multithreaded.
  // Otherwise, when merging the histgrams of the threads, TH1::Merge sums bins that have the same label in one bin.
  // This needs to come after the calls to setBinLabel.
  errorSummaryDenMap_[id]->getTH1F()->GetXaxis()->SetCanExtend(false);

  readoutSizeNoZSMap_[id] = ibooker.book1D("readoutSize", sizeTitleText + "size", 100, 0, maxFedReadoutSize_);
  readoutSizeNoZSMap_[id]->setAxisTitle("size (byte)", 1);
  readoutSizeZSMap_[id] = ibooker.book1D("readoutSizeZS", sizeTitleText + "size with zero suppression", 100, 0, maxFedReadoutSize_);
  readoutSizeZSMap_[id]->setAxisTitle("size (byte)", 1);
  readoutSizeZSExpectedMap_[id] = ibooker.book1D("readoutSizeZSExpected", "Expected " + sizeTitleText + "size with zero suppression", 100, 0, maxFedReadoutSize_);
  readoutSizeZSExpectedMap_[id]->setAxisTitle("size (byte)", 1);
}

void L1TMP7ZeroSupp::bookHistograms ( DQMStore::IBooker &  ibooker, const edm::Run &  , const edm::EventSetup &    )

overrideprotected

Definition at line 75 of file L1TMP7ZeroSupp.cc.

References DQMStore::IBooker::book1D(), bookCapIdHistograms(), capIds_, definedMaskCapIds_, maxMasks_, monitorDir_, MonitorElement::setAxisTitle(), and DQMStore::IBooker::setCurrentFolder().

                                                                                                 {
  // overall summary
  ibooker.setCurrentFolder(monitorDir_);
  bookCapIdHistograms(ibooker, maxMasks_);
  capIds_ = ibooker.book1D("capIds", "Caption ids found in data", maxMasks_, 0, maxMasks_);
  capIds_->setAxisTitle("caption id", 1);

  // per caption id subdirectories
  for (const auto &id: definedMaskCapIds_) {
    ibooker.setCurrentFolder(monitorDir_+"/CapId"+std::to_string(id));
    bookCapIdHistograms(ibooker, id);
  }
}

void L1TMP7ZeroSupp::dqmBeginRun ( const edm::Run &  r, const edm::EventSetup &  c  )

overrideprotected

Definition at line 72 of file L1TMP7ZeroSupp.cc.

{}

void L1TMP7ZeroSupp::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 48 of file L1TMP7ZeroSupp.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addUntracked(), mps_fire::i, maxMasks_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("rawData");
  desc.add<std::vector<int>>("fedIds")->setComment("FED ids to analyze.");
  desc.addUntracked<bool>("zsEnabled", true)->setComment("MP7 zero suppression is enabled.");
  desc.addUntracked<int>("lenSlinkHeader", 8)->setComment("Number of Slink header bytes.");
  desc.addUntracked<int>("lenSlinkTrailer", 8)->setComment("Number of Slink trailer bytes.");
  desc.addUntracked<int>("lenAMC13Header", 8)->setComment("Number of AMC13 header bytes.");
  desc.addUntracked<int>("lenAMC13Trailer", 8)->setComment("Number of AMC13 trailer bytes.");
  desc.addUntracked<int>("lenAMCHeader", 8)->setComment("Number of AMC header bytes.");
  desc.addUntracked<int>("lenAMCTrailer", 0)->setComment("Number of AMC trailer bytes.");
  desc.addUntracked<int>("zsFlagMask", 0x1)->setComment("Zero suppression flag mask.");
  desc.addUntracked<int>("newZsFlagMask", 0x2)->setComment("Per-BX zero suppression flag mask.");
  desc.addUntracked<int>("dataInvFlagMask", 0x1)->setComment("Data inversion flag mask.");
  desc.addUntracked<int>("maxFEDReadoutSize", 10000)->setComment("Maximal FED readout size histogram x-axis value.");
  for (unsigned int i = 0; i < maxMasks_; ++i) {
    desc.addOptionalUntracked<std::vector<int>>("maskCapId"+std::to_string(i))->setComment("ZS mask for caption id "+std::to_string(i)+".");
  }
  desc.addUntracked<bool>("checkOnlyCapIdsWithMasks", true)->setComment("Check only blocks that have a CapId for which a mask is defined.");
  desc.addUntracked<std::string>("monitorDir", "")->setComment("Target directory in the DQM file. Will be created if not existing.");
  desc.addUntracked<bool>("verbose", false);
  descriptions.add("l1tMP7ZeroSupp", desc);
}

Member Data Documentation

int L1TMP7ZeroSupp::amc13HeaderSize_

private

Definition at line 52 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::amc13TrailerSize_

private

Definition at line 53 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::amcHeaderSize_

private

Definition at line 54 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::amcTrailerSize_

private

Definition at line 55 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

MonitorElement* L1TMP7ZeroSupp::capIds_

private

Definition at line 77 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookHistograms().

bool L1TMP7ZeroSupp::checkOnlyCapIdsWithMasks_

private

Definition at line 62 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::dataInvFlagMask_

private

Definition at line 58 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

std::vector<unsigned int> L1TMP7ZeroSupp::definedMaskCapIds_

private

Definition at line 69 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), bookHistograms(), and L1TMP7ZeroSupp().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::errorSummaryDenMap_

private

Definition at line 73 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::errorSummaryNumMap_

private

Definition at line 72 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

edm::EDGetTokenT<FEDRawDataCollection> L1TMP7ZeroSupp::fedDataToken_

private

Definition at line 44 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

std::vector<int> L1TMP7ZeroSupp::fedIds_

private

Definition at line 46 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

std::vector<std::vector<int> > L1TMP7ZeroSupp::masks_

private

Definition at line 47 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and L1TMP7ZeroSupp().

int L1TMP7ZeroSupp::maxFedReadoutSize_

private

Definition at line 60 of file L1TMP7ZeroSupp.h.

Referenced by bookCapIdHistograms().

const unsigned int L1TMP7ZeroSupp::maxMasks_ = 16

staticprivate

Definition at line 67 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), bookCapIdHistograms(), bookHistograms(), fillDescriptions(), and L1TMP7ZeroSupp().

std::string L1TMP7ZeroSupp::monitorDir_

private

Definition at line 64 of file L1TMP7ZeroSupp.h.

Referenced by bookHistograms().

int L1TMP7ZeroSupp::newZsFlagMask_

private

Definition at line 56 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::readoutSizeNoZSMap_

private

Definition at line 74 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::readoutSizeZSExpectedMap_

private

Definition at line 76 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::readoutSizeZSMap_

private

Definition at line 75 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

int L1TMP7ZeroSupp::slinkHeaderSize_

private

Definition at line 50 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::slinkTrailerSize_

private

Definition at line 51 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

bool L1TMP7ZeroSupp::verbose_

private

Definition at line 65 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and L1TMP7ZeroSupp().

std::map<unsigned int, MonitorElement*> L1TMP7ZeroSupp::zeroSuppValMap_

private

Definition at line 71 of file L1TMP7ZeroSupp.h.

Referenced by analyze(), and bookCapIdHistograms().

bool L1TMP7ZeroSupp::zsEnabled_

private

Definition at line 45 of file L1TMP7ZeroSupp.h.

Referenced by analyze().

int L1TMP7ZeroSupp::zsFlagMask_

private

Definition at line 57 of file L1TMP7ZeroSupp.h.

Referenced by analyze().