CMS 3D CMS Logo

List of all members | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Attributes
L1TStage2RegionalMuonCandComp Class Reference

#include <L1TStage2RegionalMuonCandComp.h>

Inheritance diagram for L1TStage2RegionalMuonCandComp:
one::DQMEDAnalyzer< T > one::dqmimplementation::DQMBaseClass< T... >

Public Member Functions

 L1TStage2RegionalMuonCandComp (const edm::ParameterSet &ps)
 
 ~L1TStage2RegionalMuonCandComp () 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 &, const edm::EventSetup &) override
 
void bookHistograms (DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override
 
void dqmBeginRun (const edm::Run &, const edm::EventSetup &) override
 

Private Types

enum  ratioVariables {
  RBXRANGE =1, RNMUON, RMUON, RPT,
  RETA, RLOCALPHI, RSIGN, RSIGNVAL,
  RQUAL, RHF, RLINK, RPROC,
  RTF, RTRACKADDR, RDXY, RPT2
}
 
enum  tfs {
  BMTFBIN =1, OMTFNEGBIN, OMTFPOSBIN, EMTFNEGBIN,
  EMTFPOSBIN
}
 
enum  variables {
  BXRANGEGOOD =1, BXRANGEBAD, NMUONGOOD, NMUONBAD,
  MUONALL, MUONGOOD, PTBAD, ETABAD,
  LOCALPHIBAD, SIGNBAD, SIGNVALBAD, QUALBAD,
  HFBAD, LINKBAD, PROCBAD, TFBAD,
  TRACKADDRBAD, DXYBAD, PT2BAD
}
 

Private Attributes

MonitorElementerrorSummaryDen
 
MonitorElementerrorSummaryNum
 
bool ignoreBadTrkAddr
 
std::vector< int > ignoreBin
 
bool incBin [RPT2+1]
 
bool isBmtf
 
std::string monitorDir
 
MonitorElementmuColl1BxRange
 
MonitorElementmuColl1hwDXY
 
MonitorElementmuColl1hwEta
 
MonitorElementmuColl1hwHF
 
MonitorElementmuColl1hwPhi
 
MonitorElementmuColl1hwPt
 
MonitorElementmuColl1hwPt2
 
MonitorElementmuColl1hwQual
 
MonitorElementmuColl1hwSign
 
MonitorElementmuColl1hwSignValid
 
MonitorElementmuColl1link
 
MonitorElementmuColl1nMu
 
MonitorElementmuColl1processor
 
MonitorElementmuColl1trackFinderType
 
MonitorElementmuColl1TrkAddr
 
MonitorElementmuColl1TrkAddrSize
 
MonitorElementmuColl2BxRange
 
MonitorElementmuColl2hwDXY
 
MonitorElementmuColl2hwEta
 
MonitorElementmuColl2hwHF
 
MonitorElementmuColl2hwPhi
 
MonitorElementmuColl2hwPt
 
MonitorElementmuColl2hwPt2
 
MonitorElementmuColl2hwQual
 
MonitorElementmuColl2hwSign
 
MonitorElementmuColl2hwSignValid
 
MonitorElementmuColl2link
 
MonitorElementmuColl2nMu
 
MonitorElementmuColl2processor
 
MonitorElementmuColl2trackFinderType
 
MonitorElementmuColl2TrkAddr
 
MonitorElementmuColl2TrkAddrSize
 
std::string muonColl1Title
 
std::string muonColl2Title
 
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollectionmuonToken1
 
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollectionmuonToken2
 
MonitorElementsummary
 
std::string summaryTitle
 
bool verbose
 

Detailed Description

Definition at line 17 of file L1TStage2RegionalMuonCandComp.h.

Member Enumeration Documentation

Enumerator
RBXRANGE 
RNMUON 
RMUON 
RPT 
RETA 
RLOCALPHI 
RSIGN 
RSIGNVAL 
RQUAL 
RHF 
RLINK 
RPROC 
RTF 
RTRACKADDR 
RDXY 
RPT2 

Definition at line 33 of file L1TStage2RegionalMuonCandComp.h.

Enumerator
BXRANGEGOOD 
BXRANGEBAD 
NMUONGOOD 
NMUONBAD 
MUONALL 
MUONGOOD 
PTBAD 
ETABAD 
LOCALPHIBAD 
SIGNBAD 
SIGNVALBAD 
QUALBAD 
HFBAD 
LINKBAD 
PROCBAD 
TFBAD 
TRACKADDRBAD 
DXYBAD 
PT2BAD 

Definition at line 32 of file L1TStage2RegionalMuonCandComp.h.

Constructor & Destructor Documentation

L1TStage2RegionalMuonCandComp::L1TStage2RegionalMuonCandComp ( const edm::ParameterSet ps)

Definition at line 4 of file L1TStage2RegionalMuonCandComp.cc.

References mps_fire::i, ignoreBin, incBin, and RPT2.

5  : muonToken1(consumes<l1t::RegionalMuonCandBxCollection>(ps.getParameter<edm::InputTag>("regionalMuonCollection1"))),
6  muonToken2(consumes<l1t::RegionalMuonCandBxCollection>(ps.getParameter<edm::InputTag>("regionalMuonCollection2"))),
8  muonColl1Title(ps.getUntrackedParameter<std::string>("regionalMuonCollection1Title")),
9  muonColl2Title(ps.getUntrackedParameter<std::string>("regionalMuonCollection2Title")),
10  summaryTitle(ps.getUntrackedParameter<std::string>("summaryTitle")),
11  ignoreBadTrkAddr(ps.getUntrackedParameter<bool>("ignoreBadTrackAddress")),
12  ignoreBin(ps.getUntrackedParameter<std::vector<int>>("ignoreBin")),
13  verbose(ps.getUntrackedParameter<bool>("verbose")),
14  isBmtf(ps.getUntrackedParameter<bool>("isBmtf"))
15 {
16  // First include all bins
17  for (unsigned int i = 1; i <= RPT2; i++) {
18  incBin[i] = true;
19  }
20  // Then check the list of bins to ignore
21  for (const auto& i : ignoreBin) {
22  if (i > 0 && i <= RPT2) {
23  incBin[i] = false;
24  }
25  }
26 
27 }
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken1
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken2
L1TStage2RegionalMuonCandComp::~L1TStage2RegionalMuonCandComp ( )
override

Definition at line 29 of file L1TStage2RegionalMuonCandComp.cc.

29 {}

Member Function Documentation

void L1TStage2RegionalMuonCandComp::analyze ( const edm::Event e,
const edm::EventSetup c 
)
overrideprotected

Definition at line 216 of file L1TStage2RegionalMuonCandComp.cc.

References BXVector< T >::begin(), BXRANGEBAD, BXRANGEGOOD, DXYBAD, BXVector< T >::end(), errorSummaryDen, errorSummaryNum, ETABAD, MonitorElement::Fill(), edm::Event::getByToken(), BXVector< T >::getFirstBX(), BXVector< T >::getLastBX(), MonitorElement::getNbinsX(), HFBAD, mps_fire::i, ignoreBadTrkAddr, incBin, isBmtf, LINKBAD, LOCALPHIBAD, muColl1BxRange, muColl1hwDXY, muColl1hwEta, muColl1hwHF, muColl1hwPhi, muColl1hwPt, muColl1hwPt2, muColl1hwQual, muColl1hwSign, muColl1hwSignValid, muColl1link, muColl1nMu, muColl1processor, muColl1trackFinderType, muColl1TrkAddr, muColl1TrkAddrSize, muColl2BxRange, muColl2hwDXY, muColl2hwEta, muColl2hwHF, muColl2hwPhi, muColl2hwPt, muColl2hwPt2, muColl2hwQual, muColl2hwSign, muColl2hwSignValid, muColl2link, muColl2nMu, muColl2processor, muColl2trackFinderType, muColl2TrkAddr, muColl2TrkAddrSize, MUONALL, MUONGOOD, muonToken1, muonToken2, NMUONBAD, NMUONGOOD, PROCBAD, PT2BAD, PTBAD, QUALBAD, RBXRANGE, RDXY, RETA, RHF, RLINK, RLOCALPHI, RMUON, RNMUON, RPROC, RPT, RPT2, RQUAL, RSIGN, RSIGNVAL, RTF, RTRACKADDR, SIGNBAD, SIGNVALBAD, BXVector< T >::size(), summary, TFBAD, and TRACKADDRBAD.

216  {
217 
218  if (verbose) edm::LogInfo("L1TStage2RegionalMuonCandComp") << "L1TStage2RegionalMuonCandComp: analyze..." << std::endl;
219 
222  e.getByToken(muonToken1, muonBxColl1);
223  e.getByToken(muonToken2, muonBxColl2);
224 
226  int bxRange1 = muonBxColl1->getLastBX() - muonBxColl1->getFirstBX() + 1;
227  int bxRange2 = muonBxColl2->getLastBX() - muonBxColl2->getFirstBX() + 1;
228  if (bxRange1 != bxRange2) {
230  if (incBin[RBXRANGE]) errorSummaryNum->Fill(RBXRANGE);
231  int bx;
232  for (bx = muonBxColl1->getFirstBX(); bx <= muonBxColl1->getLastBX(); ++bx) {
233  muColl1BxRange->Fill(bx);
234  }
235  for (bx = muonBxColl2->getFirstBX(); bx <= muonBxColl2->getLastBX(); ++bx) {
236  muColl2BxRange->Fill(bx);
237  }
238  } else {
240  }
241 
242  for (int iBx = muonBxColl1->getFirstBX(); iBx <= muonBxColl1->getLastBX(); ++iBx) {
243  // don't analyse if this BX does not exist in the second collection
244  if (iBx < muonBxColl2->getFirstBX() || iBx > muonBxColl2->getLastBX()) continue;
245 
248 
250  // check number of muons
251  if (muonBxColl1->size(iBx) != muonBxColl2->size(iBx)) {
253  if (incBin[RNMUON]) errorSummaryNum->Fill(RNMUON);
254  muColl1nMu->Fill(muonBxColl1->size(iBx));
255  muColl2nMu->Fill(muonBxColl2->size(iBx));
256 
257  if (muonBxColl1->size(iBx) > muonBxColl2->size(iBx)) {
258  muonIt1 = muonBxColl1->begin(iBx) + muonBxColl2->size(iBx);
259  const std::map<int, int> muon1TrackAddr = muonIt1->trackAddress();
260  for (; muonIt1 != muonBxColl1->end(iBx); ++muonIt1) {
261  muColl1hwPt->Fill(muonIt1->hwPt());
262  muColl1hwEta->Fill(muonIt1->hwEta());
263  muColl1hwPhi->Fill(muonIt1->hwPhi());
264  muColl1hwSign->Fill(muonIt1->hwSign());
265  muColl1hwSignValid->Fill(muonIt1->hwSignValid());
266  muColl1hwQual->Fill(muonIt1->hwQual());
267  muColl1link->Fill(muonIt1->link());
268  muColl1processor->Fill(muonIt1->processor());
269  muColl1trackFinderType->Fill(muonIt1->trackFinderType());
270  muColl1hwHF->Fill(muonIt1->hwHF());
271  muColl1TrkAddrSize->Fill(muon1TrackAddr.size());
272  if (isBmtf){
273  muColl1hwDXY->Fill(muonIt1->hwDXY());
274  muColl1hwPt2->Fill(muonIt1->hwPt2());
275  }
276  for (std::map<int, int>::const_iterator trIt1 = muon1TrackAddr.begin(); trIt1 != muon1TrackAddr.end(); ++trIt1) {
277  muColl1TrkAddr->Fill(trIt1->first, trIt1->second);
278  }
279  }
280  } else {
281  muonIt2 = muonBxColl2->begin(iBx) + muonBxColl1->size(iBx);
282  const std::map<int, int> muon2TrackAddr = muonIt2->trackAddress();
283  for (; muonIt2 != muonBxColl2->end(iBx); ++muonIt2) {
284  muColl2hwPt->Fill(muonIt2->hwPt());
285  muColl2hwEta->Fill(muonIt2->hwEta());
286  muColl2hwPhi->Fill(muonIt2->hwPhi());
287  muColl2hwSign->Fill(muonIt2->hwSign());
288  muColl2hwSignValid->Fill(muonIt2->hwSignValid());
289  muColl2hwQual->Fill(muonIt2->hwQual());
290  muColl2link->Fill(muonIt2->link());
291  muColl2processor->Fill(muonIt2->processor());
292  muColl2trackFinderType->Fill(muonIt2->trackFinderType());
293  muColl2hwHF->Fill(muonIt2->hwHF());
294  muColl2TrkAddrSize->Fill(muon2TrackAddr.size());
295  if (isBmtf){
296  muColl2hwDXY->Fill(muonIt2->hwDXY());
297  muColl2hwPt2->Fill(muonIt2->hwPt2());
298  }
299  for (std::map<int, int>::const_iterator trIt2 = muon2TrackAddr.begin(); trIt2 != muon2TrackAddr.end(); ++trIt2) {
300  muColl2TrkAddr->Fill(trIt2->first, trIt2->second);
301  }
302  }
303  }
304  } else {
306  }
307 
308  muonIt1 = muonBxColl1->begin(iBx);
309  muonIt2 = muonBxColl2->begin(iBx);
310  //std::cout << "Analysing muons from BX " << iBx << std::endl;
311  while(muonIt1 != muonBxColl1->end(iBx) && muonIt2 != muonBxColl2->end(iBx)) {
312  //std::cout << "Coll 1 muon: hwPt=" << muonIt1->hwPt() << ", hwEta=" << muonIt1->hwEta() << ", hwPhi=" << muonIt1->hwPhi()
313  // << ", hwSign=" << muonIt1->hwSign() << ", hwSignValid=" << muonIt1->hwSignValid()
314  // << ", hwQual=" << muonIt1->hwQual() << ", link=" << muonIt1->link() << ", processor=" << muonIt1->processor()
315  // << ", trackFinderType=" << muonIt1->trackFinderType() << std::endl;
316  //std::cout << "Coll 2 muon: hwPt=" << muonIt2->hwPt() << ", hwEta=" << muonIt2->hwEta() << ", hwPhi=" << muonIt2->hwPhi()
317  // << ", hwSign=" << muonIt2->hwSign() << ", hwSignValid=" << muonIt2->hwSignValid()
318  // << ", hwQual=" << muonIt2->hwQual() << ", link=" << muonIt2->link() << ", processor=" << muonIt2->processor()
319  // << ", trackFinderType=" << muonIt2->trackFinderType() << std::endl;
320  summary->Fill(MUONALL);
321  for (int i = RMUON; i <= errorSummaryDen->getNbinsX(); ++i) {
323  }
324 
325  bool muonMismatch = false; // All muon mismatches
326  bool muonSelMismatch = false; // Muon mismatches excluding ignored bins
327  if (muonIt1->hwPt() != muonIt2->hwPt()) {
328  muonMismatch = true;
329  summary->Fill(PTBAD);
330  if (incBin[RPT]) {
331  muonSelMismatch = true;
332  errorSummaryNum->Fill(RPT);
333  }
334  }
335  if (muonIt1->hwEta() != muonIt2->hwEta()) {
336  muonMismatch = true;
337  summary->Fill(ETABAD);
338  if (incBin[RETA]) {
339  muonSelMismatch = true;
340  errorSummaryNum->Fill(RETA);
341  }
342  }
343  if (muonIt1->hwPhi() != muonIt2->hwPhi()) {
344  muonMismatch = true;
346  if (incBin[RLOCALPHI]) {
347  muonSelMismatch = true;
348  errorSummaryNum->Fill(RLOCALPHI);
349  }
350  }
351  if (muonIt1->hwSign() != muonIt2->hwSign()) {
352  muonMismatch = true;
353  summary->Fill(SIGNBAD);
354  if (incBin[RSIGN]) {
355  muonSelMismatch = true;
356  errorSummaryNum->Fill(RSIGN);
357  }
358  }
359  if (muonIt1->hwSignValid() != muonIt2->hwSignValid()) {
360  muonMismatch = true;
362  if (incBin[RSIGNVAL]) {
363  muonSelMismatch = true;
364  errorSummaryNum->Fill(RSIGNVAL);
365  }
366  }
367  if (muonIt1->hwQual() != muonIt2->hwQual()) {
368  muonMismatch = true;
369  summary->Fill(QUALBAD);
370  if (incBin[RQUAL]) {
371  muonSelMismatch = true;
372  errorSummaryNum->Fill(RQUAL);
373  }
374  }
375  if (muonIt1->hwHF() != muonIt2->hwHF()) {
376  muonMismatch = true;
377  summary->Fill(HFBAD);
378  if (incBin[RHF]) {
379  muonSelMismatch = true;
380  errorSummaryNum->Fill(RHF);
381  }
382  }
383  if (muonIt1->link() != muonIt2->link()) {
384  muonMismatch = true;
385  summary->Fill(LINKBAD);
386  if (incBin[RLINK]) {
387  muonSelMismatch = true;
388  errorSummaryNum->Fill(RLINK);
389  }
390  }
391  if (muonIt1->processor() != muonIt2->processor()) {
392  muonMismatch = true;
393  summary->Fill(PROCBAD);
394  if (incBin[RPROC]) {
395  muonSelMismatch = true;
396  errorSummaryNum->Fill(RPROC);
397  }
398  }
399  if (muonIt1->trackFinderType() != muonIt2->trackFinderType()) {
400  muonMismatch = true;
401  summary->Fill(TFBAD);
402  if (incBin[RTF]) {
403  muonSelMismatch = true;
404  errorSummaryNum->Fill(RTF);
405  }
406  }
407  // check track address
408  const std::map<int, int> muon1TrackAddr = muonIt1->trackAddress();
409  std::map<int, int> muon2TrackAddr = muonIt2->trackAddress();
410  bool badTrackAddr = false;
411  if (muon1TrackAddr.size() == muon2TrackAddr.size()) {
412  for (std::map<int, int>::const_iterator trIt1 = muon1TrackAddr.begin(); trIt1 != muon1TrackAddr.end(); ++trIt1) {
413  if (muon2TrackAddr.find(trIt1->first) == muon2TrackAddr.end()) { // key does not exist
414  badTrackAddr = true;
415  break;
416  } else if (muon2TrackAddr[trIt1->first] != trIt1->second) { // wrong value for key
417  badTrackAddr = true;
418  break;
419  }
420  }
421  } else {
422  badTrackAddr = true;
423  }
424  if (badTrackAddr) {
425  if (!ignoreBadTrkAddr) {
426  muonMismatch = true;
427  if (incBin[RTRACKADDR]) muonSelMismatch = true;
428  }
430  if (incBin[RTRACKADDR]) errorSummaryNum->Fill(RTRACKADDR);
431  }
432 
433  if (incBin[RMUON] && muonSelMismatch) {
435  }
436 
437  if(isBmtf) {
438  if (muonIt1->hwDXY() != muonIt2->hwDXY()) {
439  muonMismatch = true;
440  summary->Fill(DXYBAD);
441  if (incBin[RDXY]) {
442  muonSelMismatch = true;
443  errorSummaryNum->Fill(RDXY);
444  }
445  }
446  if (muonIt1->hwPt2() != muonIt2->hwPt2()) {
447  muonMismatch = true;
448  summary->Fill(PT2BAD);
449  if (incBin[RPT2]) {
450  muonSelMismatch = true;
451  errorSummaryNum->Fill(RPT2);
452  }
453  }
454  }
455 
456  if (muonMismatch) {
457 
458  muColl1hwPt->Fill(muonIt1->hwPt());
459  muColl1hwEta->Fill(muonIt1->hwEta());
460  muColl1hwPhi->Fill(muonIt1->hwPhi());
461  muColl1hwSign->Fill(muonIt1->hwSign());
462  muColl1hwSignValid->Fill(muonIt1->hwSignValid());
463  muColl1hwQual->Fill(muonIt1->hwQual());
464  muColl1link->Fill(muonIt1->link());
465  muColl1processor->Fill(muonIt1->processor());
466  muColl1trackFinderType->Fill(muonIt1->trackFinderType());
467  muColl1hwHF->Fill(muonIt1->hwHF());
468  muColl1TrkAddrSize->Fill(muon1TrackAddr.size());
469  if (isBmtf){
470  muColl1hwDXY->Fill(muonIt1->hwDXY());
471  muColl1hwPt2->Fill(muonIt1->hwPt2());
472  }
473  for (std::map<int, int>::const_iterator trIt1 = muon1TrackAddr.begin(); trIt1 != muon1TrackAddr.end(); ++trIt1) {
474  muColl1TrkAddr->Fill(trIt1->first, trIt1->second);
475  }
476 
477  muColl2hwPt->Fill(muonIt2->hwPt());
478  muColl2hwEta->Fill(muonIt2->hwEta());
479  muColl2hwPhi->Fill(muonIt2->hwPhi());
480  muColl2hwSign->Fill(muonIt2->hwSign());
481  muColl2hwSignValid->Fill(muonIt2->hwSignValid());
482  muColl2hwQual->Fill(muonIt2->hwQual());
483  muColl2link->Fill(muonIt2->link());
484  muColl2processor->Fill(muonIt2->processor());
485  muColl2trackFinderType->Fill(muonIt2->trackFinderType());
486  muColl2hwHF->Fill(muonIt2->hwHF());
487  muColl2TrkAddrSize->Fill(muon2TrackAddr.size());
488  if (isBmtf){
489  muColl2hwDXY->Fill(muonIt2->hwDXY());
490  muColl2hwPt2->Fill(muonIt2->hwPt2());
491  }
492  for (std::map<int, int>::const_iterator trIt2 = muon2TrackAddr.begin(); trIt2 != muon2TrackAddr.end(); ++trIt2) {
493  muColl2TrkAddr->Fill(trIt2->first, trIt2->second);
494  }
495  } else {
497  }
498 
499  ++muonIt1;
500  ++muonIt2;
501  }
502  }
503 }
const_iterator end(int bx) const
unsigned size(int bx) const
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
void Fill(long long x)
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken1
int getFirstBX() const
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken2
int getLastBX() const
int getNbinsX() const
get # of bins in X-axis
const_iterator begin(int bx) const
std::vector< RegionalMuonCand >::const_iterator const_iterator
Definition: BXVector.h:20
void L1TStage2RegionalMuonCandComp::bookHistograms ( DQMStore::IBooker ibooker,
const edm::Run ,
const edm::EventSetup  
)
overrideprotected

Definition at line 49 of file L1TStage2RegionalMuonCandComp.cc.

References BMTFBIN, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), BXRANGEBAD, BXRANGEGOOD, DXYBAD, EMTFNEGBIN, EMTFPOSBIN, errorSummaryDen, errorSummaryNum, ETABAD, MonitorElement::getNbinsX(), MonitorElement::getTH1F(), HFBAD, mps_fire::i, ignoreBadTrkAddr, incBin, isBmtf, LINKBAD, LOCALPHIBAD, monitorDir, muColl1BxRange, muColl1hwDXY, muColl1hwEta, muColl1hwHF, muColl1hwPhi, muColl1hwPt, muColl1hwPt2, muColl1hwQual, muColl1hwSign, muColl1hwSignValid, muColl1link, muColl1nMu, muColl1processor, muColl1trackFinderType, muColl1TrkAddr, muColl1TrkAddrSize, muColl2BxRange, muColl2hwDXY, muColl2hwEta, muColl2hwHF, muColl2hwPhi, muColl2hwPt, muColl2hwPt2, muColl2hwQual, muColl2hwSign, muColl2hwSignValid, muColl2link, muColl2nMu, muColl2processor, muColl2trackFinderType, muColl2TrkAddr, muColl2TrkAddrSize, MUONALL, muonColl1Title, muonColl2Title, MUONGOOD, pileupCalc::nbins, NMUONBAD, NMUONGOOD, OMTFNEGBIN, OMTFPOSBIN, PROCBAD, PT2BAD, PTBAD, QUALBAD, RBXRANGE, RDXY, RETA, RHF, RLINK, RLOCALPHI, RMUON, RNMUON, RPROC, RPT, RPT2, RQUAL, RSIGN, RSIGNVAL, RTF, RTRACKADDR, MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), SIGNBAD, SIGNVALBAD, AlCaHLTBitMon_QueryRunRegistry::string, summary, summaryTitle, TFBAD, and TRACKADDRBAD.

49  {
50 
51  std::string trkAddrIgnoreText = "";
52  if (ignoreBadTrkAddr) {
53  trkAddrIgnoreText = " (Bad track addresses ignored)";
54  }
55 
56  int nbins = 17;
57  if (isBmtf) {
58  nbins += 2;
59  }
60 
61 
62  // Subsystem Monitoring and Muon Output
64 
65  summary = ibooker.book1D("summary", (summaryTitle+trkAddrIgnoreText).c_str(), nbins, 1, nbins+1); // range to match bin numbering
66  summary->setBinLabel(BXRANGEGOOD, "BX range match", 1);
67  summary->setBinLabel(BXRANGEBAD, "BX range mismatch", 1);
68  summary->setBinLabel(NMUONGOOD, "muon collection size match", 1);
69  summary->setBinLabel(NMUONBAD, "muon collection size mismatch", 1);
70  summary->setBinLabel(MUONALL, "# muons", 1);
71  summary->setBinLabel(MUONGOOD, "# matching muons", 1);
72  summary->setBinLabel(PTBAD, "p_{T} mismatch", 1);
73  summary->setBinLabel(ETABAD, "#eta mismatch", 1);
74  summary->setBinLabel(LOCALPHIBAD, "local #phi mismatch", 1);
75  summary->setBinLabel(SIGNBAD, "sign mismatch", 1);
76  summary->setBinLabel(SIGNVALBAD, "sign valid mismatch", 1);
77  summary->setBinLabel(QUALBAD, "quality mismatch", 1);
78  summary->setBinLabel(HFBAD, "HF bit mismatch", 1);
79  summary->setBinLabel(LINKBAD, "link mismatch", 1);
80  summary->setBinLabel(PROCBAD, "processor mismatch", 1);
81  summary->setBinLabel(TFBAD, "track finder type mismatch", 1);
82  summary->setBinLabel(TRACKADDRBAD, "track address mismatch", 1);
83  if (isBmtf){
84  summary->setBinLabel(DXYBAD, "DXY mismatch", 1);
85  summary->setBinLabel(PT2BAD, "P_{T}2 mismatch", 1);
86  }
87 
88  int nbinsNum = 14;
89  if (isBmtf) {
90  nbinsNum += 2;
91  }
92 
93  errorSummaryNum = ibooker.book1D("errorSummaryNum", (summaryTitle+trkAddrIgnoreText).c_str(), nbinsNum, 1, nbinsNum+1); // range to match bin numbering
94  errorSummaryNum->setBinLabel(RBXRANGE, "BX range mismatch", 1);
95  errorSummaryNum->setBinLabel(RNMUON, "muon collection size mismatch", 1);
96  errorSummaryNum->setBinLabel(RMUON, "mismatching muons", 1);
97  errorSummaryNum->setBinLabel(RPT, "p_{T} mismatch", 1);
98  errorSummaryNum->setBinLabel(RETA, "#eta mismatch", 1);
99  errorSummaryNum->setBinLabel(RLOCALPHI, "local #phi mismatch", 1);
100  errorSummaryNum->setBinLabel(RSIGN, "sign mismatch", 1);
101  errorSummaryNum->setBinLabel(RSIGNVAL, "sign valid mismatch", 1);
102  errorSummaryNum->setBinLabel(RQUAL, "quality mismatch", 1);
103  errorSummaryNum->setBinLabel(RHF, "HF bit mismatch", 1);
104  errorSummaryNum->setBinLabel(RLINK, "link mismatch", 1);
105  errorSummaryNum->setBinLabel(RPROC, "processor mismatch", 1);
106  errorSummaryNum->setBinLabel(RTF, "track finder type mismatch", 1);
107  errorSummaryNum->setBinLabel(RTRACKADDR, "track address mismatch", 1);
108  if (isBmtf) {
109  errorSummaryNum->setBinLabel(RDXY, "DXY mismatch", 1);
110  errorSummaryNum->setBinLabel(RPT2, "P_{T}2 mismatch", 1);
111  }
112 
113  // Change the label for those bins that will be ignored
114  for (int i = 1; i <= errorSummaryNum->getNbinsX(); i++) {
115  if (incBin[i]==false) {
116  errorSummaryNum->setBinLabel(i, "Ignored", 1);
117  }
118  }
119  // Setting canExtend to false is needed to get the correct behaviour when running multithreaded.
120  // Otherwise, when merging the histgrams of the threads, TH1::Merge sums bins that have the same label in one bin.
121  // This needs to come after the calls to setBinLabel.
122  errorSummaryNum->getTH1F()->GetXaxis()->SetCanExtend(false);
123 
124  errorSummaryDen = ibooker.book1D("errorSummaryDen", "denominators", nbinsNum, 1, nbinsNum+1); // range to match bin numbering
125  errorSummaryDen->setBinLabel(RBXRANGE, "# events", 1);
126  errorSummaryDen->setBinLabel(RNMUON, "# muon collections", 1);
127  for (int i = RMUON; i <= errorSummaryDen->getNbinsX(); ++i) {
128  errorSummaryDen->setBinLabel(i, "# muons", 1);
129  }
130  // Needed for correct histogram summing in multithreaded running.
131  errorSummaryDen->getTH1F()->GetXaxis()->SetCanExtend(false);
132 
133  muColl1BxRange = ibooker.book1D("muBxRangeColl1", (muonColl1Title+" mismatching BX range").c_str(), 11, -5.5, 5.5);
134  muColl1BxRange->setAxisTitle("BX range", 1);
135  muColl1nMu = ibooker.book1D("nMuColl1", (muonColl1Title+" mismatching muon multiplicity").c_str(), 37, -0.5, 36.5);
136  muColl1nMu->setAxisTitle("Muon multiplicity", 1);
137  muColl1hwPt = ibooker.book1D("muHwPtColl1", (muonColl1Title+" mismatching muon p_{T}"+trkAddrIgnoreText).c_str(), 512, -0.5, 511.5);
138  muColl1hwPt->setAxisTitle("Hardware p_{T}", 1);
139  muColl1hwEta = ibooker.book1D("muHwEtaColl1", (muonColl1Title+" mismatching muon #eta"+trkAddrIgnoreText).c_str(), 512, -256.5, 255.5);
140  muColl1hwEta->setAxisTitle("Hardware #eta", 1);
141  muColl1hwPhi = ibooker.book1D("muHwPhiColl1", (muonColl1Title+" mismatching muon #phi"+trkAddrIgnoreText).c_str(), 256, -128.5, 127.5);
142  muColl1hwPhi->setAxisTitle("Hardware #phi", 1);
143  muColl1hwSign = ibooker.book1D("muHwSignColl1", (muonColl1Title+" mismatching muon sign"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
144  muColl1hwSign->setAxisTitle("Hardware sign", 1);
145  muColl1hwSignValid = ibooker.book1D("muHwSignValidColl1", (muonColl1Title+" mismatching muon sign valid"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
146  muColl1hwSignValid->setAxisTitle("Hardware sign valid", 1);
147  muColl1hwQual = ibooker.book1D("muHwQualColl1", (muonColl1Title+" mismatching muon quality"+trkAddrIgnoreText).c_str(), 16, -0.5, 15.5);
148  muColl1hwQual->setAxisTitle("Hardware quality", 1);
149  muColl1link = ibooker.book1D("muLinkColl1", (muonColl1Title+" mismatching muon link"+trkAddrIgnoreText).c_str(), 36, 35.5, 71.5);
150  muColl1link->setAxisTitle("Link", 1);
151  muColl1processor = ibooker.book1D("muProcessorColl1", (muonColl1Title+" mismatching muon processor"+trkAddrIgnoreText).c_str(), 12, -0.5, 11.5);
152  muColl1processor->setAxisTitle("Processor", 1);
153  muColl1trackFinderType = ibooker.book1D("muTrackFinderTypeColl1", (muonColl1Title+" mismatching muon track finder type"+trkAddrIgnoreText).c_str(), 5, -0.5, 4.5);
154  muColl1trackFinderType->setAxisTitle("Track finder type", 1);
160  muColl1hwHF = ibooker.book1D("muHwHFColl1", (muonColl1Title+" mismatching muon halo/fine-eta bit"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
161  muColl1hwHF->setAxisTitle("Hardware H/F bit", 1);
162  muColl1TrkAddrSize = ibooker.book1D("muTrkAddrSizeColl1", (muonColl1Title+" mismatching muon number of track address keys"+trkAddrIgnoreText).c_str(), 11, -0.5, 10.5);
163  muColl1TrkAddrSize->setAxisTitle("number of keys", 1);
164  muColl1TrkAddr = ibooker.book2D("muTrkAddrColl1", (muonColl1Title+" mismatching muon track address"+trkAddrIgnoreText).c_str(), 10, -0.5, 9.5, 16, -0.5, 15.5);
165  muColl1TrkAddr->setAxisTitle("key", 1);
166  muColl1TrkAddr->setAxisTitle("value", 2);
167  if (isBmtf) {
168  muColl1hwDXY = ibooker.book1D("muhwDXYColl1", (muonColl1Title+" HW DXY"+trkAddrIgnoreText).c_str(), 4, 0, 4);
169  muColl1hwDXY->setAxisTitle("Hardware DXY",1);
170  muColl1hwPt2 = ibooker.book1D("muhwPt2Coll1", (muonColl1Title+"HW p_{T}2"+trkAddrIgnoreText).c_str(), 512, -0.5, 511.5);
171  muColl1hwPt2->setAxisTitle("Hardware P_{T}2",1);
172  }
173 
174  muColl2BxRange = ibooker.book1D("muBxRangeColl2", (muonColl2Title+" mismatching BX range").c_str(), 11, -5.5, 5.5);
175  muColl2BxRange->setAxisTitle("BX range", 1);
176  muColl2nMu = ibooker.book1D("nMuColl2", (muonColl2Title+" mismatching muon multiplicity").c_str(), 37, -0.5, 36.5);
177  muColl2nMu->setAxisTitle("Muon multiplicity", 1);
178  muColl2hwPt = ibooker.book1D("muHwPtColl2", (muonColl2Title+" mismatching muon p_{T}"+trkAddrIgnoreText).c_str(), 512, -0.5, 511.5);
179  muColl2hwPt->setAxisTitle("Hardware p_{T}", 1);
180  muColl2hwEta = ibooker.book1D("muHwEtaColl2", (muonColl2Title+" mismatching muon #eta"+trkAddrIgnoreText).c_str(), 512, -256.5, 255.5);
181  muColl2hwEta->setAxisTitle("Hardware #eta", 1);
182  muColl2hwPhi = ibooker.book1D("muHwPhiColl2", (muonColl2Title+" mismatching muon #phi"+trkAddrIgnoreText).c_str(), 256, -128.5, 127.5);
183  muColl2hwPhi->setAxisTitle("Hardware #phi", 1);
184  muColl2hwSign = ibooker.book1D("muHwSignColl2", (muonColl2Title+" mismatching muon sign"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
185  muColl2hwSign->setAxisTitle("Hardware sign", 1);
186  muColl2hwSignValid = ibooker.book1D("muHwSignValidColl2", (muonColl2Title+" mismatching muon sign valid"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
187  muColl2hwSignValid->setAxisTitle("Hardware sign valid", 1);
188  muColl2hwQual = ibooker.book1D("muHwQualColl2", (muonColl2Title+" mismatching muon quality"+trkAddrIgnoreText).c_str(), 16, -0.5, 15.5);
189  muColl2hwQual->setAxisTitle("Hardware quality", 1);
190  muColl2link = ibooker.book1D("muLinkColl2", (muonColl2Title+" mismatching muon link"+trkAddrIgnoreText).c_str(), 36, 35.5, 71.5);
191  muColl2link->setAxisTitle("Link", 1);
192  muColl2processor = ibooker.book1D("muProcessorColl2", (muonColl2Title+" mismatching muon processor"+trkAddrIgnoreText).c_str(), 12, -0.5, 11.5);
193  muColl2processor->setAxisTitle("Processor", 1);
194  muColl2trackFinderType = ibooker.book1D("muTrackFinderTypeColl2", (muonColl2Title+" mismatching muon track finder type"+trkAddrIgnoreText).c_str(), 5, -0.5, 4.5);
195  muColl2trackFinderType->setAxisTitle("Track finder type", 1);
201  muColl2hwHF = ibooker.book1D("muHwHFColl2", (muonColl2Title+" mismatching muon halo/fine-eta bit"+trkAddrIgnoreText).c_str(), 2, -0.5, 1.5);
202  muColl2hwHF->setAxisTitle("Hardware H/F bit", 1);
203  muColl2TrkAddrSize = ibooker.book1D("muTrkAddrSizeColl2", (muonColl2Title+" mismatching muon number of track address keys"+trkAddrIgnoreText).c_str(), 11, -0.5, 10.5);
204  muColl2TrkAddrSize->setAxisTitle("number of keys", 1);
205  muColl2TrkAddr = ibooker.book2D("muTrkAddrColl2", (muonColl2Title+" mismatching muon track address"+trkAddrIgnoreText).c_str(), 10, -0.5, 9.5, 16, -0.5, 15.5);
206  muColl2TrkAddr->setAxisTitle("key", 1);
207  muColl2TrkAddr->setAxisTitle("value", 2);
208  if (isBmtf) {
209  muColl2hwDXY = ibooker.book1D("muhwDXYColl2", (muonColl2Title+" HW DXY"+trkAddrIgnoreText).c_str(), 4, 0, 4);
210  muColl2hwDXY->setAxisTitle("Hardware DXY",1);
211  muColl2hwPt2 = ibooker.book1D("muhwPt2Coll2", (muonColl2Title+"HW p_{T}2"+trkAddrIgnoreText).c_str(), 512, -0.5, 511.5);
212  muColl2hwPt2->setAxisTitle("Hardware P_{T}2",1);
213  }
214 }
TH1F * getTH1F() const
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:268
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:106
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:109
int getNbinsX() const
get # of bins in X-axis
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
void L1TStage2RegionalMuonCandComp::dqmBeginRun ( const edm::Run r,
const edm::EventSetup c 
)
overrideprotected

Definition at line 46 of file L1TStage2RegionalMuonCandComp.cc.

46 {}
void L1TStage2RegionalMuonCandComp::fillDescriptions ( edm::ConfigurationDescriptions descriptions)
static

Definition at line 31 of file L1TStage2RegionalMuonCandComp.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

31  {
33  desc.add<edm::InputTag>("regionalMuonCollection1")->setComment("L1T RegionalMuonCand collection 1");
34  desc.add<edm::InputTag>("regionalMuonCollection2")->setComment("L1T RegionalMuonCand collection 2");
35  desc.addUntracked<std::string>("monitorDir", "")->setComment("Target directory in the DQM file. Will be created if not existing.");
36  desc.addUntracked<std::string>("regionalMuonCollection1Title", "Regional muon collection 1")->setComment("Histogram title for first collection.");
37  desc.addUntracked<std::string>("regionalMuonCollection2Title", "Regional muon collection 2")->setComment("Histogram title for second collection.");
38  desc.addUntracked<std::string>("summaryTitle", "Summary")->setComment("Title of summary histogram.");
39  desc.addUntracked<bool>("ignoreBadTrackAddress", false)->setComment("Ignore muon track address mismatches.");
40  desc.addUntracked<std::vector<int>>("ignoreBin", std::vector<int>())->setComment("List of bins to ignore");
41  desc.addUntracked<bool>("verbose", false);
42  desc.addUntracked<bool>("isBmtf", false);
43  descriptions.add("l1tStage2RegionalMuonCandComp", desc);
44 }
void setComment(std::string const &value)
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
ParameterDescriptionBase * add(U const &iLabel, T const &value)
void add(std::string const &label, ParameterSetDescription const &psetDescription)

Member Data Documentation

MonitorElement* L1TStage2RegionalMuonCandComp::errorSummaryDen
private

Definition at line 50 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::errorSummaryNum
private

Definition at line 49 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

bool L1TStage2RegionalMuonCandComp::ignoreBadTrkAddr
private

Definition at line 43 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

std::vector<int> L1TStage2RegionalMuonCandComp::ignoreBin
private

Definition at line 44 of file L1TStage2RegionalMuonCandComp.h.

Referenced by L1TStage2RegionalMuonCandComp().

bool L1TStage2RegionalMuonCandComp::incBin[RPT2+1]
private
bool L1TStage2RegionalMuonCandComp::isBmtf
private

Definition at line 46 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

std::string L1TStage2RegionalMuonCandComp::monitorDir
private

Definition at line 39 of file L1TStage2RegionalMuonCandComp.h.

Referenced by bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1BxRange
private

Definition at line 52 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwDXY
private

Definition at line 66 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwEta
private

Definition at line 55 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwHF
private

Definition at line 63 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwPhi
private

Definition at line 56 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwPt
private

Definition at line 54 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwPt2
private

Definition at line 67 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwQual
private

Definition at line 59 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwSign
private

Definition at line 57 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1hwSignValid
private

Definition at line 58 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1link
private

Definition at line 60 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1nMu
private

Definition at line 53 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1processor
private

Definition at line 61 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1trackFinderType
private

Definition at line 62 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1TrkAddr
private

Definition at line 65 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl1TrkAddrSize
private

Definition at line 64 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2BxRange
private

Definition at line 69 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwDXY
private

Definition at line 83 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwEta
private

Definition at line 72 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwHF
private

Definition at line 80 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwPhi
private

Definition at line 73 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwPt
private

Definition at line 71 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwPt2
private

Definition at line 84 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwQual
private

Definition at line 76 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwSign
private

Definition at line 74 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2hwSignValid
private

Definition at line 75 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2link
private

Definition at line 77 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2nMu
private

Definition at line 70 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2processor
private

Definition at line 78 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2trackFinderType
private

Definition at line 79 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2TrkAddr
private

Definition at line 82 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* L1TStage2RegionalMuonCandComp::muColl2TrkAddrSize
private

Definition at line 81 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

std::string L1TStage2RegionalMuonCandComp::muonColl1Title
private

Definition at line 40 of file L1TStage2RegionalMuonCandComp.h.

Referenced by bookHistograms().

std::string L1TStage2RegionalMuonCandComp::muonColl2Title
private

Definition at line 41 of file L1TStage2RegionalMuonCandComp.h.

Referenced by bookHistograms().

edm::EDGetTokenT<l1t::RegionalMuonCandBxCollection> L1TStage2RegionalMuonCandComp::muonToken1
private

Definition at line 37 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze().

edm::EDGetTokenT<l1t::RegionalMuonCandBxCollection> L1TStage2RegionalMuonCandComp::muonToken2
private

Definition at line 38 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze().

MonitorElement* L1TStage2RegionalMuonCandComp::summary
private

Definition at line 48 of file L1TStage2RegionalMuonCandComp.h.

Referenced by analyze(), and bookHistograms().

std::string L1TStage2RegionalMuonCandComp::summaryTitle
private

Definition at line 42 of file L1TStage2RegionalMuonCandComp.h.

Referenced by bookHistograms().

bool L1TStage2RegionalMuonCandComp::verbose
private