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  int jRH = 0;
1346  CLHEP::HepMatrix sp(6, 1);
1347  CLHEP::HepMatrix se(6, 1);
1348  for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1349  jRH++;
1350  CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
1351  //int kEndcap = idRH.endcap();
1352  int kRing = idRH.ring();
1353  int kStation = idRH.station();
1354  //int kChamber = idRH.chamber();
1355  int kLayer = idRH.layer();
1356 
1358  int centerid = iRH->nStrips() / 2 + 1;
1359  int centerStrip = iRH->channels(centerid - 1);
1360 
1361  // If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
1362  if (nRH == 6) {
1363  float stpos = (*iRH).positionWithinStrip();
1364  se(kLayer, 1) = (*iRH).errorWithinStrip();
1365  // Take into account half-strip staggering of layers (ME1/1 has no staggering)
1366  if (kStation == 1 && (kRing == 1 || kRing == 4))
1367  sp(kLayer, 1) = stpos + centerStrip;
1368  else {
1369  if (kLayer == 1 || kLayer == 3 || kLayer == 5)
1370  sp(kLayer, 1) = stpos + centerStrip;
1371  if (kLayer == 2 || kLayer == 4 || kLayer == 6)
1372  sp(kLayer, 1) = stpos - 0.5 + centerStrip;
1373  }
1374  }
1375  }
1376 
1377  // Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
1378  // float residual = -99.; // used to fill always
1379  if (nRH == 6) {
1380  float expected = fitX(sp, se);
1381  float residual = expected - sp(3, 1);
1382 
1383  hSResid[typeIndex(id) - 1]->Fill(residual); // fill here so stats make sense
1384  }
1385 
1386  // hSResid[typeIndex(id)-1]->Fill(residual); // used to fill here but then stats distorted by underflows
1387 
1388  } // end segment loop
1389 }
1390 
1391 //-------------------------------------------------------------------------------------
1392 // Fits a straight line to a set of 5 points with errors. Functions assumes 6 points
1393 // and removes hit in layer 3. It then returns the expected position value in layer 3
1394 // based on the fit.
1395 //-------------------------------------------------------------------------------------
1396 float CSCOfflineMonitor::fitX(const CLHEP::HepMatrix& points, const CLHEP::HepMatrix& errors) {
1397  float S = 0;
1398  float Sx = 0;
1399  float Sy = 0;
1400  float Sxx = 0;
1401  float Sxy = 0;
1402  float sigma2 = 0;
1403 
1404  for (int i = 1; i < 7; i++) {
1405  if (i != 3) {
1406  sigma2 = errors(i, 1) * errors(i, 1);
1407  S = S + (1 / sigma2);
1408  Sy = Sy + (points(i, 1) / sigma2);
1409  Sx = Sx + ((i) / sigma2);
1410  Sxx = Sxx + (i * i) / sigma2;
1411  Sxy = Sxy + (((i)*points(i, 1)) / sigma2);
1412  }
1413  }
1414 
1415  float delta = S * Sxx - Sx * Sx;
1416  float intercept = (Sxx * Sy - Sx * Sxy) / delta;
1417  float slope = (S * Sxy - Sx * Sy) / delta;
1418 
1419  return (intercept + slope * 3);
1420 }
1421 
1422 //---------------------------------------------------------------------------------------
1423 // Given a set of digis, the CSCDetId, and the central strip of your choosing, returns
1424 // the avg. Signal-Pedestal for 6 time bin x 5 strip .
1425 //
1426 // Author: P. Jindal
1427 //---------------------------------------------------------------------------------------
1428 
1429 float CSCOfflineMonitor::getSignal(const CSCStripDigiCollection& stripdigis, CSCDetId idCS, int centerStrip) {
1430  float SigADC[5];
1431  float TotalADC = 0;
1432  SigADC[0] = 0;
1433  SigADC[1] = 0;
1434  SigADC[2] = 0;
1435  SigADC[3] = 0;
1436  SigADC[4] = 0;
1437 
1438  // Loop over strip digis
1439  CSCStripDigiCollection::DigiRangeIterator sIt;
1440 
1441  for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++) {
1442  CSCDetId id = (CSCDetId)(*sIt).first;
1443  if (id == idCS) {
1444  // First, find the Signal-Pedestal for center strip
1445  vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
1446  vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
1447  for (; digiItr != last; ++digiItr) {
1448  int thisStrip = digiItr->getStrip();
1449  if (thisStrip == (centerStrip)) {
1450  std::vector<int> myADCVals = digiItr->getADCCounts();
1451  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1452  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1453  SigADC[0] = thisSignal - 6 * thisPedestal;
1454  }
1455  // Now,find the Signal-Pedestal for neighbouring 4 strips
1456  if (thisStrip == (centerStrip + 1)) {
1457  std::vector<int> myADCVals = digiItr->getADCCounts();
1458  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1459  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1460  SigADC[1] = thisSignal - 6 * thisPedestal;
1461  }
1462  if (thisStrip == (centerStrip + 2)) {
1463  std::vector<int> myADCVals = digiItr->getADCCounts();
1464  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1465  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1466  SigADC[2] = thisSignal - 6 * thisPedestal;
1467  }
1468  if (thisStrip == (centerStrip - 1)) {
1469  std::vector<int> myADCVals = digiItr->getADCCounts();
1470  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1471  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1472  SigADC[3] = thisSignal - 6 * thisPedestal;
1473  }
1474  if (thisStrip == (centerStrip - 2)) {
1475  std::vector<int> myADCVals = digiItr->getADCCounts();
1476  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1477  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1478  SigADC[4] = thisSignal - 6 * thisPedestal;
1479  }
1480  }
1481  TotalADC = 0.2 * (SigADC[0] + SigADC[1] + SigADC[2] + SigADC[3] + SigADC[4]);
1482  }
1483  }
1484  return TotalADC;
1485 }
1486 
1487 //----------------------------------------------------------------------------
1488 // Calculate basic efficiencies for recHits and Segments
1489 // Author: S. Stoynev
1490 //----------------------------------------------------------------------------
1491 
1492 void CSCOfflineMonitor::doEfficiencies(edm::Handle<CSCWireDigiCollection> wires,
1493  edm::Handle<CSCStripDigiCollection> strips,
1494  edm::Handle<CSCRecHit2DCollection> recHits,
1495  edm::Handle<CSCSegmentCollection> cscSegments,
1496  edm::ESHandle<CSCGeometry> cscGeom) {
1497  bool allWires[2][4][4][36][6];
1498  bool allStrips[2][4][4][36][6];
1499  bool AllRecHits[2][4][4][36][6];
1500  bool AllSegments[2][4][4][36];
1501 
1502  //bool MultiSegments[2][4][4][36];
1503  for (int iE = 0; iE < 2; iE++) {
1504  for (int iS = 0; iS < 4; iS++) {
1505  for (int iR = 0; iR < 4; iR++) {
1506  for (int iC = 0; iC < 36; iC++) {
1507  AllSegments[iE][iS][iR][iC] = false;
1508  //MultiSegments[iE][iS][iR][iC] = false;
1509  for (int iL = 0; iL < 6; iL++) {
1510  allWires[iE][iS][iR][iC][iL] = false;
1511  allStrips[iE][iS][iR][iC][iL] = false;
1512  AllRecHits[iE][iS][iR][iC][iL] = false;
1513  }
1514  }
1515  }
1516  }
1517  }
1518 
1519  // Wires
1520  for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1521  CSCDetId idrec = (CSCDetId)(*dWDiter).first;
1522  std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1523  std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1524  for (; wireIter != lWire; ++wireIter) {
1525  allWires[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1526  true;
1527  break;
1528  }
1529  }
1530 
1531  //---- STRIPS
1532  for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1533  CSCDetId idrec = (CSCDetId)(*dSDiter).first;
1534  std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1535  std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1536  for (; stripIter != lStrip; ++stripIter) {
1537  std::vector<int> myADCVals = stripIter->getADCCounts();
1538  bool thisStripFired = false;
1539  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1540  float threshold = 13.3;
1541  float diff = 0.;
1542  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1543  diff = (float)myADCVals[iCount] - thisPedestal;
1544  if (diff > threshold) {
1545  thisStripFired = true;
1546  break;
1547  }
1548  }
1549  if (thisStripFired) {
1550  allStrips[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1551  true;
1552  break;
1553  }
1554  }
1555  }
1556 
1557  // Rechits
1558  for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
1559  //CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
1560  CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
1561  AllRecHits[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1562  true;
1563  }
1564 
1565  std::vector<uint> seg_ME2(2, 0);
1566  std::vector<uint> seg_ME3(2, 0);
1567  std::vector<pair<CSCDetId, CSCSegment> > theSegments(4);
1568  // Segments
1569  for (CSCSegmentCollection::const_iterator segEffIt = cscSegments->begin(); segEffIt != cscSegments->end();
1570  segEffIt++) {
1571  CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
1572  //if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
1573  //MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
1574  //}
1575  AllSegments[idseg.endcap() - 1][idseg.station() - 1][idseg.ring() - 1][idseg.chamber() - 1] = true;
1576  // "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
1577  // station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
1578  // station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
1579  if (2 == idseg.station() || 3 == idseg.station()) {
1580  uint seg_tmp;
1581  if (2 == idseg.station()) {
1582  ++seg_ME2[idseg.endcap() - 1];
1583  seg_tmp = seg_ME2[idseg.endcap() - 1];
1584  } else {
1585  ++seg_ME3[idseg.endcap() - 1];
1586  seg_tmp = seg_ME3[idseg.endcap() - 1];
1587  }
1588  // is the segment good
1589  if (1 == seg_tmp && 6 == (*segEffIt).nRecHits() && (*segEffIt).chi2() / (*segEffIt).degreesOfFreedom() < 3.) {
1590  pair<CSCDetId, CSCSegment> specSeg = make_pair((CSCDetId)(*segEffIt).cscDetId(), *segEffIt);
1591  theSegments[2 * (idseg.endcap() - 1) + (idseg.station() - 2)] = specSeg;
1592  }
1593  }
1594  /*
1595  if(2==idseg.station()){
1596  ++seg_ME2[idseg.endcap() -1];
1597  if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1598  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1599  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1600  }
1601  }
1602  else if(3==idseg.station()){
1603  ++seg_ME3[idseg.endcap() -1];
1604  if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1605  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1606  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1607  }
1608  }
1609  */
1610  }
1611  // Simple efficiency calculations
1612  for (int iE = 0; iE < 2; iE++) {
1613  for (int iS = 0; iS < 4; iS++) {
1614  for (int iR = 0; iR < 4; iR++) {
1615  for (int iC = 0; iC < 36; iC++) {
1616  int NumberOfLayers = 0;
1617  for (int iL = 0; iL < 6; iL++) {
1618  if (AllRecHits[iE][iS][iR][iC][iL]) {
1619  NumberOfLayers++;
1620  }
1621  }
1622 
1623  // set bin = 1-10 for ME-42, ME-41,...ME-11B, ME-11A,
1624  // 11-20 for ME+11A, ME+11B, ... ME+41, ME+42
1625  int bin = CSCDetId::iChamberType(iS + 1, iR + 1); // 1-10 for ME11A...ME42
1626  if (iE > 0) { // in this loop iE=1 is -z endcap
1627  bin = 11 - bin;
1628  } else { // in this loop iE=0 is +z endcap
1629  bin += 10;
1630  }
1631 
1632  if (NumberOfLayers > 1) {
1633  //if(!(MultiSegments[iE][iS][iR][iC])){
1634  if (AllSegments[iE][iS][iR][iC]) {
1635  //---- Efficient segment evenents
1636  hSnum->Fill(bin);
1637  }
1638  //---- All segment events (normalization)
1639  hSden->Fill(bin);
1640  //}
1641  }
1642  if (AllSegments[iE][iS][iR][iC]) {
1643  if (NumberOfLayers == 6) {
1644  //---- Efficient rechit events
1645  hRHnum->Fill(bin);
1646  ;
1647  }
1648  //---- All rechit events (normalization)
1649  hRHden->Fill(bin);
1650  ;
1651  }
1652  }
1653  }
1654  }
1655  }
1656 
1657  // pick a segment only if there are no others in the station
1658  std::vector<pair<CSCDetId, CSCSegment>*> theSeg;
1659  if (1 == seg_ME2[0])
1660  theSeg.push_back(&theSegments[0]);
1661  if (1 == seg_ME3[0])
1662  theSeg.push_back(&theSegments[1]);
1663  if (1 == seg_ME2[1])
1664  theSeg.push_back(&theSegments[2]);
1665  if (1 == seg_ME3[1])
1666  theSeg.push_back(&theSegments[3]);
1667 
1668  if (!theSeg.empty()) {
1669  std::map<int, GlobalPoint> extrapolatedPoint;
1670  std::map<int, GlobalPoint>::iterator it;
1671  const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
1672  // Pick which chamber with which segment to test
1673  for (unsigned int nCh = 0; nCh < ChamberContainer.size(); nCh++) {
1674  const CSCChamber* cscchamber = ChamberContainer[nCh];
1675  pair<CSCDetId, CSCSegment>* thisSegment = nullptr;
1676  for (uint iSeg = 0; iSeg < theSeg.size(); ++iSeg) {
1677  if (cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()) {
1678  if (1 == cscchamber->id().station() || 3 == cscchamber->id().station()) {
1679  if (2 == theSeg[iSeg]->first.station()) {
1680  thisSegment = theSeg[iSeg];
1681  }
1682  } else if (2 == cscchamber->id().station() || 4 == cscchamber->id().station()) {
1683  if (3 == theSeg[iSeg]->first.station()) {
1684  thisSegment = theSeg[iSeg];
1685  }
1686  }
1687  }
1688  }
1689  // this chamber is to be tested with thisSegment
1690  if (thisSegment) {
1691  CSCSegment* seg = &(thisSegment->second);
1692  const CSCChamber* segChamber = cscGeom->chamber(thisSegment->first);
1693  LocalPoint localCenter(0., 0., 0);
1694  GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
1695  // try to save some time (extrapolate a segment to a certain position only once)
1696  it = extrapolatedPoint.find(int(cscchamberCenter.z()));
1697  if (it == extrapolatedPoint.end()) {
1698  GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
1699  GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
1700  double paramaterLine = lineParametrization(segPos.z(), cscchamberCenter.z(), segDir.z());
1701  double xExtrapolated = extrapolate1D(segPos.x(), segDir.x(), paramaterLine);
1702  double yExtrapolated = extrapolate1D(segPos.y(), segDir.y(), paramaterLine);
1703  GlobalPoint globP(xExtrapolated, yExtrapolated, cscchamberCenter.z());
1704  extrapolatedPoint[int(cscchamberCenter.z())] = globP;
1705  }
1706  // Where does the extrapolated point lie in the (tested) chamber local frame? Here:
1707  LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
1708  const CSCLayer* layer_p = cscchamber->layer(1); //layer 1
1709  const CSCLayerGeometry* layerGeom = layer_p->geometry();
1710  const std::array<const float, 4>& layerBounds = layerGeom->parameters();
1711  float shiftFromEdge = 15.; //cm
1712  float shiftFromDeadZone = 10.;
1713  // is the extrapolated point within a sensitive region
1714  bool pass = withinSensitiveRegion(extrapolatedPointLocal,
1715  layerBounds,
1716  cscchamber->id().station(),
1717  cscchamber->id().ring(),
1718  shiftFromEdge,
1719  shiftFromDeadZone);
1720  if (pass) { // the extrapolation point of the segment lies within sensitive region of that chamber
1721  // how many rechit layers are there in the chamber?
1722  // 0 - maybe the muon died or is deflected at large angle? do not use that case
1723  // 1 - could be noise...
1724  // 2 or more - this is promissing; this is our definition of a reliable signal; use it below
1725  // is other definition better?
1726  int nRHLayers = 0;
1727  for (int iL = 0; iL < 6; ++iL) {
1728  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1729  [cscchamber->id().chamber() - 1][iL]) {
1730  ++nRHLayers;
1731  }
1732  }
1733 
1734  // set verticalScale to 1-10 for ME-42...ME-11A,
1735  // 11-20 for ME+11A...ME+42
1736  float verticalScale =
1737  9. + cscchamber->id().endcap() + (cscchamber->specs()->chamberType()) * (cscchamber->id().zendcap());
1738 
1739  hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()), verticalScale);
1740  if (nRHLayers > 1) { // this chamber contains a reliable signal
1741  // this is the denominator for all efficiencies
1742  hEffDenominator->Fill(float(cscchamber->id().chamber()), verticalScale);
1743  // Segment efficiency
1744  if (AllSegments[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1745  [cscchamber->id().chamber() - 1]) {
1746  hSSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale));
1747  }
1748 
1749  for (int iL = 0; iL < 6; ++iL) {
1750  float weight = 1. / 6.;
1751  // should account for the weight in the efficiency...
1752  // Rechit efficiency
1753  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1754  [cscchamber->id().chamber() - 1][iL]) {
1755  hRHSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1756  }
1757  // Wire efficiency
1758  if (allWires[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1759  [cscchamber->id().chamber() - 1][iL]) {
1760  // one shold account for the weight in the efficiency...
1761  hWireSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1762  }
1763  // Strip efficiency
1764  if (allStrips[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1765  [cscchamber->id().chamber() - 1][iL]) {
1766  // one shold account for the weight in the efficiency...
1767  hStripSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1768  }
1769  }
1770  }
1771  }
1772  }
1773  }
1774  }
1775  //
1776 }
1777 
1778 // ==============================================
1779 //
1780 // Look at BX level trigger synchronization
1781 //
1782 // ==============================================
1783 
1784 void CSCOfflineMonitor::doBXMonitor(edm::Handle<CSCALCTDigiCollection> alcts,
1785  edm::Handle<CSCCLCTDigiCollection> clcts,
1786  const edm::Event& event,
1787  const edm::EventSetup& eventSetup) {
1788  // Loop over ALCTDigis
1789 
1790  for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
1791  const CSCDetId& idALCT = (*j).first;
1792  const CSCALCTDigiCollection::Range& range = (*j).second;
1793  for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1794  // Valid digi in the chamber (or in neighbouring chamber)
1795  if ((*digiIt).isValid()) {
1796  hALCTgetBX->Fill((*digiIt).getBX());
1797  hALCTgetBXSerial->Fill(chamberSerial(idALCT), (*digiIt).getBX());
1798  hALCTgetBX2DNumerator->Fill(idALCT.chamber(), typeIndex(idALCT, 2), (*digiIt).getBX());
1799  hALCTgetBX2Denominator->Fill(idALCT.chamber(), typeIndex(idALCT, 2));
1800  }
1801  }
1802  } // end ALCT Digi loop
1803 
1804  // Loop over raw data to get TMBHeader information
1805  // Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
1806  edm::ESHandle<CSCCrateMap> hcrate;
1807 
1808  hcrate = eventSetup.getHandle(hcrateToken_);
1809 
1810  const CSCCrateMap* pcrate = hcrate.product();
1811 
1812  // Try to get raw data
1813  edm::Handle<FEDRawDataCollection> rawdata;
1814  if (!(event.getByToken(rd_token, rawdata))) {
1815  edm::LogWarning("CSCOfflineMonitor") << " FEDRawDataCollection not available";
1816  return;
1817  }
1818 
1819  bool goodEvent = false;
1820  unsigned long dccBinCheckMask = 0x06080016;
1821  unsigned int examinerMask = 0x1FEBF3F6;
1822  unsigned int errorMask = 0x0;
1823 
1824  // For new CSC readout layout, which doesn't include DCCs need to loop over DDU FED IDs.
1825  // DCC IDs are included for backward compatibility with old data
1826  std::vector<unsigned int> cscFEDids;
1827 
1828  for (unsigned int id = FEDNumbering::MINCSCFEDID; id <= FEDNumbering::MAXCSCFEDID; ++id) // loop over DCCs
1829  {
1830  cscFEDids.push_back(id);
1831  }
1832 
1833  for (unsigned int id = FEDNumbering::MINCSCDDUFEDID; id <= FEDNumbering::MAXCSCDDUFEDID; ++id) // loop over DDUs
1834  {
1835  cscFEDids.push_back(id);
1836  }
1837 
1838  for (unsigned int i = 0; i < cscFEDids.size(); i++) // loop over all CSC FEDs (DCCs and DDUs)
1839  {
1840  unsigned int id = cscFEDids[i];
1841  bool isDDU_FED = ((id >= FEDNumbering::MINCSCDDUFEDID) && (id <= FEDNumbering::MAXCSCDDUFEDID)) ? true : false;
1842 
1845 
1847  const FEDRawData& fedData = rawdata->FEDData(id);
1848  unsigned long length = fedData.size();
1849 
1850  if (length >= 32) {
1851  CSCDCCExaminer* examiner = nullptr;
1852  std::stringstream examiner_out, examiner_err;
1853  goodEvent = true;
1854  examiner = new CSCDCCExaminer();
1855  if (examinerMask & 0x40000)
1856  examiner->crcCFEB(true);
1857  if (examinerMask & 0x8000)
1858  examiner->crcTMB(true);
1859  if (examinerMask & 0x0400)
1860  examiner->crcALCT(true);
1861  examiner->setMask(examinerMask);
1862  const short unsigned int* data = (short unsigned int*)fedData.data();
1863 
1864  int res = examiner->check(data, long(fedData.size() / 2));
1865  if (res < 0) {
1866  goodEvent = false;
1867  } else {
1868  goodEvent = !(examiner->errors() & dccBinCheckMask);
1869  }
1870 
1871  if (goodEvent) {
1873 
1874  CSCDCCExaminer* ptrExaminer = examiner;
1875 
1876  std::vector<CSCDDUEventData> fed_Data;
1877  std::vector<CSCDDUEventData>* ptr_fedData = &fed_Data;
1878 
1879  if (isDDU_FED) // Use new DDU FED readout mode
1880  {
1881  CSCDDUEventData single_dduData((short unsigned int*)fedData.data(), ptrExaminer);
1882  fed_Data.push_back(single_dduData);
1883 
1884  } else // Use old DCC FED readout mode
1885  {
1886  CSCDCCEventData dccData((short unsigned int*)fedData.data(), ptrExaminer);
1887  fed_Data = dccData.dduData();
1888  }
1889 
1891  const std::vector<CSCDDUEventData>& dduData = *ptr_fedData;
1892 
1894  CSCDetId layer(1, 1, 1, 1, 1);
1895  for (unsigned int iDDU = 0; iDDU < dduData.size(); ++iDDU) { // loop over DDUs
1898  if (dduData[iDDU].trailer().errorstat() & errorMask) {
1899  LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! "
1900  << std::hex << dduData[iDDU].trailer().errorstat();
1901  continue; // to next iteration of DDU loop
1902  }
1903 
1905  const std::vector<CSCEventData>& cscData = dduData[iDDU].cscData();
1906 
1907  for (unsigned int iCSC = 0; iCSC < cscData.size(); ++iCSC) { // loop over CSCs
1908 
1910  int vmecrate = cscData[iCSC].dmbHeader()->crateID();
1911  int dmb = cscData[iCSC].dmbHeader()->dmbID();
1912 
1913  int icfeb = 0;
1914  int ilayer = 0;
1915 
1916  if ((vmecrate >= 1) && (vmecrate <= 60) && (dmb >= 1) && (dmb <= 10) && (dmb != 6)) {
1917  layer = pcrate->detId(vmecrate, dmb, icfeb, ilayer);
1918  } else {
1919  LogTrace("CSCOfflineMonitor") << " detID input out of range!!! ";
1920  LogTrace("CSCOfflineMonitor") << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
1921  continue; // to next iteration of iCSC loop
1922  }
1923 
1925  int nalct = cscData[iCSC].dmbHeader()->nalct();
1926  bool goodALCT = false;
1927  //if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
1928  if (nalct && cscData[iCSC].alctHeader()) {
1929  if (cscData[iCSC].alctHeader()->check()) {
1930  goodALCT = true;
1931  }
1932  }
1933 
1935  int nclct = cscData[iCSC].dmbHeader()->nclct();
1936  bool goodTMB = false;
1937  if (nclct && cscData[iCSC].tmbData()) {
1938  if (cscData[iCSC].tmbHeader()->check()) {
1939  if (cscData[iCSC].comparatorData()->check())
1940  goodTMB = true;
1941  }
1942  }
1943 
1944  if (goodTMB && goodALCT) {
1945  const CSCTMBHeader* tmbHead = cscData[iCSC].tmbHeader();
1946  std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
1947  if (clcts.empty() || !(clcts[0].isValid()))
1948  continue;
1949  // Check if the CLCT was in ME11a (ring 4)
1950  if (layer.station() == 1 && layer.ring() == 1 && clcts[0].getKeyStrip() > 128) {
1951  layer = CSCDetId(layer.endcap(), layer.station(), 4, layer.chamber());
1952  }
1953  hALCTMatch->Fill(tmbHead->ALCTMatchTime());
1954  hALCTMatchSerial->Fill(chamberSerial(layer), tmbHead->ALCTMatchTime());
1955  // Only fill big 2D display if ALCTMatchTime !=6, since this bin is polluted by the CLCT only triggers
1956  // One will have to look at the serial plots to see if the are a lot of entries here
1957  if (tmbHead->ALCTMatchTime() != 6) {
1958  hALCTMatch2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), tmbHead->ALCTMatchTime());
1959  hALCTMatch2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1960  }
1961 
1962  int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount() - clcts[0].getFullBX();
1963  if (TMB_CLCTpre_rel_L1A > 3563)
1964  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
1965  if (TMB_CLCTpre_rel_L1A < 0)
1966  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
1967 
1968  hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
1969  hCLCTL1ASerial->Fill(chamberSerial(layer), TMB_CLCTpre_rel_L1A);
1970  hCLCTL1A2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), TMB_CLCTpre_rel_L1A);
1971  hCLCTL1A2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1972 
1973  } // end if goodTMB and goodALCT
1974  } // end loop CSCData
1975  } // end loop DDU
1976  } // end if good event
1977  if (examiner != nullptr)
1978  delete examiner;
1979  } // end if non-zero fed data
1980  } // end DCC loop for NON-REFERENCE
1981 
1982  return;
1983 }
1984 
1985 bool CSCOfflineMonitor::withinSensitiveRegion(LocalPoint localPos,
1986  const std::array<const float, 4>& layerBounds,
1987  int station,
1988  int ring,
1989  float shiftFromEdge,
1990  float shiftFromDeadZone) {
1991  //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
1992  bool pass = false;
1993 
1994  float y_center = 0.;
1995  double yUp = layerBounds[3] + y_center;
1996  double yDown = -layerBounds[3] + y_center;
1997  double xBound1Shifted = layerBounds[0] - shiftFromEdge; //
1998  double xBound2Shifted = layerBounds[1] - shiftFromEdge; //
1999  double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
2000  double lineConst = yUp - lineSlope * xBound2Shifted;
2001  double yBorder = lineSlope * abs(localPos.x()) + lineConst;
2002 
2003  //bool withinChamberOnly = false;// false = "good region"; true - boundaries only
2004  std::vector<float> deadZoneCenter(6);
2005  float cutZone = shiftFromDeadZone; //cm
2006  //---- hardcoded... not good
2007  if (station > 1 && station < 5) {
2008  if (2 == ring) {
2009  deadZoneCenter[0] = -162.48;
2010  deadZoneCenter[1] = -81.8744;
2011  deadZoneCenter[2] = -21.18165;
2012  deadZoneCenter[3] = 39.51105;
2013  deadZoneCenter[4] = 100.2939;
2014  deadZoneCenter[5] = 160.58;
2015 
2016  if (localPos.y() > yBorder &&
2017  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2018  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2019  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone) ||
2020  (localPos.y() > deadZoneCenter[3] + cutZone && localPos.y() < deadZoneCenter[4] - cutZone) ||
2021  (localPos.y() > deadZoneCenter[4] + cutZone && localPos.y() < deadZoneCenter[5] - cutZone))) {
2022  pass = true;
2023  }
2024  } else if (1 == ring) {
2025  if (2 == station) {
2026  deadZoneCenter[0] = -95.80;
2027  deadZoneCenter[1] = -27.47;
2028  deadZoneCenter[2] = 33.67;
2029  deadZoneCenter[3] = 90.85;
2030  } else if (3 == station) {
2031  deadZoneCenter[0] = -89.305;
2032  deadZoneCenter[1] = -39.705;
2033  deadZoneCenter[2] = 20.195;
2034  deadZoneCenter[3] = 77.395;
2035  } else if (4 == station) {
2036  deadZoneCenter[0] = -75.645;
2037  deadZoneCenter[1] = -26.055;
2038  deadZoneCenter[2] = 23.855;
2039  deadZoneCenter[3] = 70.575;
2040  }
2041  if (localPos.y() > yBorder &&
2042  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2043  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2044  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2045  pass = true;
2046  }
2047  }
2048  } else if (1 == station) {
2049  if (3 == ring) {
2050  deadZoneCenter[0] = -83.155;
2051  deadZoneCenter[1] = -22.7401;
2052  deadZoneCenter[2] = 27.86665;
2053  deadZoneCenter[3] = 81.005;
2054  if (localPos.y() > yBorder &&
2055  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2056  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2057  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2058  pass = true;
2059  }
2060  } else if (2 == ring) {
2061  deadZoneCenter[0] = -86.285;
2062  deadZoneCenter[1] = -32.88305;
2063  deadZoneCenter[2] = 32.867423;
2064  deadZoneCenter[3] = 88.205;
2065  if (localPos.y() > (yBorder) &&
2066  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2067  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2068  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2069  pass = true;
2070  }
2071  } else {
2072  deadZoneCenter[0] = -81.0;
2073  deadZoneCenter[1] = 81.0;
2074  if (localPos.y() > (yBorder) &&
2075  (localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone)) {
2076  pass = true;
2077  }
2078  }
2079  }
2080  return pass;
2081 }
2082 
2083 int CSCOfflineMonitor::typeIndex(CSCDetId id, int flag) {
2084  // linearized index based on endcap, station, and ring
2085 
2086  if (flag == 1) {
2087  int index = 0;
2088  if (id.station() == 1)
2089  index = id.ring();
2090  else
2091  index = id.station() * 2 + id.ring();
2092  if (id.endcap() == 1)
2093  index = index + 10;
2094  if (id.endcap() == 2)
2095  index = 11 - index;
2096  return index;
2097  }
2098 
2099  else if (flag == 2) {
2100  int index = 0;
2101  if (id.station() == 1 && id.ring() != 4)
2102  index = id.ring() + 1;
2103  if (id.station() == 1 && id.ring() == 4)
2104  index = 1;
2105  if (id.station() != 1)
2106  index = id.station() * 2 + id.ring();
2107  if (id.endcap() == 1)
2108  index = index + 10;
2109  if (id.endcap() == 2)
2110  index = 11 - index;
2111  return index;
2112  }
2113 
2114  else
2115  return 0;
2116 }
2117 
2118 int CSCOfflineMonitor::chamberSerial(CSCDetId id) {
2119  int st = id.station();
2120  int ri = id.ring();
2121  int ch = id.chamber();
2122  int ec = id.endcap();
2123  int kSerial = ch;
2124  if (st == 1 && ri == 1)
2125  kSerial = ch;
2126  if (st == 1 && ri == 2)
2127  kSerial = ch + 36;
2128  if (st == 1 && ri == 3)
2129  kSerial = ch + 72;
2130  if (st == 1 && ri == 4)
2131  kSerial = ch;
2132  if (st == 2 && ri == 1)
2133  kSerial = ch + 108;
2134  if (st == 2 && ri == 2)
2135  kSerial = ch + 126;
2136  if (st == 3 && ri == 1)
2137  kSerial = ch + 162;
2138  if (st == 3 && ri == 2)
2139  kSerial = ch + 180;
2140  if (st == 4 && ri == 1)
2141  kSerial = ch + 216;
2142  if (st == 4 && ri == 2)
2143  kSerial = ch + 234; // from 2014
2144  if (ec == 2)
2145  kSerial = kSerial + 300;
2146  return kSerial;
2147 }
2148 
2149 void CSCOfflineMonitor::applyCSClabels(MonitorElement* me, LabelType t, AxisType a) {
2150  if (me != nullptr) {
2151  me->setAxisTitle("Chamber #");
2152  if (t == EXTENDED) {
2153  me->setBinLabel(1, "ME -4/2", a);
2154  me->setBinLabel(2, "ME -4/1", a);
2155  me->setBinLabel(3, "ME -3/2", a);
2156  me->setBinLabel(4, "ME -3/1", a);
2157  me->setBinLabel(5, "ME -2/2", a);
2158  me->setBinLabel(6, "ME -2/1", a);
2159  me->setBinLabel(7, "ME -1/3", a);
2160  me->setBinLabel(8, "ME -1/2", a);
2161  me->setBinLabel(9, "ME -1/1b", a);
2162  me->setBinLabel(10, "ME -1/1a", a);
2163  me->setBinLabel(11, "ME +1/1a", a);
2164  me->setBinLabel(12, "ME +1/1b", a);
2165  me->setBinLabel(13, "ME +1/2", a);
2166  me->setBinLabel(14, "ME +1/3", a);
2167  me->setBinLabel(15, "ME +2/1", a);
2168  me->setBinLabel(16, "ME +2/2", a);
2169  me->setBinLabel(17, "ME +3/1", a);
2170  me->setBinLabel(18, "ME +3/2", a);
2171  me->setBinLabel(19, "ME +4/1", a);
2172  me->setBinLabel(20, "ME +4/2", a);
2173  } else if (t == SMALL) {
2174  me->setBinLabel(1, "ME -4/1", a);
2175  me->setBinLabel(2, "ME -3/2", a);
2176  me->setBinLabel(3, "ME -3/1", a);
2177  me->setBinLabel(4, "ME -2/2", a);
2178  me->setBinLabel(5, "ME -2/1", a);
2179  me->setBinLabel(6, "ME -1/3", a);
2180  me->setBinLabel(7, "ME -1/2", a);
2181  me->setBinLabel(8, "ME -1/1b", a);
2182  me->setBinLabel(9, "ME -1/1a", a);
2183  me->setBinLabel(10, "ME +1/1a", a);
2184  me->setBinLabel(11, "ME +1/1b", a);
2185  me->setBinLabel(12, "ME +1/2", a);
2186  me->setBinLabel(13, "ME +1/3", a);
2187  me->setBinLabel(14, "ME +2/1", a);
2188  me->setBinLabel(15, "ME +2/2", a);
2189  me->setBinLabel(16, "ME +3/1", a);
2190  me->setBinLabel(17, "ME +3/2", a);
2191  me->setBinLabel(18, "ME +4/1", a);
2192  }
2193  }
2194 }
2195 
2196 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:2118
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:1429
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
debug_messages_cfi.errors
errors
Definition: debug_messages_cfi.py:54
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:65
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
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:234
CSCOfflineMonitor::hSnhits
std::vector< MonitorElement * > hSnhits
Definition: CSCOfflineMonitor.h:181
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: SimplePixelTopology.h:138
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
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:2083
CSCOfflineMonitor::hSnhitsAll
MonitorElement * hSnhitsAll
Definition: CSCOfflineMonitor.h:180
CSCOfflineMonitor::fitX
float fitX(const CLHEP::HepMatrix &sp, const CLHEP::HepMatrix &ep)
Definition: CSCOfflineMonitor.cc:1396
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
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:1985
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:1784
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:79
CSCOfflineMonitor::hSChiSqProb
std::vector< MonitorElement * > hSChiSqProb
Definition: CSCOfflineMonitor.h:185
CSCOfflineMonitor::hSTimeCathodeSerial
MonitorElement * hSTimeCathodeSerial
Definition: CSCOfflineMonitor.h:198
a
double a
Definition: hdecay.h:119
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:122
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:1492
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:2149
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