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