CMS 3D CMS Logo
L1TMP7ZeroSupp.cc
Go to the documentation of this file.
1 #include "DQM/L1TMonitor/interface/L1TMP7ZeroSupp.h"
2 
3 const unsigned int L1TMP7ZeroSupp::maxMasks_ = 16;
4 
5 L1TMP7ZeroSupp::L1TMP7ZeroSupp(const edm::ParameterSet& ps)
6  : fedDataToken_(consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("rawData"))),
7  zsEnabled_(ps.getUntrackedParameter<bool>("zsEnabled")),
8  fedIds_(ps.getParameter<std::vector<int>>("fedIds")),
9  slinkHeaderSize_(ps.getUntrackedParameter<int>("lenSlinkHeader")),
10  slinkTrailerSize_(ps.getUntrackedParameter<int>("lenSlinkTrailer")),
11  amc13HeaderSize_(ps.getUntrackedParameter<int>("lenAMC13Header")),
12  amc13TrailerSize_(ps.getUntrackedParameter<int>("lenAMC13Trailer")),
13  amcHeaderSize_(ps.getUntrackedParameter<int>("lenAMCHeader")),
14  amcTrailerSize_(ps.getUntrackedParameter<int>("lenAMCTrailer")),
15  newZsFlagMask_(ps.getUntrackedParameter<int>("newZsFlagMask")),
16  zsFlagMask_(ps.getUntrackedParameter<int>("zsFlagMask")),
17  dataInvFlagMask_(ps.getUntrackedParameter<int>("dataInvFlagMask")),
18  maxFedReadoutSize_(ps.getUntrackedParameter<int>("maxFEDReadoutSize")),
19  checkOnlyCapIdsWithMasks_(ps.getUntrackedParameter<bool>("checkOnlyCapIdsWithMasks")),
20  monitorDir_(ps.getUntrackedParameter<std::string>("monitorDir")),
21  verbose_(ps.getUntrackedParameter<bool>("verbose")) {
22  std::vector<int> onesMask(6, 0xffffffff);
23  masks_.reserve(maxMasks_);
24  for (unsigned int i = 0; i < maxMasks_; ++i) {
25  std::string maskCapIdStr{"maskCapId" + std::to_string(i)};
26  masks_.push_back(ps.getUntrackedParameter<std::vector<int>>(maskCapIdStr, onesMask));
27  // which masks are defined?
28  if (ps.exists(maskCapIdStr)) {
29  definedMaskCapIds_.push_back(i);
30  }
31  }
32  if (verbose_) {
33  // check masks
34  std::cout << "masks" << std::endl;
35  for (unsigned int i = 0; i < maxMasks_; ++i) {
36  std::cout << "caption ID" << i << ":" << std::endl;
37  for (const auto& maskIt : masks_.at(i)) {
38  std::cout << std::hex << std::setw(8) << std::setfill('0') << maskIt << std::dec << std::endl;
39  }
40  }
41  std::cout << "----------" << std::endl;
42  }
43 }
44 
45 L1TMP7ZeroSupp::~L1TMP7ZeroSupp() = default;
46 
47 void L1TMP7ZeroSupp::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
48  edm::ParameterSetDescription desc;
49  desc.add<edm::InputTag>("rawData");
50  desc.add<std::vector<int>>("fedIds")->setComment("FED ids to analyze.");
51  desc.addUntracked<bool>("zsEnabled", true)->setComment("MP7 zero suppression is enabled.");
52  desc.addUntracked<int>("lenSlinkHeader", 8)->setComment("Number of Slink header bytes.");
53  desc.addUntracked<int>("lenSlinkTrailer", 8)->setComment("Number of Slink trailer bytes.");
54  desc.addUntracked<int>("lenAMC13Header", 8)->setComment("Number of AMC13 header bytes.");
55  desc.addUntracked<int>("lenAMC13Trailer", 8)->setComment("Number of AMC13 trailer bytes.");
56  desc.addUntracked<int>("lenAMCHeader", 8)->setComment("Number of AMC header bytes.");
57  desc.addUntracked<int>("lenAMCTrailer", 0)->setComment("Number of AMC trailer bytes.");
58  desc.addUntracked<int>("zsFlagMask", 0x1)->setComment("Zero suppression flag mask.");
59  desc.addUntracked<int>("newZsFlagMask", 0x2)->setComment("Per-BX zero suppression flag mask.");
60  desc.addUntracked<int>("dataInvFlagMask", 0x1)->setComment("Data inversion flag mask.");
61  desc.addUntracked<int>("maxFEDReadoutSize", 10000)->setComment("Maximal FED readout size histogram x-axis value.");
62  for (unsigned int i = 0; i < maxMasks_; ++i) {
63  desc.addOptionalUntracked<std::vector<int>>("maskCapId" + std::to_string(i))
64  ->setComment("ZS mask for caption id " + std::to_string(i) + ".");
65  }
66  desc.addUntracked<bool>("checkOnlyCapIdsWithMasks", true)
67  ->setComment("Check only blocks that have a CapId for which a mask is defined.");
68  desc.addUntracked<std::string>("monitorDir", "")
69  ->setComment("Target directory in the DQM file. Will be created if not existing.");
70  desc.addUntracked<bool>("verbose", false);
71  descriptions.add("l1tMP7ZeroSupp", desc);
72 }
73 
74 void L1TMP7ZeroSupp::bookHistograms(DQMStore::IBooker& ibooker, const edm::Run&, const edm::EventSetup&) {
75  // overall summary
76  ibooker.setCurrentFolder(monitorDir_);
77  bookCapIdHistograms(ibooker, maxMasks_);
78  capIds_ = ibooker.book1D("capIds", "Caption ids found in data", maxMasks_, 0, maxMasks_);
79  capIds_->setAxisTitle("caption id", 1);
80 
81  // per caption id subdirectories
82  for (const auto& id : definedMaskCapIds_) {
83  ibooker.setCurrentFolder(monitorDir_ + "/CapId" + std::to_string(id));
84  bookCapIdHistograms(ibooker, id);
85  }
86 }
87 
88 void L1TMP7ZeroSupp::bookCapIdHistograms(DQMStore::IBooker& ibooker, const unsigned int& id) {
89  std::string summaryTitleText = "Zero suppression validation summary";
90  std::string sizeTitleText;
91  if (id == maxMasks_) {
92  sizeTitleText = "FED readout ";
93  } else {
94  summaryTitleText = summaryTitleText + ", caption id " + std::to_string(id);
95  sizeTitleText = "cumulated caption id " + std::to_string(id) + " block ";
96  }
97 
98  zeroSuppValMap_[id] = ibooker.book1D("zeroSuppVal", summaryTitleText, (int)NBINLABELS, 0, (int)NBINLABELS);
99  zeroSuppValMap_[id]->setAxisTitle("ZS status", 1);
100  zeroSuppValMap_[id]->setBinLabel(EVTS + 1, "events", 1);
101  zeroSuppValMap_[id]->setBinLabel(EVTSGOOD + 1, "good events", 1);
102  zeroSuppValMap_[id]->setBinLabel(EVTSBAD + 1, "bad events", 1);
103  zeroSuppValMap_[id]->setBinLabel(BLOCKS + 1, "blocks", 1);
104  zeroSuppValMap_[id]->setBinLabel(ZSBLKSGOOD + 1, "good blocks", 1);
105  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBAD + 1, "bad blocks", 1);
106  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBADFALSEPOS + 1, "false pos.", 1);
107  zeroSuppValMap_[id]->setBinLabel(ZSBLKSBADFALSENEG + 1, "false neg.", 1);
108  zeroSuppValMap_[id]->setBinLabel(BXBLOCKS + 1, "BX blocks", 1);
109  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSGOOD + 1, "good BX blocks", 1);
110  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBAD + 1, "bad BX blocks", 1);
111  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBADFALSEPOS + 1, "BX false pos.", 1);
112  zeroSuppValMap_[id]->setBinLabel(ZSBXBLKSBADFALSENEG + 1, "BX false neg.", 1);
113 
114  errorSummaryNumMap_[id] = ibooker.book1D("errorSummaryNum", summaryTitleText, (int)RNBINLABELS, 0, (int)RNBINLABELS);
115  errorSummaryNumMap_[id]->setBinLabel(REVTS + 1, "bad events", 1);
116  errorSummaryNumMap_[id]->setBinLabel(RBLKS + 1, "bad blocks", 1);
117  errorSummaryNumMap_[id]->setBinLabel(RBLKSFALSEPOS + 1, "false pos.", 1);
118  errorSummaryNumMap_[id]->setBinLabel(RBLKSFALSENEG + 1, "false neg.", 1);
119  errorSummaryNumMap_[id]->setBinLabel(RBXBLKS + 1, "bad BX blocks", 1);
120  errorSummaryNumMap_[id]->setBinLabel(RBXBLKSFALSEPOS + 1, "BX false pos.", 1);
121  errorSummaryNumMap_[id]->setBinLabel(RBXBLKSFALSENEG + 1, "BX false neg.", 1);
122 
123  errorSummaryDenMap_[id] = ibooker.book1D("errorSummaryDen", "denominators", (int)RNBINLABELS, 0, (int)RNBINLABELS);
124  errorSummaryDenMap_[id]->setBinLabel(REVTS + 1, "# events", 1);
125  errorSummaryDenMap_[id]->setBinLabel(RBLKS + 1, "# blocks", 1);
126  errorSummaryDenMap_[id]->setBinLabel(RBLKSFALSEPOS + 1, "# blocks", 1);
127  errorSummaryDenMap_[id]->setBinLabel(RBLKSFALSENEG + 1, "# blocks", 1);
128  errorSummaryDenMap_[id]->setBinLabel(RBXBLKS + 1, "# BX blocks", 1);
129  errorSummaryDenMap_[id]->setBinLabel(RBXBLKSFALSEPOS + 1, "# BX blocks", 1);
130  errorSummaryDenMap_[id]->setBinLabel(RBXBLKSFALSENEG + 1, "# BX blocks", 1);
131  // Setting canExtend to false is needed to get the correct behaviour when running multithreaded.
132  // Otherwise, when merging the histgrams of the threads, TH1::Merge sums bins that have the same label in one bin.
133  // This needs to come after the calls to setBinLabel.
134  errorSummaryDenMap_[id]->getTH1F()->GetXaxis()->SetCanExtend(false);
135 
136  readoutSizeNoZSMap_[id] = ibooker.book1D("readoutSize", sizeTitleText + "size", 100, 0, maxFedReadoutSize_);
137  readoutSizeNoZSMap_[id]->setAxisTitle("size (byte)", 1);
138  readoutSizeZSMap_[id] =
139  ibooker.book1D("readoutSizeZS", sizeTitleText + "size with zero suppression", 100, 0, maxFedReadoutSize_);
140  readoutSizeZSMap_[id]->setAxisTitle("size (byte)", 1);
141  readoutSizeZSExpectedMap_[id] = ibooker.book1D(
142  "readoutSizeZSExpected", "Expected " + sizeTitleText + "size with zero suppression", 100, 0, maxFedReadoutSize_);
143  readoutSizeZSExpectedMap_[id]->setAxisTitle("size (byte)", 1);
144 }
145 
146 void L1TMP7ZeroSupp::analyze(const edm::Event& e, const edm::EventSetup& c) {
147  if (verbose_)
148  edm::LogInfo("L1TDQM") << "L1TMP7ZeroSupp: analyze..." << std::endl;
149 
150  edm::Handle<FEDRawDataCollection> feds;
151  e.getByToken(fedDataToken_, feds);
152 
153  if (!feds.isValid()) {
154  edm::LogError("L1TDQM") << "Cannot analyse: no FEDRawDataCollection found";
155  return;
156  }
157 
158  zeroSuppValMap_[maxMasks_]->Fill(EVTS);
159  errorSummaryDenMap_[maxMasks_]->Fill(REVTS);
160  for (const auto& id : definedMaskCapIds_) {
161  zeroSuppValMap_[id]->Fill(EVTS);
162  errorSummaryDenMap_[id]->Fill(REVTS);
163  }
164 
165  std::map<unsigned int, bool> evtGood;
166  evtGood[maxMasks_] = true;
167  for (const auto& id : definedMaskCapIds_) {
168  evtGood[id] = true;
169  }
170  unsigned valid_count = 0;
171  for (const auto& fedId : fedIds_) {
172  const FEDRawData& l1tRcd = feds->FEDData(fedId);
173 
174  unsigned int fedDataSize = l1tRcd.size();
175  std::map<unsigned int, unsigned int> readoutSizeNoZSMap;
176  std::map<unsigned int, unsigned int> readoutSizeZSMap;
177  std::map<unsigned int, unsigned int> readoutSizeZSExpectedMap;
178  readoutSizeNoZSMap[maxMasks_] = 0;
179  readoutSizeZSMap[maxMasks_] = 0;
180  readoutSizeZSExpectedMap[maxMasks_] = 0;
181  for (const auto& id : definedMaskCapIds_) {
182  readoutSizeNoZSMap[id] = 0;
183  readoutSizeZSMap[id] = 0;
184  readoutSizeZSExpectedMap[id] = 0;
185  }
186 
187  edm::LogInfo("L1TDQM") << "Found FEDRawDataCollection with ID " << fedId << " and size " << l1tRcd.size();
188 
189  if ((int)l1tRcd.size() < slinkHeaderSize_ + slinkTrailerSize_ + amc13HeaderSize_ + amc13TrailerSize_ +
190  amcHeaderSize_ + amcTrailerSize_) {
191  if (l1tRcd.size() > 0) {
192  edm::LogError("L1TDQM") << "Cannot analyse: invalid L1T raw data (size = " << l1tRcd.size() << ") for ID "
193  << fedId << ".";
194  }
195  continue;
196  } else {
197  valid_count++;
198  }
199 
200  const unsigned char* data = l1tRcd.data();
201  FEDHeader header(data);
202 
203  if (header.check()) {
204  edm::LogInfo("L1TDQM") << "Found SLink header:"
205  << " Trigger type " << header.triggerType() << " L1 event ID " << header.lvl1ID()
206  << " BX Number " << header.bxID() << " FED source " << header.sourceID() << " FED version "
207  << header.version();
208  } else {
209  edm::LogWarning("L1TDQM") << "Did not find a SLink header!";
210  }
211 
212  FEDTrailer trailer(data + (l1tRcd.size() - slinkTrailerSize_));
213 
214  if (trailer.check()) {
215  edm::LogInfo("L1TDQM") << "Found SLink trailer:"
216  << " Length " << trailer.fragmentLength() << " CRC " << trailer.crc() << " Status "
217  << trailer.evtStatus() << " Throttling bits " << trailer.ttsBits();
218  } else {
219  edm::LogWarning("L1TDQM") << "Did not find a SLink trailer!";
220  }
221 
222  amc13::Packet packet;
223  if (!packet.parse((const uint64_t*)data,
224  (const uint64_t*)(data + slinkHeaderSize_),
225  (l1tRcd.size() - slinkHeaderSize_ - slinkTrailerSize_) / 8,
226  header.lvl1ID(),
227  header.bxID())) {
228  edm::LogError("L1TDQM") << "Could not extract AMC13 Packet.";
229  return;
230  }
231 
232  for (auto& amc : packet.payload()) {
233  if (amc.size() == 0)
234  continue;
235 
236  auto payload64 = amc.data();
237  auto start = (const uint32_t*)payload64.get();
238  // Want to have payload size in 32 bit words, but AMC measures
239  // it in 64 bit words -> factor 2.
240  const uint32_t* end = start + (amc.size() * 2);
241 
242  auto payload = std::make_unique<l1t::MP7Payload>(start, end, false);
243 
244  // getBlock() returns a non-null unique_ptr on success
245  std::unique_ptr<l1t::Block> block;
246  while ((block = payload->getBlock()) != nullptr) {
247  if (verbose_) {
248  std::cout << ">>> check zero suppression for block <<<" << std::endl
249  << "hdr: " << std::hex << std::setw(8) << std::setfill('0') << block->header().raw() << std::dec
250  << " (ID " << block->header().getID() << ", size " << block->header().getSize() << ", CapID 0x"
251  << std::hex << std::setw(2) << std::setfill('0') << block->header().getCapID() << ", flags 0x"
252  << std::hex << std::setw(2) << std::setfill('0') << block->header().getFlags() << ")" << std::dec
253  << std::endl;
254  for (const auto& word : block->payload()) {
255  std::cout << "data: " << std::hex << std::setw(8) << std::setfill('0') << word << std::dec << std::endl;
256  }
257  }
258 
259  unsigned int blockCapId = block->header().getCapID();
260  unsigned int blockSize = block->header().getSize() * 4; // times 4 to get the size in byte
261  unsigned int blockHeaderSize = sizeof(block->header().raw());
262  unsigned int blockHeaderFlags = block->header().getFlags();
263  bool newZsFlagSet = ((blockHeaderFlags & newZsFlagMask_) != 0); // use the per-BX ZS
264  bool blockZsFlagSet =
265  newZsFlagSet ? true : ((blockHeaderFlags & zsFlagMask_) != 0); // ZS validation flag for whole block
266  bool dataInvertFlagSet =
267  newZsFlagSet && ((blockHeaderFlags & dataInvFlagMask_) != 0); // invert the data before applying the mask
268 
269  capIds_->Fill(blockCapId);
270 
271  bool capIdDefined = false;
272  if (zeroSuppValMap_.find(blockCapId) != zeroSuppValMap_.end()) {
273  capIdDefined = true;
274  }
275 
276  // Only check blocks with a CapId that has a defined ZS mask.
277  if (checkOnlyCapIdsWithMasks_ and not capIdDefined) {
278  continue;
279  }
280 
281  // fill the denominator histograms
282  zeroSuppValMap_[maxMasks_]->Fill(BLOCKS);
283  errorSummaryDenMap_[maxMasks_]->Fill(RBLKS);
284  errorSummaryDenMap_[maxMasks_]->Fill(RBLKSFALSEPOS);
285  errorSummaryDenMap_[maxMasks_]->Fill(RBLKSFALSENEG);
286  if (capIdDefined) {
287  zeroSuppValMap_[blockCapId]->Fill(BLOCKS);
288  errorSummaryDenMap_[blockCapId]->Fill(RBLKS);
289  errorSummaryDenMap_[blockCapId]->Fill(RBLKSFALSEPOS);
290  errorSummaryDenMap_[blockCapId]->Fill(RBLKSFALSENEG);
291  }
292 
293  auto totalBlockSize = blockHeaderSize;
294  if (!newZsFlagSet) {
295  totalBlockSize += blockSize;
296  }
297  auto totalBlockSizeExpected = totalBlockSize;
298  auto totalBlockSizeNoZS = blockHeaderSize + blockSize;
299 
300  auto bxBlocks = block->getBxBlocks(6, newZsFlagSet); // 6 32 bit MP7 payload words per BX
301 
302  // check all BX blocks
303  bool allToSuppress = true;
304  for (const auto& bxBlock : bxBlocks) {
305  bool toSuppress = false;
306  bool bxZsFlagSet = ((bxBlock.header().getFlags() & zsFlagMask_) != 0); // ZS validation flag
307 
308  // check if this bxblock should be suppressed
309  unsigned int wordcounter = 0;
310  unsigned int wordsum = 0;
311  for (const auto& word : bxBlock.payload()) {
312  if (dataInvertFlagSet) {
313  wordsum += masks_[blockCapId].at(wordcounter % 6) & (~word);
314  } else {
315  wordsum += masks_[blockCapId].at(wordcounter % 6) & word;
316  }
317  if (verbose_) {
318  std::cout << "word: " << std::hex << std::setw(8) << std::setfill('0') << word << std::dec << ", maskword"
319  << wordcounter % 6 << ": " << std::hex << std::setw(8) << std::setfill('0')
320  << masks_[blockCapId].at(wordcounter % 6) << std::dec << ", wordsum: " << wordsum << std::endl;
321  }
322  if (wordsum > 0) {
323  if (verbose_) {
324  std::cout << "wordsum not 0: this BX block should be kept" << std::endl;
325  }
326  break;
327  }
328  ++wordcounter;
329  }
330  // the sum of payload words must be 0 for correct ZS
331  if (wordsum == 0 && zsEnabled_) {
332  toSuppress = true;
333  if (verbose_) {
334  std::cout << "wordsum == 0: this BX block should be zero suppressed" << std::endl;
335  }
336  }
337  // update the overall block status
338  allToSuppress = allToSuppress && toSuppress;
339 
340  // only fill the BX related things for the per-BX ZS
341  if (newZsFlagSet) {
342  // the ZS flag of the block is the AND of all BX block ZS flags
343  blockZsFlagSet = blockZsFlagSet && bxZsFlagSet;
344 
345  // fill the BX related bins of the denominator histogram
346  zeroSuppValMap_[maxMasks_]->Fill(BXBLOCKS);
347  errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKS);
348  errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKSFALSEPOS);
349  errorSummaryDenMap_[maxMasks_]->Fill(RBXBLKSFALSENEG);
350  if (capIdDefined) {
351  zeroSuppValMap_[blockCapId]->Fill(BXBLOCKS);
352  errorSummaryDenMap_[blockCapId]->Fill(RBXBLKS);
353  errorSummaryDenMap_[blockCapId]->Fill(RBXBLKSFALSEPOS);
354  errorSummaryDenMap_[blockCapId]->Fill(RBXBLKSFALSENEG);
355  }
356 
357  unsigned int totalBxBlockSize =
358  bxBlock.getSize() * 4 + sizeof(bxBlock.header().raw()); // times 4 to get the size in byte
359  // check if zero suppression flag agrees for the BX block
360  if (toSuppress && bxZsFlagSet) {
361  if (verbose_)
362  std::cout << "GOOD BX block with ZS flag true" << std::endl;
363  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSGOOD);
364  if (capIdDefined) {
365  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSGOOD);
366  }
367  } else if (!toSuppress && !bxZsFlagSet) {
368  if (verbose_)
369  std::cout << "GOOD BX block with ZS flag false" << std::endl;
370  totalBlockSize += totalBxBlockSize;
371  totalBlockSizeExpected += totalBxBlockSize;
372  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSGOOD);
373  if (capIdDefined) {
374  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSGOOD);
375  }
376  } else if (!toSuppress && bxZsFlagSet) {
377  if (verbose_)
378  std::cout << "BAD BX block with ZS flag true" << std::endl;
379  totalBlockSizeExpected += totalBxBlockSize;
380  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBAD);
381  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBADFALSEPOS);
382  errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKS);
383  errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKSFALSEPOS);
384  evtGood[maxMasks_] = false;
385  if (capIdDefined) {
386  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBAD);
387  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBADFALSEPOS);
388  errorSummaryNumMap_[blockCapId]->Fill(RBXBLKS);
389  errorSummaryNumMap_[blockCapId]->Fill(RBXBLKSFALSEPOS);
390  evtGood[blockCapId] = false;
391  }
392  } else {
393  if (verbose_)
394  std::cout << "BAD BX block with ZS flag false" << std::endl;
395  totalBlockSize += totalBxBlockSize;
396  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBAD);
397  zeroSuppValMap_[maxMasks_]->Fill(ZSBXBLKSBADFALSENEG);
398  errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKS);
399  errorSummaryNumMap_[maxMasks_]->Fill(RBXBLKSFALSENEG);
400  evtGood[maxMasks_] = false;
401  if (capIdDefined) {
402  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBAD);
403  zeroSuppValMap_[blockCapId]->Fill(ZSBXBLKSBADFALSENEG);
404  errorSummaryNumMap_[blockCapId]->Fill(RBXBLKS);
405  errorSummaryNumMap_[blockCapId]->Fill(RBXBLKSFALSENEG);
406  evtGood[blockCapId] = false;
407  }
408  }
409  }
410  }
411 
412  readoutSizeNoZSMap[maxMasks_] += totalBlockSizeNoZS;
413  if (capIdDefined) {
414  readoutSizeNoZSMap[blockCapId] += totalBlockSizeNoZS;
415  }
416 
417  // check if zero suppression flag agrees for the whole block
418  if (allToSuppress && blockZsFlagSet) {
419  if (verbose_)
420  std::cout << "GOOD block with ZS flag true" << std::endl;
421  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSGOOD);
422  if (capIdDefined) {
423  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSGOOD);
424  }
425  } else if (!allToSuppress && !blockZsFlagSet) {
426  if (verbose_)
427  std::cout << "GOOD block with ZS flag false" << std::endl;
428  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSGOOD);
429  readoutSizeZSMap[maxMasks_] += totalBlockSize;
430  readoutSizeZSExpectedMap[maxMasks_] += totalBlockSizeExpected;
431  if (capIdDefined) {
432  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSGOOD);
433  readoutSizeZSMap[blockCapId] += totalBlockSize;
434  readoutSizeZSExpectedMap[blockCapId] += totalBlockSizeExpected;
435  }
436  } else if (!allToSuppress && blockZsFlagSet) {
437  if (verbose_)
438  std::cout << "BAD block with ZS flag true" << std::endl;
439  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBAD);
440  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBADFALSEPOS);
441  errorSummaryNumMap_[maxMasks_]->Fill(RBLKS);
442  errorSummaryNumMap_[maxMasks_]->Fill(RBLKSFALSEPOS);
443  readoutSizeZSExpectedMap[maxMasks_] += totalBlockSizeExpected;
444  evtGood[maxMasks_] = false;
445  if (capIdDefined) {
446  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBAD);
447  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBADFALSEPOS);
448  errorSummaryNumMap_[blockCapId]->Fill(RBLKS);
449  errorSummaryNumMap_[blockCapId]->Fill(RBLKSFALSEPOS);
450  readoutSizeZSExpectedMap[blockCapId] += totalBlockSizeExpected;
451  evtGood[blockCapId] = false;
452  }
453  } else {
454  if (verbose_)
455  std::cout << "BAD block with ZS flag false" << std::endl;
456  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBAD);
457  zeroSuppValMap_[maxMasks_]->Fill(ZSBLKSBADFALSENEG);
458  errorSummaryNumMap_[maxMasks_]->Fill(RBLKS);
459  errorSummaryNumMap_[maxMasks_]->Fill(RBLKSFALSENEG);
460  readoutSizeZSMap[maxMasks_] += totalBlockSize;
461  evtGood[maxMasks_] = false;
462  if (capIdDefined) {
463  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBAD);
464  zeroSuppValMap_[blockCapId]->Fill(ZSBLKSBADFALSENEG);
465  errorSummaryNumMap_[blockCapId]->Fill(RBLKS);
466  errorSummaryNumMap_[blockCapId]->Fill(RBLKSFALSENEG);
467  readoutSizeZSMap[blockCapId] += totalBlockSize;
468  evtGood[blockCapId] = false;
469  }
470  }
471  }
472  }
473  if (verbose_) {
474  std::cout << "FED data size: " << fedDataSize << " bytes" << std::endl;
475  std::cout << "Payload size no ZS: " << readoutSizeNoZSMap[maxMasks_] << " bytes" << std::endl;
476  std::cout << "Payload size ZS: " << readoutSizeZSMap[maxMasks_] << " bytes" << std::endl;
477  std::cout << "Payload size expected ZS: " << readoutSizeZSExpectedMap[maxMasks_] << " bytes" << std::endl;
478  std::cout << "Filled readout size ZS with headers: "
479  << readoutSizeZSMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_] << " bytes" << std::endl;
480  std::cout << "Filled expected readout size ZS with headers: "
481  << readoutSizeZSExpectedMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_] << " bytes"
482  << std::endl;
483  }
484  readoutSizeNoZSMap_[maxMasks_]->Fill(fedDataSize);
485  readoutSizeZSMap_[maxMasks_]->Fill(readoutSizeZSMap[maxMasks_] + fedDataSize - readoutSizeNoZSMap[maxMasks_]);
486  readoutSizeZSExpectedMap_[maxMasks_]->Fill(readoutSizeZSExpectedMap[maxMasks_] + fedDataSize -
487  readoutSizeNoZSMap[maxMasks_]);
488  for (const auto& id : definedMaskCapIds_) {
489  readoutSizeNoZSMap_[id]->Fill(readoutSizeNoZSMap[id]);
490  readoutSizeZSMap_[id]->Fill(readoutSizeZSMap[id]);
491  readoutSizeZSExpectedMap_[id]->Fill(readoutSizeZSExpectedMap[id]);
492  }
493  }
494 
495  if (evtGood[maxMasks_]) {
496  zeroSuppValMap_[maxMasks_]->Fill(EVTSGOOD);
497  } else {
498  zeroSuppValMap_[maxMasks_]->Fill(EVTSBAD);
499  errorSummaryNumMap_[maxMasks_]->Fill(REVTS);
500  }
501  for (const auto& id : definedMaskCapIds_) {
502  if (evtGood[id]) {
503  zeroSuppValMap_[id]->Fill(EVTSGOOD);
504  } else {
505  zeroSuppValMap_[id]->Fill(EVTSBAD);
506  errorSummaryNumMap_[id]->Fill(REVTS);
507  }
508  }
509 }
L1TMP7ZeroSupp::masks_
std::vector< std::vector< int > > masks_
Definition: L1TMP7ZeroSupp.h:65
l1tstage2emulator_dqm_sourceclient-live_cfg.feds
feds
Definition: l1tstage2emulator_dqm_sourceclient-live_cfg.py:153
L1TMP7ZeroSupp::monitorDir_
std::string monitorDir_
Definition: L1TMP7ZeroSupp.h:82
L1TMP7ZeroSupp::zsFlagMask_
int zsFlagMask_
Definition: L1TMP7ZeroSupp.h:75
L1TMP7ZeroSupp::ZSBLKSGOOD
Definition: L1TMP7ZeroSupp.h:40
L1TMP7ZeroSupp::EVTS
Definition: L1TMP7ZeroSupp.h:36
electrons_cff.bool
bool
Definition: electrons_cff.py:393
L1TMP7ZeroSupp::errorSummaryNumMap_
std::map< unsigned int, MonitorElement * > errorSummaryNumMap_
Definition: L1TMP7ZeroSupp.h:90
mps_fire.i
i
Definition: mps_fire.py:428
start
Definition: start.py:1
amc13::Packet::parse
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)
Definition: AMC13Spec.cc:60
L1TMP7ZeroSupp::verbose_
bool verbose_
Definition: L1TMP7ZeroSupp.h:83
L1TMP7ZeroSupp::ZSBLKSBADFALSEPOS
Definition: L1TMP7ZeroSupp.h:42
edm::Run
Definition: Run.h:45
L1TMP7ZeroSupp.h
FEDRawDataCollection
Definition: FEDRawDataCollection.h:18
L1TMP7ZeroSupp::EVTSGOOD
Definition: L1TMP7ZeroSupp.h:37
edm
HLT enums.
Definition: AlignableModifier.h:19
FEDTrailer::crc
uint16_t crc() const
Cyclic Redundancy Code of the event fragment including header and trailer.
Definition: FEDTrailer.cc:15
gather_cfg.cout
cout
Definition: gather_cfg.py:144
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89353
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
L1TMP7ZeroSupp::maxMasks_
static const unsigned int maxMasks_
Definition: L1TMP7ZeroSupp.h:85
L1TMP7ZeroSupp::ZSBXBLKSGOOD
Definition: L1TMP7ZeroSupp.h:45
L1TMP7ZeroSupp::ZSBXBLKSBAD
Definition: L1TMP7ZeroSupp.h:46
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
FEDTrailer::evtStatus
uint8_t evtStatus() const
Event fragment status information.
Definition: FEDTrailer.cc:17
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
edm::Handle
Definition: AssociativeIterator.h:50
L1TMP7ZeroSupp::ZSBLKSBADFALSENEG
Definition: L1TMP7ZeroSupp.h:43
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
L1TMP7ZeroSupp::definedMaskCapIds_
std::vector< unsigned int > definedMaskCapIds_
Definition: L1TMP7ZeroSupp.h:87
L1TMP7ZeroSupp::RBXBLKS
Definition: L1TMP7ZeroSupp.h:56
amc13::Packet::payload
std::vector< amc::Packet > payload() const
Definition: AMC13Spec.h:92
FEDRawData::data
const unsigned char * data() const
Return a const pointer to the beginning of the data buffer.
Definition: FEDRawData.cc:24
L1TMP7ZeroSupp::RBXBLKSFALSENEG
Definition: L1TMP7ZeroSupp.h:58
L1TMP7ZeroSupp::REVTS
Definition: L1TMP7ZeroSupp.h:52
FEDRawData
Definition: FEDRawData.h:19
L1TMP7ZeroSupp::amc13TrailerSize_
int amc13TrailerSize_
Definition: L1TMP7ZeroSupp.h:71
FEDTrailer::check
bool check() const
Check that the trailer is OK.
Definition: FEDTrailer.cc:45
L1TMP7ZeroSupp::readoutSizeNoZSMap_
std::map< unsigned int, MonitorElement * > readoutSizeNoZSMap_
Definition: L1TMP7ZeroSupp.h:92
word
uint64_t word
Definition: CTPPSTotemDataFormatter.cc:29
L1TMP7ZeroSupp::fedIds_
std::vector< int > fedIds_
Definition: L1TMP7ZeroSupp.h:64
L1TMP7ZeroSupp::ZSBXBLKSBADFALSENEG
Definition: L1TMP7ZeroSupp.h:48
L1TMP7ZeroSupp::RBXBLKSFALSEPOS
Definition: L1TMP7ZeroSupp.h:57
L1TMP7ZeroSupp::ZSBXBLKSBADFALSEPOS
Definition: L1TMP7ZeroSupp.h:47
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
L1TMP7ZeroSupp::slinkTrailerSize_
int slinkTrailerSize_
Definition: L1TMP7ZeroSupp.h:69
L1TMP7ZeroSupp::dataInvFlagMask_
int dataInvFlagMask_
Definition: L1TMP7ZeroSupp.h:76
L1TMP7ZeroSupp::RBLKSFALSEPOS
Definition: L1TMP7ZeroSupp.h:54
amc13::Packet
Definition: AMC13Spec.h:69
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
mps_fire.end
end
Definition: mps_fire.py:242
L1TMP7ZeroSupp::RBLKSFALSENEG
Definition: L1TMP7ZeroSupp.h:55
L1TMP7ZeroSupp::newZsFlagMask_
int newZsFlagMask_
Definition: L1TMP7ZeroSupp.h:74
jets_cff.payload
payload
Definition: jets_cff.py:32
L1TMP7ZeroSupp::readoutSizeZSExpectedMap_
std::map< unsigned int, MonitorElement * > readoutSizeZSExpectedMap_
Definition: L1TMP7ZeroSupp.h:94
L1TMP7ZeroSupp::errorSummaryDenMap_
std::map< unsigned int, MonitorElement * > errorSummaryDenMap_
Definition: L1TMP7ZeroSupp.h:91
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
L1TMP7ZeroSupp::BXBLOCKS
Definition: L1TMP7ZeroSupp.h:44
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
L1TMP7ZeroSupp::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c) override
Definition: L1TMP7ZeroSupp.cc:146
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:681
funct::true
true
Definition: Factorize.h:173
L1TMP7ZeroSupp::~L1TMP7ZeroSupp
~L1TMP7ZeroSupp() override
L1TMP7ZeroSupp::maxFedReadoutSize_
int maxFedReadoutSize_
Definition: L1TMP7ZeroSupp.h:78
edm::ParameterSet
Definition: ParameterSet.h:47
FEDTrailer
Definition: FEDTrailer.h:14
L1TMP7ZeroSupp::zeroSuppValMap_
std::map< unsigned int, MonitorElement * > zeroSuppValMap_
Definition: L1TMP7ZeroSupp.h:89
L1TMP7ZeroSupp::RBLKS
Definition: L1TMP7ZeroSupp.h:53
L1TMP7ZeroSupp::ZSBLKSBAD
Definition: L1TMP7ZeroSupp.h:41
L1TMP7ZeroSupp::amc13HeaderSize_
int amc13HeaderSize_
Definition: L1TMP7ZeroSupp.h:70
createfilelist.int
int
Definition: createfilelist.py:10
L1TMP7ZeroSupp::bookHistograms
void bookHistograms(DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override
Definition: L1TMP7ZeroSupp.cc:74
L1TMP7ZeroSupp::amcTrailerSize_
int amcTrailerSize_
Definition: L1TMP7ZeroSupp.h:73
trackerHitRTTI::vector
Definition: trackerHitRTTI.h:21
L1TMP7ZeroSupp::capIds_
MonitorElement * capIds_
Definition: L1TMP7ZeroSupp.h:95
groupFilesInBlocks.block
block
Definition: groupFilesInBlocks.py:150
edm::EventSetup
Definition: EventSetup.h:57
l1tstage2_dqm_sourceclient-live_cfg.fedId
fedId
Definition: l1tstage2_dqm_sourceclient-live_cfg.py:88
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
FEDRawData::size
size_t size() const
Lenght of the data buffer in bytes.
Definition: FEDRawData.h:45
L1TMP7ZeroSupp::slinkHeaderSize_
int slinkHeaderSize_
Definition: L1TMP7ZeroSupp.h:68
L1TMP7ZeroSupp::amcHeaderSize_
int amcHeaderSize_
Definition: L1TMP7ZeroSupp.h:72
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
std
Definition: JetResolutionObject.h:76
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
L1TMP7ZeroSupp::RNBINLABELS
Definition: L1TMP7ZeroSupp.h:59
L1TMP7ZeroSupp::checkOnlyCapIdsWithMasks_
bool checkOnlyCapIdsWithMasks_
Definition: L1TMP7ZeroSupp.h:80
L1TMP7ZeroSupp::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: L1TMP7ZeroSupp.cc:47
amc
Definition: AMCSpec.h:8
L1TMP7ZeroSupp::fedDataToken_
edm::EDGetTokenT< FEDRawDataCollection > fedDataToken_
Definition: L1TMP7ZeroSupp.h:62
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
dqm::implementation::IBooker
Definition: DQMStore.h:43
L1TMP7ZeroSupp::readoutSizeZSMap_
std::map< unsigned int, MonitorElement * > readoutSizeZSMap_
Definition: L1TMP7ZeroSupp.h:93
RecoTauValidation_cfi.header
header
Definition: RecoTauValidation_cfi.py:292
cond::uint64_t
unsigned long long uint64_t
Definition: Time.h:13
L1TMP7ZeroSupp::zsEnabled_
bool zsEnabled_
Definition: L1TMP7ZeroSupp.h:63
L1TMP7ZeroSupp::BLOCKS
Definition: L1TMP7ZeroSupp.h:39
L1TMP7ZeroSupp::L1TMP7ZeroSupp
L1TMP7ZeroSupp(const edm::ParameterSet &ps)
Definition: L1TMP7ZeroSupp.cc:5
FEDTrailer::ttsBits
uint8_t ttsBits() const
Current value of the Trigger Throttling System bits.
Definition: FEDTrailer.cc:19
FEDHeader
Definition: FEDHeader.h:14
edm::Event
Definition: Event.h:73
L1TMP7ZeroSupp::bookCapIdHistograms
void bookCapIdHistograms(DQMStore::IBooker &ibooker, const unsigned int &id)
Definition: L1TMP7ZeroSupp.cc:88
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
TauDecayModes.dec
dec
Definition: TauDecayModes.py:143
edm::InputTag
Definition: InputTag.h:15
L1TMP7ZeroSupp::NBINLABELS
Definition: L1TMP7ZeroSupp.h:49
L1TMP7ZeroSupp::EVTSBAD
Definition: L1TMP7ZeroSupp.h:38
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
FEDTrailer::fragmentLength
uint32_t fragmentLength() const
The length of the event fragment counted in 64-bit words including header and trailer.
Definition: FEDTrailer.cc:13
Generated for CMSSW Reference Manual by doxygen 1.8.16