CMS 3D CMS Logo
L1TdeCSCTF.cc
Go to the documentation of this file.
1 /*
2  * L1TdeCSCTF.cc v1.0
3  * written by J. Gartner
4  *
5  * 2011.03.11 expanded by GP Di Giovanni
6  *
7  * There is quality test allowing to check elements outside the
8  * diagonal, so I need to add the 1D plot with all elements in the diagonal
9  * in the first bin and all elements outside the diagonal in the second bin
10  *
11  * In such way we can run the ContentsXRange quality test...
12  */
13 
14 #include "DQM/L1TMonitor/interface/L1TdeCSCTF.h"
15 #include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigiCollection.h"
16 #include "CondFormats/DataRecord/interface/L1MuTriggerScalesRcd.h"
17 #include <DataFormats/L1GlobalMuonTrigger/interface/L1MuRegionalCand.h>
18 
19 #include "CondFormats/L1TObjects/interface/L1MuTriggerScales.h"
20 #include "CondFormats/DataRecord/interface/L1MuTriggerScalesRcd.h"
21 #include "CondFormats/L1TObjects/interface/L1MuTriggerPtScale.h"
22 #include "CondFormats/DataRecord/interface/L1MuTriggerPtScaleRcd.h"
23 
24 
25 #include "DataFormats/L1CSCTrackFinder/interface/TrackStub.h"
26 
27 #include "DQMServices/Core/interface/DQMStore.h"
28 
29 #include "FWCore/Framework/interface/ESHandle.h"
30 
31 #include <iostream>
32 #include <iomanip>
33 #include <memory>
34 
35 
36 using namespace std;
37 using namespace edm;
38 
39 L1TdeCSCTF::L1TdeCSCTF(ParameterSet const& pset) {
40  dataTrackProducer = consumes<L1CSCTrackCollection>(pset.getParameter<InputTag>("dataTrackProducer"));
41  emulTrackProducer = consumes<L1CSCTrackCollection>(pset.getParameter<InputTag>("emulTrackProducer"));
42  dataStubProducer = consumes<CSCTriggerContainer<csctf::TrackStub> >(pset.getParameter<InputTag>("dataStubProducer"));
43  emulStubProducer = consumes<L1MuDTChambPhContainer>(pset.getParameter<InputTag>("emulStubProducer"));
44 
45  m_dirName = pset.getUntrackedParameter("DQMFolder", string("L1TEMU/CSCTFexpert"));
46 
47  ptLUTset = pset.getParameter<ParameterSet>("PTLUT");
48 
49  outFile = pset.getUntrackedParameter<string>("outFile", "");
50  if( !outFile.empty() )
51  {
52  LogWarning("L1TdeCSCTF")
53  << "L1T Monitoring histograms will be saved to "
54  << outFile.c_str()
55  << endl;
56  }
57 
58  bool disable = pset. getUntrackedParameter<bool>("disableROOToutput", false);
59  if(disable){
60  outFile="";
61  }
62 
63  /*bzero(srLUTs_, sizeof(srLUTs_));
64  //int endcap =1, sector =1;
65  bool TMB07=true;
66  ParameterSet srLUTset;
67  srLUTset.addUntrackedParameter<bool>("ReadLUTs", false);
68  srLUTset.addUntrackedParameter<bool>("Binary", false);
69  srLUTset.addUntrackedParameter<string>("LUTPath", "./");
70  for(int endcapItr = CSCDetId::minEndcapId(); endcapItr <= CSCDetId::maxEndcapId(); endcapItr++)
71  {
72  for(int sectorItr = CSCTriggerNumbering::minTriggerSectorId();sectorItr <= CSCTriggerNumbering::maxTriggerSectorId();sectorItr++)
73  {
74  for(int stationItr = 1; stationItr <= 4; stationItr++)
75  {
76  if(stationItr == 1)
77  {
78  for(int subsectorItr = 0; subsectorItr < 2; subsectorItr++)
79  {
80  srLUTs_[endcapItr-1][sectorItr-1][subsectorItr] = new CSCSectorReceiverLUT(endcapItr, sectorItr, subsectorItr+1, stationItr, srLUTset, TMB07);
81  }
82  } else {
83  srLUTs_[endcapItr-1][sectorItr-1][stationItr] = new CSCSectorReceiverLUT(endcapItr, sectorItr, 0, stationItr, srLUTset, TMB07);
84  } //if for station 1 or 234
85  } // stationItr loop
86  } // sectorItr loop
87  } // endcapItr loop
88  */
89  my_dtrc =std::make_unique<CSCTFDTReceiver>();
90 }
91 void L1TdeCSCTF::dqmBeginRun(const edm::Run& r, const edm::EventSetup& c){
92 }
93 
94 void L1TdeCSCTF::beginLuminosityBlock(const edm::LuminosityBlock& l, const edm::EventSetup& c){
95 }
96 
97 void L1TdeCSCTF::bookHistograms(DQMStore::IBooker &ibooker, edm::Run const&, edm::EventSetup const&)
98 {
99  //Histograms booking
100 
102  // DQM Directory Structure //
104 
105  ibooker.setCurrentFolder(m_dirName);
106 
108  // Define Monitor Elements //
110  //Monitor Elements for Pt Lut Address Field
111  pt1Comp = ibooker.book2D("pt1Comp","Hardware Vs. Emulator #Delta #phi_{12}",256,0,256,256,0,256);
112  pt1Comp->setAxisTitle("Hardware #Delta #phi_{12}",1);
113  pt1Comp->setAxisTitle("Emulator #Delta #phi_{12}",2);
114  pt2Comp = ibooker.book2D("pt2Comp","Hardware Vs. Emulator #Delta #phi_{23}",16,0,16,16,0,16);
115  pt2Comp->setAxisTitle("Hardware #Delta #phi_{23}",1);
116  pt2Comp->setAxisTitle("Emulator #Delta #phi_{23}",2);
117  pt3Comp = ibooker.book2D("pt3Comp","Hardware Vs. Emulator #eta",16,0,16,16,0,16);
118  pt3Comp->setAxisTitle("Hardware #eta",1);
119  pt3Comp->setAxisTitle("Emulator #eta",2);
120  pt4Comp = ibooker.book2D("pt4Comp","Hardware Vs. Emulator Mode",19,0,19,19,0,19);
121  pt4Comp->setAxisTitle("Hardware Mode",1);
122  pt4Comp->setAxisTitle("Emulator Mode",2);
123  //Hardware Bin Titles
124  pt4Comp->setBinLabel(1,"No Track",1);
125  pt4Comp->setBinLabel(2,"Bad Phi/Single",1);
126  pt4Comp->setBinLabel(3,"ME1-2-3",1);
127  pt4Comp->setBinLabel(4,"ME1-2-4",1);
128  pt4Comp->setBinLabel(5,"ME1-3-4",1);
129  pt4Comp->setBinLabel(6,"ME2-3-4",1);
130  pt4Comp->setBinLabel(7,"ME1-2",1);
131  pt4Comp->setBinLabel(8,"ME1-3",1);
132  pt4Comp->setBinLabel(9,"ME2-3",1);
133  pt4Comp->setBinLabel(10,"ME2-4",1);
134  pt4Comp->setBinLabel(11,"ME3-4",1);
135  pt4Comp->setBinLabel(12,"MB1-ME3",1);
136  pt4Comp->setBinLabel(13,"MB1-ME2",1);
137  pt4Comp->setBinLabel(14,"ME1-4",1);
138  pt4Comp->setBinLabel(15,"MB1-ME1",1);
139  pt4Comp->setBinLabel(16,"Halo Trigger",1);
140  pt4Comp->setBinLabel(17,"MB1-ME1-2",1);
141  pt4Comp->setBinLabel(18,"MB1-ME1-3",1);
142  pt4Comp->setBinLabel(19,"MB1-ME2-3",1);
143  //Emu Bin Titles
144  pt4Comp->setBinLabel(1,"No Track",2);
145  pt4Comp->setBinLabel(2,"Bad Phi/Single",2);
146  pt4Comp->setBinLabel(3,"ME1-2-3",2);
147  pt4Comp->setBinLabel(4,"ME1-2-4",2);
148  pt4Comp->setBinLabel(5,"ME1-3-4",2);
149  pt4Comp->setBinLabel(6,"ME2-3-4",2);
150  pt4Comp->setBinLabel(7,"ME1-2",2);
151  pt4Comp->setBinLabel(8,"ME1-3",2);
152  pt4Comp->setBinLabel(9,"ME2-3",2);
153  pt4Comp->setBinLabel(10,"ME2-4",2);
154  pt4Comp->setBinLabel(11,"ME3-4",2);
155  pt4Comp->setBinLabel(12,"MB1-ME3",2);
156  pt4Comp->setBinLabel(13,"MB1-ME2",2);
157  pt4Comp->setBinLabel(14,"ME1-4",2);
158  pt4Comp->setBinLabel(15,"MB1-ME1",2);
159  pt4Comp->setBinLabel(16,"Halo Trigger",2);
160  pt4Comp->setBinLabel(17,"MB1-ME1-2",2);
161  pt4Comp->setBinLabel(18,"MB1-ME1-3",2);
162  pt4Comp->setBinLabel(19,"MB1-ME2-3",2);
163 
164  pt5Comp = ibooker.book2D("pt5Comp","Hardware Vs. Emulator Sign, FR",4,0,4,4,0,4);
165  pt5Comp->setAxisTitle("Hardware Sign<<1|FR",1);
166  pt5Comp->setAxisTitle("Emulator Sign<<1|FR",2);
167 
168  //Monitor Elements for track variables
169  phiComp = ibooker.book2D("phiComp","Hardware Vs. Emulator Track #phi",32,0,32,32,0,32);
170  phiComp->setAxisTitle("Hardware #phi",1);
171  phiComp->setAxisTitle("Emulator #phi",2);
172  etaComp = ibooker.book2D("etaComp","Hardware Vs. Emulator Track #eta",32,0,32,32,0,32);
173  etaComp->setAxisTitle("Hardware #eta",1);
174  etaComp->setAxisTitle("Emulator #eta",2);
175  occComp = ibooker.book2D("occComp","Hardware Vs. Emulator Track Occupancy",5,0,5,5,0,5);
176  occComp->setAxisTitle("Hardware Occupancy",1);
177  occComp->setAxisTitle("Emulator Occupancy",2);
178  ptComp = ibooker.book2D("ptComp","Hardware Vs. Emulator Pt",32,0,32,32,0,32);
179  ptComp->setAxisTitle("Hardware P_{t}",1);
180  ptComp->setAxisTitle("Emulator P_{t}",2);
181  qualComp= ibooker.book2D("qualComp","Hardware Vs. Emulator Quality",4,0,4,4,0,4);
182  qualComp->setAxisTitle("Hardware Quality",1);
183  qualComp->setAxisTitle("Emulator Quality",2);
184 
185 
186  //Monitor Elemens for Dt Stubs
187  dtStubPhi = ibooker.book2D("dtStubPhi","Hardware Vs. Emulator DT Stub #phi",200,400,2400,200,400,2400);
188  dtStubPhi->setAxisTitle("Hardware Stub #phi",1);
189  dtStubPhi->setAxisTitle("Emulator Stub #phi",2);
190  badDtStubSector = ibooker.book2D("badDtStubSector","Dt Sector for bad Dt stub #phi",6,1,7,2,1,3);
191  badDtStubSector->setAxisTitle("Dt stub sector, subsector",1);
192  badDtStubSector->setAxisTitle("Dt Stub Endcap",2);
193 
194  //***********************************//
195  //* F O R Q U A L I T Y T E S T *//
196  //***********************************//
197  //1D plots for the quality test
198  //Monitor Elements for Pt Lut Address Field
199  pt1Comp_1d = ibooker.book1D("pt1Comp_1d","Hardware Vs. Emulator #Delta #phi_{12}",2,0,2);
200  pt1Comp_1d->setAxisTitle("#Delta #phi_{12}",1);
201  pt1Comp_1d->setBinLabel(1, "Agree", 1);
202  pt1Comp_1d->setBinLabel(2, "Disagree", 1);
203 
204  pt2Comp_1d = ibooker.book1D("pt2Comp_1d","Hardware Vs. Emulator #Delta #phi_{23}",2,0,2);
205  pt2Comp_1d->setAxisTitle("#Delta #phi_{23}",1);
206  pt2Comp_1d->setBinLabel(1, "Agree", 1);
207  pt2Comp_1d->setBinLabel(2, "Disagree", 1);
208 
209  pt3Comp_1d = ibooker.book1D("pt3Comp_1d","Hardware Vs. Emulator #eta",2,0,2);
210  pt3Comp_1d->setAxisTitle("#eta",1);
211  pt3Comp_1d->setBinLabel(1, "Agree", 1);
212  pt3Comp_1d->setBinLabel(2, "Disagree", 1);
213 
214  pt4Comp_1d = ibooker.book1D("pt4Comp_1d","Hardware Vs. Emulator Mode",2,0,2);
215  pt4Comp_1d->setAxisTitle("Mode",1);
216  pt4Comp_1d->setBinLabel(1, "Agree", 1);
217  pt4Comp_1d->setBinLabel(2, "Disagree", 1);
218 
219  pt5Comp_1d = ibooker.book1D("pt5Comp_1d","Hardware Vs. Emulator Sign, FR",2,0,2);
220  pt5Comp_1d->setAxisTitle("Sign<<1|FR",1);
221  pt5Comp_1d->setBinLabel(1, "Agree", 1);
222  pt5Comp_1d->setBinLabel(2, "Disagree", 1);
223 
224 
225  //Monitor Elements for track variables
226  phiComp_1d = ibooker.book1D("phiComp_1d","Hardware Vs. Emulator Track #phi",2,0,2);
227  phiComp_1d->setAxisTitle("#phi",1);
228  phiComp_1d->setBinLabel(1, "Agree", 1);
229  phiComp_1d->setBinLabel(2, "Disagree", 1);
230 
231  etaComp_1d = ibooker.book1D("etaComp_1d","Hardware Vs. Emulator Track #eta",2,0,2);
232  etaComp_1d->setAxisTitle("#eta",1);
233  etaComp_1d->setBinLabel(1, "Agree", 1);
234  etaComp_1d->setBinLabel(2, "Disagree", 1);
235 
236  occComp_1d = ibooker.book1D("occComp_1d","Hardware Vs. Emulator Track Occupancy",2,0,2);
237  occComp_1d->setAxisTitle("Occupancy",1);
238  occComp_1d->setBinLabel(1, "Agree", 1);
239  occComp_1d->setBinLabel(2, "Disagree", 1);
240 
241  ptComp_1d = ibooker.book1D("ptComp_1d","Hardware Vs. Emulator Pt",2,0,2);
242  ptComp_1d->setAxisTitle("P_{t}",1);
243  ptComp_1d->setBinLabel(1, "Agree", 1);
244  ptComp_1d->setBinLabel(2, "Disagree", 1);
245 
246  qualComp_1d= ibooker.book1D("qualComp_1d","Hardware Vs. Emulator Quality",2,0,2);
247  qualComp_1d->setAxisTitle("Quality",1);
248  qualComp_1d->setBinLabel(1, "Agree", 1);
249  qualComp_1d->setBinLabel(2, "Disagree", 1);
250 
251  //Monitor Elemens for Dt Stubs
252  dtStubPhi_1d = ibooker.book1D("dtStubPhi_1d","Hardware Vs. Emulator DT Stub #phi",2,0,2);
253  dtStubPhi_1d->setAxisTitle("DT Stub #phi",1);
254  dtStubPhi_1d->setBinLabel(1, "Agree", 1);
255  dtStubPhi_1d->setBinLabel(2, "Disagree", 1);
256 }
257 
258 void L1TdeCSCTF::analyze(Event const& e, EventSetup const& es){
259  // Initialize Arrays
261  unsigned int nDataMuons = 0;
262  unsigned int nEmulMuons = 0;
263  int dataMuonArray[8][10], emuMuonArray[8][10];
264  for(int muon=0; muon<8; muon++)
265  {
266  for(int par=0; par<3; par++)
267  {
268  dataMuonArray[muon][par]=0;
269  emuMuonArray[muon][par] =0;
270  }
271  emuMuonArray[muon][3] =-1;
272  dataMuonArray[muon][3]=-1;
273 
274  emuMuonArray[muon][4]=7;
275  dataMuonArray[muon][4]=7;
276 
277  for(int par2=5; par2<10; par2++)
278  {
279  emuMuonArray[muon][par2]= -1;
280  dataMuonArray[muon][par2]= -1;
281  }
282  }
283  // Get Hardware information, and check output of PtLUT
285  if( !dataTrackProducer.isUninitialized())
286  {
287  Handle<L1CSCTrackCollection> tracks;
288  e.getByToken(dataTrackProducer,tracks);
289 
290  // check validity of input collection
291  if(!tracks.isValid()) {
292  LogWarning("L1TdeCSCTF")
293  << "\n No valid [data tracks] product found: "
294  << " L1CSCTrackCollection"
295  << endl;
296  return;
297  }
298 
299 
300  for(L1CSCTrackCollection::const_iterator trk=tracks.product()->begin(); trk!=tracks.product()->end(); trk++)
301  {
302  if (nDataMuons>=8)
303  break;
304  if ( (trk->first.BX() <2) && (trk->first.BX() > -1) )
305  {
306  //int mOdE = (trk->first.ptLUTAddress()>>16)&0xf;
307  //cout << "D->Mode: " << mOdE << ", Rank " << trk->first.rank() << endl;
308  dataMuonArray[nDataMuons][0] = trk->first.ptLUTAddress();
309  dataMuonArray[nDataMuons][1] = trk->first.sector();
310  dataMuonArray[nDataMuons][2] = trk->first.endcap();
311  dataMuonArray[nDataMuons][8] = trk->first.outputLink();
312  dataMuonArray[nDataMuons][4] = trk->first.BX();
313  dataMuonArray[nDataMuons][5] = trk->first.rank();
314  dataMuonArray[nDataMuons][6] = trk->first.localPhi();
315  dataMuonArray[nDataMuons][7] = trk->first.eta_packed();
316  dataMuonArray[nDataMuons][9] = trk->first.modeExtended();
317  nDataMuons++;
318  }
319  }
320  }
321  // Get Emulator information
323  if( !emulTrackProducer.isUninitialized() )
324  {
325  Handle<L1CSCTrackCollection> tracks;
326  e.getByToken(emulTrackProducer,tracks);
327 
328  // check validity of input collection
329  if(!tracks.isValid()) {
330  LogWarning("L1TdeCSCTF")
331  << "\n No valid [emulator tracks] product found: "
332  << " L1CSCTrackCollection"
333  << endl;
334  return;
335  }
336 
337  for(L1CSCTrackCollection::const_iterator trk=tracks.product()->begin(); trk!=tracks.product()->end(); trk++)
338  {
339  if(nEmulMuons>=8)
340  break;
341  if((trk->first.BX() <2) && (trk->first.BX() >-1))
342  {
343  //int mOdE = (trk->first.ptLUTAddress()>>16)&0xf;
344  //cout << "E->Mode: " << mOdE << ", Rank " << trk->first.rank() << endl;
345  emuMuonArray[nEmulMuons][0] = trk->first.ptLUTAddress();
346  emuMuonArray[nEmulMuons][1] = trk->first.sector();
347  emuMuonArray[nEmulMuons][2] = trk->first.endcap();
348  emuMuonArray[nEmulMuons][4] = trk->first.BX();
349  emuMuonArray[nEmulMuons][5] = trk->first.rank();
350  emuMuonArray[nEmulMuons][6] = trk->first.localPhi();
351  emuMuonArray[nEmulMuons][7] = trk->first.eta_packed();
352  emuMuonArray[nEmulMuons][9] = trk->first.modeExtended();
353  nEmulMuons++;
354  }
355  }
356  }
357  //Fill Occupancy M.E.
358  if( (nDataMuons!=0)||(nEmulMuons!=0) ) {
359  occComp->Fill(nDataMuons,nEmulMuons);
360  (nDataMuons==nEmulMuons) ? occComp_1d->Fill(0) : occComp_1d->Fill(1);
361  }
362  // Match Tracks by sector & mode in the case of multiple tracks
364  if(nDataMuons==nEmulMuons)
365  {
366  //First, find EXACT address matches in a given sector, endcap
367  for(unsigned int mu1=0; mu1<nDataMuons; mu1++)
368  {
369  for(unsigned int mu2=0; mu2<nEmulMuons; mu2++)
370  if((emuMuonArray[mu2][1]==dataMuonArray[mu1][1])&&(emuMuonArray[mu2][2]==dataMuonArray[mu1][2]))
371  {
372  if(emuMuonArray[mu2][0]==dataMuonArray[mu1][0])
373  {
374  emuMuonArray[mu2][3]=mu1;
375  dataMuonArray[mu1][3]=1;
376  }
377  }
378  }
379  //Next, try to match unmapped
380  for(unsigned int c2a=0; c2a<nEmulMuons; c2a++)
381  {
382  if(emuMuonArray[c2a][3]==-1)
383  {
384  for(unsigned int cor_a=0; cor_a<nDataMuons; cor_a++)
385  {
386  if( (dataMuonArray[cor_a][1]==emuMuonArray[c2a][1]) && (dataMuonArray[cor_a][2]==emuMuonArray[c2a][2]))// && (dataMuonArray[cor_a][3]==-1))
387  {
388  emuMuonArray[c2a][3]=cor_a;
389  dataMuonArray[cor_a][3]=1;
390  }
391  }
392  }
393  }
394  //Check that a single emulator track is not mapped to multiple data tracks
395  bool multiMap = false;
396  if(nEmulMuons>1)
397  {
398  for(unsigned int c1a=0; c1a<(nEmulMuons-1); c1a++)
399  {
400  for(unsigned int c1b=(c1a+1); c1b<nEmulMuons; c1b++)
401  {
402  if(emuMuonArray[c1a][3]==emuMuonArray[c1b][3])
403  {
404  //cout << "Error: Multiple Emulator Muons Mapped to the same Data Muon." << endl;
405  multiMap = true;
406  break;
407  }
408  }
409  if (multiMap)
410  break;
411  }
412  }
413  //Fill histograms based on matched Tracks
414  for(unsigned int mu3=0; mu3<nEmulMuons; mu3++)
415  {
416  int mapping = emuMuonArray[mu3][3];
417  if((mapping!=-1)&&(multiMap==false))
418  {
419  //Decode LUT Address for more meaningful comparison
420  int emuPhi12 = (0x0000ff & emuMuonArray[mu3][0]);
421  int datPhi12 = (0x0000ff & dataMuonArray[mapping][0]);
422  int emuPhi23 = (0x000f00 & emuMuonArray[mu3][0])>>8;
423  int datPhi23 = (0x000f00 & dataMuonArray[mapping][0])>>8;
424  int emuEta = (0x00f000 & emuMuonArray[mu3][0])>>12;
425  int datEta = (0x00f000 & dataMuonArray[mapping][0])>>12;
426  //int emuMode = (0x0f0000 & emuMuonArray[mu3][0])>>16;
427  //int datMode = (0x0f0000 & dataMuonArray[mapping][0])>>16;
428  int emuFrSin = (0xf00000 & emuMuonArray[mu3][0])>>20;
429  int datFrSin = (0xf00000 & dataMuonArray[mapping][0])>>20;
430  //Decode Rank for more meaningful comparison
431  int emuQual = emuMuonArray[mu3][5]>>5;
432  int datQual = dataMuonArray[mapping][5]>>5;
433  int emuPt = 0x1f & emuMuonArray[mu3][5];
434  int datPt = 0x1f & dataMuonArray[mapping][5];
435  int emuModeExtended = emuMuonArray[mu3][9];
436  int datModeExtended = dataMuonArray[mapping][9];
437 
438  //Fill mode M.E., one of (the most important) PtLUT address field
439  pt4Comp->Fill(datModeExtended,emuModeExtended);
440  (datModeExtended==emuModeExtended) ? pt4Comp_1d->Fill(0) : pt4Comp_1d->Fill(1);
441  //To disentagle problems, only fill histograms if mode matches
442  if(emuModeExtended==datModeExtended)
443  {
444  //Fill Pt LUT address field M.E.
445  pt1Comp->Fill(datPhi12,emuPhi12); (datPhi12==emuPhi12) ? pt1Comp_1d->Fill(0) : pt1Comp_1d->Fill(1);
446  pt2Comp->Fill(datPhi23,emuPhi23); (datPhi23==emuPhi23) ? pt2Comp_1d->Fill(0) : pt2Comp_1d->Fill(1);
447  pt3Comp->Fill(datEta,emuEta); (datEta==emuEta) ? pt3Comp_1d->Fill(0) : pt3Comp_1d->Fill(1);
448  pt5Comp->Fill(datFrSin,emuFrSin); (datFrSin==emuFrSin) ? pt5Comp_1d->Fill(0) : pt5Comp_1d->Fill(1);
449  //Fill Track value M.E.
450  if(dataMuonArray[mapping][8]==1) //Rank Comparison available for Link 1 only due to readout limitation
451  {
452  ptComp->Fill(datPt,emuPt); (datPt==emuPt) ? ptComp_1d->Fill(0) : ptComp_1d->Fill(1);
453  qualComp->Fill(datQual,emuQual);(datQual==emuQual) ? qualComp_1d->Fill(0) : qualComp_1d->Fill(1);
454  }
455  phiComp->Fill(dataMuonArray[mapping][6],emuMuonArray[mu3][6]);
456  etaComp->Fill(dataMuonArray[mapping][7],emuMuonArray[mu3][7]);
457 
458  (dataMuonArray[mapping][6]==emuMuonArray[mu3][6]) ? phiComp_1d->Fill(0) : phiComp_1d->Fill(1);
459  (dataMuonArray[mapping][7]==emuMuonArray[mu3][7]) ? etaComp_1d->Fill(0) : etaComp_1d->Fill(1);
460  }
461  }
462  }
463  }
464 
465  //Compare DT stubs to check transmission quality
467  //Declare arrays, initialize
468  int eDtStub[7][15];
469  int dDtStub[8][15];
470  int eDtCounter = 0;
471  int dDtCounter = 0;
472  for(int dJ=0; dJ<7; dJ++)
473  {
474  for(int dK=0; dK<15; dK++)
475  {
476  eDtStub[dJ][dK] = -55;
477  dDtStub[dJ][dK] = -55;
478  dDtStub[7][dK] = -55;
479  }
480  }
481 
482  // Get Daq Recorded Stub Information
483  if( !dataStubProducer.isUninitialized() )
484  {
485  Handle<CSCTriggerContainer<csctf::TrackStub> > dtTrig;
486  e.getByToken(dataStubProducer,dtTrig);
487  // check validity of input collection
488  if(!dtTrig.isValid()) {
489  LogWarning("L1TdeCSCTF")
490  << "\n No valid [Data Stubs] product found: "
491  << " L1CSCTrackCollection"
492  << endl;
493  return;
494  }
495  const CSCTriggerContainer<csctf::TrackStub>* dt_stubs = dtTrig.product();
496  CSCTriggerContainer<csctf::TrackStub> stub_list;
497  stub_list.push_many(*dt_stubs);
498  vector<csctf::TrackStub> stuList = stub_list.get();
499  vector<csctf::TrackStub>::const_iterator stu= stuList.begin();
500  for(; stu!=stuList.end(); stu++)
501  {
502  if(dDtCounter>=15)
503  break;
504  if((stu->BX()>4) && (stu->BX()<9))
505  {
506  dDtStub[0][dDtCounter] = stu->phiPacked();
507  dDtStub[1][dDtCounter] = stu->getQuality();
508  dDtStub[2][dDtCounter] = stu->endcap();
509  dDtStub[3][dDtCounter] = stu->sector();
510  dDtStub[4][dDtCounter] = stu->subsector();
511  dDtCounter++;
512  }
513  }
514  }
515 
516  // Get Daq Recorded Stub Information
517  if( !emulStubProducer.isUninitialized() )
518  {
519  // Get Emulated Stub Information
520  Handle<L1MuDTChambPhContainer> pCon;
521  e.getByToken(emulStubProducer,pCon);
522  // check validity of input collection
523  if(!pCon.isValid()) {
524  LogWarning("L1TdeCSCTF")
525  << "\n No valid [Data Stubs] product found: "
526  << " L1CSCTrackCollection"
527  << endl;
528  return;
529  }
530  CSCTriggerContainer<csctf::TrackStub> emulStub = my_dtrc->process(pCon.product());
531  vector<csctf::TrackStub> emuList = emulStub.get();
532  vector<csctf::TrackStub>::const_iterator eStu=emuList.begin();
533  for(; eStu!=emuList.end(); eStu++)
534  {
535  if (eDtCounter>=15)
536  break;
537  if((eStu->BX()>4) && (eStu->BX()<9) )
538  {
539  eDtStub[0][eDtCounter] = eStu->phiPacked();
540  eDtStub[1][eDtCounter] = eStu->getQuality();
541  eDtStub[2][eDtCounter] = eStu->endcap();
542  eDtStub[3][eDtCounter] = eStu->sector();
543  eDtStub[4][eDtCounter] = eStu->subsector();
544  eDtCounter++;
545  }
546  }
547  }
548 
549  //cout << "Num Tracks match eDtCounter: " << eDtCounter << ", dDt: " << dDtCounter << endl;
550  //First find perfect matches
551  for(int eS=0; eS<eDtCounter; eS++)
552  {
553  //cout << "es Loop" << endl;
554  for(int dS=0; dS<dDtCounter; dS++)
555  {
556  //cout << "ds Loop" << endl;
557  if(eDtStub[2][eS]==dDtStub[2][dS])
558  {
559  //cout << "end match" << endl;
560  if(eDtStub[3][eS]==dDtStub[3][dS])
561  {
562  //cout << "sec match" << endl;
563  if(eDtStub[4][eS]==dDtStub[4][dS])
564  {
565  //cout << "First match loop, eS: " << eS << ", dS" << dS << endl;
566  if( (eDtStub[0][eS]==dDtStub[0][dS]) && (eDtStub[1][eS]==dDtStub[1][dS]) && (eDtStub[6][eS]!=1) && (dDtStub[6][dS]!=1) )
567  {
568  //cout << "Passed fist matching." << endl;
569  eDtStub[5][eS] = dS;
570  eDtStub[6][eS] = 1;
571  dDtStub[5][dS] = eS;
572  dDtStub[6][dS] = 1;
573  }
574  }
575  }
576  }
577  }
578  }
579 
580  //Now find imperfect matches
581  for(int eS2=0; eS2<eDtCounter; eS2++)
582  {
583  for(int dS2=0; dS2<dDtCounter; dS2++)
584  {
585  //cout << "1: " << eDtStub[2][eS2] << ", " << dDtStub[2][dS2] << ", " << eDtStub[3][eS2] << ", " << dDtStub[3][dS2] << ", " << eDtStub[4][eS2] << ", " << dDtStub[4][dS2] << endl;
586  if( (eDtStub[2][eS2]==dDtStub[2][dS2]) && (eDtStub[3][eS2]==dDtStub[3][dS2]) && (eDtStub[4][eS2]==dDtStub[4][dS2]) )
587  {
588  //cout << "2: " << dDtStub[7][eS2] << ", " << dDtStub[7][dS2] << ", " << abs(eDtStub[0][eS2]-dDtStub[0][dS2]) << ", " << ", " << eDtStub[6][eS2] << ", " << dDtStub[6][dS2] << endl;
589  if( ((dDtStub[7][eS2]==-55) || (dDtStub[7][dS2]>(abs(eDtStub[0][eS2]-dDtStub[0][dS2]))) ) && (eDtStub[6][eS2]!=1) && (dDtStub[6][dS2]!=1) )
590  {
591  //cout << "Imperfect match found" << endl;
592  dDtStub[5][dS2] = eS2;
593  dDtStub[6][dS2] = 2;
594  eDtStub[5][eS2] = dS2;
595  eDtStub[6][eS2] = 2;
596  dDtStub[7][dS2] = abs(eDtStub[0][eS2]-dDtStub[0][dS2]);
597  }
598  }
599  }
600  }
601 
602  //Debug time!
603  bool dtSMulti = false;
604  int dtUnmap = 0;
605  if(eDtCounter>1)
606  for(int eS3a=0; eS3a<eDtCounter-1; eS3a++)
607  for(int eS3b=eS3a+1; eS3b<eDtCounter; eS3b++)
608  {
609  if( eDtStub[5][eS3a]==eDtStub[5][eS3b] ) dtSMulti=true;
610  if( eDtStub[5][eS3a]==-55 || eDtStub[5][eS3b]==-55 ) dtUnmap++;
611  }
612 
613  if(dDtCounter>1)
614  for(int dS3a=0; dS3a<dDtCounter-1; dS3a++)
615  for(int dS3b=dS3a+1; dS3b<dDtCounter; dS3b++)
616  {
617  if( dDtStub[5][dS3a]==dDtStub[5][dS3b] ) dtSMulti=true;
618  if( dDtStub[5][dS3a]==-55||dDtStub[5][dS3b]==-55 ) dtUnmap++;
619  }
620  /*if(dtSMulti==true)
621  cout << "Multiple DT stubs mapped to the same stub" << endl;
622  if(dtUnmap!=0)
623  cout << "Unmapped DT stubs:" << dtUnmap << endl;*/
624 
625  if(dtSMulti==false && dtUnmap==0)
626  {
627  for(int phil=0; phil<eDtCounter; phil++)
628  {
629  if(eDtStub[6][phil]==1 || eDtStub[6][phil]==2)
630  {
631  int indexFil = eDtStub[3][phil]*2+eDtStub[4][phil]-1;
632  dtStubPhi->Fill(eDtStub[0][phil], dDtStub[0][ eDtStub[5][phil] ]);
633  (eDtStub[0][phil] == dDtStub[0][ eDtStub[5][phil] ]) ? dtStubPhi_1d->Fill(0) : dtStubPhi_1d->Fill(1);
634  if( eDtStub[0][phil] != dDtStub[0][ eDtStub[5][phil] ])
635  badDtStubSector->Fill(indexFil,eDtStub[2][phil]);
636  }
637  }
638  }
639 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::empty
bool empty() const
Definition: ParameterSet.h:218
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
CSCTriggerContainer::get
std::vector< T > get() const
Definition: CSCTriggerContainer.h:78
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:508
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
L1TdeCSCTF::dqmBeginRun
void dqmBeginRun(edm::Run const &, edm::EventSetup const &) override
Definition: L1TdeCSCTF.cc:91
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
L1TdeCSCTF::analyze
void analyze(edm::Event const &e, edm::EventSetup const &iSetup) override
Definition: L1TdeCSCTF.cc:258
L1TdeCSCTF::L1TdeCSCTF
L1TdeCSCTF(edm::ParameterSet const &pset)
Definition: L1TdeCSCTF.cc:39
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
L1TdeCSCTF::beginLuminosityBlock
void beginLuminosityBlock(edm::LuminosityBlock const &, edm::EventSetup const &) override
Definition: L1TdeCSCTF.cc:94
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:74
CSCTriggerContainer::push_many
void push_many(const std::vector< T > &data)
Definition: CSCTriggerContainer.h:45
L1TdeCSCTF::bookHistograms
void bookHistograms(DQMStore::IBooker &ibooker, edm::Run const &, edm::EventSetup const &) override
Definition: L1TdeCSCTF.cc:97
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:277
edm::Handle::product
T const * product() const
Definition: Handle.h:81
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
edm
HLT enums.
Definition: AlignableModifier.h:17
GetRecoTauVFromDQM_MC_cff.outFile
outFile
Definition: GetRecoTauVFromDQM_MC_cff.py:20
taus_updatedMVAIds_cff.mapping
mapping
Definition: taus_updatedMVAIds_cff.py:29
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:955
edm::Run
Definition: Run.h:43
Generated for CMSSW Reference Manual by doxygen 1.8.11