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