CMS 3D CMS Logo
CSCOfflineMonitor.cc
Go to the documentation of this file.
1 /*
2  * Offline DQM module for CSC local reconstruction - based on CSCValidation
3  *
4  */
5 
6 #include "DQMOffline/Muon/interface/CSCOfflineMonitor.h"
7 
8 using namespace std;
9 
11 // CONSTRUCTOR //
13 CSCOfflineMonitor::CSCOfflineMonitor(const edm::ParameterSet& pset)
14  : cscGeomToken_(esConsumes<CSCGeometry, MuonGeometryRecord>()),
15  hcrateToken_(esConsumes<CSCCrateMap, CSCCrateMapRcd>()) {
16  rd_token = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("FEDRawDataCollectionTag"));
17  sd_token = consumes<CSCStripDigiCollection>(pset.getParameter<edm::InputTag>("stripDigiTag"));
18  wd_token = consumes<CSCWireDigiCollection>(pset.getParameter<edm::InputTag>("wireDigiTag"));
19  al_token = consumes<CSCALCTDigiCollection>(pset.getParameter<edm::InputTag>("alctDigiTag"));
20  cl_token = consumes<CSCCLCTDigiCollection>(pset.getParameter<edm::InputTag>("clctDigiTag"));
21  rh_token = consumes<CSCRecHit2DCollection>(pset.getParameter<edm::InputTag>("cscRecHitTag"));
22  se_token = consumes<CSCSegmentCollection>(pset.getParameter<edm::InputTag>("cscSegTag"));
23 }
24 
25 void CSCOfflineMonitor::bookHistograms(DQMStore::IBooker& ibooker,
26  edm::Run const& iRun,
27  edm::EventSetup const& /* iSetup */) {
28  // occupancies
29  ibooker.cd();
30  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Occupancy");
31 
32  hCSCOccupancy = ibooker.book1D("hCSCOccupancy", "overall CSC occupancy", 13, -0.5, 12.5);
33  hCSCOccupancy->setBinLabel(2, "Total Events");
34  hCSCOccupancy->setBinLabel(4, "# Events with Wires");
35  hCSCOccupancy->setBinLabel(6, "# Events with Strips");
36  hCSCOccupancy->setBinLabel(8, "# Events with Wires&Strips");
37  hCSCOccupancy->setBinLabel(10, "# Events with Rechits");
38  hCSCOccupancy->setBinLabel(12, "# Events with Segments");
39  hOWiresAndCLCT = ibooker.book2D("hOWiresAndCLCT", "Wire and CLCT Digi Occupancy ", 36, 0.5, 36.5, 20, 0.5, 20.5);
40  hOWires = ibooker.book2D("hOWires", "Wire Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
41  hOWireSerial = ibooker.book1D("hOWireSerial", "Wire Occupancy by Chamber Serial", 601, -0.5, 600.5);
42  hOWireSerial->setAxisTitle("Chamber Serial Number");
43  hOStrips = ibooker.book2D("hOStrips", "Strip Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
44  hOStripSerial = ibooker.book1D("hOStripSerial", "Strip Occupancy by Chamber Serial", 601, -0.5, 600.5);
45  hOStripSerial->setAxisTitle("Chamber Serial Number");
46  hOStripsAndWiresAndCLCT =
47  ibooker.book2D("hOStripsAndWiresAndCLCT", "Strip And Wire And CLCT Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
48  hOStripsAndWiresAndCLCT->setAxisTitle("Chamber #");
49  hORecHits = ibooker.book2D("hORecHits", "RecHit Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
50  hORecHitsSerial = ibooker.book1D("hORecHitSerial", "RecHit Occupancy by Chamber Serial", 601, -0.5, 600.5);
51  hORecHitsSerial->setAxisTitle("Chamber Serial Number");
52  hOSegments = ibooker.book2D("hOSegments", "Segment Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
53  hOSegmentsSerial = ibooker.book1D("hOSegmentSerial", "Segment Occupancy by Chamber Serial", 601, -0.5, 600.5);
54  hOSegmentsSerial->setAxisTitle("Chamber Serial Number");
55 
56  // wire digis
57  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Digis");
58 
59  // For low multiplicities (e.g. low or no pileup)
60  hWirenGroupsTotal =
61  ibooker.book1D("hWirenGroupsTotal", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 250.); // 1 bin is 1
62  // For high multiplcities (e.g. with pileup)
63  hWirenGroupsTotalHi =
64  ibooker.book1D("hWirenGroupsTotalHi", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 1000.); // i bin is 4
65 
66  hWireTBin.push_back(ibooker.book1D("hWireTBin_m42", "Wire TBin Fired (ME -4/2); Time Bin (25ns)", 17, -0.5, 16.5));
67  hWireTBin.push_back(ibooker.book1D("hWireTBin_m41", "Wire TBin Fired (ME -4/1); Time Bin (25ns)", 17, -0.5, 16.5));
68  hWireTBin.push_back(ibooker.book1D("hWireTBin_m32", "Wire TBin Fired (ME -3/2); Time Bin (25ns)", 17, -0.5, 16.5));
69  hWireTBin.push_back(ibooker.book1D("hWireTBin_m31", "Wire TBin Fired (ME -3/1); Time Bin (25ns)", 17, -0.5, 16.5));
70  hWireTBin.push_back(ibooker.book1D("hWireTBin_m22", "Wire TBin Fired (ME -2/2); Time Bin (25ns)", 17, -0.5, 16.5));
71  hWireTBin.push_back(ibooker.book1D("hWireTBin_m21", "Wire TBin Fired (ME -2/1); Time Bin (25ns)", 17, -0.5, 16.5));
72  hWireTBin.push_back(ibooker.book1D("hWireTBin_m11a", "Wire TBin Fired (ME -1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
73  hWireTBin.push_back(ibooker.book1D("hWireTBin_m13", "Wire TBin Fired (ME -1/3); Time Bin (25ns)", 17, -0.5, 16.5));
74  hWireTBin.push_back(ibooker.book1D("hWireTBin_m12", "Wire TBin Fired (ME -1/2); Time Bin (25ns)", 17, -0.5, 16.5));
75  hWireTBin.push_back(ibooker.book1D("hWireTBin_m11b", "Wire TBin Fired (ME -1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
76  hWireTBin.push_back(ibooker.book1D("hWireTBin_p11b", "Wire TBin Fired (ME +1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
77  hWireTBin.push_back(ibooker.book1D("hWireTBin_p12", "Wire TBin Fired (ME +1/2); Time Bin (25ns)", 17, -0.5, 16.5));
78  hWireTBin.push_back(ibooker.book1D("hWireTBin_p13", "Wire TBin Fired (ME +1/3); Time Bin (25ns)", 17, -0.5, 16.5));
79  hWireTBin.push_back(ibooker.book1D("hWireTBin_p11a", "Wire TBin Fired (ME +1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
80  hWireTBin.push_back(ibooker.book1D("hWireTBin_p21", "Wire TBin Fired (ME +2/1); Time Bin (25ns)", 17, -0.5, 16.5));
81  hWireTBin.push_back(ibooker.book1D("hWireTBin_p22", "Wire TBin Fired (ME +2/2); Time Bin (25ns)", 17, -0.5, 16.5));
82  hWireTBin.push_back(ibooker.book1D("hWireTBin_p31", "Wire TBin Fired (ME +3/1); Time Bin (25ns)", 17, -0.5, 16.5));
83  hWireTBin.push_back(ibooker.book1D("hWireTBin_p32", "Wire TBin Fired (ME +3/2); Time Bin (25ns)", 17, -0.5, 16.5));
84  hWireTBin.push_back(ibooker.book1D("hWireTBin_p41", "Wire TBin Fired (ME +4/1); Time Bin (25ns)", 17, -0.5, 16.5));
85  hWireTBin.push_back(ibooker.book1D("hWireTBin_p42", "Wire TBin Fired (ME +4/2); Time Bin (25ns)", 17, -0.5, 16.5));
86  hWireNumber.push_back(
87  ibooker.book1D("hWireNumber_m42", "Wiregroup Number Fired (ME -4/2); Wiregroup #", 113, -0.5, 112.5));
88  hWireNumber.push_back(
89  ibooker.book1D("hWireNumber_m41", "Wiregroup Number Fired (ME -4/1); Wiregroup #", 113, -0.5, 112.5));
90  hWireNumber.push_back(
91  ibooker.book1D("hWireNumber_m32", "Wiregroup Number Fired (ME -3/2); Wiregroup #", 113, -0.5, 112.5));
92  hWireNumber.push_back(
93  ibooker.book1D("hWireNumber_m31", "Wiregroup Number Fired (ME -3/1); Wiregroup #", 113, -0.5, 112.5));
94  hWireNumber.push_back(
95  ibooker.book1D("hWireNumber_m22", "Wiregroup Number Fired (ME -2/2); Wiregroup #", 113, -0.5, 112.5));
96  hWireNumber.push_back(
97  ibooker.book1D("hWireNumber_m21", "Wiregroup Number Fired (ME -2/1); Wiregroup #", 113, -0.5, 112.5));
98  hWireNumber.push_back(
99  ibooker.book1D("hWireNumber_m11a", "Wiregroup Number Fired (ME -1/1a); Wiregroup #", 113, -0.5, 112.5));
100  hWireNumber.push_back(
101  ibooker.book1D("hWireNumber_m13", "Wiregroup Number Fired (ME -1/3); Wiregroup #", 113, -0.5, 112.5));
102  hWireNumber.push_back(
103  ibooker.book1D("hWireNumber_m12", "Wiregroup Number Fired (ME -1/2); Wiregroup #", 113, -0.5, 112.5));
104  hWireNumber.push_back(
105  ibooker.book1D("hWireNumber_m11b", "Wiregroup Number Fired (ME -1/1b); Wiregroup #", 113, -0.5, 112.5));
106  hWireNumber.push_back(
107  ibooker.book1D("hWireNumber_p11b", "Wiregroup Number Fired (ME +1/1b); Wiregroup #", 113, -0.5, 112.5));
108  hWireNumber.push_back(
109  ibooker.book1D("hWireNumber_p12", "Wiregroup Number Fired (ME +1/2); Wiregroup #", 113, -0.5, 112.5));
110  hWireNumber.push_back(
111  ibooker.book1D("hWireNumber_p13", "Wiregroup Number Fired (ME +1/3); Wiregroup #", 113, -0.5, 112.5));
112  hWireNumber.push_back(
113  ibooker.book1D("hWireNumber_p11a", "Wiregroup Number Fired (ME +1/1a); Wiregroup #", 113, -0.5, 112.5));
114  hWireNumber.push_back(
115  ibooker.book1D("hWireNumber_p21", "Wiregroup Number Fired (ME +2/1); Wiregroup #", 113, -0.5, 112.5));
116  hWireNumber.push_back(
117  ibooker.book1D("hWireNumber_p22", "Wiregroup Number Fired (ME +2/2); Wiregroup #", 113, -0.5, 112.5));
118  hWireNumber.push_back(
119  ibooker.book1D("hWireNumber_p31", "Wiregroup Number Fired (ME +3/1); Wiregroup #", 113, -0.5, 112.5));
120  hWireNumber.push_back(
121  ibooker.book1D("hWireNumber_p32", "Wiregroup Number Fired (ME +3/2); Wiregroup #", 113, -0.5, 112.5));
122  hWireNumber.push_back(
123  ibooker.book1D("hWireNumber_p41", "Wiregroup Number Fired (ME +4/1); Wiregroup #", 113, -0.5, 112.5));
124  hWireNumber.push_back(
125  ibooker.book1D("hWireNumber_p42", "Wiregroup Number Fired (ME +4/2); Wiregroup #", 113, -0.5, 112.5));
126 
127  // strip digis
128 
129  // For low multiplicities (e.g. low or no pileup)
130  hStripNFired = ibooker.book1D(
131  "hStripNFired", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 400, 0., 400.); // 1 bin is 1
132  // For high multiplcities (e.g. with pileup)
133  hStripNFiredHi = ibooker.book1D(
134  "hStripNFiredHi", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 500, 0., 2000.); // 1 bin is 4
135 
136  hStripNumber.push_back(
137  ibooker.book1D("hStripNumber_m42", "Strip Number Fired (ME -4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
138  hStripNumber.push_back(
139  ibooker.book1D("hStripNumber_m41", "Strip Number Fired (ME -4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
140  hStripNumber.push_back(
141  ibooker.book1D("hStripNumber_m32", "Strip Number Fired (ME -3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
142  hStripNumber.push_back(
143  ibooker.book1D("hStripNumber_m31", "Strip Number Fired (ME -3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
144  hStripNumber.push_back(
145  ibooker.book1D("hStripNumber_m22", "Strip Number Fired (ME -2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
146  hStripNumber.push_back(
147  ibooker.book1D("hStripNumber_m21", "Strip Number Fired (ME -2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
148  hStripNumber.push_back(ibooker.book1D(
149  "hStripNumber_m11a", "Strip Number Fired (ME -1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
150  hStripNumber.push_back(
151  ibooker.book1D("hStripNumber_m13", "Strip Number Fired (ME -1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
152  hStripNumber.push_back(
153  ibooker.book1D("hStripNumber_m12", "Strip Number Fired (ME -1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
154  hStripNumber.push_back(ibooker.book1D(
155  "hStripNumber_m11b", "Strip Number Fired (ME -1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
156  hStripNumber.push_back(ibooker.book1D(
157  "hStripNumber_p11b", "Strip Number Fired (ME +1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
158  hStripNumber.push_back(
159  ibooker.book1D("hStripNumber_p12", "Strip Number Fired (ME +1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
160  hStripNumber.push_back(
161  ibooker.book1D("hStripNumber_p13", "Strip Number Fired (ME +1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
162  hStripNumber.push_back(ibooker.book1D(
163  "hStripNumber_p11a", "Strip Number Fired (ME +1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
164  hStripNumber.push_back(
165  ibooker.book1D("hStripNumber_p21", "Strip Number Fired (ME +2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
166  hStripNumber.push_back(
167  ibooker.book1D("hStripNumber_p22", "Strip Number Fired (ME +2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
168  hStripNumber.push_back(
169  ibooker.book1D("hStripNumber_p31", "Strip Number Fired (ME +3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
170  hStripNumber.push_back(
171  ibooker.book1D("hStripNumber_p32", "Strip Number Fired (ME +3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
172  hStripNumber.push_back(
173  ibooker.book1D("hStripNumber_p41", "Strip Number Fired (ME +4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
174  hStripNumber.push_back(ibooker.book1D(
175  "hStripNumber_p42", "Stripgroup Number Fired (ME +4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
176 
177  // pedestal noise
178  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/PedestalNoise");
179 
180  hStripPed.push_back(
181  ibooker.book1D("hStripPedMEm42", "Pedestal Noise Distribution Chamber ME -4/2; ADC Counts", 50, -25., 25.));
182  hStripPed.push_back(
183  ibooker.book1D("hStripPedMEm41", "Pedestal Noise Distribution Chamber ME -4/1; ADC Counts", 50, -25., 25.));
184  hStripPed.push_back(
185  ibooker.book1D("hStripPedMEm32", "Pedestal Noise Distribution Chamber ME -3/2; ADC Counts", 50, -25., 25.));
186  hStripPed.push_back(
187  ibooker.book1D("hStripPedMEm31", "Pedestal Noise Distribution Chamber ME -3/1; ADC Counts", 50, -25., 25.));
188  hStripPed.push_back(
189  ibooker.book1D("hStripPedMEm22", "Pedestal Noise Distribution Chamber ME -2/2; ADC Counts", 50, -25., 25.));
190  hStripPed.push_back(
191  ibooker.book1D("hStripPedMEm21", "Pedestal Noise Distribution Chamber ME -2/1; ADC Counts", 50, -25., 25.));
192  hStripPed.push_back(
193  ibooker.book1D("hStripPedMEm11a", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
194  hStripPed.push_back(
195  ibooker.book1D("hStripPedMEm13", "Pedestal Noise Distribution Chamber ME -1/3; ADC Counts", 50, -25., 25.));
196  hStripPed.push_back(
197  ibooker.book1D("hStripPedMEm12", "Pedestal Noise Distribution Chamber ME -1/2; ADC Counts", 50, -25., 25.));
198  hStripPed.push_back(
199  ibooker.book1D("hStripPedMEm11b", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
200  hStripPed.push_back(
201  ibooker.book1D("hStripPedMEp11b", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
202  hStripPed.push_back(
203  ibooker.book1D("hStripPedMEp12", "Pedestal Noise Distribution Chamber ME +1/2; ADC Counts", 50, -25., 25.));
204  hStripPed.push_back(
205  ibooker.book1D("hStripPedMEp13", "Pedestal Noise Distribution Chamber ME +1/3; ADC Counts", 50, -25., 25.));
206  hStripPed.push_back(
207  ibooker.book1D("hStripPedMEp11a", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
208  hStripPed.push_back(
209  ibooker.book1D("hStripPedMEp21", "Pedestal Noise Distribution Chamber ME +2/1; ADC Counts", 50, -25., 25.));
210  hStripPed.push_back(
211  ibooker.book1D("hStripPedMEp22", "Pedestal Noise Distribution Chamber ME +2/2; ADC Counts", 50, -25., 25.));
212  hStripPed.push_back(
213  ibooker.book1D("hStripPedMEp31", "Pedestal Noise Distribution Chamber ME +3/1; ADC Counts", 50, -25., 25.));
214  hStripPed.push_back(
215  ibooker.book1D("hStripPedMEp32", "Pedestal Noise Distribution Chamber ME +3/2; ADC Counts", 50, -25., 25.));
216  hStripPed.push_back(
217  ibooker.book1D("hStripPedMEp41", "Pedestal Noise Distribution Chamber ME +4/1; ADC Counts", 50, -25., 25.));
218  hStripPed.push_back(
219  ibooker.book1D("hStripPedMEp42", "Pedestal Noise Distribution Chamber ME +4/2; ADC Counts", 50, -25., 25.));
220 
221  // rechits
222  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/recHits");
223 
224  // For low multiplicities (e.g. low or no pileup)
225  hRHnrechits = ibooker.book1D("hRHnrechits", "RecHits per Event; # of RecHits", 100, 0., 100.); // 1 bin is 1
226  // For high multiplcities (e.g. with pileup)
227  hRHnrechitsHi = ibooker.book1D("hRHnrechitsHi", "RecHits per Event; # of RecHits", 250, 0., 1000.); // 1 bin is 4
228 
229  hRHGlobal.push_back(ibooker.book2D(
230  "hRHGlobalp1", "recHit global X,Y station +1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
231  hRHGlobal.push_back(ibooker.book2D(
232  "hRHGlobalp2", "recHit global X,Y station +2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
233  hRHGlobal.push_back(ibooker.book2D(
234  "hRHGlobalp3", "recHit global X,Y station +3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
235  hRHGlobal.push_back(ibooker.book2D(
236  "hRHGlobalp4", "recHit global X,Y station +4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
237  hRHGlobal.push_back(ibooker.book2D(
238  "hRHGlobalm1", "recHit global X,Y station -1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
239  hRHGlobal.push_back(ibooker.book2D(
240  "hRHGlobalm2", "recHit global X,Y station -2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
241  hRHGlobal.push_back(ibooker.book2D(
242  "hRHGlobalm3", "recHit global X,Y station -3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
243  hRHGlobal.push_back(ibooker.book2D(
244  "hRHGlobalm4", "recHit global X,Y station -4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
245  hRHSumQ.push_back(ibooker.book1D("hRHSumQm42", "Sum 3x3 recHit Charge (ME -4/2); ADC counts", 100, 0, 2000));
246  hRHSumQ.push_back(ibooker.book1D("hRHSumQm41", "Sum 3x3 recHit Charge (ME -4/1); ADC counts", 100, 0, 2000));
247  hRHSumQ.push_back(ibooker.book1D("hRHSumQm32", "Sum 3x3 recHit Charge (ME -3/2); ADC counts", 100, 0, 2000));
248  hRHSumQ.push_back(ibooker.book1D("hRHSumQm31", "Sum 3x3 recHit Charge (ME -3/1); ADC counts", 100, 0, 2000));
249  hRHSumQ.push_back(ibooker.book1D("hRHSumQm22", "Sum 3x3 recHit Charge (ME -2/2); ADC counts", 100, 0, 2000));
250  hRHSumQ.push_back(ibooker.book1D("hRHSumQm21", "Sum 3x3 recHit Charge (ME -2/1); ADC counts", 100, 0, 2000));
251  hRHSumQ.push_back(ibooker.book1D("hRHSumQm11a", "Sum 3x3 recHit Charge (ME -1/1a); ADC counts", 100, 0, 4000));
252  hRHSumQ.push_back(ibooker.book1D("hRHSumQm13", "Sum 3x3 recHit Charge (ME -1/3); ADC counts", 100, 0, 2000));
253  hRHSumQ.push_back(ibooker.book1D("hRHSumQm12", "Sum 3x3 recHit Charge (ME -1/2); ADC counts", 100, 0, 2000));
254  hRHSumQ.push_back(ibooker.book1D("hRHSumQm11b", "Sum 3x3 recHit Charge (ME -1/1b); ADC counts", 100, 0, 4000));
255  hRHSumQ.push_back(ibooker.book1D("hRHSumQp11b", "Sum 3x3 recHit Charge (ME +1/1b); ADC counts", 100, 0, 4000));
256  hRHSumQ.push_back(ibooker.book1D("hRHSumQp12", "Sum 3x3 recHit Charge (ME +1/2); ADC counts", 100, 0, 2000));
257  hRHSumQ.push_back(ibooker.book1D("hRHSumQp13", "Sum 3x3 recHit Charge (ME +1/3); ADC counts", 100, 0, 2000));
258  hRHSumQ.push_back(ibooker.book1D("hRHSumQp11a", "Sum 3x3 recHit Charge (ME +1/1a); ADC counts", 100, 0, 4000));
259  hRHSumQ.push_back(ibooker.book1D("hRHSumQp21", "Sum 3x3 recHit Charge (ME +2/1); ADC counts", 100, 0, 2000));
260  hRHSumQ.push_back(ibooker.book1D("hRHSumQp22", "Sum 3x3 recHit Charge (ME +2/2); ADC counts", 100, 0, 2000));
261  hRHSumQ.push_back(ibooker.book1D("hRHSumQp31", "Sum 3x3 recHit Charge (ME +3/1); ADC counts", 100, 0, 2000));
262  hRHSumQ.push_back(ibooker.book1D("hRHSumQp32", "Sum 3x3 recHit Charge (ME +3/2); ADC counts", 100, 0, 2000));
263  hRHSumQ.push_back(ibooker.book1D("hRHSumQp41", "Sum 3x3 recHit Charge (ME +4/1); ADC counts", 100, 0, 2000));
264  hRHSumQ.push_back(ibooker.book1D("hRHSumQp42", "Sum 3x3 recHit Charge (ME +4/2); ADC counts", 100, 0, 2000));
265  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm42", "Charge Ratio (Ql+Qr)/Qt (ME -4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
266  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm41", "Charge Ratio (Ql+Qr)/Qt (ME -4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
267  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm32", "Charge Ratio (Ql+Qr)/Qt (ME -3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
268  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm31", "Charge Ratio (Ql+Qr)/Qt (ME -3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
269  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm22", "Charge Ratio (Ql+Qr)/Qt (ME -2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
270  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm21", "Charge Ratio (Ql+Qr)/Qt (ME -2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
271  hRHRatioQ.push_back(
272  ibooker.book1D("hRHRatioQm11a", "Charge Ratio (Ql+Qr)/Qt (ME -1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
273  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm13", "Charge Ratio (Ql+Qr)/Qt (ME -1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
274  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm12", "Charge Ratio (Ql+Qr)/Qt (ME -1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
275  hRHRatioQ.push_back(
276  ibooker.book1D("hRHRatioQm11b", "Charge Ratio (Ql+Qr)/Qt (ME -1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
277  hRHRatioQ.push_back(
278  ibooker.book1D("hRHRatioQp11b", "Charge Ratio (Ql+Qr)/Qt (ME +1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
279  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp12", "Charge Ratio (Ql+Qr)/Qt (ME +1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
280  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp13", "Charge Ratio (Ql+Qr)/Qt (ME +1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
281  hRHRatioQ.push_back(
282  ibooker.book1D("hRHRatioQp11a", "Charge Ratio (Ql+Qr)/Qt (ME +1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
283  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp21", "Charge Ratio (Ql+Qr)/Qt (ME +2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
284  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp22", "Charge Ratio (Ql+Qr)/Qt (ME +2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
285  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp31", "Charge Ratio (Ql+Qr)/Qt (ME +3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
286  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp32", "Charge Ratio (Ql+Qr)/Qt (ME +3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
287  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp41", "Charge Ratio (Ql+Qr)/Qt (ME +4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
288  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp42", "Charge Ratio (Ql+Qr)/Qt (ME +4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
289  hRHTiming.push_back(ibooker.book1D("hRHTimingm42", "recHit Time (ME -4/2); ns", 200, -500., 500.));
290  hRHTiming.push_back(ibooker.book1D("hRHTimingm41", "recHit Time (ME -4/1); ns", 200, -500., 500.));
291  hRHTiming.push_back(ibooker.book1D("hRHTimingm32", "recHit Time (ME -3/2); ns", 200, -500., 500.));
292  hRHTiming.push_back(ibooker.book1D("hRHTimingm31", "recHit Time (ME -3/1); ns", 200, -500., 500.));
293  hRHTiming.push_back(ibooker.book1D("hRHTimingm22", "recHit Time (ME -2/2); ns", 200, -500., 500.));
294  hRHTiming.push_back(ibooker.book1D("hRHTimingm21", "recHit Time (ME -2/1); ns", 200, -500., 500.));
295  hRHTiming.push_back(ibooker.book1D("hRHTimingm11a", "recHit Time (ME -1/1a); ns", 200, -500., 500.));
296  hRHTiming.push_back(ibooker.book1D("hRHTimingm13", "recHit Time (ME -1/3); ns", 200, -500., 500.));
297  hRHTiming.push_back(ibooker.book1D("hRHTimingm12", "recHit Time (ME -1/2); ns", 200, -500., 500.));
298  hRHTiming.push_back(ibooker.book1D("hRHTimingm11b", "recHit Time (ME -1/1b); ns", 200, -500., 500.));
299  hRHTiming.push_back(ibooker.book1D("hRHTimingp11b", "recHit Time (ME +1/1b); ns", 200, -500., 500.));
300  hRHTiming.push_back(ibooker.book1D("hRHTimingp12", "recHit Time (ME +1/2); ns", 200, -500., 500.));
301  hRHTiming.push_back(ibooker.book1D("hRHTimingp13", "recHit Time (ME +1/3); ns", 200, -500., 500.));
302  hRHTiming.push_back(ibooker.book1D("hRHTimingp11a", "recHit Time (ME +1/1a); ns", 200, -500., 500.));
303  hRHTiming.push_back(ibooker.book1D("hRHTimingp21", "recHit Time (ME +2/1); ns", 200, -500., 500.));
304  hRHTiming.push_back(ibooker.book1D("hRHTimingp22", "recHit Time (ME +2/2); ns", 200, -500., 500.));
305  hRHTiming.push_back(ibooker.book1D("hRHTimingp31", "recHit Time (ME +3/1); ns", 200, -500., 500.));
306  hRHTiming.push_back(ibooker.book1D("hRHTimingp32", "recHit Time (ME +3/2); ns", 200, -500., 500.));
307  hRHTiming.push_back(ibooker.book1D("hRHTimingp41", "recHit Time (ME +4/1); ns", 200, -500., 500.));
308  hRHTiming.push_back(ibooker.book1D("hRHTimingp42", "recHit Time (ME +4/2); ns", 200, -500., 500.));
309  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem42", "Anode recHit Time (ME -4/2); ns", 80, -500., 500.));
310  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem41", "Anode recHit Time (ME -4/1); ns", 80, -500., 500.));
311  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem32", "Anode recHit Time (ME -3/2); ns", 80, -500., 500.));
312  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem31", "Anode recHit Time (ME -3/1); ns", 80, -500., 500.));
313  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem22", "Anode recHit Time (ME -2/2); ns", 80, -500., 500.));
314  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem21", "Anode recHit Time (ME -2/1); ns", 80, -500., 500.));
315  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11a", "Anode recHit Time (ME -1/1a); ns", 80, -500., 500.));
316  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem13", "Anode recHit Time (ME -1/3); ns", 80, -500., 500.));
317  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem12", "Anode recHit Time (ME -1/2); ns", 80, -500., 500.));
318  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11b", "Anode recHit Time (ME -1/1b); ns", 80, -500., 500.));
319  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11b", "Anode recHit Time (ME +1/1b); ns", 80, -500., 500.));
320  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep12", "Anode recHit Time (ME +1/2); ns", 80, -500., 500.));
321  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep13", "Anode recHit Time (ME +1/3); ns", 80, -500., 500.));
322  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11a", "Anode recHit Time (ME +1/1a); ns", 80, -500., 500.));
323  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep21", "Anode recHit Time (ME +2/1); ns", 80, -500., 500.));
324  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep22", "Anode recHit Time (ME +2/2); ns", 80, -500., 500.));
325  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep31", "Anode recHit Time (ME +3/1); ns", 80, -500., 500.));
326  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep32", "Anode recHit Time (ME +3/2); ns", 80, -500., 500.));
327  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep41", "Anode recHit Time (ME +4/1); ns", 80, -500., 500.));
328  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep42", "Anode recHit Time (ME +4/2); ns", 80, -500., 500.));
329  hRHstpos.push_back(
330  ibooker.book1D("hRHstposm42", "Reconstructed Position on Strip (ME -4/2); Strip Widths", 120, -0.6, 0.6));
331  hRHstpos.push_back(
332  ibooker.book1D("hRHstposm41", "Reconstructed Position on Strip (ME -4/1); Strip Widths", 120, -0.6, 0.6));
333  hRHstpos.push_back(
334  ibooker.book1D("hRHstposm32", "Reconstructed Position on Strip (ME -3/2); Strip Widths", 120, -0.6, 0.6));
335  hRHstpos.push_back(
336  ibooker.book1D("hRHstposm31", "Reconstructed Position on Strip (ME -3/1); Strip Widths", 120, -0.6, 0.6));
337  hRHstpos.push_back(
338  ibooker.book1D("hRHstposm22", "Reconstructed Position on Strip (ME -2/2); Strip Widths", 120, -0.6, 0.6));
339  hRHstpos.push_back(
340  ibooker.book1D("hRHstposm21", "Reconstructed Position on Strip (ME -2/1); Strip Widths", 120, -0.6, 0.6));
341  hRHstpos.push_back(
342  ibooker.book1D("hRHstposm11a", "Reconstructed Position on Strip (ME -1/1a); Strip Widths", 120, -0.6, 0.6));
343  hRHstpos.push_back(
344  ibooker.book1D("hRHstposm13", "Reconstructed Position on Strip (ME -1/3); Strip Widths", 120, -0.6, 0.6));
345  hRHstpos.push_back(
346  ibooker.book1D("hRHstposm12", "Reconstructed Position on Strip (ME -1/2); Strip Widths", 120, -0.6, 0.6));
347  hRHstpos.push_back(
348  ibooker.book1D("hRHstposm11b", "Reconstructed Position on Strip (ME -1/1b); Strip Widths", 120, -0.6, 0.6));
349  hRHstpos.push_back(
350  ibooker.book1D("hRHstposp11b", "Reconstructed Position on Strip (ME +1/1b); Strip Widths", 120, -0.6, 0.6));
351  hRHstpos.push_back(
352  ibooker.book1D("hRHstposp12", "Reconstructed Position on Strip (ME +1/2); Strip Widths", 120, -0.6, 0.6));
353  hRHstpos.push_back(
354  ibooker.book1D("hRHstposp13", "Reconstructed Position on Strip (ME +1/3); Strip Widths", 120, -0.6, 0.6));
355  hRHstpos.push_back(
356  ibooker.book1D("hRHstposp11a", "Reconstructed Position on Strip (ME +1/1a); Strip Widths", 120, -0.6, 0.6));
357  hRHstpos.push_back(
358  ibooker.book1D("hRHstposp21", "Reconstructed Position on Strip (ME +2/1); Strip Widths", 120, -0.6, 0.6));
359  hRHstpos.push_back(
360  ibooker.book1D("hRHstposp22", "Reconstructed Position on Strip (ME +2/2); Strip Widths", 120, -0.6, 0.6));
361  hRHstpos.push_back(
362  ibooker.book1D("hRHstposp31", "Reconstructed Position on Strip (ME +3/1); Strip Widths", 120, -0.6, 0.6));
363  hRHstpos.push_back(
364  ibooker.book1D("hRHstposp32", "Reconstructed Position on Strip (ME +3/2); Strip Widths", 120, -0.6, 0.6));
365  hRHstpos.push_back(
366  ibooker.book1D("hRHstposp41", "Reconstructed Position on Strip (ME +4/1); Strip Widths", 120, -0.6, 0.6));
367  hRHstpos.push_back(
368  ibooker.book1D("hRHstposp42", "Reconstructed Position on Strip (ME +4/2); Strip Widths", 120, -0.6, 0.6));
369  hRHsterr.push_back(
370  ibooker.book1D("hRHsterrm42", "Estimated Error on Strip Measurement (ME -4/2); Strip Widths", 75, -0.01, 0.24));
371  hRHsterr.push_back(
372  ibooker.book1D("hRHsterrm41", "Estimated Error on Strip Measurement (ME -4/1); Strip Widths", 75, -0.01, 0.24));
373  hRHsterr.push_back(
374  ibooker.book1D("hRHsterrm32", "Estimated Error on Strip Measurement (ME -3/2); Strip Widths", 75, -0.01, 0.24));
375  hRHsterr.push_back(
376  ibooker.book1D("hRHsterrm31", "Estimated Error on Strip Measurement (ME -3/1); Strip Widths", 75, -0.01, 0.24));
377  hRHsterr.push_back(
378  ibooker.book1D("hRHsterrm22", "Estimated Error on Strip Measurement (ME -2/2); Strip Widths", 75, -0.01, 0.24));
379  hRHsterr.push_back(
380  ibooker.book1D("hRHsterrm21", "Estimated Error on Strip Measurement (ME -2/1); Strip Widths", 75, -0.01, 0.24));
381  hRHsterr.push_back(
382  ibooker.book1D("hRHsterrm11a", "Estimated Error on Strip Measurement (ME -1/1a); Strip Widths", 75, -0.01, 0.24));
383  hRHsterr.push_back(
384  ibooker.book1D("hRHsterrm13", "Estimated Error on Strip Measurement (ME -1/3); Strip Widths", 75, -0.01, 0.24));
385  hRHsterr.push_back(
386  ibooker.book1D("hRHsterrm12", "Estimated Error on Strip Measurement (ME -1/2); Strip Widths", 75, -0.01, 0.24));
387  hRHsterr.push_back(
388  ibooker.book1D("hRHsterrm11b", "Estimated Error on Strip Measurement (ME -1/1b); Strip Widths", 75, -0.01, 0.24));
389  hRHsterr.push_back(
390  ibooker.book1D("hRHsterrp11b", "Estimated Error on Strip Measurement (ME +1/1b); Strip Widths", 75, -0.01, 0.24));
391  hRHsterr.push_back(
392  ibooker.book1D("hRHsterrp12", "Estimated Error on Strip Measurement (ME +1/2); Strip Widths", 75, -0.01, 0.24));
393  hRHsterr.push_back(
394  ibooker.book1D("hRHsterrp13", "Estimated Error on Strip Measurement (ME +1/3); Strip Widths", 75, -0.01, 0.24));
395  hRHsterr.push_back(
396  ibooker.book1D("hRHsterrp11a", "Estimated Error on Strip Measurement (ME +1/1a); Strip Widths", 75, -0.01, 0.24));
397  hRHsterr.push_back(
398  ibooker.book1D("hRHsterrp21", "Estimated Error on Strip Measurement (ME +2/1); Strip Widths", 75, -0.01, 0.24));
399  hRHsterr.push_back(
400  ibooker.book1D("hRHsterrp22", "Estimated Error on Strip Measurement (ME +2/2); Strip Widths", 75, -0.01, 0.24));
401  hRHsterr.push_back(
402  ibooker.book1D("hRHsterrp31", "Estimated Error on Strip Measurement (ME +3/1); Strip Widths", 75, -0.01, 0.24));
403  hRHsterr.push_back(
404  ibooker.book1D("hRHsterrp32", "Estimated Error on Strip Measurement (ME +3/2); Strip Widths", 75, -0.01, 0.24));
405  hRHsterr.push_back(
406  ibooker.book1D("hRHsterrp41", "Estimated Error on Strip Measurement (ME +4/1); Strip Widths", 75, -0.01, 0.24));
407  hRHsterr.push_back(
408  ibooker.book1D("hRHsterrp42", "Estimated Error on Strip Measurement (ME +4/2); Strip Widths", 75, -0.01, 0.24));
409 
410  // segments
411  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Segments");
412 
413  hSnSegments = ibooker.book1D("hSnSegments", "Segments per Event; # of Segments", 100, 0., 100.); // 1 bin is 1
414 
415  hSnhitsAll = ibooker.book1D("hSnhits", "N hits on Segments; # of hits", 8, -0.5, 7.5);
416  hSnhits.push_back(ibooker.book1D("hSnhitsm42", "# of hits on Segments (ME -4/2); # of hits", 8, -0.5, 7.5));
417  hSnhits.push_back(ibooker.book1D("hSnhitsm41", "# of hits on Segments (ME -4/1); # of hits", 8, -0.5, 7.5));
418  hSnhits.push_back(ibooker.book1D("hSnhitsm32", "# of hits on Segments (ME -3/2); # of hits", 8, -0.5, 7.5));
419  hSnhits.push_back(ibooker.book1D("hSnhitsm31", "# of hits on Segments (ME -3/1); # of hits", 8, -0.5, 7.5));
420  hSnhits.push_back(ibooker.book1D("hSnhitsm22", "# of hits on Segments (ME -2/2); # of hits", 8, -0.5, 7.5));
421  hSnhits.push_back(ibooker.book1D("hSnhitsm21", "# of hits on Segments (ME -2/1); # of hits", 8, -0.5, 7.5));
422  hSnhits.push_back(ibooker.book1D("hSnhitsm11a", "# of hits on Segments (ME -1/1a); # of hits", 8, -0.5, 7.5));
423  hSnhits.push_back(ibooker.book1D("hSnhitsm13", "# of hits on Segments (ME -1/3); # of hits", 8, -0.5, 7.5));
424  hSnhits.push_back(ibooker.book1D("hSnhitsm12", "# of hits on Segments (ME -1/2); # of hits", 8, -0.5, 7.5));
425  hSnhits.push_back(ibooker.book1D("hSnhitsm11b", "# of hits on Segments (ME -1/1b); # of hits", 8, -0.5, 7.5));
426  hSnhits.push_back(ibooker.book1D("hSnhitsp11b", "# of hits on Segments (ME +1/1b); # of hits", 8, -0.5, 7.5));
427  hSnhits.push_back(ibooker.book1D("hSnhitsp12", "# of hits on Segments (ME +1/2); # of hits", 8, -0.5, 7.5));
428  hSnhits.push_back(ibooker.book1D("hSnhitsp13", "# of hits on Segments (ME +1/3); # of hits", 8, -0.5, 7.5));
429  hSnhits.push_back(ibooker.book1D("hSnhitsp11a", "# of hits on Segments (ME +1/1a); # of hits", 8, -0.5, 7.5));
430  hSnhits.push_back(ibooker.book1D("hSnhitsp21", "# of hits on Segments (ME +2/1); # of hits", 8, -0.5, 7.5));
431  hSnhits.push_back(ibooker.book1D("hSnhitsp22", "# of hits on Segments (ME +2/2); # of hits", 8, -0.5, 7.5));
432  hSnhits.push_back(ibooker.book1D("hSnhitsp31", "# of hits on Segments (ME +3/1); # of hits", 8, -0.5, 7.5));
433  hSnhits.push_back(ibooker.book1D("hSnhitsp32", "# of hits on Segments (ME +3/2); # of hits", 8, -0.5, 7.5));
434  hSnhits.push_back(ibooker.book1D("hSnhitsp41", "# of hits on Segments (ME +4/1); # of hits", 8, -0.5, 7.5));
435  hSnhits.push_back(ibooker.book1D("hSnhitsp42", "# of hits on Segments (ME +4/2); # of hits", 8, -0.5, 7.5));
436  hSChiSqAll = ibooker.book1D("hSChiSq", "Segment Normalized Chi2; Chi2/ndof", 110, -0.05, 10.5);
437  hSChiSq.push_back(ibooker.book1D("hSChiSqm42", "Segment Normalized Chi2 (ME -4/2); Chi2/ndof", 110, -0.05, 10.5));
438  hSChiSq.push_back(ibooker.book1D("hSChiSqm41", "Segment Normalized Chi2 (ME -4/1); Chi2/ndof", 110, -0.05, 10.5));
439  hSChiSq.push_back(ibooker.book1D("hSChiSqm32", "Segment Normalized Chi2 (ME -3/2); Chi2/ndof", 110, -0.05, 10.5));
440  hSChiSq.push_back(ibooker.book1D("hSChiSqm31", "Segment Normalized Chi2 (ME -3/1); Chi2/ndof", 110, -0.05, 10.5));
441  hSChiSq.push_back(ibooker.book1D("hSChiSqm22", "Segment Normalized Chi2 (ME -2/2); Chi2/ndof", 110, -0.05, 10.5));
442  hSChiSq.push_back(ibooker.book1D("hSChiSqm21", "Segment Normalized Chi2 (ME -2/1); Chi2/ndof", 110, -0.05, 10.5));
443  hSChiSq.push_back(ibooker.book1D("hSChiSqm11a", "Segment Normalized Chi2 (ME -1/1a); Chi2/ndof", 110, -0.05, 10.5));
444  hSChiSq.push_back(ibooker.book1D("hSChiSqm13", "Segment Normalized Chi2 (ME -1/3); Chi2/ndof", 110, -0.05, 10.5));
445  hSChiSq.push_back(ibooker.book1D("hSChiSqm12", "Segment Normalized Chi2 (ME -1/2); Chi2/ndof", 110, -0.05, 10.5));
446  hSChiSq.push_back(ibooker.book1D("hSChiSqm11b", "Segment Normalized Chi2 (ME -1/1b); Chi2/ndof", 110, -0.05, 10.5));
447  hSChiSq.push_back(ibooker.book1D("hSChiSqp11b", "Segment Normalized Chi2 (ME +1/1b); Chi2/ndof", 110, -0.05, 10.5));
448  hSChiSq.push_back(ibooker.book1D("hSChiSqp12", "Segment Normalized Chi2 (ME +1/2); Chi2/ndof", 110, -0.05, 10.5));
449  hSChiSq.push_back(ibooker.book1D("hSChiSqp13", "Segment Normalized Chi2 (ME +1/3); Chi2/ndof", 110, -0.05, 10.5));
450  hSChiSq.push_back(ibooker.book1D("hSChiSqp11a", "Segment Normalized Chi2 (ME +1/1a); Chi2/ndof", 110, -0.05, 10.5));
451  hSChiSq.push_back(ibooker.book1D("hSChiSqp21", "Segment Normalized Chi2 (ME +2/1); Chi2/ndof", 110, -0.05, 10.5));
452  hSChiSq.push_back(ibooker.book1D("hSChiSqp22", "Segment Normalized Chi2 (ME +2/2); Chi2/ndof", 110, -0.05, 10.5));
453  hSChiSq.push_back(ibooker.book1D("hSChiSqp31", "Segment Normalized Chi2 (ME +3/1); Chi2/ndof", 110, -0.05, 10.5));
454  hSChiSq.push_back(ibooker.book1D("hSChiSqp32", "Segment Normalized Chi2 (ME +3/2); Chi2/ndof", 110, -0.05, 10.5));
455  hSChiSq.push_back(ibooker.book1D("hSChiSqp41", "Segment Normalized Chi2 (ME +4/1); Chi2/ndof", 110, -0.05, 10.5));
456  hSChiSq.push_back(ibooker.book1D("hSChiSqp42", "Segment Normalized Chi2 (ME +4/2); Chi2/ndof", 110, -0.05, 10.5));
457  hSChiSqProbAll = ibooker.book1D("hSChiSqProb", "Segment chi2 Probability; Probability", 110, -0.05, 1.05);
458  hSChiSqProb.push_back(
459  ibooker.book1D("hSChiSqProbm42", "Segment chi2 Probability (ME -4/2); Probability", 110, -0.05, 1.05));
460  hSChiSqProb.push_back(
461  ibooker.book1D("hSChiSqProbm41", "Segment chi2 Probability (ME -4/1); Probability", 110, -0.05, 1.05));
462  hSChiSqProb.push_back(
463  ibooker.book1D("hSChiSqProbm32", "Segment chi2 Probability (ME -3/2); Probability", 110, -0.05, 1.05));
464  hSChiSqProb.push_back(
465  ibooker.book1D("hSChiSqProbm31", "Segment chi2 Probability (ME -3/1); Probability", 110, -0.05, 1.05));
466  hSChiSqProb.push_back(
467  ibooker.book1D("hSChiSqProbm22", "Segment chi2 Probability (ME -2/2); Probability", 110, -0.05, 1.05));
468  hSChiSqProb.push_back(
469  ibooker.book1D("hSChiSqProbm21", "Segment chi2 Probability (ME -2/1); Probability", 110, -0.05, 1.05));
470  hSChiSqProb.push_back(
471  ibooker.book1D("hSChiSqProbm11a", "Segment chi2 Probability (ME -1/1a); Probability", 110, -0.05, 1.05));
472  hSChiSqProb.push_back(
473  ibooker.book1D("hSChiSqProbm13", "Segment chi2 Probability (ME -1/3); Probability", 110, -0.05, 1.05));
474  hSChiSqProb.push_back(
475  ibooker.book1D("hSChiSqProbm12", "Segment chi2 Probability (ME -1/2); Probability", 110, -0.05, 1.05));
476  hSChiSqProb.push_back(
477  ibooker.book1D("hSChiSqProbm11b", "Segment chi2 Probability (ME -1/1b); Probability", 110, -0.05, 1.05));
478  hSChiSqProb.push_back(
479  ibooker.book1D("hSChiSqProbp11b", "Segment chi2 Probability (ME +1/1b); Probability", 110, -0.05, 1.05));
480  hSChiSqProb.push_back(
481  ibooker.book1D("hSChiSqProbp12", "Segment chi2 Probability (ME +1/2); Probability", 110, -0.05, 1.05));
482  hSChiSqProb.push_back(
483  ibooker.book1D("hSChiSqProbp13", "Segment chi2 Probability (ME +1/3); Probability", 110, -0.05, 1.05));
484  hSChiSqProb.push_back(
485  ibooker.book1D("hSChiSqProbp11a", "Segment chi2 Probability (ME +1/1a); Probability", 110, -0.05, 1.05));
486  hSChiSqProb.push_back(
487  ibooker.book1D("hSChiSqProbp21", "Segment chi2 Probability (ME +2/1); Probability", 110, -0.05, 1.05));
488  hSChiSqProb.push_back(
489  ibooker.book1D("hSChiSqProbp22", "Segment chi2 Probability (ME +2/2); Probability", 110, -0.05, 1.05));
490  hSChiSqProb.push_back(
491  ibooker.book1D("hSChiSqProbp31", "Segment chi2 Probability (ME +3/1); Probability", 110, -0.05, 1.05));
492  hSChiSqProb.push_back(
493  ibooker.book1D("hSChiSqProbp32", "Segment chi2 Probability (ME +3/2); Probability", 110, -0.05, 1.05));
494  hSChiSqProb.push_back(
495  ibooker.book1D("hSChiSqProbp41", "Segment chi2 Probability (ME +4/1); Probability", 110, -0.05, 1.05));
496  hSChiSqProb.push_back(
497  ibooker.book1D("hSChiSqProbp42", "Segment chi2 Probability (ME +4/2); Probability", 110, -0.05, 1.05));
498  hSGlobalTheta =
499  ibooker.book1D("hSGlobalTheta", "Segment Direction (Global Theta); Global Theta (radians)", 136, -0.1, 3.3);
500  hSGlobalPhi = ibooker.book1D("hSGlobalPhi", "Segment Direction (Global Phi); Global Phi (radians)", 128, -3.2, 3.2);
501 
502  hSTimeDiff = ibooker.book1D("hSTimeDiff", "Anode Minus Cathode Segment Time [ns]", 50, -50, 50);
503  hSTimeDiffByChamberType.push_back(
504  ibooker.book1D("hSTimeDiff_m42", "Anode Minus Cathode Segment Time (ME -4/2) [ns]", 50, -50, 50));
505  hSTimeDiffByChamberType.push_back(
506  ibooker.book1D("hSTimeDiff_m41", "Anode Minus Cathode Segment Time (ME -4/1) [ns]", 50, -50, 50));
507  hSTimeDiffByChamberType.push_back(
508  ibooker.book1D("hSTimeDiff_m32", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
509  hSTimeDiffByChamberType.push_back(
510  ibooker.book1D("hSTimeDiff_m31", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
511  hSTimeDiffByChamberType.push_back(
512  ibooker.book1D("hSTimeDiff_m22", "Anode Minus Cathode Segment Time (ME -2/2) [ns]", 50, -50, 50));
513  hSTimeDiffByChamberType.push_back(
514  ibooker.book1D("hSTimeDiff_m21", "Anode Minus Cathode Segment Time (ME -2/1) [ns]", 50, -50, 50));
515  hSTimeDiffByChamberType.push_back(
516  ibooker.book1D("hSTimeDiff_m11a", "Anode Minus Cathode Segment Time (ME -1/1a) [ns]", 50, -50, 50));
517  hSTimeDiffByChamberType.push_back(
518  ibooker.book1D("hSTimeDiff_m13", "Anode Minus Cathode Segment Time (ME -1/3) [ns]", 50, -50, 50));
519  hSTimeDiffByChamberType.push_back(
520  ibooker.book1D("hSTimeDiff_m12", "Anode Minus Cathode Segment Time (ME -1/2) [ns]", 50, -50, 50));
521  hSTimeDiffByChamberType.push_back(
522  ibooker.book1D("hSTimeDiff_m11b", "Anode Minus Cathode Segment Time (ME -1/1b) [ns]", 50, -50, 50));
523  hSTimeDiffByChamberType.push_back(
524  ibooker.book1D("hSTimeDiff_p11b", "Anode Minus Cathode Segment Time (ME +1/1b) [ns]", 50, -50, 50));
525  hSTimeDiffByChamberType.push_back(
526  ibooker.book1D("hSTimeDiff_p12", "Anode Minus Cathode Segment Time (ME +1/2) [ns]", 50, -50, 50));
527  hSTimeDiffByChamberType.push_back(
528  ibooker.book1D("hSTimeDiff_p13", "Anode Minus Cathode Segment Time (ME +1/3) [ns]", 50, -50, 50));
529  hSTimeDiffByChamberType.push_back(
530  ibooker.book1D("hSTimeDiff_p11a", "Anode Minus Cathode Segment Time (ME +1/1a) [ns]", 50, -50, 50));
531  hSTimeDiffByChamberType.push_back(
532  ibooker.book1D("hSTimeDiff_p21", "Anode Minus Cathode Segment Time (ME +2/1) [ns]", 50, -50, 50));
533  hSTimeDiffByChamberType.push_back(
534  ibooker.book1D("hSTimeDiff_p22", "Anode Minus Cathode Segment Time (ME +2/2) [ns]", 50, -50, 50));
535  hSTimeDiffByChamberType.push_back(
536  ibooker.book1D("hSTimeDiff_p31", "Anode Minus Cathode Segment Time (ME +3/1) [ns]", 50, -50, 50));
537  hSTimeDiffByChamberType.push_back(
538  ibooker.book1D("hSTimeDiff_p32", "Anode Minus Cathode Segment Time (ME +3/2) [ns]", 50, -50, 50));
539  hSTimeDiffByChamberType.push_back(
540  ibooker.book1D("hSTimeDiff_p41", "Anode Minus Cathode Segment Time (ME +4/1) [ns]", 50, -50, 50));
541  hSTimeDiffByChamberType.push_back(
542  ibooker.book1D("hSTimeDiff_p42", "Anode Minus Cathode Segment Time (ME +4/2) [ns]", 50, -50, 50));
543 
544  hSTimeAnode = ibooker.book1D("hSTimeAnode", "Anode Only Segment Time [ns]", 200, -200, 200);
545  hSTimeAnodeByChamberType.push_back(
546  ibooker.book1D("hSTimeAnode_m42", "Anode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
547  hSTimeAnodeByChamberType.push_back(
548  ibooker.book1D("hSTimeAnode_m41", "Anode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
549  hSTimeAnodeByChamberType.push_back(
550  ibooker.book1D("hSTimeAnode_m32", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
551  hSTimeAnodeByChamberType.push_back(
552  ibooker.book1D("hSTimeAnode_m31", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
553  hSTimeAnodeByChamberType.push_back(
554  ibooker.book1D("hSTimeAnode_m22", "Anode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
555  hSTimeAnodeByChamberType.push_back(
556  ibooker.book1D("hSTimeAnode_m21", "Anode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
557  hSTimeAnodeByChamberType.push_back(
558  ibooker.book1D("hSTimeAnode_m11a", "Anode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
559  hSTimeAnodeByChamberType.push_back(
560  ibooker.book1D("hSTimeAnode_m13", "Anode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
561  hSTimeAnodeByChamberType.push_back(
562  ibooker.book1D("hSTimeAnode_m12", "Anode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
563  hSTimeAnodeByChamberType.push_back(
564  ibooker.book1D("hSTimeAnode_m11b", "Anode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
565  hSTimeAnodeByChamberType.push_back(
566  ibooker.book1D("hSTimeAnode_p11b", "Anode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
567  hSTimeAnodeByChamberType.push_back(
568  ibooker.book1D("hSTimeAnode_p12", "Anode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
569  hSTimeAnodeByChamberType.push_back(
570  ibooker.book1D("hSTimeAnode_p13", "Anode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
571  hSTimeAnodeByChamberType.push_back(
572  ibooker.book1D("hSTimeAnode_p11a", "Anode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
573  hSTimeAnodeByChamberType.push_back(
574  ibooker.book1D("hSTimeAnode_p21", "Anode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
575  hSTimeAnodeByChamberType.push_back(
576  ibooker.book1D("hSTimeAnode_p22", "Anode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
577  hSTimeAnodeByChamberType.push_back(
578  ibooker.book1D("hSTimeAnode_p31", "Anode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
579  hSTimeAnodeByChamberType.push_back(
580  ibooker.book1D("hSTimeAnode_p32", "Anode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
581  hSTimeAnodeByChamberType.push_back(
582  ibooker.book1D("hSTimeAnode_p41", "Anode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
583  hSTimeAnodeByChamberType.push_back(
584  ibooker.book1D("hSTimeAnode_p42", "Anode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
585 
586  hSTimeCathode = ibooker.book1D("hSTimeCathode", "Cathode Only Segment Time [ns]", 200, -200, 200);
587  hSTimeCathodeByChamberType.push_back(
588  ibooker.book1D("hSTimeCathode_m42", "Cathode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
589  hSTimeCathodeByChamberType.push_back(
590  ibooker.book1D("hSTimeCathode_m41", "Cathode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
591  hSTimeCathodeByChamberType.push_back(
592  ibooker.book1D("hSTimeCathode_m32", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
593  hSTimeCathodeByChamberType.push_back(
594  ibooker.book1D("hSTimeCathode_m31", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
595  hSTimeCathodeByChamberType.push_back(
596  ibooker.book1D("hSTimeCathode_m22", "Cathode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
597  hSTimeCathodeByChamberType.push_back(
598  ibooker.book1D("hSTimeCathode_m21", "Cathode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
599  hSTimeCathodeByChamberType.push_back(
600  ibooker.book1D("hSTimeCathode_m11a", "Cathode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
601  hSTimeCathodeByChamberType.push_back(
602  ibooker.book1D("hSTimeCathode_m13", "Cathode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
603  hSTimeCathodeByChamberType.push_back(
604  ibooker.book1D("hSTimeCathode_m12", "Cathode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
605  hSTimeCathodeByChamberType.push_back(
606  ibooker.book1D("hSTimeCathode_m11b", "Cathode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
607  hSTimeCathodeByChamberType.push_back(
608  ibooker.book1D("hSTimeCathode_p11b", "Cathode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
609  hSTimeCathodeByChamberType.push_back(
610  ibooker.book1D("hSTimeCathode_p12", "Cathode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
611  hSTimeCathodeByChamberType.push_back(
612  ibooker.book1D("hSTimeCathode_p13", "Cathode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
613  hSTimeCathodeByChamberType.push_back(
614  ibooker.book1D("hSTimeCathode_p11a", "Cathode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
615  hSTimeCathodeByChamberType.push_back(
616  ibooker.book1D("hSTimeCathode_p21", "Cathode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
617  hSTimeCathodeByChamberType.push_back(
618  ibooker.book1D("hSTimeCathode_p22", "Cathode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
619  hSTimeCathodeByChamberType.push_back(
620  ibooker.book1D("hSTimeCathode_p31", "Cathode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
621  hSTimeCathodeByChamberType.push_back(
622  ibooker.book1D("hSTimeCathode_p32", "Cathode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
623  hSTimeCathodeByChamberType.push_back(
624  ibooker.book1D("hSTimeCathode_p41", "Cathode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
625  hSTimeCathodeByChamberType.push_back(
626  ibooker.book1D("hSTimeCathode_p42", "Cathode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
627 
628  hSTimeCombined = ibooker.book1D("hSTimeCombined", "Segment Time (anode+cathode times) [ns]", 200, -200, 200);
629  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
630  "hSTimeCombined_m42", "Segment Time (anode+cathode times) Segment Time (ME -4/2) [ns]", 200, -200, 200));
631  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
632  "hSTimeCombined_m41", "Segment Time (anode+cathode times) Segment Time (ME -4/1) [ns]", 200, -200, 200));
633  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
634  "hSTimeCombined_m32", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
635  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
636  "hSTimeCombined_m31", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
637  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
638  "hSTimeCombined_m22", "Segment Time (anode+cathode times) Segment Time (ME -2/2) [ns]", 200, -200, 200));
639  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
640  "hSTimeCombined_m21", "Segment Time (anode+cathode times) Segment Time (ME -2/1) [ns]", 200, -200, 200));
641  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
642  "hSTimeCombined_m11a", "Segment Time (anode+cathode times) Segment Time (ME -1/1a) [ns]", 200, -200, 200));
643  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
644  "hSTimeCombined_m13", "Segment Time (anode+cathode times) Segment Time (ME -1/3) [ns]", 200, -200, 200));
645  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
646  "hSTimeCombined_m12", "Segment Time (anode+cathode times) Segment Time (ME -1/2) [ns]", 200, -200, 200));
647  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
648  "hSTimeCombined_m11b", "Segment Time (anode+cathode times) Segment Time (ME -1/1b) [ns]", 200, -200, 200));
649  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
650  "hSTimeCombined_p11b", "Segment Time (anode+cathode times) Segment Time (ME +1/1b) [ns]", 200, -200, 200));
651  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
652  "hSTimeCombined_p12", "Segment Time (anode+cathode times) Segment Time (ME +1/2) [ns]", 200, -200, 200));
653  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
654  "hSTimeCombined_p13", "Segment Time (anode+cathode times) Segment Time (ME +1/3) [ns]", 200, -200, 200));
655  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
656  "hSTimeCombined_p11a", "Segment Time (anode+cathode times) Segment Time (ME +1/1a) [ns]", 200, -200, 200));
657  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
658  "hSTimeCombined_p21", "Segment Time (anode+cathode times) Segment Time (ME +2/1) [ns]", 200, -200, 200));
659  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
660  "hSTimeCombined_p22", "Segment Time (anode+cathode times) Segment Time (ME +2/2) [ns]", 200, -200, 200));
661  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
662  "hSTimeCombined_p31", "Segment Time (anode+cathode times) Segment Time (ME +3/1) [ns]", 200, -200, 200));
663  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
664  "hSTimeCombined_p32", "Segment Time (anode+cathode times) Segment Time (ME +3/2) [ns]", 200, -200, 200));
665  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
666  "hSTimeCombined_p41", "Segment Time (anode+cathode times) Segment Time (ME +4/1) [ns]", 200, -200, 200));
667  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
668  "hSTimeCombined_p42", "Segment Time (anode+cathode times) Segment Time (ME +4/2) [ns]", 200, -200, 200));
669 
670  hSTimeDiffSerial =
671  ibooker.book2D("hSTimeDiffSerial", "Anode Minus Cathode Segment Time [ns]", 601, -0.5, 600.5, 200, -50, 50);
672  hSTimeAnodeSerial =
673  ibooker.book2D("hSTimeAnodeSerial", "Anode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
674  hSTimeCathodeSerial =
675  ibooker.book2D("hSTimeCathodeSerial", "Cathode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
676  hSTimeCombinedSerial = ibooker.book2D(
677  "hSTimeCombinedSerial", "Segment Time (anode+cathode times) [ns]", 601, -0.5, 600.5, 200, -200, 200);
678 
679  hSTimeVsZ = ibooker.book2D("hSTimeVsZ", "Segment Time vs. Z; [ns] vs. [cm]", 200, -1200, 1200, 200, -200, 200);
680  hSTimeVsTOF =
681  ibooker.book2D("hSTimeVsTOF", "Segment Time vs. Distance from IP; [ns] vs. [cm]", 180, 500, 1400, 200, -200, 200);
682 
683  // resolution
684  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Resolution");
685 
686  hSResid.push_back(ibooker.book1D(
687  "hSResidm42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/2); Strip Widths", 100, -0.5, 0.5));
688  hSResid.push_back(ibooker.book1D(
689  "hSResidm41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/1); Strip Widths", 100, -0.5, 0.5));
690  hSResid.push_back(ibooker.book1D(
691  "hSResidm32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/2); Strip Widths", 100, -0.5, 0.5));
692  hSResid.push_back(ibooker.book1D(
693  "hSResidm31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/1); Strip Widths", 100, -0.5, 0.5));
694  hSResid.push_back(ibooker.book1D(
695  "hSResidm22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/2); Strip Widths", 100, -0.5, 0.5));
696  hSResid.push_back(ibooker.book1D(
697  "hSResidm21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/1); Strip Widths", 100, -0.5, 0.5));
698  hSResid.push_back(ibooker.book1D(
699  "hSResidm11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1a); Strip Widths", 100, -0.5, 0.5));
700  hSResid.push_back(ibooker.book1D(
701  "hSResidm13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/3); Strip Widths", 100, -0.5, 0.5));
702  hSResid.push_back(ibooker.book1D(
703  "hSResidm12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/2); Strip Widths", 100, -0.5, 0.5));
704  hSResid.push_back(ibooker.book1D(
705  "hSResidm11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1b); Strip Widths", 100, -0.5, 0.5));
706  hSResid.push_back(ibooker.book1D(
707  "hSResidp11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1b); Strip Widths", 100, -0.5, 0.5));
708  hSResid.push_back(ibooker.book1D(
709  "hSResidp12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/2); Strip Widths", 100, -0.5, 0.5));
710  hSResid.push_back(ibooker.book1D(
711  "hSResidp13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/3); Strip Widths", 100, -0.5, 0.5));
712  hSResid.push_back(ibooker.book1D(
713  "hSResidp11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1a); Strip Widths", 100, -0.5, 0.5));
714  hSResid.push_back(ibooker.book1D(
715  "hSResidp21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/1); Strip Widths", 100, -0.5, 0.5));
716  hSResid.push_back(ibooker.book1D(
717  "hSResidp22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/2); Strip Widths", 100, -0.5, 0.5));
718  hSResid.push_back(ibooker.book1D(
719  "hSResidp31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/1); Strip Widths", 100, -0.5, 0.5));
720  hSResid.push_back(ibooker.book1D(
721  "hSResidp32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/2); Strip Widths", 100, -0.5, 0.5));
722  hSResid.push_back(ibooker.book1D(
723  "hSResidp41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/1); Strip Widths", 100, -0.5, 0.5));
724  hSResid.push_back(ibooker.book1D(
725  "hSResidp42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/2); Strip Widths", 100, -0.5, 0.5));
726 
727  // efficiency
728  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Efficiency");
729 
730  // hSSTE = ibooker.book1D("hSSTE","hSSTE",40,0.5,40.5);
731  // hRHSTE = ibooker.book1D("hRHSTE","hRHSTE",40,0.5,40.5);
732  hSnum = ibooker.book1D("hSnum", "CSC w rechits in 2+ layers && segment(s)", 20, 0.5, 20.5);
733  hSden = ibooker.book1D("hSden", "CSC w rechits in 2+ layers", 20, 0.5, 20.5);
734  hRHnum = ibooker.book1D("hRHnum", "CSC w segment(s) && rechits in 6 layers", 20, 0.5, 20.5);
735  hRHden = ibooker.book1D("hRHden", "CSC w segment(s)", 20, 0.5, 20.5);
736  applyCSClabels(hSnum, EXTENDED, X);
737  applyCSClabels(hSden, EXTENDED, X);
738  applyCSClabels(hRHnum, EXTENDED, X);
739  applyCSClabels(hRHden, EXTENDED, X);
740 
741  // hSEff = ibooker.book1D("hSEff","Segment Efficiency",20,0.5,20.5);
742  // hRHEff = ibooker.book1D("hRHEff","recHit Efficiency",20,0.5,20.5);
743  hSSTE2 = ibooker.book2D("hSSTE2", "hSSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
744  hRHSTE2 = ibooker.book2D("hRHSTE2", "hRHSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
745  hStripSTE2 = ibooker.book2D("hStripSTE2", "hStripSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
746  hWireSTE2 = ibooker.book2D("hWireSTE2", "hWireSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
747  hEffDenominator = ibooker.book2D("hEffDenominator", "hEffDenominator", 36, 0.5, 36.5, 20, 0.5, 20.5);
748  // hSEff2 = ibooker.book2D("hSEff2","Segment Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
749  // hRHEff2 = ibooker.book2D("hRHEff2","recHit Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
750  // hStripReadoutEff2 = ibooker.book2D("hStripReadoutEff2","strip readout ratio [(strip+clct+wires)/(clct+wires)] 2D",36,0.5,36.5, 20, 0.5, 20.5);
751  // hStripReadoutEff2->setAxisTitle("Chamber #");
752  // hStripEff2 = ibooker.book2D("hStripEff2","strip Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
753  // hWireEff2 = ibooker.book2D("hWireEff2","wire Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
754  hSensitiveAreaEvt =
755  ibooker.book2D("hSensitiveAreaEvt", "Events Passing Selection for Efficiency", 36, 0.5, 36.5, 20, 0.5, 20.5);
756 
757  // bx monitor for trigger synchronization
758  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/BXMonitor");
759 
760  hALCTgetBX = ibooker.book1D("hALCTgetBX", "ALCT position in ALCT-L1A match window [BX]", 7, -0.5, 6.5);
761  // hALCTgetBXChamberMeans = ibooker.book1D("hALCTgetBXChamberMeans","Chamber Mean ALCT position in ALCT-L1A match window [BX]",60,0,6);
762  hALCTgetBXSerial =
763  ibooker.book2D("hALCTgetBXSerial", "ALCT position in ALCT-L1A match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
764  hALCTgetBXSerial->setAxisTitle("Chamber Serial Number");
765  hALCTgetBX2DNumerator = ibooker.book2D(
766  "hALCTgetBX2DNumerator", "ALCT position in ALCT-L1A match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
767  // hALCTgetBX2DMeans = ibooker.book2D("hALCTgetBX2DMeans","ALCT position in ALCT-L1A match window [BX]",36,0.5,36.5,20,0.5,20.5);
768  hALCTgetBX2Denominator =
769  ibooker.book2D("hALCTgetBX2Denominator", "Number of ALCT Digis checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
770  // hALCTgetBX2DMeans->setAxisTitle("Chamber #");
771  hALCTgetBX2Denominator->setAxisTitle("Chamber #");
772  hALCTMatch = ibooker.book1D("hALCTMatch", "ALCT position in ALCT-CLCT match window [BX]", 7, -0.5, 6.5);
773  // hALCTMatchChamberMeans = ibooker.book1D("hALCTMatchChamberMeans","Chamber Mean ALCT position in ALCT-CLCT match window [BX]",60,0,6);
774  hALCTMatchSerial = ibooker.book2D(
775  "hALCTMatchSerial", "ALCT position in ALCT-CLCT match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
776  hALCTMatchSerial->setAxisTitle("Chamber Serial Number");
777  hALCTMatch2DNumerator = ibooker.book2D(
778  "hALCTMatch2DNumerator", "ALCT position in ALCT-CLCT match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
779  // hALCTMatch2DMeans = ibooker.book2D("hALCTMatch2DMeans","ALCT position in ALCT-CLCT match window [BX]",36,0.5,36.5,20,0.5,20.5);
780  hALCTMatch2Denominator =
781  ibooker.book2D("hALCTMatch2Denominator", "Number of ALCT-CLCT matches checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
782  // hALCTMatch2DMeans->setAxisTitle("Chamber #");
783  hALCTMatch2Denominator->setAxisTitle("Chamber #");
784  hCLCTL1A = ibooker.book1D("hCLCTL1A", "L1A - CLCTpreTrigger at TMB [BX]", 40, 149.5, 189.5);
785  // hCLCTL1AChamberMeans = ibooker.book1D("hCLCTL1AChamberMeans","Chamber Mean L1A - CLCTpreTrigger at TMB [BX]",90,150,159);
786  hCLCTL1ASerial =
787  ibooker.book2D("hCLCTL1ASerial", "L1A - CLCTpreTrigger at TMB [BX]", 601, -0.5, 600.5, 40, 149.5, 189.5);
788  hCLCTL1ASerial->setAxisTitle("Chamber Serial Number");
789  hCLCTL1A2DNumerator =
790  ibooker.book2D("hCLCTL1A2DNumerator", "L1A - CLCTpreTrigger at TMB [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
791  // hCLCTL1A2DMeans = ibooker.book2D("hCLCTL1A2DMeans","L1A - CLCTpreTrigger at TMB [BX]",36,0.5,36.5,20,0.5,20.5);
792  hCLCTL1A2Denominator =
793  ibooker.book2D("hCLCTL1A2Denominator", "Number of TMB CLCTs checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
794 
795  // labels
796  applyCSClabels(hOWiresAndCLCT, EXTENDED, Y);
797  applyCSClabels(hOWires, EXTENDED, Y);
798  applyCSClabels(hOStrips, EXTENDED, Y);
799  applyCSClabels(hOStripsAndWiresAndCLCT, EXTENDED, Y);
800  applyCSClabels(hORecHits, EXTENDED, Y);
801  applyCSClabels(hOSegments, EXTENDED, Y);
802  // applyCSClabels(hSEff, EXTENDED, X);
803  // applyCSClabels(hRHEff, EXTENDED, X);
804  // applyCSClabels(hSEff2, SMALL, Y);
805  applyCSClabels(hSSTE2, EXTENDED, Y);
806  applyCSClabels(hEffDenominator, EXTENDED, Y);
807  // applyCSClabels(hRHEff2, SMALL, Y);
808  applyCSClabels(hRHSTE2, EXTENDED, Y);
809  // applyCSClabels(hStripReadoutEff2, EXTENDED, Y);
810  // applyCSClabels(hStripEff2, SMALL, Y);
811  applyCSClabels(hStripSTE2, EXTENDED, Y);
812  // applyCSClabels(hWireEff2, SMALL, Y);
813  applyCSClabels(hWireSTE2, EXTENDED, Y);
814  applyCSClabels(hSensitiveAreaEvt, EXTENDED, Y);
815  // applyCSClabels(hALCTgetBX2DMeans, EXTENDED, Y);
816  applyCSClabels(hALCTgetBX2Denominator, EXTENDED, Y);
817  // applyCSClabels(hALCTMatch2DMeans, EXTENDED, Y);
818  applyCSClabels(hALCTMatch2Denominator, EXTENDED, Y);
819  // applyCSClabels(hCLCTL1A2DMeans, EXTENDED, Y);
820  applyCSClabels(hCLCTL1A2Denominator, EXTENDED, Y);
821 }
822 
824 // Analysis //
826 void CSCOfflineMonitor::analyze(const edm::Event& event, const edm::EventSetup& eventSetup) {
827  edm::Handle<CSCWireDigiCollection> wires;
828  edm::Handle<CSCStripDigiCollection> strips;
829  edm::Handle<CSCALCTDigiCollection> alcts;
830  edm::Handle<CSCCLCTDigiCollection> clcts;
831  event.getByToken(sd_token, strips);
832  event.getByToken(wd_token, wires);
833  event.getByToken(al_token, alcts);
834  event.getByToken(cl_token, clcts);
835 
836  // Get the CSC Geometry :
837  edm::ESHandle<CSCGeometry> cscGeom;
838 
839  cscGeom = eventSetup.getHandle(cscGeomToken_);
840 
841  // Get the RecHits collection :
842  edm::Handle<CSCRecHit2DCollection> recHits;
843  event.getByToken(rh_token, recHits);
844 
845  // get CSC segment collection
846  edm::Handle<CSCSegmentCollection> cscSegments;
847  event.getByToken(se_token, cscSegments);
848 
849  doOccupancies(strips, wires, recHits, cscSegments, clcts);
850  doStripDigis(strips);
851  doWireDigis(wires);
852  doRecHits(recHits, strips, cscGeom);
853  doSegments(cscSegments, cscGeom);
854  doResolution(cscSegments, cscGeom);
855  doPedestalNoise(strips, cscGeom);
856  doEfficiencies(wires, strips, recHits, cscSegments, cscGeom);
857  doBXMonitor(alcts, clcts, event, eventSetup);
858 }
859 
860 // ==============================================
861 //
862 // look at Occupancies
863 //
864 // ==============================================
865 
866 void CSCOfflineMonitor::doOccupancies(edm::Handle<CSCStripDigiCollection> strips,
867  edm::Handle<CSCWireDigiCollection> wires,
868  edm::Handle<CSCRecHit2DCollection> recHits,
869  edm::Handle<CSCSegmentCollection> cscSegments,
870  edm::Handle<CSCCLCTDigiCollection> clcts) {
871  bool clcto[2][4][4][36];
872  bool wireo[2][4][4][36];
873  bool stripo[2][4][4][36];
874  bool rechito[2][4][4][36];
875  bool segmento[2][4][4][36];
876 
877  bool hasWires = false;
878  bool hasStrips = false;
879  bool hasRecHits = false;
880  bool hasSegments = false;
881 
882  for (int e = 0; e < 2; e++) {
883  for (int s = 0; s < 4; s++) {
884  for (int r = 0; r < 4; r++) {
885  for (int c = 0; c < 36; c++) {
886  clcto[e][s][r][c] = false;
887  wireo[e][s][r][c] = false;
888  stripo[e][s][r][c] = false;
889  rechito[e][s][r][c] = false;
890  segmento[e][s][r][c] = false;
891  }
892  }
893  }
894  }
895 
896  //clcts
897  for (CSCCLCTDigiCollection::DigiRangeIterator j = clcts->begin(); j != clcts->end(); j++) {
898  CSCDetId id = (CSCDetId)(*j).first;
899  int kEndcap = id.endcap();
900  int kRing = id.ring();
901  int kStation = id.station();
902  int kChamber = id.chamber();
903  const CSCCLCTDigiCollection::Range& range = (*j).second;
904  for (CSCCLCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
905  // Valid digi in the chamber (or in neighbouring chamber)
906  if ((*digiIt).isValid()) {
907  //Check whether this CLCT came from ME11a
908  if (kStation == 1 && kRing == 1 && (*digiIt).getKeyStrip() > 128)
909  kRing = 4;
910  clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
911  }
912  }
913  }
914 
915  //wires
916  for (CSCWireDigiCollection::DigiRangeIterator wi = wires->begin(); wi != wires->end(); wi++) {
917  CSCDetId id = (CSCDetId)(*wi).first;
918  int kEndcap = id.endcap();
919  int kRing = id.ring();
920  int kStation = id.station();
921  int kChamber = id.chamber();
922  std::vector<CSCWireDigi>::const_iterator wireIt = (*wi).second.first;
923  std::vector<CSCWireDigi>::const_iterator lastWire = (*wi).second.second;
924  for (; wireIt != lastWire; ++wireIt) {
925  if (!wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
926  wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
927  hOWires->Fill(kChamber, typeIndex(id, 2));
928  hOWireSerial->Fill(chamberSerial(id));
929  hasWires = true;
930  if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1])
931  hOWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
932  //Also check for a CLCT in ME11a if you're in ME11 already
933  if (kStation == 1 && kRing == 1 && clcto[kEndcap - 1][kStation - 1][3][kChamber - 1]) {
934  CSCDetId idME11a = CSCDetId(kEndcap, kStation, 4, kChamber);
935  hOWiresAndCLCT->Fill(kChamber, typeIndex(idME11a, 2));
936  }
937  }
938  } //end for loop
939  }
940 
941  //strips
942  for (CSCStripDigiCollection::DigiRangeIterator si = strips->begin(); si != strips->end(); si++) {
943  CSCDetId id = (CSCDetId)(*si).first;
944  int kEndcap = id.endcap();
945  int kRing = id.ring();
946  int kStation = id.station();
947  int kChamber = id.chamber();
948  std::vector<CSCStripDigi>::const_iterator stripIt = (*si).second.first;
949  std::vector<CSCStripDigi>::const_iterator lastStrip = (*si).second.second;
950  for (; stripIt != lastStrip; ++stripIt) {
951  std::vector<int> myADCVals = stripIt->getADCCounts();
952  bool thisStripFired = false;
953  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
954  float threshold = 13.3;
955  float diff = 0.;
956  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
957  diff = (float)myADCVals[iCount] - thisPedestal;
958  if (diff > threshold) {
959  thisStripFired = true;
960  }
961  }
962  if (thisStripFired) {
963  if (!stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
964  stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
965  hOStrips->Fill(kChamber, typeIndex(id, 2));
966  hOStripSerial->Fill(chamberSerial(id));
967  hasStrips = true;
968  if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
969  // check if there is a wire digi in this chamber too
970  // for ME 1/4 check for a wire in ME 1/1
971  if (wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] ||
972  (kRing == 4 && wireo[kEndcap - 1][kStation - 1][0][kChamber - 1])) {
973  hOStripsAndWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
974  }
975  } //end clct and wire digi check
976  }
977  } //end if (thisStripFired)
978  }
979  }
980 
981  //rechits
982  CSCRecHit2DCollection::const_iterator recIt;
983  for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
984  CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
985  int kEndcap = idrec.endcap();
986  int kRing = idrec.ring();
987  int kStation = idrec.station();
988  int kChamber = idrec.chamber();
989  if (!rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
990  rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
991  hORecHitsSerial->Fill(chamberSerial(idrec));
992  hORecHits->Fill(kChamber, typeIndex(idrec, 2));
993  hasRecHits = true;
994  }
995  }
996 
997  //segments
998  for (CSCSegmentCollection::const_iterator segIt = cscSegments->begin(); segIt != cscSegments->end(); segIt++) {
999  CSCDetId id = (CSCDetId)(*segIt).cscDetId();
1000  int kEndcap = id.endcap();
1001  int kRing = id.ring();
1002  int kStation = id.station();
1003  int kChamber = id.chamber();
1004  if (!segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
1005  segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
1006  hOSegmentsSerial->Fill(chamberSerial(id));
1007  hOSegments->Fill(kChamber, typeIndex(id, 2));
1008  hasSegments = true;
1009  }
1010  }
1011 
1012  //Overall CSC Occupancy
1013  hCSCOccupancy->Fill(1);
1014  if (hasWires)
1015  hCSCOccupancy->Fill(3);
1016  if (hasStrips)
1017  hCSCOccupancy->Fill(5);
1018  if (hasWires && hasStrips)
1019  hCSCOccupancy->Fill(7);
1020  if (hasRecHits)
1021  hCSCOccupancy->Fill(9);
1022  if (hasSegments)
1023  hCSCOccupancy->Fill(11);
1024 }
1025 
1026 // ==============================================
1027 //
1028 // look at WIRE DIGIs
1029 //
1030 // ==============================================
1031 
1032 void CSCOfflineMonitor::doWireDigis(edm::Handle<CSCWireDigiCollection> wires) {
1033  int nWireGroupsTotal = 0;
1034  for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1035  CSCDetId id = (CSCDetId)(*dWDiter).first;
1036  std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1037  std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1038  for (; wireIter != lWire; ++wireIter) {
1039  int myWire = wireIter->getWireGroup();
1040  int myTBin = wireIter->getTimeBin();
1041  nWireGroupsTotal++;
1042  hWireTBin[typeIndex(id) - 1]->Fill(myTBin);
1043  hWireNumber[typeIndex(id) - 1]->Fill(myWire);
1044  }
1045  } // end wire loop
1046 
1047  hWirenGroupsTotal->Fill(nWireGroupsTotal);
1048  hWirenGroupsTotalHi->Fill(nWireGroupsTotal);
1049 }
1050 
1051 // ==============================================
1052 //
1053 // look at STRIP DIGIs
1054 //
1055 // ==============================================
1056 
1057 void CSCOfflineMonitor::doStripDigis(edm::Handle<CSCStripDigiCollection> strips) {
1058  int nStripsFired = 0;
1059  for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1060  CSCDetId id = (CSCDetId)(*dSDiter).first;
1061  std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1062  std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1063  for (; stripIter != lStrip; ++stripIter) {
1064  int myStrip = stripIter->getStrip();
1065  std::vector<int> myADCVals = stripIter->getADCCounts();
1066  bool thisStripFired = false;
1067  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1068  float threshold = 13.3;
1069  float diff = 0.;
1070  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1071  diff = (float)myADCVals[iCount] - thisPedestal;
1072  if (diff > threshold) {
1073  thisStripFired = true;
1074  }
1075  }
1076  if (thisStripFired) {
1077  nStripsFired++;
1078  hStripNumber[typeIndex(id) - 1]->Fill(myStrip);
1079  }
1080  }
1081  } // end strip loop
1082 
1083  hStripNFired->Fill(nStripsFired);
1084  hStripNFiredHi->Fill(nStripsFired);
1085 
1086  // fill n per event
1087 }
1088 
1089 //=======================================================
1090 //
1091 // Look at the Pedestal Noise Distributions
1092 //
1093 //=======================================================
1094 
1095 void CSCOfflineMonitor::doPedestalNoise(edm::Handle<CSCStripDigiCollection> strips,
1096  edm::ESHandle<CSCGeometry> cscGeom) {
1097  for (CSCStripDigiCollection::DigiRangeIterator dPNiter = strips->begin(); dPNiter != strips->end(); dPNiter++) {
1098  CSCDetId id = (CSCDetId)(*dPNiter).first;
1099  int kStation = id.station();
1100  int kRing = id.ring();
1101  std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
1102  std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
1103  for (; pedIt != lStrip; ++pedIt) {
1104  int myStrip = pedIt->getStrip();
1105  std::vector<int> myADCVals = pedIt->getADCCounts();
1106  float TotalADC = getSignal(*strips, id, myStrip);
1107  bool thisStripFired = false;
1108  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1109  float thisSignal =
1110  (1. / 6) * (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1111  float threshold = 13.3;
1112 
1113  // Why is this code block even here? Doesn't use myStrip after setting it (converts channel to strip
1114  // for ganged ME11A
1115  if ((kStation == 1 && kRing == 4) && cscGeom->gangedStrips()) {
1116  kRing = 1;
1117  if (myStrip <= 16)
1118  myStrip += 64; // no trapping for any bizarreness
1119  }
1120 
1121  if (TotalADC > threshold) {
1122  thisStripFired = true;
1123  }
1124  if (!thisStripFired) {
1125  float ADC = thisSignal - thisPedestal;
1126  hStripPed[typeIndex(id) - 1]->Fill(ADC);
1127  }
1128  }
1129  }
1130 }
1131 
1132 // ==============================================
1133 //
1134 // look at RECHITs
1135 //
1136 // ==============================================
1137 
1138 void CSCOfflineMonitor::doRecHits(edm::Handle<CSCRecHit2DCollection> recHits,
1139  edm::Handle<CSCStripDigiCollection> strips,
1140  edm::ESHandle<CSCGeometry> cscGeom) {
1141  // Get the RecHits collection :
1142  int nRecHits = recHits->size();
1143 
1144  // ---------------------
1145  // Loop over rechits
1146  // ---------------------
1147  // Build iterator for rechits and loop :
1148  CSCRecHit2DCollection::const_iterator dRHIter;
1149  for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
1150  // Find chamber with rechits in CSC
1151  CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
1152 
1153  // Store rechit as a Local Point:
1154  LocalPoint rhitlocal = (*dRHIter).localPosition();
1155  //float xreco = rhitlocal.x();
1156  //float yreco = rhitlocal.y();
1157 
1158  // Get the reconstucted strip position and error
1159  float stpos = (*dRHIter).positionWithinStrip();
1160  float sterr = (*dRHIter).errorWithinStrip();
1161 
1163 
1164  int adcsize = dRHIter->nStrips() * dRHIter->nTimeBins();
1165  float rHSumQ = 0;
1166  float sumsides = 0;
1167  for (unsigned int i = 0; i < dRHIter->nStrips(); i++) {
1168  for (unsigned int j = 0; j < dRHIter->nTimeBins() - 1; j++) {
1169  rHSumQ += dRHIter->adcs(i, j);
1170  if (i != 1)
1171  sumsides += dRHIter->adcs(i, j); // skip central strip
1172  }
1173  }
1174 
1175  float rHratioQ = sumsides / rHSumQ;
1176  if (adcsize != 12)
1177  rHratioQ = -99;
1178 
1179  // Get the signal timing of this hit
1180  float rHtime = (*dRHIter).tpeak(); //calculated from cathode SCA bins
1181  float rHtimeAnode = (*dRHIter).wireTime(); // calculated from anode wire bx
1182 
1183  // Get pointer to the layer:
1184  const CSCLayer* csclayer = cscGeom->layer(idrec);
1185 
1186  // Transform hit position from local chamber geometry to global CMS geom
1187  GlobalPoint rhitglobal = csclayer->toGlobal(rhitlocal);
1188  float grecx = rhitglobal.x();
1189  float grecy = rhitglobal.y();
1190 
1191  // Fill some histograms
1192  int sIndex = idrec.station() + ((idrec.endcap() - 1) * 4);
1193  int tIndex = typeIndex(idrec);
1194  hRHSumQ[tIndex - 1]->Fill(rHSumQ);
1195  hRHRatioQ[tIndex - 1]->Fill(rHratioQ);
1196  hRHstpos[tIndex - 1]->Fill(stpos);
1197  hRHsterr[tIndex - 1]->Fill(sterr);
1198  hRHTiming[tIndex - 1]->Fill(rHtime);
1199  hRHTimingAnode[tIndex - 1]->Fill(rHtimeAnode);
1200  hRHGlobal[sIndex - 1]->Fill(grecx, grecy);
1201 
1202  } //end rechit loop
1203 
1204  // if (nRecHits == 0) nRecHits = -1; // I see no point in doing this
1205  hRHnrechits->Fill(nRecHits);
1206  hRHnrechitsHi->Fill(nRecHits);
1207 }
1208 
1209 // ==============================================
1210 //
1211 // look at SEGMENTs
1212 //
1213 // ===============================================
1214 
1215 void CSCOfflineMonitor::doSegments(edm::Handle<CSCSegmentCollection> cscSegments, edm::ESHandle<CSCGeometry> cscGeom) {
1216  // get CSC segment collection
1217  int nSegments = cscSegments->size();
1218 
1219  for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1220  CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1221  float chisq = (*dSiter).chi2();
1222  int nhits = (*dSiter).nRecHits();
1223  int nDOF = 2 * nhits - 4;
1224  float nChi2 = chisq / nDOF;
1225  double chisqProb = ChiSquaredProbability((double)chisq, nDOF);
1226  LocalPoint localPos = (*dSiter).localPosition();
1227  LocalVector segDir = (*dSiter).localDirection();
1228 
1229  // prepare to calculate segment times
1230  float timeCathode = 0; //average from cathode information alone
1231  float timeAnode = 0; //average from pruned anode information alone
1232  float timeCombined = 0; //average from cathode hits and pruned anode list
1233  std::vector<float> cathodeTimes;
1234  std::vector<float> anodeTimes;
1235  // Get the CSC recHits that contribute to this segment.
1236  std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1237  for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1238  if (!((*iRH).isValid()))
1239  continue; // only interested in valid hits
1240  cathodeTimes.push_back((*iRH).tpeak());
1241  anodeTimes.push_back((*iRH).wireTime());
1242  } //end rechit loop
1243 
1244  // Calculate cathode average
1245  for (unsigned int i = 0; i < cathodeTimes.size(); i++)
1246  timeCathode += cathodeTimes[i] / cathodeTimes.size();
1247 
1248  // Prune the anode list to deal with the late tail
1249  float anodeMaxDiff;
1250  bool modified = false;
1251  std::vector<float>::iterator anodeMaxHit;
1252  do {
1253  if (anodeTimes.empty())
1254  continue;
1255  timeAnode = 0;
1256  anodeMaxDiff = 0;
1257  modified = false;
1258 
1259  // Find the average
1260  for (unsigned int j = 0; j < anodeTimes.size(); j++)
1261  timeAnode += anodeTimes[j] / anodeTimes.size();
1262 
1263  // Find the maximum outlier hit
1264  for (unsigned int j = 0; j < anodeTimes.size(); j++) {
1265  if (fabs(anodeTimes[j] - timeAnode) > anodeMaxDiff) {
1266  anodeMaxHit = anodeTimes.begin() + j;
1267  anodeMaxDiff = fabs(anodeTimes[j] - timeAnode);
1268  }
1269  }
1270 
1271  // Cut hit if its greater than some time away
1272  if (anodeMaxDiff > 26) {
1273  modified = true;
1274  anodeTimes.erase(anodeMaxHit);
1275  }
1276  } while (modified);
1277 
1278  // Calculate combined anode and cathode time average
1279  if (cathodeTimes.size() + anodeTimes.size() > 0)
1280  timeCombined = (timeCathode * cathodeTimes.size() + timeAnode * anodeTimes.size()) /
1281  (cathodeTimes.size() + anodeTimes.size());
1282 
1283  // global transformation
1284  float globX = 0.;
1285  float globY = 0.;
1286  float globZ = 0.;
1287  float globTOF = 0.;
1288  float globTheta = 0.;
1289  float globPhi = 0.;
1290  const CSCChamber* cscchamber = cscGeom->chamber(id);
1291  if (cscchamber) {
1292  GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
1293  globX = globalPosition.x();
1294  globY = globalPosition.y();
1295  globZ = globalPosition.z();
1296  globTOF = sqrt(globX * globX + globY * globY + globZ * globZ);
1297  GlobalVector globalDirection = cscchamber->toGlobal(segDir);
1298  globTheta = globalDirection.theta();
1299  globPhi = globalDirection.phi();
1300  }
1301 
1302  // Fill histos
1303  int tIndex = typeIndex(id);
1304  hSnhitsAll->Fill(nhits);
1305  hSnhits[tIndex - 1]->Fill(nhits);
1306  hSChiSqAll->Fill(nChi2);
1307  hSChiSq[tIndex - 1]->Fill(nChi2);
1308  hSChiSqProbAll->Fill(chisqProb);
1309  hSChiSqProb[tIndex - 1]->Fill(chisqProb);
1310  hSGlobalTheta->Fill(globTheta);
1311  hSGlobalPhi->Fill(globPhi);
1312  hSTimeDiff->Fill(timeAnode - timeCathode);
1313  hSTimeDiffByChamberType[tIndex - 1]->Fill(timeAnode - timeCathode);
1314  hSTimeAnode->Fill(timeAnode);
1315  hSTimeAnodeByChamberType[tIndex - 1]->Fill(timeAnode);
1316  hSTimeCathode->Fill(timeCathode);
1317  hSTimeCathodeByChamberType[tIndex - 1]->Fill(timeCathode);
1318  hSTimeCombined->Fill(timeCombined);
1319  hSTimeCombinedByChamberType[tIndex - 1]->Fill(timeCombined);
1320  hSTimeDiffSerial->Fill(chamberSerial(id), timeAnode - timeCathode);
1321  hSTimeAnodeSerial->Fill(chamberSerial(id), timeAnode);
1322  hSTimeCathodeSerial->Fill(chamberSerial(id), timeCathode);
1323  hSTimeCombinedSerial->Fill(chamberSerial(id), timeCombined);
1324  hSTimeVsZ->Fill(globZ, timeCombined);
1325  hSTimeVsTOF->Fill(globTOF, timeCombined);
1326 
1327  } // end segment loop
1328 
1329  hSnSegments->Fill(nSegments);
1330 }
1331 
1332 // ==============================================
1333 //
1334 // look at hit Resolution
1335 //
1336 // ==============================================
1337 void CSCOfflineMonitor::doResolution(edm::Handle<CSCSegmentCollection> cscSegments,
1338  edm::ESHandle<CSCGeometry> cscGeom) {
1339  for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1340  CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1341  //
1342  // try to get the CSC recHits that contribute to this segment.
1343  std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1344  int nRH = (*dSiter).nRecHits();
1345  CLHEP::HepMatrix sp(6, 1);
1346  CLHEP::HepMatrix se(6, 1);
1347  for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1348  CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
1349  //int kEndcap = idRH.endcap();
1350  int kRing = idRH.ring();
1351  int kStation = idRH.station();
1352  //int kChamber = idRH.chamber();
1353  int kLayer = idRH.layer();
1354 
1356  int centerid = iRH->nStrips() / 2 + 1;
1357  int centerStrip = iRH->channels(centerid - 1);
1358 
1359  // If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
1360  if (nRH == 6) {
1361  float stpos = (*iRH).positionWithinStrip();
1362  se(kLayer, 1) = (*iRH).errorWithinStrip();
1363  // Take into account half-strip staggering of layers (ME1/1 has no staggering)
1364  if (kStation == 1 && (kRing == 1 || kRing == 4))
1365  sp(kLayer, 1) = stpos + centerStrip;
1366  else {
1367  if (kLayer == 1 || kLayer == 3 || kLayer == 5)
1368  sp(kLayer, 1) = stpos + centerStrip;
1369  if (kLayer == 2 || kLayer == 4 || kLayer == 6)
1370  sp(kLayer, 1) = stpos - 0.5 + centerStrip;
1371  }
1372  }
1373  }
1374 
1375  // Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
1376  // float residual = -99.; // used to fill always
1377  if (nRH == 6) {
1378  float expected = fitX(sp, se);
1379  float residual = expected - sp(3, 1);
1380 
1381  hSResid[typeIndex(id) - 1]->Fill(residual); // fill here so stats make sense
1382  }
1383 
1384  // hSResid[typeIndex(id)-1]->Fill(residual); // used to fill here but then stats distorted by underflows
1385 
1386  } // end segment loop
1387 }
1388 
1389 //-------------------------------------------------------------------------------------
1390 // Fits a straight line to a set of 5 points with errors. Functions assumes 6 points
1391 // and removes hit in layer 3. It then returns the expected position value in layer 3
1392 // based on the fit.
1393 //-------------------------------------------------------------------------------------
1394 float CSCOfflineMonitor::fitX(const CLHEP::HepMatrix& points, const CLHEP::HepMatrix& errors) {
1395  float S = 0;
1396  float Sx = 0;
1397  float Sy = 0;
1398  float Sxx = 0;
1399  float Sxy = 0;
1400  float sigma2 = 0;
1401 
1402  for (int i = 1; i < 7; i++) {
1403  if (i != 3) {
1404  sigma2 = errors(i, 1) * errors(i, 1);
1405  S = S + (1 / sigma2);
1406  Sy = Sy + (points(i, 1) / sigma2);
1407  Sx = Sx + ((i) / sigma2);
1408  Sxx = Sxx + (i * i) / sigma2;
1409  Sxy = Sxy + (((i)*points(i, 1)) / sigma2);
1410  }
1411  }
1412 
1413  float delta = S * Sxx - Sx * Sx;
1414  float intercept = (Sxx * Sy - Sx * Sxy) / delta;
1415  float slope = (S * Sxy - Sx * Sy) / delta;
1416 
1417  return (intercept + slope * 3);
1418 }
1419 
1420 //---------------------------------------------------------------------------------------
1421 // Given a set of digis, the CSCDetId, and the central strip of your choosing, returns
1422 // the avg. Signal-Pedestal for 6 time bin x 5 strip .
1423 //
1424 // Author: P. Jindal
1425 //---------------------------------------------------------------------------------------
1426 
1427 float CSCOfflineMonitor::getSignal(const CSCStripDigiCollection& stripdigis, CSCDetId idCS, int centerStrip) {
1428  float SigADC[5];
1429  float TotalADC = 0;
1430  SigADC[0] = 0;
1431  SigADC[1] = 0;
1432  SigADC[2] = 0;
1433  SigADC[3] = 0;
1434  SigADC[4] = 0;
1435 
1436  // Loop over strip digis
1437  CSCStripDigiCollection::DigiRangeIterator sIt;
1438 
1439  for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++) {
1440  CSCDetId id = (CSCDetId)(*sIt).first;
1441  if (id == idCS) {
1442  // First, find the Signal-Pedestal for center strip
1443  vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
1444  vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
1445  for (; digiItr != last; ++digiItr) {
1446  int thisStrip = digiItr->getStrip();
1447  if (thisStrip == (centerStrip)) {
1448  std::vector<int> myADCVals = digiItr->getADCCounts();
1449  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1450  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1451  SigADC[0] = thisSignal - 6 * thisPedestal;
1452  }
1453  // Now,find the Signal-Pedestal for neighbouring 4 strips
1454  if (thisStrip == (centerStrip + 1)) {
1455  std::vector<int> myADCVals = digiItr->getADCCounts();
1456  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1457  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1458  SigADC[1] = thisSignal - 6 * thisPedestal;
1459  }
1460  if (thisStrip == (centerStrip + 2)) {
1461  std::vector<int> myADCVals = digiItr->getADCCounts();
1462  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1463  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1464  SigADC[2] = thisSignal - 6 * thisPedestal;
1465  }
1466  if (thisStrip == (centerStrip - 1)) {
1467  std::vector<int> myADCVals = digiItr->getADCCounts();
1468  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1469  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1470  SigADC[3] = thisSignal - 6 * thisPedestal;
1471  }
1472  if (thisStrip == (centerStrip - 2)) {
1473  std::vector<int> myADCVals = digiItr->getADCCounts();
1474  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1475  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1476  SigADC[4] = thisSignal - 6 * thisPedestal;
1477  }
1478  }
1479  TotalADC = 0.2 * (SigADC[0] + SigADC[1] + SigADC[2] + SigADC[3] + SigADC[4]);
1480  }
1481  }
1482  return TotalADC;
1483 }
1484 
1485 //----------------------------------------------------------------------------
1486 // Calculate basic efficiencies for recHits and Segments
1487 // Author: S. Stoynev
1488 //----------------------------------------------------------------------------
1489 
1490 void CSCOfflineMonitor::doEfficiencies(edm::Handle<CSCWireDigiCollection> wires,
1491  edm::Handle<CSCStripDigiCollection> strips,
1492  edm::Handle<CSCRecHit2DCollection> recHits,
1493  edm::Handle<CSCSegmentCollection> cscSegments,
1494  edm::ESHandle<CSCGeometry> cscGeom) {
1495  bool allWires[2][4][4][36][6];
1496  bool allStrips[2][4][4][36][6];
1497  bool AllRecHits[2][4][4][36][6];
1498  bool AllSegments[2][4][4][36];
1499 
1500  //bool MultiSegments[2][4][4][36];
1501  for (int iE = 0; iE < 2; iE++) {
1502  for (int iS = 0; iS < 4; iS++) {
1503  for (int iR = 0; iR < 4; iR++) {
1504  for (int iC = 0; iC < 36; iC++) {
1505  AllSegments[iE][iS][iR][iC] = false;
1506  //MultiSegments[iE][iS][iR][iC] = false;
1507  for (int iL = 0; iL < 6; iL++) {
1508  allWires[iE][iS][iR][iC][iL] = false;
1509  allStrips[iE][iS][iR][iC][iL] = false;
1510  AllRecHits[iE][iS][iR][iC][iL] = false;
1511  }
1512  }
1513  }
1514  }
1515  }
1516 
1517  // Wires
1518  for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1519  CSCDetId idrec = (CSCDetId)(*dWDiter).first;
1520  std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1521  std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1522  for (; wireIter != lWire; ++wireIter) {
1523  allWires[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1524  true;
1525  break;
1526  }
1527  }
1528 
1529  //---- STRIPS
1530  for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1531  CSCDetId idrec = (CSCDetId)(*dSDiter).first;
1532  std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1533  std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1534  for (; stripIter != lStrip; ++stripIter) {
1535  std::vector<int> myADCVals = stripIter->getADCCounts();
1536  bool thisStripFired = false;
1537  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1538  float threshold = 13.3;
1539  float diff = 0.;
1540  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1541  diff = (float)myADCVals[iCount] - thisPedestal;
1542  if (diff > threshold) {
1543  thisStripFired = true;
1544  break;
1545  }
1546  }
1547  if (thisStripFired) {
1548  allStrips[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1549  true;
1550  break;
1551  }
1552  }
1553  }
1554 
1555  // Rechits
1556  for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
1557  //CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
1558  CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
1559  AllRecHits[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1560  true;
1561  }
1562 
1563  std::vector<uint> seg_ME2(2, 0);
1564  std::vector<uint> seg_ME3(2, 0);
1565  std::vector<pair<CSCDetId, CSCSegment> > theSegments(4);
1566  // Segments
1567  for (CSCSegmentCollection::const_iterator segEffIt = cscSegments->begin(); segEffIt != cscSegments->end();
1568  segEffIt++) {
1569  CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
1570  //if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
1571  //MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
1572  //}
1573  AllSegments[idseg.endcap() - 1][idseg.station() - 1][idseg.ring() - 1][idseg.chamber() - 1] = true;
1574  // "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
1575  // station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
1576  // station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
1577  if (2 == idseg.station() || 3 == idseg.station()) {
1578  uint seg_tmp;
1579  if (2 == idseg.station()) {
1580  ++seg_ME2[idseg.endcap() - 1];
1581  seg_tmp = seg_ME2[idseg.endcap() - 1];
1582  } else {
1583  ++seg_ME3[idseg.endcap() - 1];
1584  seg_tmp = seg_ME3[idseg.endcap() - 1];
1585  }
1586  // is the segment good
1587  if (1 == seg_tmp && 6 == (*segEffIt).nRecHits() && (*segEffIt).chi2() / (*segEffIt).degreesOfFreedom() < 3.) {
1588  pair<CSCDetId, CSCSegment> specSeg = make_pair((CSCDetId)(*segEffIt).cscDetId(), *segEffIt);
1589  theSegments[2 * (idseg.endcap() - 1) + (idseg.station() - 2)] = specSeg;
1590  }
1591  }
1592  /*
1593  if(2==idseg.station()){
1594  ++seg_ME2[idseg.endcap() -1];
1595  if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1596  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1597  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1598  }
1599  }
1600  else if(3==idseg.station()){
1601  ++seg_ME3[idseg.endcap() -1];
1602  if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1603  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1604  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1605  }
1606  }
1607  */
1608  }
1609  // Simple efficiency calculations
1610  for (int iE = 0; iE < 2; iE++) {
1611  for (int iS = 0; iS < 4; iS++) {
1612  for (int iR = 0; iR < 4; iR++) {
1613  for (int iC = 0; iC < 36; iC++) {
1614  int NumberOfLayers = 0;
1615  for (int iL = 0; iL < 6; iL++) {
1616  if (AllRecHits[iE][iS][iR][iC][iL]) {
1617  NumberOfLayers++;
1618  }
1619  }
1620 
1621  // set bin = 1-10 for ME-42, ME-41,...ME-11B, ME-11A,
1622  // 11-20 for ME+11A, ME+11B, ... ME+41, ME+42
1623  int bin = CSCDetId::iChamberType(iS + 1, iR + 1); // 1-10 for ME11A...ME42
1624  if (iE > 0) { // in this loop iE=1 is -z endcap
1625  bin = 11 - bin;
1626  } else { // in this loop iE=0 is +z endcap
1627  bin += 10;
1628  }
1629 
1630  if (NumberOfLayers > 1) {
1631  //if(!(MultiSegments[iE][iS][iR][iC])){
1632  if (AllSegments[iE][iS][iR][iC]) {
1633  //---- Efficient segment evenents
1634  hSnum->Fill(bin);
1635  }
1636  //---- All segment events (normalization)
1637  hSden->Fill(bin);
1638  //}
1639  }
1640  if (AllSegments[iE][iS][iR][iC]) {
1641  if (NumberOfLayers == 6) {
1642  //---- Efficient rechit events
1643  hRHnum->Fill(bin);
1644  ;
1645  }
1646  //---- All rechit events (normalization)
1647  hRHden->Fill(bin);
1648  ;
1649  }
1650  }
1651  }
1652  }
1653  }
1654 
1655  // pick a segment only if there are no others in the station
1656  std::vector<pair<CSCDetId, CSCSegment>*> theSeg;
1657  if (1 == seg_ME2[0])
1658  theSeg.push_back(&theSegments[0]);
1659  if (1 == seg_ME3[0])
1660  theSeg.push_back(&theSegments[1]);
1661  if (1 == seg_ME2[1])
1662  theSeg.push_back(&theSegments[2]);
1663  if (1 == seg_ME3[1])
1664  theSeg.push_back(&theSegments[3]);
1665 
1666  if (!theSeg.empty()) {
1667  std::map<int, GlobalPoint> extrapolatedPoint;
1668  std::map<int, GlobalPoint>::iterator it;
1669  const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
1670  // Pick which chamber with which segment to test
1671  for (unsigned int nCh = 0; nCh < ChamberContainer.size(); nCh++) {
1672  const CSCChamber* cscchamber = ChamberContainer[nCh];
1673  pair<CSCDetId, CSCSegment>* thisSegment = nullptr;
1674  for (uint iSeg = 0; iSeg < theSeg.size(); ++iSeg) {
1675  if (cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()) {
1676  if (1 == cscchamber->id().station() || 3 == cscchamber->id().station()) {
1677  if (2 == theSeg[iSeg]->first.station()) {
1678  thisSegment = theSeg[iSeg];
1679  }
1680  } else if (2 == cscchamber->id().station() || 4 == cscchamber->id().station()) {
1681  if (3 == theSeg[iSeg]->first.station()) {
1682  thisSegment = theSeg[iSeg];
1683  }
1684  }
1685  }
1686  }
1687  // this chamber is to be tested with thisSegment
1688  if (thisSegment) {
1689  CSCSegment* seg = &(thisSegment->second);
1690  const CSCChamber* segChamber = cscGeom->chamber(thisSegment->first);
1691  LocalPoint localCenter(0., 0., 0);
1692  GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
1693  // try to save some time (extrapolate a segment to a certain position only once)
1694  it = extrapolatedPoint.find(int(cscchamberCenter.z()));
1695  if (it == extrapolatedPoint.end()) {
1696  GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
1697  GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
1698  double paramaterLine = lineParametrization(segPos.z(), cscchamberCenter.z(), segDir.z());
1699  double xExtrapolated = extrapolate1D(segPos.x(), segDir.x(), paramaterLine);
1700  double yExtrapolated = extrapolate1D(segPos.y(), segDir.y(), paramaterLine);
1701  GlobalPoint globP(xExtrapolated, yExtrapolated, cscchamberCenter.z());
1702  extrapolatedPoint[int(cscchamberCenter.z())] = globP;
1703  }
1704  // Where does the extrapolated point lie in the (tested) chamber local frame? Here:
1705  LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
1706  const CSCLayer* layer_p = cscchamber->layer(1); //layer 1
1707  const CSCLayerGeometry* layerGeom = layer_p->geometry();
1708  const std::array<const float, 4>& layerBounds = layerGeom->parameters();
1709  float shiftFromEdge = 15.; //cm
1710  float shiftFromDeadZone = 10.;
1711  // is the extrapolated point within a sensitive region
1712  bool pass = withinSensitiveRegion(extrapolatedPointLocal,
1713  layerBounds,
1714  cscchamber->id().station(),
1715  cscchamber->id().ring(),
1716  shiftFromEdge,
1717  shiftFromDeadZone);
1718  if (pass) { // the extrapolation point of the segment lies within sensitive region of that chamber
1719  // how many rechit layers are there in the chamber?
1720  // 0 - maybe the muon died or is deflected at large angle? do not use that case
1721  // 1 - could be noise...
1722  // 2 or more - this is promissing; this is our definition of a reliable signal; use it below
1723  // is other definition better?
1724  int nRHLayers = 0;
1725  for (int iL = 0; iL < 6; ++iL) {
1726  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1727  [cscchamber->id().chamber() - 1][iL]) {
1728  ++nRHLayers;
1729  }
1730  }
1731 
1732  // set verticalScale to 1-10 for ME-42...ME-11A,
1733  // 11-20 for ME+11A...ME+42
1734  float verticalScale =
1735  9. + cscchamber->id().endcap() + (cscchamber->specs()->chamberType()) * (cscchamber->id().zendcap());
1736 
1737  hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()), verticalScale);
1738  if (nRHLayers > 1) { // this chamber contains a reliable signal
1739  // this is the denominator for all efficiencies
1740  hEffDenominator->Fill(float(cscchamber->id().chamber()), verticalScale);
1741  // Segment efficiency
1742  if (AllSegments[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1743  [cscchamber->id().chamber() - 1]) {
1744  hSSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale));
1745  }
1746 
1747  for (int iL = 0; iL < 6; ++iL) {
1748  float weight = 1. / 6.;
1749  // should account for the weight in the efficiency...
1750  // Rechit efficiency
1751  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1752  [cscchamber->id().chamber() - 1][iL]) {
1753  hRHSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1754  }
1755  // Wire efficiency
1756  if (allWires[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1757  [cscchamber->id().chamber() - 1][iL]) {
1758  // one shold account for the weight in the efficiency...
1759  hWireSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1760  }
1761  // Strip efficiency
1762  if (allStrips[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1763  [cscchamber->id().chamber() - 1][iL]) {
1764  // one shold account for the weight in the efficiency...
1765  hStripSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1766  }
1767  }
1768  }
1769  }
1770  }
1771  }
1772  }
1773  //
1774 }
1775 
1776 // ==============================================
1777 //
1778 // Look at BX level trigger synchronization
1779 //
1780 // ==============================================
1781 
1782 void CSCOfflineMonitor::doBXMonitor(edm::Handle<CSCALCTDigiCollection> alcts,
1783  edm::Handle<CSCCLCTDigiCollection> clcts,
1784  const edm::Event& event,
1785  const edm::EventSetup& eventSetup) {
1786  // Loop over ALCTDigis
1787 
1788  for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
1789  const CSCDetId& idALCT = (*j).first;
1790  const CSCALCTDigiCollection::Range& range = (*j).second;
1791  for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1792  // Valid digi in the chamber (or in neighbouring chamber)
1793  if ((*digiIt).isValid()) {
1794  hALCTgetBX->Fill((*digiIt).getBX());
1795  hALCTgetBXSerial->Fill(chamberSerial(idALCT), (*digiIt).getBX());
1796  hALCTgetBX2DNumerator->Fill(idALCT.chamber(), typeIndex(idALCT, 2), (*digiIt).getBX());
1797  hALCTgetBX2Denominator->Fill(idALCT.chamber(), typeIndex(idALCT, 2));
1798  }
1799  }
1800  } // end ALCT Digi loop
1801 
1802  // Loop over raw data to get TMBHeader information
1803  // Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
1804  edm::ESHandle<CSCCrateMap> hcrate;
1805 
1806  hcrate = eventSetup.getHandle(hcrateToken_);
1807 
1808  const CSCCrateMap* pcrate = hcrate.product();
1809 
1810  // Try to get raw data
1811  edm::Handle<FEDRawDataCollection> rawdata;
1812  if (!(event.getByToken(rd_token, rawdata))) {
1813  edm::LogWarning("CSCOfflineMonitor") << " FEDRawDataCollection not available";
1814  return;
1815  }
1816 
1817  bool goodEvent = false;
1818  unsigned long dccBinCheckMask = 0x06080016;
1819  unsigned int examinerMask = 0x1FEBF3F6;
1820  unsigned int errorMask = 0x0;
1821 
1822  // For new CSC readout layout, which doesn't include DCCs need to loop over DDU FED IDs.
1823  // DCC IDs are included for backward compatibility with old data
1824  std::vector<unsigned int> cscFEDids;
1825 
1826  for (unsigned int id = FEDNumbering::MINCSCFEDID; id <= FEDNumbering::MAXCSCFEDID; ++id) // loop over DCCs
1827  {
1828  cscFEDids.push_back(id);
1829  }
1830 
1831  for (unsigned int id = FEDNumbering::MINCSCDDUFEDID; id <= FEDNumbering::MAXCSCDDUFEDID; ++id) // loop over DDUs
1832  {
1833  cscFEDids.push_back(id);
1834  }
1835 
1836  for (unsigned int i = 0; i < cscFEDids.size(); i++) // loop over all CSC FEDs (DCCs and DDUs)
1837  {
1838  unsigned int id = cscFEDids[i];
1839  bool isDDU_FED = ((id >= FEDNumbering::MINCSCDDUFEDID) && (id <= FEDNumbering::MAXCSCDDUFEDID)) ? true : false;
1840 
1843 
1845  const FEDRawData& fedData = rawdata->FEDData(id);
1846  unsigned long length = fedData.size();
1847 
1848  if (length >= 32) {
1849  CSCDCCExaminer* examiner = nullptr;
1850  std::stringstream examiner_out, examiner_err;
1851  goodEvent = true;
1852  examiner = new CSCDCCExaminer();
1853  if (examinerMask & 0x40000)
1854  examiner->crcCFEB(true);
1855  if (examinerMask & 0x8000)
1856  examiner->crcTMB(true);
1857  if (examinerMask & 0x0400)
1858  examiner->crcALCT(true);
1859  examiner->setMask(examinerMask);
1860  const short unsigned int* data = (short unsigned int*)fedData.data();
1861 
1862  int res = examiner->check(data, long(fedData.size() / 2));
1863  if (res < 0) {
1864  goodEvent = false;
1865  } else {
1866  goodEvent = !(examiner->errors() & dccBinCheckMask);
1867  }
1868 
1869  if (goodEvent) {
1871 
1872  CSCDCCExaminer* ptrExaminer = examiner;
1873 
1874  std::vector<CSCDDUEventData> fed_Data;
1875  std::vector<CSCDDUEventData>* ptr_fedData = &fed_Data;
1876 
1877  if (isDDU_FED) // Use new DDU FED readout mode
1878  {
1879  CSCDDUEventData single_dduData((short unsigned int*)fedData.data(), ptrExaminer);
1880  fed_Data.push_back(single_dduData);
1881 
1882  } else // Use old DCC FED readout mode
1883  {
1884  CSCDCCEventData dccData((short unsigned int*)fedData.data(), ptrExaminer);
1885  fed_Data = dccData.dduData();
1886  }
1887 
1889  const std::vector<CSCDDUEventData>& dduData = *ptr_fedData;
1890 
1892  CSCDetId layer(1, 1, 1, 1, 1);
1893  for (unsigned int iDDU = 0; iDDU < dduData.size(); ++iDDU) { // loop over DDUs
1896  if (dduData[iDDU].trailer().errorstat() & errorMask) {
1897  LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! "
1898  << std::hex << dduData[iDDU].trailer().errorstat();
1899  continue; // to next iteration of DDU loop
1900  }
1901 
1903  const std::vector<CSCEventData>& cscData = dduData[iDDU].cscData();
1904 
1905  for (unsigned int iCSC = 0; iCSC < cscData.size(); ++iCSC) { // loop over CSCs
1906 
1908  int vmecrate = cscData[iCSC].dmbHeader()->crateID();
1909  int dmb = cscData[iCSC].dmbHeader()->dmbID();
1910 
1911  int icfeb = 0;
1912  int ilayer = 0;
1913 
1914  if ((vmecrate >= 1) && (vmecrate <= 60) && (dmb >= 1) && (dmb <= 10) && (dmb != 6)) {
1915  layer = pcrate->detId(vmecrate, dmb, icfeb, ilayer);
1916  } else {
1917  LogTrace("CSCOfflineMonitor") << " detID input out of range!!! ";
1918  LogTrace("CSCOfflineMonitor") << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
1919  continue; // to next iteration of iCSC loop
1920  }
1921 
1923  int nalct = cscData[iCSC].dmbHeader()->nalct();
1924  bool goodALCT = false;
1925  //if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
1926  if (nalct && cscData[iCSC].alctHeader()) {
1927  if (cscData[iCSC].alctHeader()->check()) {
1928  goodALCT = true;
1929  }
1930  }
1931 
1933  int nclct = cscData[iCSC].dmbHeader()->nclct();
1934  bool goodTMB = false;
1935  if (nclct && cscData[iCSC].tmbData()) {
1936  if (cscData[iCSC].tmbHeader()->check()) {
1937  if (cscData[iCSC].comparatorData()->check())
1938  goodTMB = true;
1939  }
1940  }
1941 
1942  if (goodTMB && goodALCT) {
1943  const CSCTMBHeader* tmbHead = cscData[iCSC].tmbHeader();
1944  std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
1945  if (clcts.empty() || !(clcts[0].isValid()))
1946  continue;
1947  // Check if the CLCT was in ME11a (ring 4)
1948  if (layer.station() == 1 && layer.ring() == 1 && clcts[0].getKeyStrip() > 128) {
1949  layer = CSCDetId(layer.endcap(), layer.station(), 4, layer.chamber());
1950  }
1951  hALCTMatch->Fill(tmbHead->ALCTMatchTime());
1952  hALCTMatchSerial->Fill(chamberSerial(layer), tmbHead->ALCTMatchTime());
1953  // Only fill big 2D display if ALCTMatchTime !=6, since this bin is polluted by the CLCT only triggers
1954  // One will have to look at the serial plots to see if the are a lot of entries here
1955  if (tmbHead->ALCTMatchTime() != 6) {
1956  hALCTMatch2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), tmbHead->ALCTMatchTime());
1957  hALCTMatch2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1958  }
1959 
1960  int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount() - clcts[0].getFullBX();
1961  if (TMB_CLCTpre_rel_L1A > 3563)
1962  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
1963  if (TMB_CLCTpre_rel_L1A < 0)
1964  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
1965 
1966  hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
1967  hCLCTL1ASerial->Fill(chamberSerial(layer), TMB_CLCTpre_rel_L1A);
1968  hCLCTL1A2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), TMB_CLCTpre_rel_L1A);
1969  hCLCTL1A2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1970 
1971  } // end if goodTMB and goodALCT
1972  } // end loop CSCData
1973  } // end loop DDU
1974  } // end if good event
1975  if (examiner != nullptr)
1976  delete examiner;
1977  } // end if non-zero fed data
1978  } // end DCC loop for NON-REFERENCE
1979 
1980  return;
1981 }
1982 
1983 bool CSCOfflineMonitor::withinSensitiveRegion(LocalPoint localPos,
1984  const std::array<const float, 4>& layerBounds,
1985  int station,
1986  int ring,
1987  float shiftFromEdge,
1988  float shiftFromDeadZone) {
1989  //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
1990  bool pass = false;
1991 
1992  float y_center = 0.;
1993  double yUp = layerBounds[3] + y_center;
1994  double yDown = -layerBounds[3] + y_center;
1995  double xBound1Shifted = layerBounds[0] - shiftFromEdge; //
1996  double xBound2Shifted = layerBounds[1] - shiftFromEdge; //
1997  double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
1998  double lineConst = yUp - lineSlope * xBound2Shifted;
1999  double yBorder = lineSlope * abs(localPos.x()) + lineConst;
2000 
2001  //bool withinChamberOnly = false;// false = "good region"; true - boundaries only
2002  std::vector<float> deadZoneCenter(6);
2003  float cutZone = shiftFromDeadZone; //cm
2004  //---- hardcoded... not good
2005  if (station > 1 && station < 5) {
2006  if (2 == ring) {
2007  deadZoneCenter[0] = -162.48;
2008  deadZoneCenter[1] = -81.8744;
2009  deadZoneCenter[2] = -21.18165;
2010  deadZoneCenter[3] = 39.51105;
2011  deadZoneCenter[4] = 100.2939;
2012  deadZoneCenter[5] = 160.58;
2013 
2014  if (localPos.y() > yBorder &&
2015  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2016  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2017  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone) ||
2018  (localPos.y() > deadZoneCenter[3] + cutZone && localPos.y() < deadZoneCenter[4] - cutZone) ||
2019  (localPos.y() > deadZoneCenter[4] + cutZone && localPos.y() < deadZoneCenter[5] - cutZone))) {
2020  pass = true;
2021  }
2022  } else if (1 == ring) {
2023  if (2 == station) {
2024  deadZoneCenter[0] = -95.80;
2025  deadZoneCenter[1] = -27.47;
2026  deadZoneCenter[2] = 33.67;
2027  deadZoneCenter[3] = 90.85;
2028  } else if (3 == station) {
2029  deadZoneCenter[0] = -89.305;
2030  deadZoneCenter[1] = -39.705;
2031  deadZoneCenter[2] = 20.195;
2032  deadZoneCenter[3] = 77.395;
2033  } else if (4 == station) {
2034  deadZoneCenter[0] = -75.645;
2035  deadZoneCenter[1] = -26.055;
2036  deadZoneCenter[2] = 23.855;
2037  deadZoneCenter[3] = 70.575;
2038  }
2039  if (localPos.y() > yBorder &&
2040  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2041  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2042  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2043  pass = true;
2044  }
2045  }
2046  } else if (1 == station) {
2047  if (3 == ring) {
2048  deadZoneCenter[0] = -83.155;
2049  deadZoneCenter[1] = -22.7401;
2050  deadZoneCenter[2] = 27.86665;
2051  deadZoneCenter[3] = 81.005;
2052  if (localPos.y() > yBorder &&
2053  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2054  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2055  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2056  pass = true;
2057  }
2058  } else if (2 == ring) {
2059  deadZoneCenter[0] = -86.285;
2060  deadZoneCenter[1] = -32.88305;
2061  deadZoneCenter[2] = 32.867423;
2062  deadZoneCenter[3] = 88.205;
2063  if (localPos.y() > (yBorder) &&
2064  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2065  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2066  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2067  pass = true;
2068  }
2069  } else {
2070  deadZoneCenter[0] = -81.0;
2071  deadZoneCenter[1] = 81.0;
2072  if (localPos.y() > (yBorder) &&
2073  (localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone)) {
2074  pass = true;
2075  }
2076  }
2077  }
2078  return pass;
2079 }
2080 
2081 int CSCOfflineMonitor::typeIndex(CSCDetId id, int flag) {
2082  // linearized index based on endcap, station, and ring
2083 
2084  if (flag == 1) {
2085  int index = 0;
2086  if (id.station() == 1)
2087  index = id.ring();
2088  else
2089  index = id.station() * 2 + id.ring();
2090  if (id.endcap() == 1)
2091  index = index + 10;
2092  if (id.endcap() == 2)
2093  index = 11 - index;
2094  return index;
2095  }
2096 
2097  else if (flag == 2) {
2098  int index = 0;
2099  if (id.station() == 1 && id.ring() != 4)
2100  index = id.ring() + 1;
2101  if (id.station() == 1 && id.ring() == 4)
2102  index = 1;
2103  if (id.station() != 1)
2104  index = id.station() * 2 + id.ring();
2105  if (id.endcap() == 1)
2106  index = index + 10;
2107  if (id.endcap() == 2)
2108  index = 11 - index;
2109  return index;
2110  }
2111 
2112  else
2113  return 0;
2114 }
2115 
2116 int CSCOfflineMonitor::chamberSerial(CSCDetId id) {
2117  int st = id.station();
2118  int ri = id.ring();
2119  int ch = id.chamber();
2120  int ec = id.endcap();
2121  int kSerial = ch;
2122  if (st == 1 && ri == 1)
2123  kSerial = ch;
2124  if (st == 1 && ri == 2)
2125  kSerial = ch + 36;
2126  if (st == 1 && ri == 3)
2127  kSerial = ch + 72;
2128  if (st == 1 && ri == 4)
2129  kSerial = ch;
2130  if (st == 2 && ri == 1)
2131  kSerial = ch + 108;
2132  if (st == 2 && ri == 2)
2133  kSerial = ch + 126;
2134  if (st == 3 && ri == 1)
2135  kSerial = ch + 162;
2136  if (st == 3 && ri == 2)
2137  kSerial = ch + 180;
2138  if (st == 4 && ri == 1)
2139  kSerial = ch + 216;
2140  if (st == 4 && ri == 2)
2141  kSerial = ch + 234; // from 2014
2142  if (ec == 2)
2143  kSerial = kSerial + 300;
2144  return kSerial;
2145 }
2146 
2147 void CSCOfflineMonitor::applyCSClabels(MonitorElement* me, LabelType t, AxisType a) {
2148  if (me != nullptr) {
2149  me->setAxisTitle("Chamber #");
2150  if (t == EXTENDED) {
2151  me->setBinLabel(1, "ME -4/2", a);
2152  me->setBinLabel(2, "ME -4/1", a);
2153  me->setBinLabel(3, "ME -3/2", a);
2154  me->setBinLabel(4, "ME -3/1", a);
2155  me->setBinLabel(5, "ME -2/2", a);
2156  me->setBinLabel(6, "ME -2/1", a);
2157  me->setBinLabel(7, "ME -1/3", a);
2158  me->setBinLabel(8, "ME -1/2", a);
2159  me->setBinLabel(9, "ME -1/1b", a);
2160  me->setBinLabel(10, "ME -1/1a", a);
2161  me->setBinLabel(11, "ME +1/1a", a);
2162  me->setBinLabel(12, "ME +1/1b", a);
2163  me->setBinLabel(13, "ME +1/2", a);
2164  me->setBinLabel(14, "ME +1/3", a);
2165  me->setBinLabel(15, "ME +2/1", a);
2166  me->setBinLabel(16, "ME +2/2", a);
2167  me->setBinLabel(17, "ME +3/1", a);
2168  me->setBinLabel(18, "ME +3/2", a);
2169  me->setBinLabel(19, "ME +4/1", a);
2170  me->setBinLabel(20, "ME +4/2", a);
2171  } else if (t == SMALL) {
2172  me->setBinLabel(1, "ME -4/1", a);
2173  me->setBinLabel(2, "ME -3/2", a);
2174  me->setBinLabel(3, "ME -3/1", a);
2175  me->setBinLabel(4, "ME -2/2", a);
2176  me->setBinLabel(5, "ME -2/1", a);
2177  me->setBinLabel(6, "ME -1/3", a);
2178  me->setBinLabel(7, "ME -1/2", a);
2179  me->setBinLabel(8, "ME -1/1b", a);
2180  me->setBinLabel(9, "ME -1/1a", a);
2181  me->setBinLabel(10, "ME +1/1a", a);
2182  me->setBinLabel(11, "ME +1/1b", a);
2183  me->setBinLabel(12, "ME +1/2", a);
2184  me->setBinLabel(13, "ME +1/3", a);
2185  me->setBinLabel(14, "ME +2/1", a);
2186  me->setBinLabel(15, "ME +2/2", a);
2187  me->setBinLabel(16, "ME +3/1", a);
2188  me->setBinLabel(17, "ME +3/2", a);
2189  me->setBinLabel(18, "ME +4/1", a);
2190  }
2191  }
2192 }
2193 
2194 DEFINE_FWK_MODULE(CSCOfflineMonitor);
CSCOfflineMonitor::hEffDenominator
MonitorElement * hEffDenominator
Definition: CSCOfflineMonitor.h:235
CSCDCCEventData
01/20/05 A.Tumanov
Definition: CSCDCCEventData.h:13
CSCOfflineMonitor::hOSegmentsSerial
MonitorElement * hOSegmentsSerial
Definition: CSCOfflineMonitor.h:216
CSCOfflineMonitor::al_token
edm::EDGetTokenT< CSCALCTDigiCollection > al_token
Definition: CSCOfflineMonitor.h:87
CSCOfflineMonitor::hRHden
MonitorElement * hRHden
Definition: CSCOfflineMonitor.h:223
CSCDCCExaminer::crcCFEB
void crcCFEB(bool enable)
Definition: CSCDCCExaminer.cc:45
CSCChamberSpecs::chamberType
int chamberType() const
Definition: CSCChamberSpecs.cc:154
CSCOfflineMonitor::hSTimeCathodeByChamberType
std::vector< MonitorElement * > hSTimeCathodeByChamberType
Definition: CSCOfflineMonitor.h:193
CSCOfflineMonitor::hOWireSerial
MonitorElement * hOWireSerial
Definition: CSCOfflineMonitor.h:213
deDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
CSCChamber::layer
const CSCLayer * layer(CSCDetId id) const
Return the layer corresponding to the given id.
Definition: CSCChamber.cc:30
CSCOfflineMonitor::hSensitiveAreaEvt
MonitorElement * hSensitiveAreaEvt
Definition: CSCOfflineMonitor.h:236
CSCOfflineMonitor::hcrateToken_
const edm::ESGetToken< CSCCrateMap, CSCCrateMapRcd > hcrateToken_
Definition: CSCOfflineMonitor.h:94
CSCOfflineMonitor::hOStrips
MonitorElement * hOStrips
Definition: CSCOfflineMonitor.h:209
CSCOfflineMonitor::chamberSerial
int chamberSerial(CSCDetId id)
Definition: CSCOfflineMonitor.cc:2116
CSCOfflineMonitor::hSTimeAnodeByChamberType
std::vector< MonitorElement * > hSTimeAnodeByChamberType
Definition: CSCOfflineMonitor.h:191
mps_fire.i
i
Definition: mps_fire.py:429
RPCNoise_example.check
check
Definition: RPCNoise_example.py:71
CSCSegment::localPosition
LocalPoint localPosition() const override
Definition: CSCSegment.h:39
CSCDetId::zendcap
short int zendcap() const
Definition: CSCDetId.h:91
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
CSCOfflineMonitor::hSTimeDiffByChamberType
std::vector< MonitorElement * > hSTimeDiffByChamberType
Definition: CSCOfflineMonitor.h:189
CSCOfflineMonitor::hSResid
std::vector< MonitorElement * > hSResid
Definition: CSCOfflineMonitor.h:204
CSCOfflineMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: CSCOfflineMonitor.cc:25
CSCGeometry::chamber
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
remoteMonitoring_LASER_era2018_cfg.threshold
threshold
Definition: remoteMonitoring_LASER_era2018_cfg.py:582
CSCOfflineMonitor::hORecHits
MonitorElement * hORecHits
Definition: CSCOfflineMonitor.h:211
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:36
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
CSCOfflineMonitor::hRHSumQ
std::vector< MonitorElement * > hRHSumQ
Definition: CSCOfflineMonitor.h:171
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
CSCOfflineMonitor::hStripSTE2
MonitorElement * hStripSTE2
Definition: CSCOfflineMonitor.h:228
CSCOfflineMonitor::hWireNumber
std::vector< MonitorElement * > hWireNumber
Definition: CSCOfflineMonitor.h:159
cms::cuda::for
for(int i=first, nt=offsets[nh];i< nt;i+=gridDim.x *blockDim.x)
Definition: HistoContainer.h:15
CSCOfflineMonitor::doResolution
void doResolution(edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
Definition: CSCOfflineMonitor.cc:1337
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
slope
static const double slope[3]
Definition: CastorTimeSlew.cc:6
CSCOfflineMonitor::hRHGlobal
std::vector< MonitorElement * > hRHGlobal
Definition: CSCOfflineMonitor.h:170
hiPixelPairStep_cff.points
points
Definition: hiPixelPairStep_cff.py:94
CSCOfflineMonitor::wd_token
edm::EDGetTokenT< CSCWireDigiCollection > wd_token
Definition: CSCOfflineMonitor.h:85
CSCOfflineMonitor::hALCTMatch2DNumerator
MonitorElement * hALCTMatch2DNumerator
Definition: CSCOfflineMonitor.h:251
CSCOfflineMonitor::hORecHitsSerial
MonitorElement * hORecHitsSerial
Definition: CSCOfflineMonitor.h:215
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
FEDRawData::size
size_t size() const
Lenght of the data buffer in bytes.
Definition: FEDRawData.h:45
weight
Definition: weight.py:1
CSCOfflineMonitor::getSignal
float getSignal(const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)
Definition: CSCOfflineMonitor.cc:1427
CSCOfflineMonitor::hSTimeAnodeSerial
MonitorElement * hSTimeAnodeSerial
Definition: CSCOfflineMonitor.h:197
CSCOfflineMonitor::hWirenGroupsTotal
MonitorElement * hWirenGroupsTotal
Definition: CSCOfflineMonitor.h:156
dtChamberEfficiency_cfi.cscSegments
cscSegments
Definition: dtChamberEfficiency_cfi.py:15
CSCDetId::layer
int layer() const
Definition: CSCDetId.h:56
CSCOfflineMonitor::hCLCTL1ASerial
MonitorElement * hCLCTL1ASerial
Definition: CSCOfflineMonitor.h:254
CSCOfflineMonitor::hOStripSerial
MonitorElement * hOStripSerial
Definition: CSCOfflineMonitor.h:214
CSCOfflineMonitor::hStripNumber
std::vector< MonitorElement * > hStripNumber
Definition: CSCOfflineMonitor.h:164
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:85
CSCOfflineMonitor::hSSTE2
MonitorElement * hSSTE2
Definition: CSCOfflineMonitor.h:226
CSCDetId::iChamberType
unsigned short iChamberType() const
Definition: CSCDetId.h:96
CSCDCCExaminer::crcALCT
void crcALCT(bool enable)
Definition: CSCDCCExaminer.cc:29
CSCOfflineMonitor::hWireSTE2
MonitorElement * hWireSTE2
Definition: CSCOfflineMonitor.h:229
CSCOfflineMonitor::analyze
void analyze(const edm::Event &event, const edm::EventSetup &eventSetup) override
Definition: CSCOfflineMonitor.cc:826
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:35
res
Definition: Electron.h:6
CSCOfflineMonitor::hSTimeAnode
MonitorElement * hSTimeAnode
Definition: CSCOfflineMonitor.h:190
CSCOfflineMonitor::hSGlobalPhi
MonitorElement * hSGlobalPhi
Definition: CSCOfflineMonitor.h:187
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:242
CSCOfflineMonitor::hSnhits
std::vector< MonitorElement * > hSnhits
Definition: CSCOfflineMonitor.h:181
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
CSCOfflineMonitor::CSCOfflineMonitor
CSCOfflineMonitor(const edm::ParameterSet &pset)
Definition: CSCOfflineMonitor.cc:13
CSCOfflineMonitor::hOWires
MonitorElement * hOWires
Definition: CSCOfflineMonitor.h:207
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:292
CSCOfflineMonitor::hSnSegments
MonitorElement * hSnSegments
Definition: CSCOfflineMonitor.h:179
CSCSegment::localDirection
LocalVector localDirection() const override
Local direction.
Definition: CSCSegment.h:42
edm::RangeMap::const_iterator
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
CSCOfflineMonitor::cscGeomToken_
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > cscGeomToken_
Definition: CSCOfflineMonitor.h:92
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
CSCOfflineMonitor::hOStripsAndWiresAndCLCT
MonitorElement * hOStripsAndWiresAndCLCT
Definition: CSCOfflineMonitor.h:210
CSCTMBHeader::ALCTMatchTime
uint16_t ALCTMatchTime() const
Definition: CSCTMBHeader.h:44
CSCGeometry::gangedStrips
bool gangedStrips() const
Definition: CSCGeometry.h:110
CSCDCCEventData::dduData
const std::vector< CSCDDUEventData > & dduData() const
accessor to dduData
Definition: CSCDCCEventData.h:25
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
CSCTMBHeader::BXNCount
uint16_t BXNCount() const
Definition: CSCTMBHeader.h:43
CSCOfflineMonitor::hOSegments
MonitorElement * hOSegments
Definition: CSCOfflineMonitor.h:212
CSCOfflineMonitor::rd_token
edm::EDGetTokenT< FEDRawDataCollection > rd_token
Definition: CSCOfflineMonitor.h:84
nano_mu_digi_cff.errors
errors
Definition: nano_mu_digi_cff.py:96
nano_mu_digi_cff.float
float
Definition: nano_mu_digi_cff.py:13
CSCOfflineMonitor::hRHstpos
std::vector< MonitorElement * > hRHstpos
Definition: CSCOfflineMonitor.h:175
CSCOfflineMonitor::hALCTMatchSerial
MonitorElement * hALCTMatchSerial
Definition: CSCOfflineMonitor.h:247
CSCOfflineMonitor::typeIndex
int typeIndex(CSCDetId id, int flag=1)
Definition: CSCOfflineMonitor.cc:2081
CSCOfflineMonitor::hSnhitsAll
MonitorElement * hSnhitsAll
Definition: CSCOfflineMonitor.h:180
CSCOfflineMonitor::fitX
float fitX(const CLHEP::HepMatrix &sp, const CLHEP::HepMatrix &ep)
Definition: CSCOfflineMonitor.cc:1394
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
CSCOfflineMonitor::hRHnrechitsHi
MonitorElement * hRHnrechitsHi
Definition: CSCOfflineMonitor.h:169
hlt_dqm_clientPB-live_cfg.me
me
Definition: hlt_dqm_clientPB-live_cfg.py:62
CSCOfflineMonitor::hALCTgetBX
MonitorElement * hALCTgetBX
Definition: CSCOfflineMonitor.h:239
CSCOfflineMonitor::cl_token
edm::EDGetTokenT< CSCCLCTDigiCollection > cl_token
Definition: CSCOfflineMonitor.h:88
CSCOfflineMonitor::hALCTMatch
MonitorElement * hALCTMatch
Definition: CSCOfflineMonitor.h:246
CSCDCCExaminer::crcTMB
void crcTMB(bool enable)
Definition: CSCDCCExaminer.cc:37
CSCOfflineMonitor::hSChiSq
std::vector< MonitorElement * > hSChiSq
Definition: CSCOfflineMonitor.h:183
CSCOfflineMonitor::hSGlobalTheta
MonitorElement * hSGlobalTheta
Definition: CSCOfflineMonitor.h:186
CSCOfflineMonitor::hSTimeDiffSerial
MonitorElement * hSTimeDiffSerial
Definition: CSCOfflineMonitor.h:196
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13
CSCDetId::chamber
int chamber() const
Definition: CSCDetId.h:62
CSCOfflineMonitor::hSTimeCombined
MonitorElement * hSTimeCombined
Definition: CSCOfflineMonitor.h:194
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
CSCOfflineMonitor::hOWiresAndCLCT
MonitorElement * hOWiresAndCLCT
Definition: CSCOfflineMonitor.h:208
change_name.diff
diff
Definition: change_name.py:13
CSCOfflineMonitor::hSden
MonitorElement * hSden
Definition: CSCOfflineMonitor.h:221
CSCOfflineMonitor::hCLCTL1A2Denominator
MonitorElement * hCLCTL1A2Denominator
Definition: CSCOfflineMonitor.h:257
CSCOfflineMonitor::hSTimeCombinedByChamberType
std::vector< MonitorElement * > hSTimeCombinedByChamberType
Definition: CSCOfflineMonitor.h:195
CSCOfflineMonitor::hALCTgetBX2Denominator
MonitorElement * hALCTgetBX2Denominator
Definition: CSCOfflineMonitor.h:243
kLayer
static const std::string kLayer("layer")
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:772
CSCOfflineMonitor::se_token
edm::EDGetTokenT< CSCSegmentCollection > se_token
Definition: CSCOfflineMonitor.h:90
GeomDet::toGlobal
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
FEDRawDataCollection::FEDData
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
Definition: FEDRawDataCollection.cc:19
CSCOfflineMonitor::sd_token
edm::EDGetTokenT< CSCStripDigiCollection > sd_token
Definition: CSCOfflineMonitor.h:86
CSCOfflineMonitor::hSTimeVsZ
MonitorElement * hSTimeVsZ
Definition: CSCOfflineMonitor.h:200
CSCOfflineMonitor::doSegments
void doSegments(edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
Definition: CSCOfflineMonitor.cc:1215
CSCOfflineMonitor::hRHSTE2
MonitorElement * hRHSTE2
Definition: CSCOfflineMonitor.h:227
nano_mu_digi_cff.layer
layer
Definition: nano_mu_digi_cff.py:27
CSCOfflineMonitor::hSChiSqAll
MonitorElement * hSChiSqAll
Definition: CSCOfflineMonitor.h:182
CSCOfflineMonitor::hCSCOccupancy
MonitorElement * hCSCOccupancy
Definition: CSCOfflineMonitor.h:217
CSCOfflineMonitor::hWireTBin
std::vector< MonitorElement * > hWireTBin
Definition: CSCOfflineMonitor.h:158
CSCCrateMap::detId
CSCDetId detId(int vme, int dmb, int cfeb, int layer=0) const
Definition: CSCCrateMap.cc:9
CSCDetId::station
int station() const
Definition: CSCDetId.h:79
CSCOfflineMonitor::hCLCTL1A2DNumerator
MonitorElement * hCLCTL1A2DNumerator
Definition: CSCOfflineMonitor.h:258
CSCOfflineMonitor::hRHTiming
std::vector< MonitorElement * > hRHTiming
Definition: CSCOfflineMonitor.h:172
CSCOfflineMonitor::doWireDigis
void doWireDigis(edm::Handle< CSCWireDigiCollection > wires)
Definition: CSCOfflineMonitor.cc:1032
TrapezoidalPlaneBounds::parameters
virtual const std::array< const float, 4 > parameters() const
Definition: TrapezoidalPlaneBounds.cc:49
CSCOfflineMonitor::hALCTgetBX2DNumerator
MonitorElement * hALCTgetBX2DNumerator
Definition: CSCOfflineMonitor.h:244
MuonDigiCollection::Range
std::pair< const_iterator, const_iterator > Range
Definition: MuonDigiCollection.h:95
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:212
CSCOfflineMonitor::hALCTMatch2Denominator
MonitorElement * hALCTMatch2Denominator
Definition: CSCOfflineMonitor.h:250
CSCDetId::endcap
int endcap() const
Definition: CSCDetId.h:85
MuonDigiCollection::const_iterator
std::vector< DigiType >::const_iterator const_iterator
Definition: MuonDigiCollection.h:94
CSCOfflineMonitor::hCLCTL1A
MonitorElement * hCLCTL1A
Definition: CSCOfflineMonitor.h:253
CSCOfflineMonitor::hRHTimingAnode
std::vector< MonitorElement * > hRHTimingAnode
Definition: CSCOfflineMonitor.h:173
CSCOfflineMonitor::withinSensitiveRegion
bool withinSensitiveRegion(LocalPoint localPos, const std::array< const float, 4 > &layerBounds, int station, int ring, float shiftFromEdge, float shiftFromDeadZone)
Definition: CSCOfflineMonitor.cc:1983
CSCOfflineMonitor::hRHRatioQ
std::vector< MonitorElement * > hRHRatioQ
Definition: CSCOfflineMonitor.h:174
CSCOfflineMonitor::hRHsterr
std::vector< MonitorElement * > hRHsterr
Definition: CSCOfflineMonitor.h:176
CSCOfflineMonitor::doBXMonitor
void doBXMonitor(edm::Handle< CSCALCTDigiCollection > alcts, edm::Handle< CSCCLCTDigiCollection > clcts, const edm::Event &event, const edm::EventSetup &eventSetup)
Definition: CSCOfflineMonitor.cc:1782
CSCDCCExaminer::check
int32_t check(const uint16_t *&buffer, int32_t length)
Definition: CSCDCCExaminer.cc:264
CSCOfflineMonitor::hSTimeDiff
MonitorElement * hSTimeDiff
Definition: CSCOfflineMonitor.h:188
CSCOfflineMonitor::hSTimeCathode
MonitorElement * hSTimeCathode
Definition: CSCOfflineMonitor.h:192
CSCGeometry::ChamberContainer
std::vector< const CSCChamber * > ChamberContainer
Definition: CSCGeometry.h:30
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:80
CSCOfflineMonitor::hSChiSqProb
std::vector< MonitorElement * > hSChiSqProb
Definition: CSCOfflineMonitor.h:185
CSCOfflineMonitor::hSTimeCathodeSerial
MonitorElement * hSTimeCathodeSerial
Definition: CSCOfflineMonitor.h:198
a
double a
Definition: hdecay.h:121
CSCOfflineMonitor::hWirenGroupsTotalHi
MonitorElement * hWirenGroupsTotalHi
Definition: CSCOfflineMonitor.h:157
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
CSCOfflineMonitor::doStripDigis
void doStripDigis(edm::Handle< CSCStripDigiCollection > strips)
Definition: CSCOfflineMonitor.cc:1057
CSCDCCExaminer::errors
ExaminerStatusType errors(void) const
Definition: CSCDCCExaminer.h:171
CSCOfflineMonitor::hStripNFired
MonitorElement * hStripNFired
Definition: CSCOfflineMonitor.h:162
CSCOfflineMonitor::doPedestalNoise
void doPedestalNoise(edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)
Definition: CSCOfflineMonitor.cc:1095
CSCOfflineMonitor::hSTimeCombinedSerial
MonitorElement * hSTimeCombinedSerial
Definition: CSCOfflineMonitor.h:199
CSCOfflineMonitor::hStripPed
std::vector< MonitorElement * > hStripPed
Definition: CSCOfflineMonitor.h:165
FEDRawData::data
const unsigned char * data() const
Return a const pointer to the beginning of the data buffer.
Definition: FEDRawData.cc:24
DigiDM_cff.strips
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32
CSCOfflineMonitor::rh_token
edm::EDGetTokenT< CSCRecHit2DCollection > rh_token
Definition: CSCOfflineMonitor.h:89
errors
Definition: errors.py:1
CSCOfflineMonitor::hALCTgetBXSerial
MonitorElement * hALCTgetBXSerial
Definition: CSCOfflineMonitor.h:240
CSCOfflineMonitor::hSTimeVsTOF
MonitorElement * hSTimeVsTOF
Definition: CSCOfflineMonitor.h:201
DigiDM_cff.wires
wires
Definition: DigiDM_cff.py:33
CSCOfflineMonitor::hRHnrechits
MonitorElement * hRHnrechits
Definition: CSCOfflineMonitor.h:168
CSCDetId::ring
int ring() const
Definition: CSCDetId.h:68
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128
CSCOfflineMonitor::hSnum
MonitorElement * hSnum
Definition: CSCOfflineMonitor.h:220
CSCGeometry::chambers
const ChamberContainer & chambers() const
Return a vector of all chambers.
Definition: CSCGeometry.cc:96
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
CSCOfflineMonitor::hStripNFiredHi
MonitorElement * hStripNFiredHi
Definition: CSCOfflineMonitor.h:163
CSCOfflineMonitor::extrapolate1D
double extrapolate1D(double initPosition, double initDirection, double parameterOfTheLine)
Definition: CSCOfflineMonitor.h:139
CSCGeometry::layer
const CSCLayer * layer(CSCDetId id) const
Return the layer corresponding to given DetId.
Definition: CSCGeometry.cc:105
CSCOfflineMonitor::lineParametrization
double lineParametrization(double z1Position, double z2Position, double z1Direction)
Definition: CSCOfflineMonitor.h:134
mps_merge.weight
weight
Definition: mps_merge.py:88
CSCOfflineMonitor::doEfficiencies
void doEfficiencies(edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
Definition: CSCOfflineMonitor.cc:1490
options_cfi.eventSetup
eventSetup
Definition: options_cfi.py:12
CSCOfflineMonitor::doOccupancies
void doOccupancies(edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::Handle< CSCCLCTDigiCollection > clcts)
Definition: CSCOfflineMonitor.cc:866
CSCOfflineMonitor::hRHnum
MonitorElement * hRHnum
Definition: CSCOfflineMonitor.h:222
CSCChamber::specs
const CSCChamberSpecs * specs() const
Definition: CSCChamber.h:39
CSCDCCExaminer::setMask
void setMask(ExaminerMaskType mask)
Definition: CSCDCCExaminer.h:168
event
Definition: event.py:1
edm::Run
Definition: Run.h:45
CSCOfflineMonitor::hSChiSqProbAll
MonitorElement * hSChiSqProbAll
Definition: CSCOfflineMonitor.h:184
PV3DBase::theta
Geom::Theta< T > theta() const
Definition: PV3DBase.h:72
CSCOfflineMonitor::doRecHits
void doRecHits(edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)
Definition: CSCOfflineMonitor.cc:1138
CSCChamber::id
CSCDetId id() const
Get the (concrete) DetId.
Definition: CSCChamber.h:34
CSCOfflineMonitor::applyCSClabels
void applyCSClabels(MonitorElement *meHisto, LabelType t, AxisType a)
Definition: CSCOfflineMonitor.cc:2147
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:801
Generated for CMSSW Reference Manual by doxygen 1.8.14