CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
L1TCSCTF.cc
Go to the documentation of this file.
1 /*
2  * \file L1TCSCTF.cc
3  *
4  * \author J. Berryhill
5  *
6  */
7 
8 #include "DQM/L1TMonitor/interface/L1TCSCTF.h"
9 #include "DQMServices/Core/interface/DQMStore.h"
10 
11 // includes to fetch all reguired data products from the edm::Event
12 #include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigiCollection.h"
13 #include "DataFormats/L1CSCTrackFinder/interface/L1CSCTrackCollection.h"
14 #include "DataFormats/L1CSCTrackFinder/interface/L1CSCStatusDigiCollection.h"
15 #include "L1Trigger/CSCCommonTrigger/interface/CSCTriggerGeometry.h"
16 #include "Geometry/Records/interface/MuonGeometryRecord.h"
17 
18 #include "DataFormats/L1CSCTrackFinder/interface/CSCTriggerContainer.h"
19 #include "DataFormats/L1CSCTrackFinder/interface/TrackStub.h"
20 
21 
22 using namespace std;
23 using namespace edm;
24 
25 L1TCSCTF::L1TCSCTF(const ParameterSet& ps)
26 // if some piece of data is absent - configure corresponding source with 'null:'
27 // : csctfSource_( ps.getParameter< InputTag >("csctfSource") )
28  : gmtProducer( ps.getParameter< InputTag >("gmtProducer") ),
29  lctProducer( ps.getParameter< InputTag >("lctProducer") ),
30  trackProducer( ps.getParameter< InputTag >("trackProducer") ),
31  statusProducer( ps.getParameter< InputTag >("statusProducer") ),
32  mbProducer( ps.getParameter< InputTag >("mbProducer") )
33 {
34 
35  // verbosity switch
36  verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
37 
38  if(verbose_) edm::LogInfo("DataNotFound") << "L1TCSCTF: constructor...." << endl;
39 
40  outputFile_ = ps.getUntrackedParameter<string>("outputFile", "");
41  if ( outputFile_.size() != 0 )
42  {
43  edm::LogInfo("DataNotFound") << "L1T Monitoring histograms will be saved to " << outputFile_.c_str() << endl;
44  }
45 
46  bool disable = ps.getUntrackedParameter<bool>("disableROOToutput", false);
47  if(disable){
48  outputFile_="";
49  }
50 
51  gangedME11a_ = ps.getUntrackedParameter<bool>("gangedME11a", false);
52 
53  // instantiate standard on-fly SR LUTs from CSC TF emulator package
54  bzero(srLUTs_,sizeof(srLUTs_));
55  int endcap=1, sector=1; // assume SR LUTs are all same for every sector in either of endcaps
56  bool TMB07=true; // specific TMB firmware
57  // Create a dummy pset for SR LUTs
58  edm::ParameterSet srLUTset;
59  srLUTset.addUntrackedParameter<bool>("ReadLUTs", false);
60  srLUTset.addUntrackedParameter<bool>("Binary", false);
61  srLUTset.addUntrackedParameter<std::string>("LUTPath", "./");
62  for(int station=1,fpga=0; station<=4 && fpga<5; station++)
63  {
64  if(station==1)
65  for(int subSector=0; subSector<2 && fpga<5; subSector++)
66  srLUTs_[fpga++] = new CSCSectorReceiverLUT(endcap, sector, subSector+1, station, srLUTset, TMB07);
67  else
68  srLUTs_[fpga++] = new CSCSectorReceiverLUT(endcap, sector, 0, station, srLUTset, TMB07);
69  }
70 
71  //set Token(-s)
72  edm::InputTag statusTag_(statusProducer.label(),statusProducer.instance());
73  edm::InputTag corrlctsTag_(lctProducer.label(),lctProducer.instance());
74  edm::InputTag tracksTag_(trackProducer.label(),trackProducer.instance());
75  edm::InputTag dtStubsTag_(mbProducer.label(), mbProducer.instance());
76  edm::InputTag mbtracksTag_(trackProducer.label(),trackProducer.instance());
77 
78  gmtProducerToken_ = consumes<L1MuGMTReadoutCollection>(ps.getParameter< InputTag >("gmtProducer"));
79  statusToken_ = consumes<L1CSCStatusDigiCollection>(statusTag_);
80  corrlctsToken_ = consumes<CSCCorrelatedLCTDigiCollection>(corrlctsTag_);
81  tracksToken_ = consumes<L1CSCTrackCollection>(tracksTag_);
82  dtStubsToken_ = consumes<CSCTriggerContainer<csctf::TrackStub> >(dtStubsTag_);
83  mbtracksToken_ = consumes<L1CSCTrackCollection>(mbtracksTag_);
84 }
85 
86 L1TCSCTF::~L1TCSCTF()
87 {
88 
89  for(int i=0; i<5; i++)
90  delete srLUTs_[i]; //free the array of pointers
91 }
92 
93 void L1TCSCTF::dqmBeginRun(const edm::Run& r, const edm::EventSetup& c){
94 }
95 
96 void L1TCSCTF::bookHistograms(DQMStore::IBooker &ibooker, edm::Run const&, edm::EventSetup const&)
97 {
98  m_scalesCacheID = -999;
99  m_ptScaleCacheID = -999;
100 
101  nev_ = 0;
102  ibooker.setCurrentFolder("L1T/L1TCSCTF");
103 
104  // Error counting histogram:
105  // 1) checks TF data integrity (error rate - first bin),
106  // 2) monitors sychronization on input links (4 errors types: SE/SM/BX/AF; ORed for all time bins, links, and SPs),
107  // 3) reports FMM status (if in any SP FMM status != "Ready" - fill the last bin)
108  csctferrors = ibooker.book1D("CSCTF_errors","CSCTF Errors",6,0,6);
109  csctferrors->setAxisTitle("Error type",1);
110  csctferrors->setAxisTitle("Number of Errors",2);
111  csctferrors->setBinLabel(1,"Corruptions",1);
112  csctferrors->setBinLabel(2,"Synch. Err.",1);
113  csctferrors->setBinLabel(3,"Synch. Mod.",1);
114  csctferrors->setBinLabel(4,"BX mismatch",1);
115  csctferrors->setBinLabel(5,"Time misalign.",1);
116  csctferrors->setBinLabel(6,"FMM != Ready",1);
117 
118  // Occupancy histogram Eta x Y, where Y:
119  // 1) Phi_packed of input LCTs from 1st, 2nd, 3rd, and 4th stations
120  // 2) Phi_packed of output tracks
121  // (all 12 SPs - 360 degree coveradge)
122  csctfoccupancies = ibooker.book2D("CSCTF_occupancies", "CSCTF Occupancies", 64,-32,31,32,0,6.2);
123  csctfoccupancies->setAxisTitle("#eta",1);
124  csctfoccupancies->setAxisTitle("#phi",2);
125  csctfoccupancies->setBinLabel( 1,"-2.5", 1);
126  csctfoccupancies->setBinLabel( 8,"-2.1", 1);
127  csctfoccupancies->setBinLabel(18,"-1.6", 1);
128  csctfoccupancies->setBinLabel(26,"-1.2", 1);
129  csctfoccupancies->setBinLabel(32,"-0.9", 1);
130  csctfoccupancies->setBinLabel(33, "0.9", 1);
131  csctfoccupancies->setBinLabel(39, "1.2", 1);
132  csctfoccupancies->setBinLabel(47, "1.6", 1);
133  csctfoccupancies->setBinLabel(57, "2.1", 1);
134  csctfoccupancies->setBinLabel(64, "2.5", 1);
135 
136  // ... and for halo muons only
137  csctfoccupancies_H = ibooker.book2D("CSCTF_occupancies_H", "CSCTF Halo Occupancies", 64,-32,31,32,0,6.2);
138  csctfoccupancies_H->setAxisTitle("#eta",1);
139  csctfoccupancies_H->setAxisTitle("#phi",2);
140  csctfoccupancies_H->setBinLabel( 1,"-2.5", 1);
141  csctfoccupancies_H->setBinLabel( 8,"-2.1", 1);
142  csctfoccupancies_H->setBinLabel(18,"-1.6", 1);
143  csctfoccupancies_H->setBinLabel(26,"-1.2", 1);
144  csctfoccupancies_H->setBinLabel(32,"-0.9", 1);
145  csctfoccupancies_H->setBinLabel(33, "0.9", 1);
146  csctfoccupancies_H->setBinLabel(39, "1.2", 1);
147  csctfoccupancies_H->setBinLabel(47, "1.6", 1);
148  csctfoccupancies_H->setBinLabel(57, "2.1", 1);
149  csctfoccupancies_H->setBinLabel(64, "2.5", 1);
150 
151  //haloDelEta12 = ibooker.book1D("CSCTF_Halo_Eta12", "#Delta #eta_{12} for Halo Muons", 40, -0.20,0.30);
152  //haloDelEta112 = ibooker.book1D("CSCTF_Halo_Eta112","#Delta #eta_{112} for Halo Muons", 40, -0.20,0.30);
153  //haloDelEta13 = ibooker.book1D("CSCTF_Halo_Eta13", "#Delta #eta_{13} for Halo Muons", 40, -0.20,0.30);
154  //haloDelEta113 = ibooker.book1D("CSCTF_Halo_Eta113","#Delta #eta_{113} for Halo Muons", 40, -0.20,0.30);
155 
156  // Quality VS Mode
157  trackModeVsQ = ibooker.book2D("CSCTF_Track_ModeVsQual","CSC Track Mode Vs Quality", 19, -0.5, 18.5, 4, 0, 4);
158  trackModeVsQ->setAxisTitle("Track Type", 1);
159  trackModeVsQ->setBinLabel(1,"No Track",1);
160  trackModeVsQ->setBinLabel(2,"Bad Phi/Single",1);
161  trackModeVsQ->setBinLabel(3,"ME1-2-3",1);
162  trackModeVsQ->setBinLabel(4,"ME1-2-4",1);
163  trackModeVsQ->setBinLabel(5,"ME1-3-4",1);
164  trackModeVsQ->setBinLabel(6,"ME2-3-4",1);
165  trackModeVsQ->setBinLabel(7,"ME1-2",1);
166  trackModeVsQ->setBinLabel(8,"ME1-3",1);
167  trackModeVsQ->setBinLabel(9,"ME2-3",1);
168  trackModeVsQ->setBinLabel(10,"ME2-4",1);
169  trackModeVsQ->setBinLabel(11,"ME3-4",1);
170  trackModeVsQ->setBinLabel(12,"MB1-ME3",1);
171  trackModeVsQ->setBinLabel(13,"MB1-ME2",1);
172  trackModeVsQ->setBinLabel(14,"ME1-4",1);
173  trackModeVsQ->setBinLabel(15,"MB1-ME1",1);
174  trackModeVsQ->setBinLabel(16,"Halo Trigger",1);
175  trackModeVsQ->setBinLabel(17,"MB1-ME1-2",1);
176  trackModeVsQ->setBinLabel(18,"MB1-ME1-3",1);
177  trackModeVsQ->setBinLabel(19,"MB1-ME2-3",1);
178 
179  trackModeVsQ->setAxisTitle("Quality",2);
180  trackModeVsQ->setBinLabel(1,"0",2);
181  trackModeVsQ->setBinLabel(2,"1",2);
182  trackModeVsQ->setBinLabel(3,"2",2);
183  trackModeVsQ->setBinLabel(4,"3",2);
184 
185  // Mode
186  csctfTrackM = ibooker.book1D("CSCTF_Track_Mode","CSC Track Mode", 19, -0.5, 18.5);
187  csctfTrackM->setAxisTitle("Track Type", 1);
188  csctfTrackM->setBinLabel(1,"No Track",1);
189  csctfTrackM->setBinLabel(2,"Bad Phi/Single",1);
190  csctfTrackM->setBinLabel(3,"ME1-2-3",1);
191  csctfTrackM->setBinLabel(4,"ME1-2-4",1);
192  csctfTrackM->setBinLabel(5,"ME1-3-4",1);
193  csctfTrackM->setBinLabel(6,"ME2-3-4",1);
194  csctfTrackM->setBinLabel(7,"ME1-2",1);
195  csctfTrackM->setBinLabel(8,"ME1-3",1);
196  csctfTrackM->setBinLabel(9,"ME2-3",1);
197  csctfTrackM->setBinLabel(10,"ME2-4",1);
198  csctfTrackM->setBinLabel(11,"ME3-4",1);
199  csctfTrackM->setBinLabel(12,"MB1-ME3",1);
200  csctfTrackM->setBinLabel(13,"MB1-ME2",1);
201  csctfTrackM->setBinLabel(14,"ME1-4",1);
202  csctfTrackM->setBinLabel(15,"MB1-ME1",1);
203  csctfTrackM->setBinLabel(16,"Halo Trigger",1);
204  csctfTrackM->setBinLabel(17,"MB1-ME1-2",1);
205  csctfTrackM->setBinLabel(18,"MB1-ME1-3",1);
206  csctfTrackM->setBinLabel(19,"MB1-ME2-3",1);
207 
208  // Chamber Occupancy
209  csctfChamberOccupancies = ibooker.book2D("CSCTF_Chamber_Occupancies","CSCTF Chamber Occupancies", 54, -0.05, 5.35, 10, -5.5, 4.5);
210  csctfChamberOccupancies->setAxisTitle("Sector, (chambers 1-9 not labeled)",1);
211  csctfChamberOccupancies->setBinLabel(1,"ME-4",2);
212  csctfChamberOccupancies->setBinLabel(2,"ME-3",2);
213  csctfChamberOccupancies->setBinLabel(3,"ME-2",2);
214  csctfChamberOccupancies->setBinLabel(4,"ME-1b",2);
215  csctfChamberOccupancies->setBinLabel(5,"ME-1a",2);
216  csctfChamberOccupancies->setBinLabel(6,"ME+1a",2);
217  csctfChamberOccupancies->setBinLabel(7,"ME+1b",2);
218  csctfChamberOccupancies->setBinLabel(8,"ME+2",2);
219  csctfChamberOccupancies->setBinLabel(9,"ME+3",2);
220  csctfChamberOccupancies->setBinLabel(10,"ME+4",2);
221  csctfChamberOccupancies->setBinLabel(1, "1",1);
222  csctfChamberOccupancies->setBinLabel(10,"2",1);
223  csctfChamberOccupancies->setBinLabel(19,"3",1);
224  csctfChamberOccupancies->setBinLabel(28,"4",1);
225  csctfChamberOccupancies->setBinLabel(37,"5",1);
226  csctfChamberOccupancies->setBinLabel(46,"6",1);
227 
228  // Track Phi
229  csctfTrackPhi = ibooker.book1D("CSCTF_Track_Phi", "CSCTF Track #phi",144,0,2*M_PI);
230  csctfTrackPhi->setAxisTitle("Track #phi", 1);
231 
232  // Track Eta
233  csctfTrackEta = ibooker.book1D("CSCTF_Track_Eta", "CSCTF Track #eta",64,-32,32);
234  csctfTrackEta->setAxisTitle("Track #eta", 1);
235  csctfTrackEta->setBinLabel( 1,"-2.5", 1);
236  csctfTrackEta->setBinLabel( 8,"-2.1", 1);
237  csctfTrackEta->setBinLabel(18,"-1.6", 1);
238  csctfTrackEta->setBinLabel(26,"-1.2", 1);
239  csctfTrackEta->setBinLabel(32,"-0.9", 1);
240  csctfTrackEta->setBinLabel(33, "0.9", 1);
241  csctfTrackEta->setBinLabel(39, "1.2", 1);
242  csctfTrackEta->setBinLabel(47, "1.6", 1);
243  csctfTrackEta->setBinLabel(57, "2.1", 1);
244  csctfTrackEta->setBinLabel(64, "2.5", 1);
245 
246  // Track Eta Low Quality
247  csctfTrackEtaLowQ = ibooker.book1D("CSCTF_Track_Eta_LowQ", "CSCTF Track #eta LQ",64,-32,32);
248  csctfTrackEtaLowQ->setAxisTitle("Track #eta", 1);
249  csctfTrackEtaLowQ->setBinLabel( 1,"-2.5", 1);
250  csctfTrackEtaLowQ->setBinLabel( 8,"-2.1", 1);
251  csctfTrackEtaLowQ->setBinLabel(18,"-1.6", 1);
252  csctfTrackEtaLowQ->setBinLabel(26,"-1.2", 1);
253  csctfTrackEtaLowQ->setBinLabel(32,"-0.9", 1);
254  csctfTrackEtaLowQ->setBinLabel(33, "0.9", 1);
255  csctfTrackEtaLowQ->setBinLabel(39, "1.2", 1);
256  csctfTrackEtaLowQ->setBinLabel(47, "1.6", 1);
257  csctfTrackEtaLowQ->setBinLabel(57, "2.1", 1);
258  csctfTrackEtaLowQ->setBinLabel(64, "2.5", 1);
259 
260 
261  // Track Eta High Quality
262  csctfTrackEtaHighQ = ibooker.book1D("CSCTF_Track_Eta_HighQ", "CSCTF Track #eta HQ",64,-32,32);
263  csctfTrackEtaHighQ->setAxisTitle("Track #eta", 1);
264  csctfTrackEtaHighQ->setBinLabel( 1,"-2.5", 1);
265  csctfTrackEtaHighQ->setBinLabel( 8,"-2.1", 1);
266  csctfTrackEtaHighQ->setBinLabel(18,"-1.6", 1);
267  csctfTrackEtaHighQ->setBinLabel(26,"-1.2", 1);
268  csctfTrackEtaHighQ->setBinLabel(32,"-0.9", 1);
269  csctfTrackEtaHighQ->setBinLabel(33, "0.9", 1);
270  csctfTrackEtaHighQ->setBinLabel(39, "1.2", 1);
271  csctfTrackEtaHighQ->setBinLabel(47, "1.6", 1);
272  csctfTrackEtaHighQ->setBinLabel(57, "2.1", 1);
273  csctfTrackEtaHighQ->setBinLabel(64, "2.5", 1);
274 
275 
276  // Halo Phi
277  csctfTrackPhi_H = ibooker.book1D("CSCTF_Track_Phi_H", "CSCTF Halo #phi",144,0,2*M_PI);
278  csctfTrackPhi_H->setAxisTitle("Track #phi", 1);
279 
280  // Halo Eta
281  csctfTrackEta_H = ibooker.book1D("CSCTF_Track_Eta_H", "CSCTF Halo #eta",64,-32,32);
282  csctfTrackEta_H->setAxisTitle("Track #eta", 1);
283  csctfTrackEta_H->setBinLabel( 1,"-2.5", 1);
284  csctfTrackEta_H->setBinLabel( 8,"-2.1", 1);
285  csctfTrackEta_H->setBinLabel(18,"-1.6", 1);
286  csctfTrackEta_H->setBinLabel(26,"-1.2", 1);
287  csctfTrackEta_H->setBinLabel(32,"-0.9", 1);
288  csctfTrackEta_H->setBinLabel(33, "0.9", 1);
289  csctfTrackEta_H->setBinLabel(39, "1.2", 1);
290  csctfTrackEta_H->setBinLabel(47, "1.6", 1);
291  csctfTrackEta_H->setBinLabel(57, "2.1", 1);
292  csctfTrackEta_H->setBinLabel(64, "2.5", 1);
293 
294  // Track Timing
295  csctfbx = ibooker.book2D("CSCTF_bx","CSCTF BX", 12,1,13, 7,-3,3) ;
296  csctfbx->setAxisTitle("Sector (Endcap)", 1);
297  csctfbx->setBinLabel( 1," 1 (+)",1);
298  csctfbx->setBinLabel( 2," 2 (+)",1);
299  csctfbx->setBinLabel( 3," 3 (+)",1);
300  csctfbx->setBinLabel( 4," 4 (+)",1);
301  csctfbx->setBinLabel( 5," 5 (+)",1);
302  csctfbx->setBinLabel( 6," 6 (+)",1);
303  csctfbx->setBinLabel( 7," 7 (-)",1);
304  csctfbx->setBinLabel( 8," 8 (-)",1);
305  csctfbx->setBinLabel( 9," 9 (-)",1);
306  csctfbx->setBinLabel(10,"10 (-)",1);
307  csctfbx->setBinLabel(11,"11 (-)",1);
308  csctfbx->setBinLabel(12,"12 (-)",1);
309 
310  csctfbx->setAxisTitle("CSCTF BX", 2);
311  csctfbx->setBinLabel( 1, "-3", 2);
312  csctfbx->setBinLabel( 2, "-2", 2);
313  csctfbx->setBinLabel( 3, "-1", 2);
314  csctfbx->setBinLabel( 4, "-0", 2);
315  csctfbx->setBinLabel( 5, " 1", 2);
316  csctfbx->setBinLabel( 6, " 2", 2);
317  csctfbx->setBinLabel( 7, " 3", 2);
318 
319  // Halo Timing
320  csctfbx_H = ibooker.book2D("CSCTF_bx_H","CSCTF HALO BX", 12,1,13, 7,-3,3) ;
321  csctfbx_H->setAxisTitle("Sector (Endcap)", 1);
322  csctfbx_H->setBinLabel( 1," 1 (+)",1);
323  csctfbx_H->setBinLabel( 2," 2 (+)",1);
324  csctfbx_H->setBinLabel( 3," 3 (+)",1);
325  csctfbx_H->setBinLabel( 4," 4 (+)",1);
326  csctfbx_H->setBinLabel( 5," 5 (+)",1);
327  csctfbx_H->setBinLabel( 6," 6 (+)",1);
328  csctfbx_H->setBinLabel( 7," 7 (-)",1);
329  csctfbx_H->setBinLabel( 8," 8 (-)",1);
330  csctfbx_H->setBinLabel( 9," 9 (-)",1);
331  csctfbx_H->setBinLabel(10,"10 (-)",1);
332  csctfbx_H->setBinLabel(11,"11 (-)",1);
333  csctfbx_H->setBinLabel(12,"12 (-)",1);
334 
335  csctfbx_H->setAxisTitle("CSCTF BX", 2);
336  csctfbx_H->setBinLabel( 1, "-3", 2);
337  csctfbx_H->setBinLabel( 2, "-2", 2);
338  csctfbx_H->setBinLabel( 3, "-1", 2);
339  csctfbx_H->setBinLabel( 4, "-0", 2);
340  csctfbx_H->setBinLabel( 5, " 1", 2);
341  csctfbx_H->setBinLabel( 6, " 2", 2);
342  csctfbx_H->setBinLabel( 7, " 3", 2);
343 
344  // Number of Tracks Stubs
345  cscTrackStubNumbers = ibooker.book1D("CSCTF_TrackStubs", "Number of Stubs in CSCTF Tracks", 5, 0, 5);
346  cscTrackStubNumbers->setBinLabel( 1, "0", 1);
347  cscTrackStubNumbers->setBinLabel( 2, "1", 1);
348  cscTrackStubNumbers->setBinLabel( 3, "2", 1);
349  cscTrackStubNumbers->setBinLabel( 4, "3", 1);
350  cscTrackStubNumbers->setBinLabel( 5, "4", 1);
351 
352  // Number of Tracks
353  csctfntrack = ibooker.book1D("CSCTF_ntrack","Number of CSCTracks found per event", 5, 0, 5 ) ;
354  csctfntrack->setBinLabel( 1, "0", 1);
355  csctfntrack->setBinLabel( 2, "1", 1);
356  csctfntrack->setBinLabel( 3, "2", 1);
357  csctfntrack->setBinLabel( 4, "3", 1);
358  csctfntrack->setBinLabel( 5, "4", 1);
359  //}
360 
361  char hname [200];
362  char htitle[200];
363 
364  for(int i=0; i<12; i++) {
365 
366  sprintf(hname ,"DTstubsTimeTrackMenTimeArrival_%d",i+1);
367  sprintf(htitle,"T_{track} - T_{DT stub} sector %d",i+1);
368 
369  DTstubsTimeTrackMenTimeArrival[i] = ibooker.book2D(hname,htitle, 7,-3,3, 2,1,3);
370  DTstubsTimeTrackMenTimeArrival[i]->getTH2F()->SetMinimum(0);
371 
372  // axis makeup
373  DTstubsTimeTrackMenTimeArrival[i]->setAxisTitle("bx_{CSC track} - bx_{DT stub}",1);
374  DTstubsTimeTrackMenTimeArrival[i]->setAxisTitle("subsector",2);
375 
376  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(1,"-3",1);
377  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(2,"-2",1);
378  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(3,"-1",1);
379  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(4, "0",1);
380  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(5,"+1",1);
381  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(6,"+2",1);
382  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(7,"+3",1);
383 
384  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(1,"sub1",2);
385  DTstubsTimeTrackMenTimeArrival[i]->setBinLabel(2,"sub2",2);
386 
387  }
388 
389 
390  // NEW: CSC EVENT LCT PLOTS
391  csctflcts = ibooker.book2D("CSCTF_LCT", "CSCTF LCTs", 12,1,13, 18,0,18);
392  csctflcts->setAxisTitle("CSCTF LCT BX",1);
393  csctflcts->setBinLabel(1,"1",1);
394  csctflcts->setBinLabel(2,"2",1);
395  csctflcts->setBinLabel(3,"3",1);
396  csctflcts->setBinLabel(4,"4",1);
397  csctflcts->setBinLabel(5,"5",1);
398  csctflcts->setBinLabel(6,"6",1);
399  csctflcts->setBinLabel(7,"7",1);
400  csctflcts->setBinLabel(8,"8",1);
401  csctflcts->setBinLabel(9,"9",1);
402  csctflcts->setBinLabel(10,"10",1);
403  csctflcts->setBinLabel(11,"11",1);
404  csctflcts->setBinLabel(12,"12",1);
405 
406  int ihist = 0;
407  for (int iEndcap = 0; iEndcap < 2; iEndcap++) {
408  for (int iStation = 1; iStation < 5; iStation++) {
409  for (int iRing = 1; iRing < 4; iRing++) {
410  if (iStation != 1 && iRing > 2) continue;
411  TString signEndcap="+";
412  if(iEndcap==0) signEndcap="-";
413 
414  char lcttitle[200];
415  snprintf(lcttitle,200,"ME%s%d/%d", signEndcap.Data(), iStation, iRing);
416  if(ihist<=8){
417  csctflcts -> setBinLabel(9-ihist,lcttitle,2);
418  }
419  else csctflcts -> setBinLabel(ihist+1,lcttitle,2);
420 
421  ihist++;
422  }
423  }
424  }
425 
426 
427  // plots for ME1/1 chambers
428  me11_lctStrip = ibooker.book1D("CSC_ME11_LCT_Strip", "CSC_ME11_LCT_Strip", 223, 0, 223);
429  me11_lctStrip->setAxisTitle("Cathode HalfStrip, ME1/1", 1);
430 
431  me11_lctWire = ibooker.book1D("CSC_ME11_LCT_Wire", "CSC_ME11_LCT_Wire", 112, 0, 112);
432  me11_lctWire->setAxisTitle("Anode Wiregroup, ME1/1", 1);
433 
434  me11_lctLocalPhi = ibooker.book1D("CSC_ME11_LCT_LocalPhi", "CSC_ME11_LCT_LocalPhi", 200,0,1024);
435  me11_lctLocalPhi ->setAxisTitle("LCT Local #it{#phi}, ME1/1", 1);
436 
437  me11_lctPackedPhi = ibooker.book1D("CSC_ME11_LCT_PackedPhi", "CSC_ME11_LCT_PackedPhi", 200,0,4096);
438  me11_lctPackedPhi ->setAxisTitle("LCT Packed #it{#phi}, ME1/1",1);
439 
440  me11_lctGblPhi = ibooker.book1D("CSC_ME11_LCT_GblPhi", "CSC_ME11_LCT_GblPhi", 200, 0, 2*M_PI);
441  me11_lctGblPhi ->setAxisTitle("LCT Global #it{#phi}, ME1/1", 1);
442 
443  me11_lctGblEta = ibooker.book1D("CSC_ME11_LCT_GblEta", "CSC_ME11_LCT_GblEta", 50, 0.9, 2.5);
444  me11_lctGblEta ->setAxisTitle("LCT Global #eta, ME1/1", 1);
445 
446 
447  // plots for ME4/2 chambers
448  me42_lctGblPhi = ibooker.book1D("CSC_ME42_LCT_GblPhi", "CSC_ME42_LCT_GblPhi", 200, 0, 2*M_PI);
449  me42_lctGblPhi ->setAxisTitle("LCT Global #it{#phi}, ME4/2", 1);
450 
451  me42_lctGblEta = ibooker.book1D("CSC_ME42_LCT_GblEta", "CSC_ME42_LCT_GblEta", 50, 0.9, 2.5);
452  me42_lctGblEta ->setAxisTitle("LCT Global #eta, ME4/2", 1);
453 
454  //
455  csc_strip_MEplus11= ibooker.book2D("csc_strip_MEplus11", "csc_strip_MEplus11", 36,1,37, 240,0,240);
456  csc_strip_MEplus11->setAxisTitle("Cathode HalfStrip", 2);
457  csc_strip_MEplus11->setAxisTitle("ME+1/1", 1);
458  csc_strip_MEplus12= ibooker.book2D("csc_strip_MEplus12", "csc_strip_MEplus12", 36,1,37, 240,0,240);
459  csc_strip_MEplus12->setAxisTitle("Cathode HalfStrip", 2);
460  csc_strip_MEplus12->setAxisTitle("ME+1/2", 1);
461  csc_strip_MEplus13= ibooker.book2D("csc_strip_MEplus13", "csc_strip_MEplus13", 36,1,37, 240,0,240);
462  csc_strip_MEplus13->setAxisTitle("Cathode HalfStrip", 2);
463  csc_strip_MEplus13->setAxisTitle("ME+1/3", 1);
464  csc_strip_MEplus21= ibooker.book2D("csc_strip_MEplus21", "csc_strip_MEplus21", 18,1,19, 240,0,240);
465  csc_strip_MEplus21->setAxisTitle("Cathode HalfStrip", 2);
466  csc_strip_MEplus21->setAxisTitle("ME+2/1", 1);
467  csc_strip_MEplus22= ibooker.book2D("csc_strip_MEplus22", "csc_strip_MEplus22", 36,1,37, 240,0,240);
468  csc_strip_MEplus22->setAxisTitle("Cathode HalfStrip", 2);
469  csc_strip_MEplus22->setAxisTitle("ME+2/2", 1);
470  csc_strip_MEplus31= ibooker.book2D("csc_strip_MEplus31", "csc_strip_MEplus31", 18,1,19, 240,0,240);
471  csc_strip_MEplus31->setAxisTitle("Cathode HalfStrip", 2);
472  csc_strip_MEplus31->setAxisTitle("ME+3/1", 1);
473  csc_strip_MEplus32= ibooker.book2D("csc_strip_MEplus32", "csc_strip_MEplus32", 36,1,37, 240,0,240);
474  csc_strip_MEplus32->setAxisTitle("Cathode HalfStrip", 2);
475  csc_strip_MEplus32->setAxisTitle("ME+3/2", 1);
476  csc_strip_MEplus41= ibooker.book2D("csc_strip_MEplus41", "csc_strip_MEplus41", 18,1,19, 240,0,240);
477  csc_strip_MEplus41->setAxisTitle("Cathode HalfStrip", 2);
478  csc_strip_MEplus41->setAxisTitle("ME+4/1", 1);
479  csc_strip_MEplus42= ibooker.book2D("csc_strip_MEplus42", "csc_strip_MEplus42", 36,1,37, 240,0,240);
480  csc_strip_MEplus42->setAxisTitle("Cathode HalfStrip", 2);
481  csc_strip_MEplus42->setAxisTitle("ME+4/2", 1);
482 
483  csc_strip_MEminus11= ibooker.book2D("csc_strip_MEminus11", "csc_strip_MEminus11", 36,1,37, 240,0,240);
484  csc_strip_MEminus11->setAxisTitle("Cathode HalfStrip", 2);
485  csc_strip_MEminus11->setAxisTitle("ME-1/1", 1);
486  csc_strip_MEminus12= ibooker.book2D("csc_strip_MEminus12", "csc_strip_MEminus12", 36,1,37, 240,0,240);
487  csc_strip_MEminus12->setAxisTitle("Cathode HalfStrip", 2);
488  csc_strip_MEminus12->setAxisTitle("ME-1/2", 1);
489  csc_strip_MEminus13= ibooker.book2D("csc_strip_MEminus13", "csc_strip_MEminus13", 36,1,37, 240,0,240);
490  csc_strip_MEminus13->setAxisTitle("Cathode HalfStrip", 2);
491  csc_strip_MEminus13->setAxisTitle("ME-1/3", 1);
492  csc_strip_MEminus21= ibooker.book2D("csc_strip_MEminus21", "csc_strip_MEminus21", 18,1,19, 240,0,240);
493  csc_strip_MEminus21->setAxisTitle("Cathode HalfStrip", 2);
494  csc_strip_MEminus21->setAxisTitle("ME-2/1", 1);
495  csc_strip_MEminus22= ibooker.book2D("csc_strip_MEminus22", "csc_strip_MEminus22", 36,1,37, 240,0,240);
496  csc_strip_MEminus22->setAxisTitle("Cathode HalfStrip", 2);
497  csc_strip_MEminus22->setAxisTitle("ME-2/2", 1);
498  csc_strip_MEminus31= ibooker.book2D("csc_strip_MEminus31", "csc_strip_MEminus31", 18,1,19, 240,0,240);
499  csc_strip_MEminus31->setAxisTitle("Cathode HalfStrip", 2);
500  csc_strip_MEminus31->setAxisTitle("ME-3/1", 1);
501  csc_strip_MEminus32= ibooker.book2D("csc_strip_MEminus32", "csc_strip_MEminus32", 36,1,37, 240,0,240);
502  csc_strip_MEminus32->setAxisTitle("Cathode HalfStrip", 2);
503  csc_strip_MEminus32->setAxisTitle("ME-3/2", 1);
504  csc_strip_MEminus41= ibooker.book2D("csc_strip_MEminus41", "csc_strip_MEminus41", 18,1,19, 240,0,240);
505  csc_strip_MEminus41->setAxisTitle("Cathode HalfStrip", 2);
506  csc_strip_MEminus41->setAxisTitle("ME-4/1", 1);
507  csc_strip_MEminus42= ibooker.book2D("csc_strip_MEminus42", "csc_strip_MEminus42", 36,1,37, 240,0,240);
508  csc_strip_MEminus42->setAxisTitle("Cathode HalfStrip", 2);
509  csc_strip_MEminus42->setAxisTitle("ME-4/2", 1);
510 
511  csc_wire_MEplus11= ibooker.book2D("csc_wire_MEplus11", "csc_wire_MEplus11", 36,1,37, 120,0,120);
512  csc_wire_MEplus11->setAxisTitle("Anode Wiregroup", 2);
513  csc_wire_MEplus11->setAxisTitle("ME+1/1", 1);
514  csc_wire_MEplus12= ibooker.book2D("csc_wire_MEplus12", "csc_wire_MEplus12", 36,1,37, 120,0,120);
515  csc_wire_MEplus12->setAxisTitle("Anode Wiregroup", 2);
516  csc_wire_MEplus12->setAxisTitle("ME+1/2", 1);
517  csc_wire_MEplus13= ibooker.book2D("csc_wire_MEplus13", "csc_wire_MEplus13", 36,1,37, 120,0,120);
518  csc_wire_MEplus13->setAxisTitle("Anode Wiregroup", 2);
519  csc_wire_MEplus13->setAxisTitle("ME+1/3", 1);
520  csc_wire_MEplus21= ibooker.book2D("csc_wire_MEplus21", "csc_wire_MEplus21", 18,1,19, 120,0,120);
521  csc_wire_MEplus21->setAxisTitle("Anode Wiregroup", 2);
522  csc_wire_MEplus21->setAxisTitle("ME+2/1", 1);
523  csc_wire_MEplus22= ibooker.book2D("csc_wire_MEplus22", "csc_wire_MEplus22", 36,1,37, 120,0,120);
524  csc_wire_MEplus22->setAxisTitle("Anode Wiregroup", 2);
525  csc_wire_MEplus22->setAxisTitle("ME+2/2", 1);
526  csc_wire_MEplus31= ibooker.book2D("csc_wire_MEplus31", "csc_wire_MEplus31", 18,1,19, 120,0,120);
527  csc_wire_MEplus31->setAxisTitle("Anode Wiregroup", 2);
528  csc_wire_MEplus31->setAxisTitle("ME+3/1", 1);
529  csc_wire_MEplus32= ibooker.book2D("csc_wire_MEplus32", "csc_wire_MEplus32", 36,1,37, 120,0,120);
530  csc_wire_MEplus32->setAxisTitle("Anode Wiregroup", 2);
531  csc_wire_MEplus32->setAxisTitle("ME+3/2", 1);
532  csc_wire_MEplus41= ibooker.book2D("csc_wire_MEplus41", "csc_wire_MEplus41", 18,1,19, 120,0,120);
533  csc_wire_MEplus41->setAxisTitle("Anode Wiregroup", 2);
534  csc_wire_MEplus41->setAxisTitle("ME+4/1", 1);
535  csc_wire_MEplus42= ibooker.book2D("csc_wire_MEplus42", "csc_wire_MEplus42", 36,1,37, 120,0,120);
536  csc_wire_MEplus42->setAxisTitle("Anode Wiregroup", 2);
537  csc_wire_MEplus42->setAxisTitle("ME+4/2", 1);
538 
539  csc_wire_MEminus11= ibooker.book2D("csc_wire_MEminus11", "csc_wire_MEminus11", 36,1,37, 120,0,120);
540  csc_wire_MEminus11->setAxisTitle("Anode Wiregroup", 2);
541  csc_wire_MEminus11->setAxisTitle("ME-1/1", 1);
542  csc_wire_MEminus12= ibooker.book2D("csc_wire_MEminus12", "csc_wire_MEminus12", 36,1,37, 120,0,120);
543  csc_wire_MEminus12->setAxisTitle("Anode Wiregroup", 2);
544  csc_wire_MEminus12->setAxisTitle("ME-1/2", 1);
545  csc_wire_MEminus13= ibooker.book2D("csc_wire_MEminus13", "csc_wire_MEminus13", 36,1,37, 120,0,120);
546  csc_wire_MEminus13->setAxisTitle("Anode Wiregroup", 2);
547  csc_wire_MEminus13->setAxisTitle("ME-1/3", 1);
548  csc_wire_MEminus21= ibooker.book2D("csc_wire_MEminus21", "csc_wire_MEminus21", 18,1,19, 120,0,120);
549  csc_wire_MEminus21->setAxisTitle("Anode Wiregroup", 2);
550  csc_wire_MEminus21->setAxisTitle("ME-2/1", 1);
551  csc_wire_MEminus22= ibooker.book2D("csc_wire_MEminus22", "csc_wire_MEminus22", 36,1,37, 120,0,120);
552  csc_wire_MEminus22->setAxisTitle("Anode Wiregroup", 2);
553  csc_wire_MEminus22->setAxisTitle("ME-2/2", 1);
554  csc_wire_MEminus31= ibooker.book2D("csc_wire_MEminus31", "csc_wire_MEminus31", 18,1,19, 120,0,120);
555  csc_wire_MEminus31->setAxisTitle("Anode Wiregroup", 2);
556  csc_wire_MEminus31->setAxisTitle("ME-3/1", 1);
557  csc_wire_MEminus32= ibooker.book2D("csc_wire_MEminus32", "csc_wire_MEminus32", 36,1,37, 120,0,120);
558  csc_wire_MEminus32->setAxisTitle("Anode Wiregroup", 2);
559  csc_wire_MEminus32->setAxisTitle("ME-3/2", 1);
560  csc_wire_MEminus41= ibooker.book2D("csc_wire_MEminus41", "csc_wire_MEminus41", 18,1,19, 120,0,120);
561  csc_wire_MEminus41->setAxisTitle("Anode Wiregroup", 2);
562  csc_wire_MEminus41->setAxisTitle("ME-4/1", 1);
563  csc_wire_MEminus42= ibooker.book2D("csc_wire_MEminus42", "csc_wire_MEminus42", 36,1,37, 120,0,120);
564  csc_wire_MEminus42->setAxisTitle("Anode Wiregroup", 2);
565  csc_wire_MEminus42->setAxisTitle("ME-4/2", 1);
566 
567 
568 
569  for(int cscid = 1; cscid < 37; cscid++){
570  char bxtitle[100];
571  sprintf(bxtitle,"%d", cscid);
572 
573  csc_strip_MEplus11 ->setBinLabel(cscid,bxtitle,1);
574  csc_strip_MEplus12 ->setBinLabel(cscid,bxtitle,1);
575  csc_strip_MEplus13 ->setBinLabel(cscid,bxtitle,1);
576  csc_strip_MEplus22 ->setBinLabel(cscid,bxtitle,1);
577  csc_strip_MEplus32 ->setBinLabel(cscid,bxtitle,1);
578  csc_strip_MEplus42 ->setBinLabel(cscid,bxtitle,1);
579 
580  csc_strip_MEminus11 ->setBinLabel(cscid,bxtitle,1);
581  csc_strip_MEminus12 ->setBinLabel(cscid,bxtitle,1);
582  csc_strip_MEminus13 ->setBinLabel(cscid,bxtitle,1);
583  csc_strip_MEminus22 ->setBinLabel(cscid,bxtitle,1);
584  csc_strip_MEminus32 ->setBinLabel(cscid,bxtitle,1);
585  csc_strip_MEminus42 ->setBinLabel(cscid,bxtitle,1);
586 
587  csc_wire_MEplus11 ->setBinLabel(cscid,bxtitle,1);
588  csc_wire_MEplus12 ->setBinLabel(cscid,bxtitle,1);
589  csc_wire_MEplus13 ->setBinLabel(cscid,bxtitle,1);
590  csc_wire_MEplus22 ->setBinLabel(cscid,bxtitle,1);
591  csc_wire_MEplus32 ->setBinLabel(cscid,bxtitle,1);
592  csc_wire_MEplus42 ->setBinLabel(cscid,bxtitle,1);
593 
594  csc_wire_MEminus11 ->setBinLabel(cscid,bxtitle,1);
595  csc_wire_MEminus12 ->setBinLabel(cscid,bxtitle,1);
596  csc_wire_MEminus13 ->setBinLabel(cscid,bxtitle,1);
597  csc_wire_MEminus22 ->setBinLabel(cscid,bxtitle,1);
598  csc_wire_MEminus32 ->setBinLabel(cscid,bxtitle,1);
599  csc_wire_MEminus42 ->setBinLabel(cscid,bxtitle,1);
600  }
601 
602 
603  for(int cscid = 1; cscid < 19; cscid++){
604  char bxtitle[100];
605  sprintf(bxtitle,"%d", cscid);
606 
607  csc_strip_MEplus21 ->setBinLabel(cscid,bxtitle,1);
608  csc_strip_MEplus31 ->setBinLabel(cscid,bxtitle,1);
609  csc_strip_MEplus41 ->setBinLabel(cscid,bxtitle,1);
610 
611  csc_strip_MEminus21 ->setBinLabel(cscid,bxtitle,1);
612  csc_strip_MEminus31 ->setBinLabel(cscid,bxtitle,1);
613  csc_strip_MEminus41 ->setBinLabel(cscid,bxtitle,1);
614 
615  csc_wire_MEplus21 ->setBinLabel(cscid,bxtitle,1);
616  csc_wire_MEplus31 ->setBinLabel(cscid,bxtitle,1);
617  csc_wire_MEplus41 ->setBinLabel(cscid,bxtitle,1);
618 
619  csc_wire_MEminus21 ->setBinLabel(cscid,bxtitle,1);
620  csc_wire_MEminus31 ->setBinLabel(cscid,bxtitle,1);
621  csc_wire_MEminus41 ->setBinLabel(cscid,bxtitle,1);
622 
623  }
624 
625 }
626 
627 void L1TCSCTF::analyze(const Event& e, const EventSetup& c)
628 {
629 
630  if( c.get< L1MuTriggerScalesRcd > ().cacheIdentifier() != m_scalesCacheID ||
631  c.get< L1MuTriggerPtScaleRcd >().cacheIdentifier() != m_ptScaleCacheID ){
632 
633  ESHandle< L1MuTriggerScales > scales;
634  c.get< L1MuTriggerScalesRcd >().get(scales);
635  ts = scales.product();
636  ESHandle< L1MuTriggerPtScale > ptscales;
637  c.get< L1MuTriggerPtScaleRcd >().get(ptscales);
638  tpts = ptscales.product();
639  m_scalesCacheID = c.get< L1MuTriggerScalesRcd >().cacheIdentifier();
640  m_ptScaleCacheID = c.get< L1MuTriggerPtScaleRcd >().cacheIdentifier();
641 
642  edm::LogInfo("L1TCSCTF") << "Changing triggerscales and triggerptscales...";
643  }
644 
645  int NumCSCTfTracksRep = 0;
646  nev_++;
647  if(verbose_) edm::LogInfo("DataNotFound") << "L1TCSCTF: analyze...." << endl;
648 
649  edm::Handle<L1MuGMTReadoutCollection> pCollection;
650  if( gmtProducer.label() != "null" )
651  { // GMT block
652  e.getByToken(gmtProducerToken_, pCollection);
653  if (!pCollection.isValid())
654  {
655  edm::LogInfo("DataNotFound") << "can't find L1MuGMTReadoutCollection with label "; // << csctfSource_.label() ;
656  return;
657  }
658 
659  L1MuGMTReadoutCollection const* gmtrc = pCollection.product();
660  vector<L1MuGMTReadoutRecord> gmt_records = gmtrc->getRecords();
661  vector<L1MuGMTReadoutRecord>::const_iterator RRItr;
662 
663  // Look if the readout window contains one (and only one CSC cands)
664  // to make it simpler I reject events with more than a CSC cand in the
665  // same readout window
666 
667  // count non-empty candidates in this bx
668  int bxWindow = 0;
669  int nCands = 0;
670 
671  for( RRItr = gmt_records.begin(); RRItr != gmt_records.end(); RRItr++ ) {
672  bxWindow++;
673 
674  // get the csc candidates
675  vector<L1MuRegionalCand> INPCands = RRItr->getCSCCands();
676  vector<L1MuRegionalCand>::const_iterator INPItr;
677 
678  BxInEvent_ = 0;
679  isCSCcand_ = false;
680  int nCandsBx = 0;
681 
682  for( INPItr = INPCands.begin(); INPItr != INPCands.end(); ++INPItr ) {
683  if(!INPItr->empty())
684  {
685  nCandsBx++;
686  nCands++;
687  BxInEvent_ = RRItr->getBxInEvent();
688  if (verbose_) edm::LogInfo("DataNotFound") << "cand " << nCandsBx << " -> assigned CSCTF bx: " << INPItr->bx() << endl;
689  }
690  }
691  if (verbose_)
692  if(nCandsBx) edm::LogInfo("DataNotFound") << nCandsBx << " cands in bx: " << BxInEvent_ << endl;
693  }
694 
695  if (nCands != 1) return;
696  else isCSCcand_ = true;
697  if (verbose_) edm::LogInfo("DataNotFound") << "bxWindow: " << bxWindow << endl;
698 
699  int ncsctftrack = 0;
700  if (verbose_)
701  {
702  edm::LogInfo("DataNotFound") << "\tCSCTFCand ntrack " << ncsctftrack << endl;
703  }
704  } // end of GMT block
705 
706  L1ABXN = -999;
707  if( statusProducer.label() != "null" )
708  {
709  edm::Handle<L1CSCStatusDigiCollection> status;
710  e.getByToken(statusToken_, status);
711  bool integrity=status->first, se=false, sm=false, bx=false, af=false, fmm=false;
712  int nStat = 0;
713 
714  for(std::vector<L1CSCSPStatusDigi>::const_iterator stat=status->second.begin(); stat!=status->second.end(); stat++)
715  {
716  se |= stat->SEs()&0xFFF;
717  sm |= stat->SMs()&0xFFF;
718  bx |= stat->BXs()&0xFFF;
719  af |= stat->AFs()&0xFFF;
720  fmm|= stat->FMM()!=8;
721 
722  if(stat->VPs() != 0)
723  {
724  L1ABXN += stat->BXN();
725  nStat++;
726  }
727  }
728  // compute the average
729  if(nStat!=0) L1ABXN /= nStat;
730  if(integrity) csctferrors->Fill(0.5);
731  if(se) csctferrors->Fill(1.5);
732  if(sm) csctferrors->Fill(2.5);
733  if(bx) csctferrors->Fill(3.5);
734  if(af) csctferrors->Fill(4.5);
735  if(fmm) csctferrors->Fill(5.5);
736  }
737 
738  if( lctProducer.label() != "null" )
739  {
740  edm::ESHandle<CSCGeometry> pDD;
741  c.get<MuonGeometryRecord>().get( pDD );
742  CSCTriggerGeometry::setGeometry(pDD);
743 
744  edm::Handle<CSCCorrelatedLCTDigiCollection> corrlcts;
745  e.getByToken(corrlctsToken_, corrlcts);
746 
747  for(CSCCorrelatedLCTDigiCollection::DigiRangeIterator csc=corrlcts.product()->begin(); csc!=corrlcts.product()->end(); csc++)
748  {
749  CSCCorrelatedLCTDigiCollection::Range range1 = corrlcts.product()->get((*csc).first);
750  for(CSCCorrelatedLCTDigiCollection::const_iterator lct=range1.first; lct!=range1.second; lct++)
751  {
752  int endcap = (*csc).first.endcap()-1;
753  int station = (*csc).first.station()-1;
754  int sector = (*csc).first.triggerSector()-1;
755  int subSector = CSCTriggerNumbering::triggerSubSectorFromLabels((*csc).first);
756  int ring = (*csc).first.ring();
757  int cscId = (*csc).first.triggerCscId()-1;
758  int fpga = ( subSector ? subSector-1 : station+1 );
759  int strip = lct -> getStrip();
760  int keyWire = lct -> getKeyWG();
761  int bx = lct -> getBX();
762 
763 
764  int endcapAssignment = 1;
765  int shift = 1;
766  float sectorArg = sector;
767  //float sectorArg = j;
768 
769  if( endcap == 1 ){
770  endcapAssignment = -1;
771  shift = 2;
772  //sectorArg = sector - 6;
773  }
774 
775  int signedStation = (station + shift)* endcapAssignment;
776  if( (station == 0) && (endcap == 0)) signedStation = subSector - 1;
777  if( (station == 0) && (endcap == 1)) signedStation = (-1)*subSector;
778 
779  float chamberArg1 = cscId * 0.1 + sectorArg;
780  //float chamberArg1 = i*0.1 + sectorArg;
781  //std::cout << "First" << i << " " << sectorArg << " " << chamberArg1 << std::endl;
782 
783  float chamberArg11 = chamberArg1;
784  if(sectorArg == 1) chamberArg1 = chamberArg11 - 0.1;
785  if(sectorArg == 2) chamberArg1 = chamberArg11 - 0.2;
786  if(sectorArg == 3) chamberArg1 = chamberArg11 - 0.3;
787  if(sectorArg == 4) chamberArg1 = chamberArg11 - 0.4;
788  if(sectorArg == 5) chamberArg1 = chamberArg11 - 0.5;
789 
790  //std::cout << "cscId, station, sector, endcap, sectorArg, chamber Arg: " << cscId << ", " << station << ", " <<sector << ", " << endcap << ", " << chamberArg1 << ", " << signedStation << std::endl;
791 
792  csctfChamberOccupancies->Fill(chamberArg1, signedStation);
793  //int bunchX = ( (lct->getBX()) - 6 );
794 
795  //int timingSectorArg = 3*(sector) + (lct->getMPCLink());
796  //if( endcap == 1) timingSectorArg = 3*(sector + 6) + (lct->getMPCLink());
797  //std::cout << "Sector, MPCLink, TSA, endcap: " << sector << ", " << lct->getMPCLink() << ", " << timingSectorArg << ", " << endcap << std::endl;
798 
799  //csctfbx->Fill(timingSectorArg, bunchX );
800  //std::cout << "LCT'S, encap: " << endcap << ", station: " << station << ", sector: " << sector << ", subSector: " << subSector << ", cscId: " << cscId << std:: endl;
801  //End JAG
802 
803  // Check if Det Id is within pysical range:
804  if( endcap<0||endcap>1 || sector<0||sector>6 || station<0||station>3 || cscId<0||cscId>8 || fpga<0||fpga>4)
805  {
806  edm::LogError("L1CSCTF: CSC TP are out of range: ")<<" endcap: "<<(endcap+1)<<" station: "<<(station+1) <<" sector: "<<(sector+1)<<" subSector: "<<subSector<<" fpga: "<<fpga<<" cscId: "<<(cscId+1);
807  continue;
808  }
809  lclphidat lclPhi;
810  try {
811  lclPhi = srLUTs_[fpga]->localPhi(lct->getStrip(), lct->getPattern(), lct->getQuality(), lct->getBend(), gangedME11a_);
812  } catch(cms::Exception &) {
813  bzero(&lclPhi,sizeof(lclPhi));
814  }
815 
816  gblphidat gblPhi;
817  try {
818  gblPhi = srLUTs_[fpga]->globalPhiME(lclPhi.phi_local, lct->getKeyWG(), cscId+1, gangedME11a_);
819  } catch(cms::Exception &) {
820  bzero(&gblPhi,sizeof(gblPhi));
821  }
822 
823  gbletadat gblEta;
824  try {
825  gblEta = srLUTs_[fpga]->globalEtaME(lclPhi.phi_bend_local, lclPhi.phi_local, lct->getKeyWG(), cscId+1, gangedME11a_);
826  } catch(cms::Exception &) {
827  bzero(&gblEta,sizeof(gblEta));
828  }
829 
830 
831  //TrackStub
832  csctf::TrackStub theStub((*lct), (*csc).first);
833  theStub.setPhiPacked(gblPhi.global_phi);
834  theStub.setEtaPacked(gblEta.global_eta);
835 
836  float etaG = theStub.etaValue();
837  float phiG = fmod( theStub.phiValue()+15.0*M_PI/180+(sector)*60.0*M_PI/180, 2.*M_PI );
838 
839 
840  //BX plots
841  // endcap==1: minus side; endcap==0: plus side
842  // station=0,1,2,3; ring=1,2,3;
843  if(endcap==1) {
844  if(station==0) {
845  if(ring==1) csctflcts -> Fill(bx, 8.5);
846  else if(ring==2) csctflcts -> Fill(bx, 7.5);
847  else csctflcts -> Fill(bx, 6.5);
848  } else if(station==1) {
849  if(ring==1) csctflcts -> Fill(bx, 5.5);
850  else csctflcts -> Fill(bx, 4.5);
851  } else if(station==2) {
852  if(ring==1) csctflcts -> Fill(bx, 3.5);
853  else csctflcts -> Fill(bx, 2.5);
854  } else if(station==3) {
855  if(ring==1) csctflcts -> Fill(bx, 1.5);
856  else csctflcts -> Fill(bx, 0.5);
857  }
858 
859  } else {
860  if(station==0) {
861  if(ring==1) csctflcts -> Fill(bx, 9.5);
862  else if(ring==2) csctflcts -> Fill(bx, 10.5);
863  else csctflcts -> Fill(bx, 11.5);
864  } else if(station==1) {
865  if(ring==1) csctflcts -> Fill(bx, 12.5);
866  else csctflcts -> Fill(bx, 13.5);
867  } else if(station==2) {
868  if(ring==1) csctflcts -> Fill(bx, 14.5);
869  else csctflcts -> Fill(bx, 15.5);
870  } else if(station==3) {
871  if(ring==1) csctflcts -> Fill(bx, 16.5);
872  else csctflcts -> Fill(bx, 17.5);
873  }
874  }
875 
876 
877 
878 
879 
880  // only for ME1/1
881  if(station == 0 && ring == 1){
882  me11_lctStrip -> Fill(strip);
883  me11_lctWire -> Fill(keyWire);
884  me11_lctLocalPhi -> Fill(lclPhi.phi_local);
885  me11_lctPackedPhi-> Fill(theStub.phiPacked());
886  me11_lctGblPhi -> Fill(phiG);
887  me11_lctGblEta -> Fill(etaG);
888  }
889 
890  // only for ME4/2
891  if(station == 3 && ring == 2){
892  me42_lctGblPhi -> Fill(phiG);
893  me42_lctGblEta -> Fill(etaG);
894  }
895 
896 
897  //ME1/1
898  if (station == 0 && ring == 1){
899  int realID = cscId+6*sector+3*subSector;
900  if(realID>36) realID -= 36;
901  if(endcap == 0) { csc_strip_MEplus11 -> Fill(realID,strip); csc_wire_MEplus11 -> Fill(realID,keyWire); }
902  if(endcap == 1) { csc_strip_MEminus11 -> Fill(realID,strip); csc_wire_MEminus11 -> Fill(realID,keyWire); }
903  }
904  //ME1/2
905  if (station == 0 && ring == 2){
906  int realID = (cscId-3)+6*sector+3*subSector;
907  if(realID>36) realID -= 36;
908  if(endcap == 0) { csc_strip_MEplus12 -> Fill(realID,strip); csc_wire_MEplus12 -> Fill(realID,keyWire); }
909  if(endcap == 1) { csc_strip_MEminus12 -> Fill(realID,strip); csc_wire_MEminus12 -> Fill(realID,keyWire); }
910  }
911  //ME1/3
912  if (station == 0 && ring == 3){
913  int realID = (cscId-6)+6*sector+3*subSector;
914  if(realID>36) realID -= 36;
915  if(endcap == 0) { csc_strip_MEplus13 -> Fill(realID,strip); csc_wire_MEplus13 -> Fill(realID,keyWire); }
916  if(endcap == 1) { csc_strip_MEminus13 -> Fill(realID,strip); csc_wire_MEminus13 -> Fill(realID,keyWire); }
917  }
918  //ME2/1
919  if (station == 1 && ring == 1){
920  int realID = cscId+3*sector+2;
921  if(realID>18) realID -= 18;
922  if(endcap == 0) { csc_strip_MEplus21 -> Fill(realID,strip); csc_wire_MEplus21 -> Fill(realID,keyWire); }
923  if(endcap == 1) { csc_strip_MEminus21 -> Fill(realID,strip); csc_wire_MEminus21 -> Fill(realID,keyWire); }
924  }
925  //ME2/2
926  if (station == 1 && ring == 2){
927  int realID = (cscId-3)+6*sector+3;
928  if(realID>36) realID -= 36;
929  if(endcap == 0) { csc_strip_MEplus22 -> Fill(realID,strip); csc_wire_MEplus22 -> Fill(realID,keyWire); }
930  if(endcap == 1) { csc_strip_MEminus22 -> Fill(realID,strip); csc_wire_MEminus22 -> Fill(realID,keyWire); }
931  }
932 
933  //ME3/1
934  if (station == 2 && ring == 1){
935  int realID = cscId+3*sector+2;
936  if(realID>18) realID -= 18;
937  if(endcap == 0) { csc_strip_MEplus31 -> Fill(realID,strip); csc_wire_MEplus31 -> Fill(realID,keyWire); }
938  if(endcap == 1) { csc_strip_MEminus31 -> Fill(realID,strip); csc_wire_MEminus31 -> Fill(realID,keyWire); }
939  }
940 
941  //ME3/2
942  if (station == 2 && ring == 2){
943  int realID = (cscId-3)+6*sector+3;
944  if(realID>36) realID -= 36;
945  if(endcap == 0) { csc_strip_MEplus32 -> Fill(realID,strip); csc_wire_MEplus32 -> Fill(realID,keyWire); }
946  if(endcap == 1) { csc_strip_MEminus32 -> Fill(realID,strip); csc_wire_MEminus32 -> Fill(realID,keyWire); }
947  }
948  //ME4/1
949  if (station == 3 && ring == 1){
950  int realID = cscId+3*sector+2;
951  if(realID>18) realID -= 18;
952  if(endcap == 0) { csc_strip_MEplus41 -> Fill(realID,strip); csc_wire_MEplus41 -> Fill(realID,keyWire);}
953  if(endcap == 1) { csc_strip_MEminus41 -> Fill(realID,strip); csc_wire_MEminus41 -> Fill(realID,keyWire);}
954  }
955  //ME4/2
956  if (station == 3 && ring == 2){
957  int realID = (cscId-3)+6*sector+3;
958  if(realID>36) realID -= 36;
959  if(endcap == 0) { csc_strip_MEplus42 -> Fill(realID,strip); csc_wire_MEplus42 -> Fill(realID,keyWire); }
960  if(endcap == 1) { csc_strip_MEminus42 -> Fill(realID,strip); csc_wire_MEminus42 -> Fill(realID,keyWire); }
961  }
962 
963 
964 
965 
966 
967 
968  // SR LUT gives packed eta and phi values -> normilize them to 1 by scale them to 'max' and shift by 'min'
969  //float etaP = gblEta.global_eta/127*1.5 + 0.9;
970  //float phiP = (gblPhi.global_phi);// + ( sector )*4096 + station*4096*12) * 1./(4*4096*12);
971  //std::cout << "LCT Eta & Phi Coordinates: " << etaP << ", " << phiP << "." << std::endl;
972  //csctfoccupancies->Fill( gblEta.global_eta/127. * 1.5 + 0.9, (gblPhi.global_phi + ( sector + (endcap?0:6) )*4096 + station*4096*12) * 1./(4*4096*12) );
973  }//lct != range1.scond
974  }//csc!=corrlcts.product()->end()
975  }// lctProducer.label() != "null"
976 
977 
978 
979  if( trackProducer.label() != "null" )
980  {
981  edm::Handle<L1CSCTrackCollection> tracks;
982  e.getByToken(tracksToken_, tracks);
983  for(L1CSCTrackCollection::const_iterator trk=tracks->begin(); trk<tracks->end(); trk++)
984  {
985 
986  NumCSCTfTracksRep++;
987  long LUTAdd = trk->first.ptLUTAddress();
988  int trigMode = ( (LUTAdd)&0xf0000 ) >> 16;
989  int trEta = (trk->first.eta_packed() );
990 
991 
992  // trk->first.endcap() = 2 for - endcap
993  // = 1 for + endcap
994  //int trEndcap = (trk->first.endcap()==2 ? trk->first.endcap()-3 : trk->first.endcap());
995  if( trk->first.endcap() != 1)
996  {
997  int holder = trEta;
998  trEta = -1*holder;
999  trEta -= 1;
1000  }
1001 
1002  int trSector = 6*(trk->first.endcap()-1)+trk->first.sector();
1003  int trBX = trk->first.BX();
1004 
1005  //Here is what is done with output phi value:
1006  //output_phi = (phi / 32) * 3 /16
1007  //where:
1008  //phi is 12-bit phi, 4096 bins covering 62 degrees
1009  //output_phi is 5-bit value
1010 
1011  //Easy to see that output_phi can have values from 0 to 23, or 24 total combinations.
1012  //This gives per-bin phi value of 62/24 = 2.583333 degrees.
1013 
1014  // Sector 1 nominally starts at 15 degrees but there 1 degree overlap between sectors so 14 degrees effectively
1015  //double trPhi = trk->first.localPhi() * 62. / 24.;
1016  double trPhi = ts->getPhiScale()->getLowEdge(trk->first.localPhi());
1017  double trPhi02PI = fmod(trPhi +
1018  ((trSector-1)*M_PI/3) +
1019  (M_PI*14/180.), 2*M_PI);
1020 
1021  if (trigMode == 15) {
1022  csctfTrackPhi_H -> Fill( trPhi02PI );
1023  csctfTrackEta_H -> Fill( trEta );
1024  csctfoccupancies_H -> Fill( trEta, trPhi02PI );
1025  csctfbx_H -> Fill( trSector, trBX );
1026  }
1027  else{
1028  csctfTrackPhi -> Fill( trPhi02PI );
1029  csctfTrackEta -> Fill( trEta );
1030  csctfoccupancies -> Fill( trEta, trPhi02PI );
1031  csctfbx -> Fill( trSector, trBX );
1032 
1033  // Low Quality / High Quality Eta Distributions
1034  //|eta| < 2.1
1035  if (abs(trEta) < 24) {
1036  if (trigMode == 2 ||
1037  trigMode == 3 ||
1038  trigMode == 4 ||
1039  trigMode == 5 ||
1040  trigMode == 6 ||
1041  trigMode == 7 ||
1042  trigMode == 11 ||
1043  trigMode == 12 ||
1044  trigMode == 13 ||
1045  trigMode == 14 ) csctfTrackEtaHighQ -> Fill (trEta);
1046 
1047  if (trigMode == 8 ||
1048  trigMode == 9 ||
1049  trigMode == 10 ) csctfTrackEtaLowQ -> Fill (trEta);
1050  }
1051  else {//|eta| > 2.1
1052  if (trigMode == 2 ||
1053  trigMode == 3 ||
1054  trigMode == 4 ||
1055  trigMode == 5 ) csctfTrackEtaHighQ -> Fill (trEta);
1056  else
1057  csctfTrackEtaLowQ -> Fill (trEta);
1058  }
1059  }
1060 
1061  csctfTrackM->Fill( trk->first.modeExtended() );
1062 
1063  // we monitor the track quality only on the first link
1064  // so let's make sure to fill the plot if there is something that
1065  // is read from the hardware
1066  int trRank = trk->first.rank();
1067  if (trRank) {
1068  int trQuality = ((trRank>>5)&0x3);
1069  trackModeVsQ->Fill( trk->first.modeExtended(), trQuality );
1070  }
1071 
1072  /*
1073  OLD METHOD FOR FILLING HALO PLOTS, IMPROVED METHOD USING ASSOCIATED TRACK STUBS
1074  BELOW ~LINE 605
1075  if( trigMode == 15 )
1076  {
1077 
1078  double haloVals[4][4];
1079  for( int i = 0; i < 4; i++)
1080  {
1081  haloVals[i][0] = 0;
1082  }
1083 
1084  edm::Handle<CSCCorrelatedLCTDigiCollection> corrlcts;
1085  for(CSCCorrelatedLCTDigiCollection::DigiRangeIterator csc=corrlcts.product()->begin(); csc!=corrlcts.product()->end(); csc++)
1086  {
1087  CSCCorrelatedLCTDigiCollection::Range range1 = corrlcts.product()->get((*csc).first);
1088  for(CSCCorrelatedLCTDigiCollection::const_iterator lct=range1.first; lct!=range1.second; lct++)
1089  {
1090  int endcap = (*csc).first.endcap()-1;
1091  int station = (*csc).first.station()-1;
1092  int sector = (*csc).first.triggerSector()-1;
1093  int cscId = (*csc).first.triggerCscId()-1;
1094  int subSector = CSCTriggerNumbering::triggerSubSectorFromLabels((*csc).first);
1095  int fpga = ( subSector ? subSector-1 : station+1 );
1096 
1097  if(station != 4)
1098  {
1099  int modEnd = 1;
1100  if( endcap == 0 ) modEnd = -1;
1101  int indexHalo = modEnd + station;
1102  if(haloVals[indexHalo][0] == 1.0) haloVals[indexHalo][3] = 1.0;
1103  if(haloVals[indexHalo][0] == 0) haloVals[indexHalo][0] = 1.0;
1104  haloVals[indexHalo][1] = sector*1.0;
1105 
1106  lclphidat lclPhi;
1107  lclPhi = srLUTs_[fpga]->localPhi(lct->getStrip(), lct->getPattern(), lct->getQuality(), lct->getBend());
1108  gblphidat gblPhi;
1109  gblPhi = srLUTs_[fpga]->globalPhiME(lclPhi.phi_local, lct->getKeyWG(), cscId+1);
1110  gbletadat gblEta;
1111  gblEta = srLUTs_[fpga]->globalEtaME(lclPhi.phi_bend_local, lclPhi.phi_local, lct->getKeyWG(), cscId+1);
1112 
1113  haloVals[indexHalo][2] = gblEta.global_eta/127. * 1.5 + 0.9;
1114  } //station1 or 2
1115  } //lct first to second
1116  } //corrlcts
1117 
1118  if( (haloVals[0][0] == 1.) && (haloVals[1][0] == 1.) && (haloVals[0][3] != 1.) && (haloVals[1][3] != 1.) )
1119  {
1120  if( haloVals[0][1] == haloVals[1][1] ){
1121  double delEta23 = haloVals[1][2] - haloVals[0][2];
1122  haloDelEta23->Fill( delEta23 );
1123  }
1124  }
1125 
1126  if( (haloVals[2][0] == 1.) && (haloVals[3][0] == 1.) && (haloVals[2][3] != 1.) && (haloVals[3][3] != 1.) )
1127  {
1128  if( haloVals[2][1] == haloVals[3][1] ){
1129  double delEta23 = haloVals[3][2] - haloVals[2][2];
1130  haloDelEta23->Fill( delEta23 );
1131  }
1132  }
1133  } //halo trigger
1134  */
1135 
1136  int cscTrackStub = 0;
1137  //float haloEta[3];
1138  //for(int i=0; i<3; i++) haloEta[i]=-1.0;
1139  //bool haloME11 = false;
1140  CSCCorrelatedLCTDigiCollection lctsOfTracks=trk->second;
1141  for(CSCCorrelatedLCTDigiCollection::DigiRangeIterator trackStub=lctsOfTracks.begin(); trackStub!=lctsOfTracks.end(); trackStub++)
1142  {
1143  CSCCorrelatedLCTDigiCollection::Range range2 = lctsOfTracks.get((*trackStub).first);
1144  for(CSCCorrelatedLCTDigiCollection::const_iterator lct=range2.first; lct!=range2.second; lct++)
1145  {
1146 // int station = (*trackStub).first.station()-1;
1147 // if(station != 4)
1148 // {
1149 // // int endcap = (*trackStub).first.endcap()-1;
1150 // // int sector = (*trackStub).first.triggerSector()-1;
1151 // int cscId = (*trackStub).first.triggerCscId()-1;
1152 // int subSector = CSCTriggerNumbering::triggerSubSectorFromLabels((*trackStub).first);
1153 // int fpga = ( subSector ? subSector-1 : station+1 );
1154 
1155 // lclphidat lclPhi;
1156 // lclPhi = srLUTs_[fpga]->localPhi(lct->getStrip(), lct->getPattern(), lct->getQuality(), lct->getBend());
1157 // gblphidat gblPhi;
1158 // gblPhi = srLUTs_[fpga]->globalPhiME(lclPhi.phi_local, lct->getKeyWG(), cscId+1);
1159 // gbletadat gblEta;
1160 // gblEta = srLUTs_[fpga]->globalEtaME(lclPhi.phi_bend_local, lclPhi.phi_local, lct->getKeyWG(), cscId+1);
1161 // haloEta[station-1] = gblEta.global_eta/127. * 1.5 + 0.9;
1162 // if(station==1 && cscId<2) haloME11 = true;
1163 // }
1164  cscTrackStub++;
1165  }
1166  }
1167  cscTrackStubNumbers->Fill(cscTrackStub);
1168 
1169 // if(trigMode == 15)
1170 // {
1171 // float dEta13 = haloEta[2]-haloEta[0];
1172 // float dEta12 = haloEta[1]-haloEta[0];
1173 // if(haloME11)
1174 // {
1175 // if(haloEta[1]!=-1.0) haloDelEta112->Fill(dEta12);
1176 // if(haloEta[2]!=-1.0) haloDelEta113->Fill(dEta13);
1177 // } else {
1178 // if(haloEta[1]!=-1.0) haloDelEta12->Fill(dEta12);
1179 // if(haloEta[2]!=-1.0) haloDelEta13->Fill(dEta13);
1180 // }
1181 // }
1182  //
1183 
1184 
1185 
1186  }
1187  }
1188  csctfntrack->Fill(NumCSCTfTracksRep);
1189 
1190 
1191  if( mbProducer.label() != "null" )
1192  {
1193  // handle to needed collections
1194  edm::Handle<CSCTriggerContainer<csctf::TrackStub> > dtStubs;
1195  e.getByToken(dtStubsToken_, dtStubs);
1196  edm::Handle<L1CSCTrackCollection> tracks;
1197  e.getByToken(mbtracksToken_, tracks);
1198 
1199  // loop on the DT stubs
1200  std::vector<csctf::TrackStub> vstubs = dtStubs->get();
1201  for(std::vector<csctf::TrackStub>::const_iterator stub=vstubs.begin();
1202  stub!=vstubs.end(); stub++)
1203  {
1204  if (verbose_)
1205  {
1206  edm::LogInfo("DataNotFound") << "\n mbEndcap: " << stub->endcap();
1207  edm::LogInfo("DataNotFound") << "\n stub->getStrip()[FLAG]: " << stub->getStrip();
1208  edm::LogInfo("DataNotFound") << "\n stub->getKeyWG()[CAL]: " << stub->getKeyWG();
1209  edm::LogInfo("DataNotFound") << "\n stub->BX(): " << stub->BX();
1210  edm::LogInfo("DataNotFound") << "\n stub->sector(): " << stub->sector();
1211  edm::LogInfo("DataNotFound") << "\n stub->subsector(): " << stub->subsector();
1212  edm::LogInfo("DataNotFound") << "\n stub->station(): " << stub->station();
1213  edm::LogInfo("DataNotFound") << "\n stub->phiPacked(): " << stub->phiPacked();
1214  edm::LogInfo("DataNotFound") << "\n stub->getBend(): " << stub->getBend();
1215  edm::LogInfo("DataNotFound") << "\n stub->getQuality(): " << stub->getQuality();
1216  edm::LogInfo("DataNotFound") << "\n stub->cscid(): " << stub->cscid() << endl;
1217  }
1218  // define the sector ID
1219  int mbId = (stub->endcap()==2) ? 6 : 0;
1220  mbId += stub->sector();
1221  // *** do not fill if CalMB variable is set ***
1222  // horrible! They used the same class to write up the LCT and MB info,
1223  // but given the MB does not have strip and WG they replaced this two
1224  // with the flag and cal bits... :S
1225  if (stub->getKeyWG() == 0)
1226  {
1227  // if FLAG =1, muon belong to previous BX
1228  int bxDT = stub->BX()-stub->getStrip(); // correct by the FLAG
1229  int subDT = stub->subsector();
1230 
1231  // Fill the event only if CSC had or would have triggered
1232  if (isCSCcand_)
1233  {
1234  //look for tracks in the event and compare the matching DT stubs
1235  int trkBX = 0;
1236  for(L1CSCTrackCollection::const_iterator trk=tracks->begin(); trk<tracks->end(); trk++)
1237  {
1238  trkBX = trk->first.BX();
1239  int trkId = (trk->first.endcap()==2) ? 6 : 0;
1240  trkId += trk->first.sector();
1241  if (verbose_){
1242  edm::LogInfo("DataNotFound") << "\n trk BX: " << trkBX
1243  << " Sector: " << trkId
1244  << " SubSector: " << trk->first.subsector()
1245  << " Endcap: " << trk->first.endcap();
1246 
1247  edm::LogInfo("DataNotFound") << "\n DT BX: " << stub->BX()
1248  << " Sector: " << mbId
1249  << " SubSector: " << stub->subsector()
1250  << " Endcap: " << stub->endcap() << endl;
1251  }
1252 
1253  if (mbId == trkId)
1254  {
1255  if (verbose_) {
1256  edm::LogInfo("DataNotFound") << " --> MATCH" << endl;
1257  edm::LogInfo("DataNotFound") << "Fill :" << trkBX+6-bxDT << " -- " << subDT << " -- cands" << endl;
1258  }
1259  // DT bx ranges from 3 to 9
1260  // trk bx ranges from -3 to 3
1261  DTstubsTimeTrackMenTimeArrival[mbId-1]->Fill(bxDT-trkBX-6,subDT);//subsec
1262  }
1263  }// loop on the tracks
1264  }//if (isCSCcand_){
1265  }//if (stub->getKeyWG() == 0) {
1266  }
1267  }
1268 }
L1TCSCTF::DTstubsTimeTrackMenTimeArrival
MonitorElement * DTstubsTimeTrackMenTimeArrival[12]
Definition: L1TCSCTF.h:166
L1TCSCTF::csctfoccupancies
MonitorElement * csctfoccupancies
Definition: L1TCSCTF.h:83
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::eventsetup::EventSetupRecord::cacheIdentifier
unsigned long long cacheIdentifier() const
Definition: EventSetupRecord.h:174
L1TCSCTF::csctfTrackEtaHighQ
MonitorElement * csctfTrackEtaHighQ
Definition: L1TCSCTF.h:99
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
L1TCSCTF::csctflcts
MonitorElement * csctflcts
Definition: L1TCSCTF.h:108
CSCSectorReceiverLUT::localPhi
lclphidat localPhi(int strip, int pattern, int quality, int lr, const bool gangedME1a=false) const
Geometry Lookup Tables.
Definition: CSCSectorReceiverLUT.cc:205
L1TCSCTF::csctfTrackPhi
MonitorElement * csctfTrackPhi
Definition: L1TCSCTF.h:96
L1TCSCTF::csc_strip_MEminus22
MonitorElement * csc_strip_MEminus22
Definition: L1TCSCTF.h:137
L1TCSCTF::verbose_
bool verbose_
Definition: L1TCSCTF.h:174
L1TCSCTF::m_scalesCacheID
unsigned long long m_scalesCacheID
Definition: L1TCSCTF.h:184
L1TCSCTF::csctfTrackPhi_H
MonitorElement * csctfTrackPhi_H
Definition: L1TCSCTF.h:100
L1TCSCTF::csc_wire_MEplus31
MonitorElement * csc_wire_MEplus31
Definition: L1TCSCTF.h:148
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:449
Reference_intrackfit_cff.endcap
endcap
Definition: Reference_intrackfit_cff.py:82
L1TCSCTF::csc_strip_MEplus21
MonitorElement * csc_strip_MEplus21
Definition: L1TCSCTF.h:126
L1TCSCTF::csc_strip_MEplus11
MonitorElement * csc_strip_MEplus11
Definition: L1TCSCTF.h:123
L1MuScale::getLowEdge
virtual float getLowEdge(unsigned packed) const =0
get the low edge of bin represented by packed
L1TCSCTF::csc_wire_MEminus13
MonitorElement * csc_wire_MEminus13
Definition: L1TCSCTF.h:155
L1TCSCTF::csc_wire_MEminus22
MonitorElement * csc_wire_MEminus22
Definition: L1TCSCTF.h:157
L1TCSCTF::me11_lctGblPhi
MonitorElement * me11_lctGblPhi
Definition: L1TCSCTF.h:115
MonitorElement::setBinLabel
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)
Definition: MonitorElement.cc:920
L1TCSCTF::csc_wire_MEplus12
MonitorElement * csc_wire_MEplus12
Definition: L1TCSCTF.h:144
L1TCSCTF::csc_wire_MEminus31
MonitorElement * csc_wire_MEminus31
Definition: L1TCSCTF.h:158
L1TCSCTF::csctfbx
MonitorElement * csctfbx
Definition: L1TCSCTF.h:79
L1TCSCTF::csc_wire_MEminus32
MonitorElement * csc_wire_MEminus32
Definition: L1TCSCTF.h:159
L1TCSCTF::csctfTrackEtaLowQ
MonitorElement * csctfTrackEtaLowQ
Definition: L1TCSCTF.h:98
L1TCSCTF::mbProducer
edm::InputTag mbProducer
Definition: L1TCSCTF.h:177
L1TCSCTF::csc_strip_MEminus12
MonitorElement * csc_strip_MEminus12
Definition: L1TCSCTF.h:134
CSCTriggerGeometry::setGeometry
static void setGeometry(const edm::ESHandle< CSCGeometry > &thegeom)
Definition: CSCTriggerGeometry.h:19
L1TCSCTF::csctfTrackEta
MonitorElement * csctfTrackEta
Definition: L1TCSCTF.h:97
L1TCSCTF::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: L1TCSCTF.cc:627
L1TCSCTF::me11_lctWire
MonitorElement * me11_lctWire
Definition: L1TCSCTF.h:112
L1TCSCTF::csc_strip_MEminus31
MonitorElement * csc_strip_MEminus31
Definition: L1TCSCTF.h:138
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
L1TCSCTF::outputFile_
std::string outputFile_
Definition: L1TCSCTF.h:173
csctf::TrackStub::phiPacked
unsigned phiPacked() const
Return the binned phi for this stub.
Definition: TrackStub.h:44
L1TCSCTF::csc_wire_MEminus21
MonitorElement * csc_wire_MEminus21
Definition: L1TCSCTF.h:156
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
L1TCSCTF::statusProducer
edm::InputTag statusProducer
Definition: L1TCSCTF.h:177
L1TCSCTF::statusToken_
edm::EDGetTokenT< L1CSCStatusDigiCollection > statusToken_
Definition: L1TCSCTF.h:189
L1TCSCTF::csctfTrackEta_H
MonitorElement * csctfTrackEta_H
Definition: L1TCSCTF.h:101
L1TCSCTF::me42_lctGblPhi
MonitorElement * me42_lctGblPhi
Definition: L1TCSCTF.h:119
L1TCSCTF::ts
const L1MuTriggerScales * ts
Definition: L1TCSCTF.h:182
L1TCSCTF::gangedME11a_
bool gangedME11a_
Definition: L1TCSCTF.h:178
CSCSectorReceiverLUT::globalPhiME
gblphidat globalPhiME(int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const
Definition: CSCSectorReceiverLUT.cc:502
L1TCSCTF::cscTrackStubNumbers
MonitorElement * cscTrackStubNumbers
Definition: L1TCSCTF.h:102
L1TCSCTF::csc_strip_MEminus32
MonitorElement * csc_strip_MEminus32
Definition: L1TCSCTF.h:139
L1TCSCTF::L1ABXN
int L1ABXN
Definition: L1TCSCTF.h:170
L1TCSCTF::me11_lctStrip
MonitorElement * me11_lctStrip
Definition: L1TCSCTF.h:111
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
L1TCSCTF::BxInEvent_
int BxInEvent_
Definition: L1TCSCTF.h:167
L1TCSCTF::csc_strip_MEminus42
MonitorElement * csc_strip_MEminus42
Definition: L1TCSCTF.h:141
L1TCSCTF::csc_wire_MEplus41
MonitorElement * csc_wire_MEplus41
Definition: L1TCSCTF.h:150
L1TCSCTF::~L1TCSCTF
virtual ~L1TCSCTF()
Definition: L1TCSCTF.cc:86
csctf::TrackStub::etaValue
double etaValue() const
return the Eta Value of this stub&#39;s position.
Definition: TrackStub.h:36
L1MuTriggerScales::getPhiScale
const L1MuScale * getPhiScale() const
get the phi scale
Definition: L1MuTriggerScales.h:201
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
L1TCSCTF::csc_strip_MEplus13
MonitorElement * csc_strip_MEplus13
Definition: L1TCSCTF.h:125
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
L1TCSCTF::csc_strip_MEplus22
MonitorElement * csc_strip_MEplus22
Definition: L1TCSCTF.h:127
L1TCSCTF::nev_
int nev_
Definition: L1TCSCTF.h:172
L1TCSCTF::csc_wire_MEminus41
MonitorElement * csc_wire_MEminus41
Definition: L1TCSCTF.h:160
L1TCSCTF::L1TCSCTF
L1TCSCTF(const edm::ParameterSet &ps)
Definition: L1TCSCTF.cc:25
L1TCSCTF::csctfChamberOccupancies
MonitorElement * csctfChamberOccupancies
Definition: L1TCSCTF.h:95
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
L1TCSCTF::csc_wire_MEplus13
MonitorElement * csc_wire_MEplus13
Definition: L1TCSCTF.h:145
L1TCSCTF::lctProducer
edm::InputTag lctProducer
Definition: L1TCSCTF.h:177
M_PI
#define M_PI
Definition: readTestVector.cc:25
L1TCSCTF::csc_wire_MEplus21
MonitorElement * csc_wire_MEplus21
Definition: L1TCSCTF.h:146
L1TCSCTF::bookHistograms
virtual void bookHistograms(DQMStore::IBooker &ibooker, edm::Run const &, edm::EventSetup const &) override
Definition: L1TCSCTF.cc:96
L1TCSCTF::tracksToken_
edm::EDGetTokenT< L1CSCTrackCollection > tracksToken_
Definition: L1TCSCTF.h:191
L1TCSCTF::csc_strip_MEminus41
MonitorElement * csc_strip_MEminus41
Definition: L1TCSCTF.h:140
L1TCSCTF::me42_lctGblEta
MonitorElement * me42_lctGblEta
Definition: L1TCSCTF.h:120
L1TCSCTF::srLUTs_
CSCSectorReceiverLUT * srLUTs_[5]
Definition: L1TCSCTF.h:180
L1TCSCTF::csc_strip_MEplus31
MonitorElement * csc_strip_MEplus31
Definition: L1TCSCTF.h:128
L1TCSCTF::csc_wire_MEplus32
MonitorElement * csc_wire_MEplus32
Definition: L1TCSCTF.h:149
L1TCSCTF::corrlctsToken_
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection > corrlctsToken_
Definition: L1TCSCTF.h:190
csctf::TrackStub::phiValue
double phiValue() const
return the Phi Value of this stub&#39;s position in local coordinates.
Definition: TrackStub.h:38
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
L1TCSCTF::csctferrors
MonitorElement * csctferrors
Definition: L1TCSCTF.h:82
edm::Handle::product
T const * product() const
Definition: Handle.h:81
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39
edm::ParameterSet::addUntrackedParameter
void addUntrackedParameter(std::string const &name, T const &value)
Definition: ParameterSet.h:207
L1TCSCTF::csc_wire_MEminus42
MonitorElement * csc_wire_MEminus42
Definition: L1TCSCTF.h:161
L1TCSCTF::isCSCcand_
bool isCSCcand_
Definition: L1TCSCTF.h:168
gblphidat
class global_phi_data gblphidat
L1TCSCTF::csc_strip_MEplus41
MonitorElement * csc_strip_MEplus41
Definition: L1TCSCTF.h:130
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
L1TCSCTF::csctfTrackM
MonitorElement * csctfTrackM
Definition: L1TCSCTF.h:103
L1TCSCTF::mbtracksToken_
edm::EDGetTokenT< L1CSCTrackCollection > mbtracksToken_
Definition: L1TCSCTF.h:193
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
L1TCSCTF::csctfbx_H
MonitorElement * csctfbx_H
Definition: L1TCSCTF.h:80
MuonDigiCollection< CSCDetId, CSCCorrelatedLCTDigi >::const_iterator
std::vector< CSCCorrelatedLCTDigi >::const_iterator const_iterator
Definition: MuonDigiCollection.h:110
lclphidat
class local_phi_data lclphidat
Data Types.
L1TCSCTF::dqmBeginRun
virtual void dqmBeginRun(const edm::Run &, const edm::EventSetup &)
Definition: L1TCSCTF.cc:93
CSCTriggerNumbering::triggerSubSectorFromLabels
static int triggerSubSectorFromLabels(int station, int chamber)
Definition: CSCTriggerNumbering.cc:118
L1TCSCTF::csctfntrack
MonitorElement * csctfntrack
Definition: L1TCSCTF.h:78
L1TCSCTF::trackProducer
edm::InputTag trackProducer
Definition: L1TCSCTF.h:177
L1TCSCTF::gmtProducerToken_
edm::EDGetTokenT< L1MuGMTReadoutCollection > gmtProducerToken_
Definition: L1TCSCTF.h:188
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
L1TCSCTF::csc_wire_MEplus42
MonitorElement * csc_wire_MEplus42
Definition: L1TCSCTF.h:151
L1TCSCTF::trackModeVsQ
MonitorElement * trackModeVsQ
Definition: L1TCSCTF.h:104
L1TCSCTF::me11_lctGblEta
MonitorElement * me11_lctGblEta
Definition: L1TCSCTF.h:116
CSCSectorReceiverLUT::globalEtaME
gbletadat globalEtaME(int phi_bend, int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const
Definition: CSCSectorReceiverLUT.cc:778
L1MuGMTReadoutCollection::getRecords
std::vector< L1MuGMTReadoutRecord > const & getRecords() const
Definition: L1MuGMTReadoutCollection.h:51
L1TCSCTF::csc_strip_MEminus21
MonitorElement * csc_strip_MEminus21
Definition: L1TCSCTF.h:136
L1TCSCTF::csctfoccupancies_H
MonitorElement * csctfoccupancies_H
Definition: L1TCSCTF.h:84
L1TCSCTF::csc_strip_MEplus32
MonitorElement * csc_strip_MEplus32
Definition: L1TCSCTF.h:129
L1TCSCTF::csc_strip_MEplus12
MonitorElement * csc_strip_MEplus12
Definition: L1TCSCTF.h:124
edm::shift
static unsigned int const shift
Definition: LuminosityBlockID.cc:9
csctf::TrackStub::setPhiPacked
void setPhiPacked(const unsigned &phi_)
Definition: TrackStub.h:33
MuonDigiCollection< CSCDetId, CSCCorrelatedLCTDigi >::Range
std::pair< const_iterator, const_iterator > Range
Definition: MuonDigiCollection.h:111
L1TCSCTF::tpts
const L1MuTriggerPtScale * tpts
Definition: L1TCSCTF.h:183
L1TCSCTF::me11_lctLocalPhi
MonitorElement * me11_lctLocalPhi
Definition: L1TCSCTF.h:113
L1TCSCTF::csc_strip_MEminus11
MonitorElement * csc_strip_MEminus11
Definition: L1TCSCTF.h:133
L1TCSCTF::csc_strip_MEminus13
MonitorElement * csc_strip_MEminus13
Definition: L1TCSCTF.h:135
L1TCSCTF::m_ptScaleCacheID
unsigned long long m_ptScaleCacheID
Definition: L1TCSCTF.h:185
L1TCSCTF::csc_wire_MEplus11
MonitorElement * csc_wire_MEplus11
Definition: L1TCSCTF.h:143
ntuplemaker.status
tuple status
Definition: ntuplemaker.py:245
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1481
L1TCSCTF::csc_wire_MEminus12
MonitorElement * csc_wire_MEminus12
Definition: L1TCSCTF.h:154
gbletadat
class global_eta_data gbletadat
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:947
L1TCSCTF::csc_strip_MEplus42
MonitorElement * csc_strip_MEplus42
Definition: L1TCSCTF.h:131
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:43
L1TCSCTF::dtStubsToken_
edm::EDGetTokenT< CSCTriggerContainer< csctf::TrackStub > > dtStubsToken_
Definition: L1TCSCTF.h:192
L1TCSCTF::gmtProducer
edm::InputTag gmtProducer
Definition: L1TCSCTF.h:177
csctf::TrackStub::setEtaPacked
void setEtaPacked(const unsigned &eta_)
set Eta and Phi from integer values.
Definition: TrackStub.h:32
L1TCSCTF::me11_lctPackedPhi
MonitorElement * me11_lctPackedPhi
Definition: L1TCSCTF.h:114
L1TCSCTF::csc_wire_MEplus22
MonitorElement * csc_wire_MEplus22
Definition: L1TCSCTF.h:147
L1TCSCTF::csc_wire_MEminus11
MonitorElement * csc_wire_MEminus11
Definition: L1TCSCTF.h:153
edm::Run
Definition: Run.h:41
HLT_25ns14e33_v1_cff.trackProducer
tuple trackProducer
Definition: HLT_25ns14e33_v1_cff.py:8123
Generated for CMSSW Reference Manual by doxygen 1.8.5