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