CMS 3D CMS Logo

L1TStage2RegionalMuonCandComp.cc
Go to the documentation of this file.
2 
3 
5  : muonToken1(consumes<l1t::RegionalMuonCandBxCollection>(ps.getParameter<edm::InputTag>("regionalMuonCollection1"))),
6  muonToken2(consumes<l1t::RegionalMuonCandBxCollection>(ps.getParameter<edm::InputTag>("regionalMuonCollection2"))),
7  monitorDir(ps.getUntrackedParameter<std::string>("monitorDir")),
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 }
28 
30 
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 }
45 
47 
48 
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 }
215 
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 }
504 
const_iterator end(int bx) const
void setComment(std::string const &value)
unsigned size(int bx) const
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
BXVector< RegionalMuonCand > RegionalMuonCandBxCollection
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
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)
delete x;
Definition: CaloConfig.h:22
void analyze(const edm::Event &, const edm::EventSetup &) override
void Fill(long long x)
L1TStage2RegionalMuonCandComp(const edm::ParameterSet &ps)
void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:268
void dqmBeginRun(const edm::Run &, const edm::EventSetup &) override
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:106
ParameterDescriptionBase * add(U const &iLabel, T const &value)
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken1
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
int getFirstBX() const
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:109
edm::EDGetTokenT< l1t::RegionalMuonCandBxCollection > muonToken2
void add(std::string const &label, ParameterSetDescription const &psetDescription)
HLT enums.
void bookHistograms(DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override
int getLastBX() const
int getNbinsX() const
get # of bins in X-axis
const_iterator begin(int bx) const
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: Run.h:45
std::vector< RegionalMuonCand >::const_iterator const_iterator
Definition: BXVector.h:20