File indexing completed on 2021-09-03 22:28:16
0001
0002
0003
0004
0005
0006 #include "DQMOffline/Muon/interface/CSCOfflineMonitor.h"
0007
0008 using namespace std;
0009
0010
0011
0012
0013 CSCOfflineMonitor::CSCOfflineMonitor(const edm::ParameterSet& pset)
0014 : cscGeomToken_(esConsumes<CSCGeometry, MuonGeometryRecord>()),
0015 hcrateToken_(esConsumes<CSCCrateMap, CSCCrateMapRcd>()) {
0016 rd_token = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("FEDRawDataCollectionTag"));
0017 sd_token = consumes<CSCStripDigiCollection>(pset.getParameter<edm::InputTag>("stripDigiTag"));
0018 wd_token = consumes<CSCWireDigiCollection>(pset.getParameter<edm::InputTag>("wireDigiTag"));
0019 al_token = consumes<CSCALCTDigiCollection>(pset.getParameter<edm::InputTag>("alctDigiTag"));
0020 cl_token = consumes<CSCCLCTDigiCollection>(pset.getParameter<edm::InputTag>("clctDigiTag"));
0021 rh_token = consumes<CSCRecHit2DCollection>(pset.getParameter<edm::InputTag>("cscRecHitTag"));
0022 se_token = consumes<CSCSegmentCollection>(pset.getParameter<edm::InputTag>("cscSegTag"));
0023 }
0024
0025 void CSCOfflineMonitor::bookHistograms(DQMStore::IBooker& ibooker,
0026 edm::Run const& iRun,
0027 edm::EventSetup const& ) {
0028
0029 ibooker.cd();
0030 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Occupancy");
0031
0032 hCSCOccupancy = ibooker.book1D("hCSCOccupancy", "overall CSC occupancy", 13, -0.5, 12.5);
0033 hCSCOccupancy->setBinLabel(2, "Total Events");
0034 hCSCOccupancy->setBinLabel(4, "# Events with Wires");
0035 hCSCOccupancy->setBinLabel(6, "# Events with Strips");
0036 hCSCOccupancy->setBinLabel(8, "# Events with Wires&Strips");
0037 hCSCOccupancy->setBinLabel(10, "# Events with Rechits");
0038 hCSCOccupancy->setBinLabel(12, "# Events with Segments");
0039 hOWiresAndCLCT = ibooker.book2D("hOWiresAndCLCT", "Wire and CLCT Digi Occupancy ", 36, 0.5, 36.5, 20, 0.5, 20.5);
0040 hOWires = ibooker.book2D("hOWires", "Wire Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
0041 hOWireSerial = ibooker.book1D("hOWireSerial", "Wire Occupancy by Chamber Serial", 601, -0.5, 600.5);
0042 hOWireSerial->setAxisTitle("Chamber Serial Number");
0043 hOStrips = ibooker.book2D("hOStrips", "Strip Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
0044 hOStripSerial = ibooker.book1D("hOStripSerial", "Strip Occupancy by Chamber Serial", 601, -0.5, 600.5);
0045 hOStripSerial->setAxisTitle("Chamber Serial Number");
0046 hOStripsAndWiresAndCLCT =
0047 ibooker.book2D("hOStripsAndWiresAndCLCT", "Strip And Wire And CLCT Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
0048 hOStripsAndWiresAndCLCT->setAxisTitle("Chamber #");
0049 hORecHits = ibooker.book2D("hORecHits", "RecHit Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
0050 hORecHitsSerial = ibooker.book1D("hORecHitSerial", "RecHit Occupancy by Chamber Serial", 601, -0.5, 600.5);
0051 hORecHitsSerial->setAxisTitle("Chamber Serial Number");
0052 hOSegments = ibooker.book2D("hOSegments", "Segment Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
0053 hOSegmentsSerial = ibooker.book1D("hOSegmentSerial", "Segment Occupancy by Chamber Serial", 601, -0.5, 600.5);
0054 hOSegmentsSerial->setAxisTitle("Chamber Serial Number");
0055
0056
0057 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Digis");
0058
0059
0060 hWirenGroupsTotal =
0061 ibooker.book1D("hWirenGroupsTotal", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 250.);
0062
0063 hWirenGroupsTotalHi =
0064 ibooker.book1D("hWirenGroupsTotalHi", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 1000.);
0065
0066 hWireTBin.push_back(ibooker.book1D("hWireTBin_m42", "Wire TBin Fired (ME -4/2); Time Bin (25ns)", 17, -0.5, 16.5));
0067 hWireTBin.push_back(ibooker.book1D("hWireTBin_m41", "Wire TBin Fired (ME -4/1); Time Bin (25ns)", 17, -0.5, 16.5));
0068 hWireTBin.push_back(ibooker.book1D("hWireTBin_m32", "Wire TBin Fired (ME -3/2); Time Bin (25ns)", 17, -0.5, 16.5));
0069 hWireTBin.push_back(ibooker.book1D("hWireTBin_m31", "Wire TBin Fired (ME -3/1); Time Bin (25ns)", 17, -0.5, 16.5));
0070 hWireTBin.push_back(ibooker.book1D("hWireTBin_m22", "Wire TBin Fired (ME -2/2); Time Bin (25ns)", 17, -0.5, 16.5));
0071 hWireTBin.push_back(ibooker.book1D("hWireTBin_m21", "Wire TBin Fired (ME -2/1); Time Bin (25ns)", 17, -0.5, 16.5));
0072 hWireTBin.push_back(ibooker.book1D("hWireTBin_m11a", "Wire TBin Fired (ME -1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
0073 hWireTBin.push_back(ibooker.book1D("hWireTBin_m13", "Wire TBin Fired (ME -1/3); Time Bin (25ns)", 17, -0.5, 16.5));
0074 hWireTBin.push_back(ibooker.book1D("hWireTBin_m12", "Wire TBin Fired (ME -1/2); Time Bin (25ns)", 17, -0.5, 16.5));
0075 hWireTBin.push_back(ibooker.book1D("hWireTBin_m11b", "Wire TBin Fired (ME -1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
0076 hWireTBin.push_back(ibooker.book1D("hWireTBin_p11b", "Wire TBin Fired (ME +1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
0077 hWireTBin.push_back(ibooker.book1D("hWireTBin_p12", "Wire TBin Fired (ME +1/2); Time Bin (25ns)", 17, -0.5, 16.5));
0078 hWireTBin.push_back(ibooker.book1D("hWireTBin_p13", "Wire TBin Fired (ME +1/3); Time Bin (25ns)", 17, -0.5, 16.5));
0079 hWireTBin.push_back(ibooker.book1D("hWireTBin_p11a", "Wire TBin Fired (ME +1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
0080 hWireTBin.push_back(ibooker.book1D("hWireTBin_p21", "Wire TBin Fired (ME +2/1); Time Bin (25ns)", 17, -0.5, 16.5));
0081 hWireTBin.push_back(ibooker.book1D("hWireTBin_p22", "Wire TBin Fired (ME +2/2); Time Bin (25ns)", 17, -0.5, 16.5));
0082 hWireTBin.push_back(ibooker.book1D("hWireTBin_p31", "Wire TBin Fired (ME +3/1); Time Bin (25ns)", 17, -0.5, 16.5));
0083 hWireTBin.push_back(ibooker.book1D("hWireTBin_p32", "Wire TBin Fired (ME +3/2); Time Bin (25ns)", 17, -0.5, 16.5));
0084 hWireTBin.push_back(ibooker.book1D("hWireTBin_p41", "Wire TBin Fired (ME +4/1); Time Bin (25ns)", 17, -0.5, 16.5));
0085 hWireTBin.push_back(ibooker.book1D("hWireTBin_p42", "Wire TBin Fired (ME +4/2); Time Bin (25ns)", 17, -0.5, 16.5));
0086 hWireNumber.push_back(
0087 ibooker.book1D("hWireNumber_m42", "Wiregroup Number Fired (ME -4/2); Wiregroup #", 113, -0.5, 112.5));
0088 hWireNumber.push_back(
0089 ibooker.book1D("hWireNumber_m41", "Wiregroup Number Fired (ME -4/1); Wiregroup #", 113, -0.5, 112.5));
0090 hWireNumber.push_back(
0091 ibooker.book1D("hWireNumber_m32", "Wiregroup Number Fired (ME -3/2); Wiregroup #", 113, -0.5, 112.5));
0092 hWireNumber.push_back(
0093 ibooker.book1D("hWireNumber_m31", "Wiregroup Number Fired (ME -3/1); Wiregroup #", 113, -0.5, 112.5));
0094 hWireNumber.push_back(
0095 ibooker.book1D("hWireNumber_m22", "Wiregroup Number Fired (ME -2/2); Wiregroup #", 113, -0.5, 112.5));
0096 hWireNumber.push_back(
0097 ibooker.book1D("hWireNumber_m21", "Wiregroup Number Fired (ME -2/1); Wiregroup #", 113, -0.5, 112.5));
0098 hWireNumber.push_back(
0099 ibooker.book1D("hWireNumber_m11a", "Wiregroup Number Fired (ME -1/1a); Wiregroup #", 113, -0.5, 112.5));
0100 hWireNumber.push_back(
0101 ibooker.book1D("hWireNumber_m13", "Wiregroup Number Fired (ME -1/3); Wiregroup #", 113, -0.5, 112.5));
0102 hWireNumber.push_back(
0103 ibooker.book1D("hWireNumber_m12", "Wiregroup Number Fired (ME -1/2); Wiregroup #", 113, -0.5, 112.5));
0104 hWireNumber.push_back(
0105 ibooker.book1D("hWireNumber_m11b", "Wiregroup Number Fired (ME -1/1b); Wiregroup #", 113, -0.5, 112.5));
0106 hWireNumber.push_back(
0107 ibooker.book1D("hWireNumber_p11b", "Wiregroup Number Fired (ME +1/1b); Wiregroup #", 113, -0.5, 112.5));
0108 hWireNumber.push_back(
0109 ibooker.book1D("hWireNumber_p12", "Wiregroup Number Fired (ME +1/2); Wiregroup #", 113, -0.5, 112.5));
0110 hWireNumber.push_back(
0111 ibooker.book1D("hWireNumber_p13", "Wiregroup Number Fired (ME +1/3); Wiregroup #", 113, -0.5, 112.5));
0112 hWireNumber.push_back(
0113 ibooker.book1D("hWireNumber_p11a", "Wiregroup Number Fired (ME +1/1a); Wiregroup #", 113, -0.5, 112.5));
0114 hWireNumber.push_back(
0115 ibooker.book1D("hWireNumber_p21", "Wiregroup Number Fired (ME +2/1); Wiregroup #", 113, -0.5, 112.5));
0116 hWireNumber.push_back(
0117 ibooker.book1D("hWireNumber_p22", "Wiregroup Number Fired (ME +2/2); Wiregroup #", 113, -0.5, 112.5));
0118 hWireNumber.push_back(
0119 ibooker.book1D("hWireNumber_p31", "Wiregroup Number Fired (ME +3/1); Wiregroup #", 113, -0.5, 112.5));
0120 hWireNumber.push_back(
0121 ibooker.book1D("hWireNumber_p32", "Wiregroup Number Fired (ME +3/2); Wiregroup #", 113, -0.5, 112.5));
0122 hWireNumber.push_back(
0123 ibooker.book1D("hWireNumber_p41", "Wiregroup Number Fired (ME +4/1); Wiregroup #", 113, -0.5, 112.5));
0124 hWireNumber.push_back(
0125 ibooker.book1D("hWireNumber_p42", "Wiregroup Number Fired (ME +4/2); Wiregroup #", 113, -0.5, 112.5));
0126
0127
0128
0129
0130 hStripNFired = ibooker.book1D(
0131 "hStripNFired", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 400, 0., 400.);
0132
0133 hStripNFiredHi = ibooker.book1D(
0134 "hStripNFiredHi", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 500, 0., 2000.);
0135
0136 hStripNumber.push_back(
0137 ibooker.book1D("hStripNumber_m42", "Strip Number Fired (ME -4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0138 hStripNumber.push_back(
0139 ibooker.book1D("hStripNumber_m41", "Strip Number Fired (ME -4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0140 hStripNumber.push_back(
0141 ibooker.book1D("hStripNumber_m32", "Strip Number Fired (ME -3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0142 hStripNumber.push_back(
0143 ibooker.book1D("hStripNumber_m31", "Strip Number Fired (ME -3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0144 hStripNumber.push_back(
0145 ibooker.book1D("hStripNumber_m22", "Strip Number Fired (ME -2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0146 hStripNumber.push_back(
0147 ibooker.book1D("hStripNumber_m21", "Strip Number Fired (ME -2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0148 hStripNumber.push_back(ibooker.book1D(
0149 "hStripNumber_m11a", "Strip Number Fired (ME -1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0150 hStripNumber.push_back(
0151 ibooker.book1D("hStripNumber_m13", "Strip Number Fired (ME -1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0152 hStripNumber.push_back(
0153 ibooker.book1D("hStripNumber_m12", "Strip Number Fired (ME -1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0154 hStripNumber.push_back(ibooker.book1D(
0155 "hStripNumber_m11b", "Strip Number Fired (ME -1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0156 hStripNumber.push_back(ibooker.book1D(
0157 "hStripNumber_p11b", "Strip Number Fired (ME +1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0158 hStripNumber.push_back(
0159 ibooker.book1D("hStripNumber_p12", "Strip Number Fired (ME +1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0160 hStripNumber.push_back(
0161 ibooker.book1D("hStripNumber_p13", "Strip Number Fired (ME +1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0162 hStripNumber.push_back(ibooker.book1D(
0163 "hStripNumber_p11a", "Strip Number Fired (ME +1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0164 hStripNumber.push_back(
0165 ibooker.book1D("hStripNumber_p21", "Strip Number Fired (ME +2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0166 hStripNumber.push_back(
0167 ibooker.book1D("hStripNumber_p22", "Strip Number Fired (ME +2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0168 hStripNumber.push_back(
0169 ibooker.book1D("hStripNumber_p31", "Strip Number Fired (ME +3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0170 hStripNumber.push_back(
0171 ibooker.book1D("hStripNumber_p32", "Strip Number Fired (ME +3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0172 hStripNumber.push_back(
0173 ibooker.book1D("hStripNumber_p41", "Strip Number Fired (ME +4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0174 hStripNumber.push_back(ibooker.book1D(
0175 "hStripNumber_p42", "Stripgroup Number Fired (ME +4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
0176
0177
0178 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/PedestalNoise");
0179
0180 hStripPed.push_back(
0181 ibooker.book1D("hStripPedMEm42", "Pedestal Noise Distribution Chamber ME -4/2; ADC Counts", 50, -25., 25.));
0182 hStripPed.push_back(
0183 ibooker.book1D("hStripPedMEm41", "Pedestal Noise Distribution Chamber ME -4/1; ADC Counts", 50, -25., 25.));
0184 hStripPed.push_back(
0185 ibooker.book1D("hStripPedMEm32", "Pedestal Noise Distribution Chamber ME -3/2; ADC Counts", 50, -25., 25.));
0186 hStripPed.push_back(
0187 ibooker.book1D("hStripPedMEm31", "Pedestal Noise Distribution Chamber ME -3/1; ADC Counts", 50, -25., 25.));
0188 hStripPed.push_back(
0189 ibooker.book1D("hStripPedMEm22", "Pedestal Noise Distribution Chamber ME -2/2; ADC Counts", 50, -25., 25.));
0190 hStripPed.push_back(
0191 ibooker.book1D("hStripPedMEm21", "Pedestal Noise Distribution Chamber ME -2/1; ADC Counts", 50, -25., 25.));
0192 hStripPed.push_back(
0193 ibooker.book1D("hStripPedMEm11a", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
0194 hStripPed.push_back(
0195 ibooker.book1D("hStripPedMEm13", "Pedestal Noise Distribution Chamber ME -1/3; ADC Counts", 50, -25., 25.));
0196 hStripPed.push_back(
0197 ibooker.book1D("hStripPedMEm12", "Pedestal Noise Distribution Chamber ME -1/2; ADC Counts", 50, -25., 25.));
0198 hStripPed.push_back(
0199 ibooker.book1D("hStripPedMEm11b", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
0200 hStripPed.push_back(
0201 ibooker.book1D("hStripPedMEp11b", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
0202 hStripPed.push_back(
0203 ibooker.book1D("hStripPedMEp12", "Pedestal Noise Distribution Chamber ME +1/2; ADC Counts", 50, -25., 25.));
0204 hStripPed.push_back(
0205 ibooker.book1D("hStripPedMEp13", "Pedestal Noise Distribution Chamber ME +1/3; ADC Counts", 50, -25., 25.));
0206 hStripPed.push_back(
0207 ibooker.book1D("hStripPedMEp11a", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
0208 hStripPed.push_back(
0209 ibooker.book1D("hStripPedMEp21", "Pedestal Noise Distribution Chamber ME +2/1; ADC Counts", 50, -25., 25.));
0210 hStripPed.push_back(
0211 ibooker.book1D("hStripPedMEp22", "Pedestal Noise Distribution Chamber ME +2/2; ADC Counts", 50, -25., 25.));
0212 hStripPed.push_back(
0213 ibooker.book1D("hStripPedMEp31", "Pedestal Noise Distribution Chamber ME +3/1; ADC Counts", 50, -25., 25.));
0214 hStripPed.push_back(
0215 ibooker.book1D("hStripPedMEp32", "Pedestal Noise Distribution Chamber ME +3/2; ADC Counts", 50, -25., 25.));
0216 hStripPed.push_back(
0217 ibooker.book1D("hStripPedMEp41", "Pedestal Noise Distribution Chamber ME +4/1; ADC Counts", 50, -25., 25.));
0218 hStripPed.push_back(
0219 ibooker.book1D("hStripPedMEp42", "Pedestal Noise Distribution Chamber ME +4/2; ADC Counts", 50, -25., 25.));
0220
0221
0222 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/recHits");
0223
0224
0225 hRHnrechits = ibooker.book1D("hRHnrechits", "RecHits per Event; # of RecHits", 100, 0., 100.);
0226
0227 hRHnrechitsHi = ibooker.book1D("hRHnrechitsHi", "RecHits per Event; # of RecHits", 250, 0., 1000.);
0228
0229 hRHGlobal.push_back(ibooker.book2D(
0230 "hRHGlobalp1", "recHit global X,Y station +1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0231 hRHGlobal.push_back(ibooker.book2D(
0232 "hRHGlobalp2", "recHit global X,Y station +2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0233 hRHGlobal.push_back(ibooker.book2D(
0234 "hRHGlobalp3", "recHit global X,Y station +3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0235 hRHGlobal.push_back(ibooker.book2D(
0236 "hRHGlobalp4", "recHit global X,Y station +4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0237 hRHGlobal.push_back(ibooker.book2D(
0238 "hRHGlobalm1", "recHit global X,Y station -1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0239 hRHGlobal.push_back(ibooker.book2D(
0240 "hRHGlobalm2", "recHit global X,Y station -2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0241 hRHGlobal.push_back(ibooker.book2D(
0242 "hRHGlobalm3", "recHit global X,Y station -3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0243 hRHGlobal.push_back(ibooker.book2D(
0244 "hRHGlobalm4", "recHit global X,Y station -4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
0245 hRHSumQ.push_back(ibooker.book1D("hRHSumQm42", "Sum 3x3 recHit Charge (ME -4/2); ADC counts", 100, 0, 2000));
0246 hRHSumQ.push_back(ibooker.book1D("hRHSumQm41", "Sum 3x3 recHit Charge (ME -4/1); ADC counts", 100, 0, 2000));
0247 hRHSumQ.push_back(ibooker.book1D("hRHSumQm32", "Sum 3x3 recHit Charge (ME -3/2); ADC counts", 100, 0, 2000));
0248 hRHSumQ.push_back(ibooker.book1D("hRHSumQm31", "Sum 3x3 recHit Charge (ME -3/1); ADC counts", 100, 0, 2000));
0249 hRHSumQ.push_back(ibooker.book1D("hRHSumQm22", "Sum 3x3 recHit Charge (ME -2/2); ADC counts", 100, 0, 2000));
0250 hRHSumQ.push_back(ibooker.book1D("hRHSumQm21", "Sum 3x3 recHit Charge (ME -2/1); ADC counts", 100, 0, 2000));
0251 hRHSumQ.push_back(ibooker.book1D("hRHSumQm11a", "Sum 3x3 recHit Charge (ME -1/1a); ADC counts", 100, 0, 4000));
0252 hRHSumQ.push_back(ibooker.book1D("hRHSumQm13", "Sum 3x3 recHit Charge (ME -1/3); ADC counts", 100, 0, 2000));
0253 hRHSumQ.push_back(ibooker.book1D("hRHSumQm12", "Sum 3x3 recHit Charge (ME -1/2); ADC counts", 100, 0, 2000));
0254 hRHSumQ.push_back(ibooker.book1D("hRHSumQm11b", "Sum 3x3 recHit Charge (ME -1/1b); ADC counts", 100, 0, 4000));
0255 hRHSumQ.push_back(ibooker.book1D("hRHSumQp11b", "Sum 3x3 recHit Charge (ME +1/1b); ADC counts", 100, 0, 4000));
0256 hRHSumQ.push_back(ibooker.book1D("hRHSumQp12", "Sum 3x3 recHit Charge (ME +1/2); ADC counts", 100, 0, 2000));
0257 hRHSumQ.push_back(ibooker.book1D("hRHSumQp13", "Sum 3x3 recHit Charge (ME +1/3); ADC counts", 100, 0, 2000));
0258 hRHSumQ.push_back(ibooker.book1D("hRHSumQp11a", "Sum 3x3 recHit Charge (ME +1/1a); ADC counts", 100, 0, 4000));
0259 hRHSumQ.push_back(ibooker.book1D("hRHSumQp21", "Sum 3x3 recHit Charge (ME +2/1); ADC counts", 100, 0, 2000));
0260 hRHSumQ.push_back(ibooker.book1D("hRHSumQp22", "Sum 3x3 recHit Charge (ME +2/2); ADC counts", 100, 0, 2000));
0261 hRHSumQ.push_back(ibooker.book1D("hRHSumQp31", "Sum 3x3 recHit Charge (ME +3/1); ADC counts", 100, 0, 2000));
0262 hRHSumQ.push_back(ibooker.book1D("hRHSumQp32", "Sum 3x3 recHit Charge (ME +3/2); ADC counts", 100, 0, 2000));
0263 hRHSumQ.push_back(ibooker.book1D("hRHSumQp41", "Sum 3x3 recHit Charge (ME +4/1); ADC counts", 100, 0, 2000));
0264 hRHSumQ.push_back(ibooker.book1D("hRHSumQp42", "Sum 3x3 recHit Charge (ME +4/2); ADC counts", 100, 0, 2000));
0265 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm42", "Charge Ratio (Ql+Qr)/Qt (ME -4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0266 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm41", "Charge Ratio (Ql+Qr)/Qt (ME -4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0267 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm32", "Charge Ratio (Ql+Qr)/Qt (ME -3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0268 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm31", "Charge Ratio (Ql+Qr)/Qt (ME -3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0269 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm22", "Charge Ratio (Ql+Qr)/Qt (ME -2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0270 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm21", "Charge Ratio (Ql+Qr)/Qt (ME -2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0271 hRHRatioQ.push_back(
0272 ibooker.book1D("hRHRatioQm11a", "Charge Ratio (Ql+Qr)/Qt (ME -1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0273 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm13", "Charge Ratio (Ql+Qr)/Qt (ME -1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0274 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm12", "Charge Ratio (Ql+Qr)/Qt (ME -1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0275 hRHRatioQ.push_back(
0276 ibooker.book1D("hRHRatioQm11b", "Charge Ratio (Ql+Qr)/Qt (ME -1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0277 hRHRatioQ.push_back(
0278 ibooker.book1D("hRHRatioQp11b", "Charge Ratio (Ql+Qr)/Qt (ME +1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0279 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp12", "Charge Ratio (Ql+Qr)/Qt (ME +1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0280 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp13", "Charge Ratio (Ql+Qr)/Qt (ME +1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0281 hRHRatioQ.push_back(
0282 ibooker.book1D("hRHRatioQp11a", "Charge Ratio (Ql+Qr)/Qt (ME +1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0283 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp21", "Charge Ratio (Ql+Qr)/Qt (ME +2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0284 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp22", "Charge Ratio (Ql+Qr)/Qt (ME +2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0285 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp31", "Charge Ratio (Ql+Qr)/Qt (ME +3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0286 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp32", "Charge Ratio (Ql+Qr)/Qt (ME +3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0287 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp41", "Charge Ratio (Ql+Qr)/Qt (ME +4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0288 hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp42", "Charge Ratio (Ql+Qr)/Qt (ME +4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
0289 hRHTiming.push_back(ibooker.book1D("hRHTimingm42", "recHit Time (ME -4/2); ns", 200, -500., 500.));
0290 hRHTiming.push_back(ibooker.book1D("hRHTimingm41", "recHit Time (ME -4/1); ns", 200, -500., 500.));
0291 hRHTiming.push_back(ibooker.book1D("hRHTimingm32", "recHit Time (ME -3/2); ns", 200, -500., 500.));
0292 hRHTiming.push_back(ibooker.book1D("hRHTimingm31", "recHit Time (ME -3/1); ns", 200, -500., 500.));
0293 hRHTiming.push_back(ibooker.book1D("hRHTimingm22", "recHit Time (ME -2/2); ns", 200, -500., 500.));
0294 hRHTiming.push_back(ibooker.book1D("hRHTimingm21", "recHit Time (ME -2/1); ns", 200, -500., 500.));
0295 hRHTiming.push_back(ibooker.book1D("hRHTimingm11a", "recHit Time (ME -1/1a); ns", 200, -500., 500.));
0296 hRHTiming.push_back(ibooker.book1D("hRHTimingm13", "recHit Time (ME -1/3); ns", 200, -500., 500.));
0297 hRHTiming.push_back(ibooker.book1D("hRHTimingm12", "recHit Time (ME -1/2); ns", 200, -500., 500.));
0298 hRHTiming.push_back(ibooker.book1D("hRHTimingm11b", "recHit Time (ME -1/1b); ns", 200, -500., 500.));
0299 hRHTiming.push_back(ibooker.book1D("hRHTimingp11b", "recHit Time (ME +1/1b); ns", 200, -500., 500.));
0300 hRHTiming.push_back(ibooker.book1D("hRHTimingp12", "recHit Time (ME +1/2); ns", 200, -500., 500.));
0301 hRHTiming.push_back(ibooker.book1D("hRHTimingp13", "recHit Time (ME +1/3); ns", 200, -500., 500.));
0302 hRHTiming.push_back(ibooker.book1D("hRHTimingp11a", "recHit Time (ME +1/1a); ns", 200, -500., 500.));
0303 hRHTiming.push_back(ibooker.book1D("hRHTimingp21", "recHit Time (ME +2/1); ns", 200, -500., 500.));
0304 hRHTiming.push_back(ibooker.book1D("hRHTimingp22", "recHit Time (ME +2/2); ns", 200, -500., 500.));
0305 hRHTiming.push_back(ibooker.book1D("hRHTimingp31", "recHit Time (ME +3/1); ns", 200, -500., 500.));
0306 hRHTiming.push_back(ibooker.book1D("hRHTimingp32", "recHit Time (ME +3/2); ns", 200, -500., 500.));
0307 hRHTiming.push_back(ibooker.book1D("hRHTimingp41", "recHit Time (ME +4/1); ns", 200, -500., 500.));
0308 hRHTiming.push_back(ibooker.book1D("hRHTimingp42", "recHit Time (ME +4/2); ns", 200, -500., 500.));
0309 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem42", "Anode recHit Time (ME -4/2); ns", 80, -500., 500.));
0310 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem41", "Anode recHit Time (ME -4/1); ns", 80, -500., 500.));
0311 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem32", "Anode recHit Time (ME -3/2); ns", 80, -500., 500.));
0312 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem31", "Anode recHit Time (ME -3/1); ns", 80, -500., 500.));
0313 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem22", "Anode recHit Time (ME -2/2); ns", 80, -500., 500.));
0314 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem21", "Anode recHit Time (ME -2/1); ns", 80, -500., 500.));
0315 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11a", "Anode recHit Time (ME -1/1a); ns", 80, -500., 500.));
0316 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem13", "Anode recHit Time (ME -1/3); ns", 80, -500., 500.));
0317 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem12", "Anode recHit Time (ME -1/2); ns", 80, -500., 500.));
0318 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11b", "Anode recHit Time (ME -1/1b); ns", 80, -500., 500.));
0319 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11b", "Anode recHit Time (ME +1/1b); ns", 80, -500., 500.));
0320 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep12", "Anode recHit Time (ME +1/2); ns", 80, -500., 500.));
0321 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep13", "Anode recHit Time (ME +1/3); ns", 80, -500., 500.));
0322 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11a", "Anode recHit Time (ME +1/1a); ns", 80, -500., 500.));
0323 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep21", "Anode recHit Time (ME +2/1); ns", 80, -500., 500.));
0324 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep22", "Anode recHit Time (ME +2/2); ns", 80, -500., 500.));
0325 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep31", "Anode recHit Time (ME +3/1); ns", 80, -500., 500.));
0326 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep32", "Anode recHit Time (ME +3/2); ns", 80, -500., 500.));
0327 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep41", "Anode recHit Time (ME +4/1); ns", 80, -500., 500.));
0328 hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep42", "Anode recHit Time (ME +4/2); ns", 80, -500., 500.));
0329 hRHstpos.push_back(
0330 ibooker.book1D("hRHstposm42", "Reconstructed Position on Strip (ME -4/2); Strip Widths", 120, -0.6, 0.6));
0331 hRHstpos.push_back(
0332 ibooker.book1D("hRHstposm41", "Reconstructed Position on Strip (ME -4/1); Strip Widths", 120, -0.6, 0.6));
0333 hRHstpos.push_back(
0334 ibooker.book1D("hRHstposm32", "Reconstructed Position on Strip (ME -3/2); Strip Widths", 120, -0.6, 0.6));
0335 hRHstpos.push_back(
0336 ibooker.book1D("hRHstposm31", "Reconstructed Position on Strip (ME -3/1); Strip Widths", 120, -0.6, 0.6));
0337 hRHstpos.push_back(
0338 ibooker.book1D("hRHstposm22", "Reconstructed Position on Strip (ME -2/2); Strip Widths", 120, -0.6, 0.6));
0339 hRHstpos.push_back(
0340 ibooker.book1D("hRHstposm21", "Reconstructed Position on Strip (ME -2/1); Strip Widths", 120, -0.6, 0.6));
0341 hRHstpos.push_back(
0342 ibooker.book1D("hRHstposm11a", "Reconstructed Position on Strip (ME -1/1a); Strip Widths", 120, -0.6, 0.6));
0343 hRHstpos.push_back(
0344 ibooker.book1D("hRHstposm13", "Reconstructed Position on Strip (ME -1/3); Strip Widths", 120, -0.6, 0.6));
0345 hRHstpos.push_back(
0346 ibooker.book1D("hRHstposm12", "Reconstructed Position on Strip (ME -1/2); Strip Widths", 120, -0.6, 0.6));
0347 hRHstpos.push_back(
0348 ibooker.book1D("hRHstposm11b", "Reconstructed Position on Strip (ME -1/1b); Strip Widths", 120, -0.6, 0.6));
0349 hRHstpos.push_back(
0350 ibooker.book1D("hRHstposp11b", "Reconstructed Position on Strip (ME +1/1b); Strip Widths", 120, -0.6, 0.6));
0351 hRHstpos.push_back(
0352 ibooker.book1D("hRHstposp12", "Reconstructed Position on Strip (ME +1/2); Strip Widths", 120, -0.6, 0.6));
0353 hRHstpos.push_back(
0354 ibooker.book1D("hRHstposp13", "Reconstructed Position on Strip (ME +1/3); Strip Widths", 120, -0.6, 0.6));
0355 hRHstpos.push_back(
0356 ibooker.book1D("hRHstposp11a", "Reconstructed Position on Strip (ME +1/1a); Strip Widths", 120, -0.6, 0.6));
0357 hRHstpos.push_back(
0358 ibooker.book1D("hRHstposp21", "Reconstructed Position on Strip (ME +2/1); Strip Widths", 120, -0.6, 0.6));
0359 hRHstpos.push_back(
0360 ibooker.book1D("hRHstposp22", "Reconstructed Position on Strip (ME +2/2); Strip Widths", 120, -0.6, 0.6));
0361 hRHstpos.push_back(
0362 ibooker.book1D("hRHstposp31", "Reconstructed Position on Strip (ME +3/1); Strip Widths", 120, -0.6, 0.6));
0363 hRHstpos.push_back(
0364 ibooker.book1D("hRHstposp32", "Reconstructed Position on Strip (ME +3/2); Strip Widths", 120, -0.6, 0.6));
0365 hRHstpos.push_back(
0366 ibooker.book1D("hRHstposp41", "Reconstructed Position on Strip (ME +4/1); Strip Widths", 120, -0.6, 0.6));
0367 hRHstpos.push_back(
0368 ibooker.book1D("hRHstposp42", "Reconstructed Position on Strip (ME +4/2); Strip Widths", 120, -0.6, 0.6));
0369 hRHsterr.push_back(
0370 ibooker.book1D("hRHsterrm42", "Estimated Error on Strip Measurement (ME -4/2); Strip Widths", 75, -0.01, 0.24));
0371 hRHsterr.push_back(
0372 ibooker.book1D("hRHsterrm41", "Estimated Error on Strip Measurement (ME -4/1); Strip Widths", 75, -0.01, 0.24));
0373 hRHsterr.push_back(
0374 ibooker.book1D("hRHsterrm32", "Estimated Error on Strip Measurement (ME -3/2); Strip Widths", 75, -0.01, 0.24));
0375 hRHsterr.push_back(
0376 ibooker.book1D("hRHsterrm31", "Estimated Error on Strip Measurement (ME -3/1); Strip Widths", 75, -0.01, 0.24));
0377 hRHsterr.push_back(
0378 ibooker.book1D("hRHsterrm22", "Estimated Error on Strip Measurement (ME -2/2); Strip Widths", 75, -0.01, 0.24));
0379 hRHsterr.push_back(
0380 ibooker.book1D("hRHsterrm21", "Estimated Error on Strip Measurement (ME -2/1); Strip Widths", 75, -0.01, 0.24));
0381 hRHsterr.push_back(
0382 ibooker.book1D("hRHsterrm11a", "Estimated Error on Strip Measurement (ME -1/1a); Strip Widths", 75, -0.01, 0.24));
0383 hRHsterr.push_back(
0384 ibooker.book1D("hRHsterrm13", "Estimated Error on Strip Measurement (ME -1/3); Strip Widths", 75, -0.01, 0.24));
0385 hRHsterr.push_back(
0386 ibooker.book1D("hRHsterrm12", "Estimated Error on Strip Measurement (ME -1/2); Strip Widths", 75, -0.01, 0.24));
0387 hRHsterr.push_back(
0388 ibooker.book1D("hRHsterrm11b", "Estimated Error on Strip Measurement (ME -1/1b); Strip Widths", 75, -0.01, 0.24));
0389 hRHsterr.push_back(
0390 ibooker.book1D("hRHsterrp11b", "Estimated Error on Strip Measurement (ME +1/1b); Strip Widths", 75, -0.01, 0.24));
0391 hRHsterr.push_back(
0392 ibooker.book1D("hRHsterrp12", "Estimated Error on Strip Measurement (ME +1/2); Strip Widths", 75, -0.01, 0.24));
0393 hRHsterr.push_back(
0394 ibooker.book1D("hRHsterrp13", "Estimated Error on Strip Measurement (ME +1/3); Strip Widths", 75, -0.01, 0.24));
0395 hRHsterr.push_back(
0396 ibooker.book1D("hRHsterrp11a", "Estimated Error on Strip Measurement (ME +1/1a); Strip Widths", 75, -0.01, 0.24));
0397 hRHsterr.push_back(
0398 ibooker.book1D("hRHsterrp21", "Estimated Error on Strip Measurement (ME +2/1); Strip Widths", 75, -0.01, 0.24));
0399 hRHsterr.push_back(
0400 ibooker.book1D("hRHsterrp22", "Estimated Error on Strip Measurement (ME +2/2); Strip Widths", 75, -0.01, 0.24));
0401 hRHsterr.push_back(
0402 ibooker.book1D("hRHsterrp31", "Estimated Error on Strip Measurement (ME +3/1); Strip Widths", 75, -0.01, 0.24));
0403 hRHsterr.push_back(
0404 ibooker.book1D("hRHsterrp32", "Estimated Error on Strip Measurement (ME +3/2); Strip Widths", 75, -0.01, 0.24));
0405 hRHsterr.push_back(
0406 ibooker.book1D("hRHsterrp41", "Estimated Error on Strip Measurement (ME +4/1); Strip Widths", 75, -0.01, 0.24));
0407 hRHsterr.push_back(
0408 ibooker.book1D("hRHsterrp42", "Estimated Error on Strip Measurement (ME +4/2); Strip Widths", 75, -0.01, 0.24));
0409
0410
0411 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Segments");
0412
0413 hSnSegments = ibooker.book1D("hSnSegments", "Segments per Event; # of Segments", 100, 0., 100.);
0414
0415 hSnhitsAll = ibooker.book1D("hSnhits", "N hits on Segments; # of hits", 8, -0.5, 7.5);
0416 hSnhits.push_back(ibooker.book1D("hSnhitsm42", "# of hits on Segments (ME -4/2); # of hits", 8, -0.5, 7.5));
0417 hSnhits.push_back(ibooker.book1D("hSnhitsm41", "# of hits on Segments (ME -4/1); # of hits", 8, -0.5, 7.5));
0418 hSnhits.push_back(ibooker.book1D("hSnhitsm32", "# of hits on Segments (ME -3/2); # of hits", 8, -0.5, 7.5));
0419 hSnhits.push_back(ibooker.book1D("hSnhitsm31", "# of hits on Segments (ME -3/1); # of hits", 8, -0.5, 7.5));
0420 hSnhits.push_back(ibooker.book1D("hSnhitsm22", "# of hits on Segments (ME -2/2); # of hits", 8, -0.5, 7.5));
0421 hSnhits.push_back(ibooker.book1D("hSnhitsm21", "# of hits on Segments (ME -2/1); # of hits", 8, -0.5, 7.5));
0422 hSnhits.push_back(ibooker.book1D("hSnhitsm11a", "# of hits on Segments (ME -1/1a); # of hits", 8, -0.5, 7.5));
0423 hSnhits.push_back(ibooker.book1D("hSnhitsm13", "# of hits on Segments (ME -1/3); # of hits", 8, -0.5, 7.5));
0424 hSnhits.push_back(ibooker.book1D("hSnhitsm12", "# of hits on Segments (ME -1/2); # of hits", 8, -0.5, 7.5));
0425 hSnhits.push_back(ibooker.book1D("hSnhitsm11b", "# of hits on Segments (ME -1/1b); # of hits", 8, -0.5, 7.5));
0426 hSnhits.push_back(ibooker.book1D("hSnhitsp11b", "# of hits on Segments (ME +1/1b); # of hits", 8, -0.5, 7.5));
0427 hSnhits.push_back(ibooker.book1D("hSnhitsp12", "# of hits on Segments (ME +1/2); # of hits", 8, -0.5, 7.5));
0428 hSnhits.push_back(ibooker.book1D("hSnhitsp13", "# of hits on Segments (ME +1/3); # of hits", 8, -0.5, 7.5));
0429 hSnhits.push_back(ibooker.book1D("hSnhitsp11a", "# of hits on Segments (ME +1/1a); # of hits", 8, -0.5, 7.5));
0430 hSnhits.push_back(ibooker.book1D("hSnhitsp21", "# of hits on Segments (ME +2/1); # of hits", 8, -0.5, 7.5));
0431 hSnhits.push_back(ibooker.book1D("hSnhitsp22", "# of hits on Segments (ME +2/2); # of hits", 8, -0.5, 7.5));
0432 hSnhits.push_back(ibooker.book1D("hSnhitsp31", "# of hits on Segments (ME +3/1); # of hits", 8, -0.5, 7.5));
0433 hSnhits.push_back(ibooker.book1D("hSnhitsp32", "# of hits on Segments (ME +3/2); # of hits", 8, -0.5, 7.5));
0434 hSnhits.push_back(ibooker.book1D("hSnhitsp41", "# of hits on Segments (ME +4/1); # of hits", 8, -0.5, 7.5));
0435 hSnhits.push_back(ibooker.book1D("hSnhitsp42", "# of hits on Segments (ME +4/2); # of hits", 8, -0.5, 7.5));
0436 hSChiSqAll = ibooker.book1D("hSChiSq", "Segment Normalized Chi2; Chi2/ndof", 110, -0.05, 10.5);
0437 hSChiSq.push_back(ibooker.book1D("hSChiSqm42", "Segment Normalized Chi2 (ME -4/2); Chi2/ndof", 110, -0.05, 10.5));
0438 hSChiSq.push_back(ibooker.book1D("hSChiSqm41", "Segment Normalized Chi2 (ME -4/1); Chi2/ndof", 110, -0.05, 10.5));
0439 hSChiSq.push_back(ibooker.book1D("hSChiSqm32", "Segment Normalized Chi2 (ME -3/2); Chi2/ndof", 110, -0.05, 10.5));
0440 hSChiSq.push_back(ibooker.book1D("hSChiSqm31", "Segment Normalized Chi2 (ME -3/1); Chi2/ndof", 110, -0.05, 10.5));
0441 hSChiSq.push_back(ibooker.book1D("hSChiSqm22", "Segment Normalized Chi2 (ME -2/2); Chi2/ndof", 110, -0.05, 10.5));
0442 hSChiSq.push_back(ibooker.book1D("hSChiSqm21", "Segment Normalized Chi2 (ME -2/1); Chi2/ndof", 110, -0.05, 10.5));
0443 hSChiSq.push_back(ibooker.book1D("hSChiSqm11a", "Segment Normalized Chi2 (ME -1/1a); Chi2/ndof", 110, -0.05, 10.5));
0444 hSChiSq.push_back(ibooker.book1D("hSChiSqm13", "Segment Normalized Chi2 (ME -1/3); Chi2/ndof", 110, -0.05, 10.5));
0445 hSChiSq.push_back(ibooker.book1D("hSChiSqm12", "Segment Normalized Chi2 (ME -1/2); Chi2/ndof", 110, -0.05, 10.5));
0446 hSChiSq.push_back(ibooker.book1D("hSChiSqm11b", "Segment Normalized Chi2 (ME -1/1b); Chi2/ndof", 110, -0.05, 10.5));
0447 hSChiSq.push_back(ibooker.book1D("hSChiSqp11b", "Segment Normalized Chi2 (ME +1/1b); Chi2/ndof", 110, -0.05, 10.5));
0448 hSChiSq.push_back(ibooker.book1D("hSChiSqp12", "Segment Normalized Chi2 (ME +1/2); Chi2/ndof", 110, -0.05, 10.5));
0449 hSChiSq.push_back(ibooker.book1D("hSChiSqp13", "Segment Normalized Chi2 (ME +1/3); Chi2/ndof", 110, -0.05, 10.5));
0450 hSChiSq.push_back(ibooker.book1D("hSChiSqp11a", "Segment Normalized Chi2 (ME +1/1a); Chi2/ndof", 110, -0.05, 10.5));
0451 hSChiSq.push_back(ibooker.book1D("hSChiSqp21", "Segment Normalized Chi2 (ME +2/1); Chi2/ndof", 110, -0.05, 10.5));
0452 hSChiSq.push_back(ibooker.book1D("hSChiSqp22", "Segment Normalized Chi2 (ME +2/2); Chi2/ndof", 110, -0.05, 10.5));
0453 hSChiSq.push_back(ibooker.book1D("hSChiSqp31", "Segment Normalized Chi2 (ME +3/1); Chi2/ndof", 110, -0.05, 10.5));
0454 hSChiSq.push_back(ibooker.book1D("hSChiSqp32", "Segment Normalized Chi2 (ME +3/2); Chi2/ndof", 110, -0.05, 10.5));
0455 hSChiSq.push_back(ibooker.book1D("hSChiSqp41", "Segment Normalized Chi2 (ME +4/1); Chi2/ndof", 110, -0.05, 10.5));
0456 hSChiSq.push_back(ibooker.book1D("hSChiSqp42", "Segment Normalized Chi2 (ME +4/2); Chi2/ndof", 110, -0.05, 10.5));
0457 hSChiSqProbAll = ibooker.book1D("hSChiSqProb", "Segment chi2 Probability; Probability", 110, -0.05, 1.05);
0458 hSChiSqProb.push_back(
0459 ibooker.book1D("hSChiSqProbm42", "Segment chi2 Probability (ME -4/2); Probability", 110, -0.05, 1.05));
0460 hSChiSqProb.push_back(
0461 ibooker.book1D("hSChiSqProbm41", "Segment chi2 Probability (ME -4/1); Probability", 110, -0.05, 1.05));
0462 hSChiSqProb.push_back(
0463 ibooker.book1D("hSChiSqProbm32", "Segment chi2 Probability (ME -3/2); Probability", 110, -0.05, 1.05));
0464 hSChiSqProb.push_back(
0465 ibooker.book1D("hSChiSqProbm31", "Segment chi2 Probability (ME -3/1); Probability", 110, -0.05, 1.05));
0466 hSChiSqProb.push_back(
0467 ibooker.book1D("hSChiSqProbm22", "Segment chi2 Probability (ME -2/2); Probability", 110, -0.05, 1.05));
0468 hSChiSqProb.push_back(
0469 ibooker.book1D("hSChiSqProbm21", "Segment chi2 Probability (ME -2/1); Probability", 110, -0.05, 1.05));
0470 hSChiSqProb.push_back(
0471 ibooker.book1D("hSChiSqProbm11a", "Segment chi2 Probability (ME -1/1a); Probability", 110, -0.05, 1.05));
0472 hSChiSqProb.push_back(
0473 ibooker.book1D("hSChiSqProbm13", "Segment chi2 Probability (ME -1/3); Probability", 110, -0.05, 1.05));
0474 hSChiSqProb.push_back(
0475 ibooker.book1D("hSChiSqProbm12", "Segment chi2 Probability (ME -1/2); Probability", 110, -0.05, 1.05));
0476 hSChiSqProb.push_back(
0477 ibooker.book1D("hSChiSqProbm11b", "Segment chi2 Probability (ME -1/1b); Probability", 110, -0.05, 1.05));
0478 hSChiSqProb.push_back(
0479 ibooker.book1D("hSChiSqProbp11b", "Segment chi2 Probability (ME +1/1b); Probability", 110, -0.05, 1.05));
0480 hSChiSqProb.push_back(
0481 ibooker.book1D("hSChiSqProbp12", "Segment chi2 Probability (ME +1/2); Probability", 110, -0.05, 1.05));
0482 hSChiSqProb.push_back(
0483 ibooker.book1D("hSChiSqProbp13", "Segment chi2 Probability (ME +1/3); Probability", 110, -0.05, 1.05));
0484 hSChiSqProb.push_back(
0485 ibooker.book1D("hSChiSqProbp11a", "Segment chi2 Probability (ME +1/1a); Probability", 110, -0.05, 1.05));
0486 hSChiSqProb.push_back(
0487 ibooker.book1D("hSChiSqProbp21", "Segment chi2 Probability (ME +2/1); Probability", 110, -0.05, 1.05));
0488 hSChiSqProb.push_back(
0489 ibooker.book1D("hSChiSqProbp22", "Segment chi2 Probability (ME +2/2); Probability", 110, -0.05, 1.05));
0490 hSChiSqProb.push_back(
0491 ibooker.book1D("hSChiSqProbp31", "Segment chi2 Probability (ME +3/1); Probability", 110, -0.05, 1.05));
0492 hSChiSqProb.push_back(
0493 ibooker.book1D("hSChiSqProbp32", "Segment chi2 Probability (ME +3/2); Probability", 110, -0.05, 1.05));
0494 hSChiSqProb.push_back(
0495 ibooker.book1D("hSChiSqProbp41", "Segment chi2 Probability (ME +4/1); Probability", 110, -0.05, 1.05));
0496 hSChiSqProb.push_back(
0497 ibooker.book1D("hSChiSqProbp42", "Segment chi2 Probability (ME +4/2); Probability", 110, -0.05, 1.05));
0498 hSGlobalTheta =
0499 ibooker.book1D("hSGlobalTheta", "Segment Direction (Global Theta); Global Theta (radians)", 136, -0.1, 3.3);
0500 hSGlobalPhi = ibooker.book1D("hSGlobalPhi", "Segment Direction (Global Phi); Global Phi (radians)", 128, -3.2, 3.2);
0501
0502 hSTimeDiff = ibooker.book1D("hSTimeDiff", "Anode Minus Cathode Segment Time [ns]", 50, -50, 50);
0503 hSTimeDiffByChamberType.push_back(
0504 ibooker.book1D("hSTimeDiff_m42", "Anode Minus Cathode Segment Time (ME -4/2) [ns]", 50, -50, 50));
0505 hSTimeDiffByChamberType.push_back(
0506 ibooker.book1D("hSTimeDiff_m41", "Anode Minus Cathode Segment Time (ME -4/1) [ns]", 50, -50, 50));
0507 hSTimeDiffByChamberType.push_back(
0508 ibooker.book1D("hSTimeDiff_m32", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
0509 hSTimeDiffByChamberType.push_back(
0510 ibooker.book1D("hSTimeDiff_m31", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
0511 hSTimeDiffByChamberType.push_back(
0512 ibooker.book1D("hSTimeDiff_m22", "Anode Minus Cathode Segment Time (ME -2/2) [ns]", 50, -50, 50));
0513 hSTimeDiffByChamberType.push_back(
0514 ibooker.book1D("hSTimeDiff_m21", "Anode Minus Cathode Segment Time (ME -2/1) [ns]", 50, -50, 50));
0515 hSTimeDiffByChamberType.push_back(
0516 ibooker.book1D("hSTimeDiff_m11a", "Anode Minus Cathode Segment Time (ME -1/1a) [ns]", 50, -50, 50));
0517 hSTimeDiffByChamberType.push_back(
0518 ibooker.book1D("hSTimeDiff_m13", "Anode Minus Cathode Segment Time (ME -1/3) [ns]", 50, -50, 50));
0519 hSTimeDiffByChamberType.push_back(
0520 ibooker.book1D("hSTimeDiff_m12", "Anode Minus Cathode Segment Time (ME -1/2) [ns]", 50, -50, 50));
0521 hSTimeDiffByChamberType.push_back(
0522 ibooker.book1D("hSTimeDiff_m11b", "Anode Minus Cathode Segment Time (ME -1/1b) [ns]", 50, -50, 50));
0523 hSTimeDiffByChamberType.push_back(
0524 ibooker.book1D("hSTimeDiff_p11b", "Anode Minus Cathode Segment Time (ME +1/1b) [ns]", 50, -50, 50));
0525 hSTimeDiffByChamberType.push_back(
0526 ibooker.book1D("hSTimeDiff_p12", "Anode Minus Cathode Segment Time (ME +1/2) [ns]", 50, -50, 50));
0527 hSTimeDiffByChamberType.push_back(
0528 ibooker.book1D("hSTimeDiff_p13", "Anode Minus Cathode Segment Time (ME +1/3) [ns]", 50, -50, 50));
0529 hSTimeDiffByChamberType.push_back(
0530 ibooker.book1D("hSTimeDiff_p11a", "Anode Minus Cathode Segment Time (ME +1/1a) [ns]", 50, -50, 50));
0531 hSTimeDiffByChamberType.push_back(
0532 ibooker.book1D("hSTimeDiff_p21", "Anode Minus Cathode Segment Time (ME +2/1) [ns]", 50, -50, 50));
0533 hSTimeDiffByChamberType.push_back(
0534 ibooker.book1D("hSTimeDiff_p22", "Anode Minus Cathode Segment Time (ME +2/2) [ns]", 50, -50, 50));
0535 hSTimeDiffByChamberType.push_back(
0536 ibooker.book1D("hSTimeDiff_p31", "Anode Minus Cathode Segment Time (ME +3/1) [ns]", 50, -50, 50));
0537 hSTimeDiffByChamberType.push_back(
0538 ibooker.book1D("hSTimeDiff_p32", "Anode Minus Cathode Segment Time (ME +3/2) [ns]", 50, -50, 50));
0539 hSTimeDiffByChamberType.push_back(
0540 ibooker.book1D("hSTimeDiff_p41", "Anode Minus Cathode Segment Time (ME +4/1) [ns]", 50, -50, 50));
0541 hSTimeDiffByChamberType.push_back(
0542 ibooker.book1D("hSTimeDiff_p42", "Anode Minus Cathode Segment Time (ME +4/2) [ns]", 50, -50, 50));
0543
0544 hSTimeAnode = ibooker.book1D("hSTimeAnode", "Anode Only Segment Time [ns]", 200, -200, 200);
0545 hSTimeAnodeByChamberType.push_back(
0546 ibooker.book1D("hSTimeAnode_m42", "Anode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
0547 hSTimeAnodeByChamberType.push_back(
0548 ibooker.book1D("hSTimeAnode_m41", "Anode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
0549 hSTimeAnodeByChamberType.push_back(
0550 ibooker.book1D("hSTimeAnode_m32", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
0551 hSTimeAnodeByChamberType.push_back(
0552 ibooker.book1D("hSTimeAnode_m31", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
0553 hSTimeAnodeByChamberType.push_back(
0554 ibooker.book1D("hSTimeAnode_m22", "Anode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
0555 hSTimeAnodeByChamberType.push_back(
0556 ibooker.book1D("hSTimeAnode_m21", "Anode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
0557 hSTimeAnodeByChamberType.push_back(
0558 ibooker.book1D("hSTimeAnode_m11a", "Anode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
0559 hSTimeAnodeByChamberType.push_back(
0560 ibooker.book1D("hSTimeAnode_m13", "Anode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
0561 hSTimeAnodeByChamberType.push_back(
0562 ibooker.book1D("hSTimeAnode_m12", "Anode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
0563 hSTimeAnodeByChamberType.push_back(
0564 ibooker.book1D("hSTimeAnode_m11b", "Anode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
0565 hSTimeAnodeByChamberType.push_back(
0566 ibooker.book1D("hSTimeAnode_p11b", "Anode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
0567 hSTimeAnodeByChamberType.push_back(
0568 ibooker.book1D("hSTimeAnode_p12", "Anode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
0569 hSTimeAnodeByChamberType.push_back(
0570 ibooker.book1D("hSTimeAnode_p13", "Anode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
0571 hSTimeAnodeByChamberType.push_back(
0572 ibooker.book1D("hSTimeAnode_p11a", "Anode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
0573 hSTimeAnodeByChamberType.push_back(
0574 ibooker.book1D("hSTimeAnode_p21", "Anode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
0575 hSTimeAnodeByChamberType.push_back(
0576 ibooker.book1D("hSTimeAnode_p22", "Anode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
0577 hSTimeAnodeByChamberType.push_back(
0578 ibooker.book1D("hSTimeAnode_p31", "Anode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
0579 hSTimeAnodeByChamberType.push_back(
0580 ibooker.book1D("hSTimeAnode_p32", "Anode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
0581 hSTimeAnodeByChamberType.push_back(
0582 ibooker.book1D("hSTimeAnode_p41", "Anode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
0583 hSTimeAnodeByChamberType.push_back(
0584 ibooker.book1D("hSTimeAnode_p42", "Anode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
0585
0586 hSTimeCathode = ibooker.book1D("hSTimeCathode", "Cathode Only Segment Time [ns]", 200, -200, 200);
0587 hSTimeCathodeByChamberType.push_back(
0588 ibooker.book1D("hSTimeCathode_m42", "Cathode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
0589 hSTimeCathodeByChamberType.push_back(
0590 ibooker.book1D("hSTimeCathode_m41", "Cathode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
0591 hSTimeCathodeByChamberType.push_back(
0592 ibooker.book1D("hSTimeCathode_m32", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
0593 hSTimeCathodeByChamberType.push_back(
0594 ibooker.book1D("hSTimeCathode_m31", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
0595 hSTimeCathodeByChamberType.push_back(
0596 ibooker.book1D("hSTimeCathode_m22", "Cathode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
0597 hSTimeCathodeByChamberType.push_back(
0598 ibooker.book1D("hSTimeCathode_m21", "Cathode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
0599 hSTimeCathodeByChamberType.push_back(
0600 ibooker.book1D("hSTimeCathode_m11a", "Cathode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
0601 hSTimeCathodeByChamberType.push_back(
0602 ibooker.book1D("hSTimeCathode_m13", "Cathode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
0603 hSTimeCathodeByChamberType.push_back(
0604 ibooker.book1D("hSTimeCathode_m12", "Cathode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
0605 hSTimeCathodeByChamberType.push_back(
0606 ibooker.book1D("hSTimeCathode_m11b", "Cathode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
0607 hSTimeCathodeByChamberType.push_back(
0608 ibooker.book1D("hSTimeCathode_p11b", "Cathode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
0609 hSTimeCathodeByChamberType.push_back(
0610 ibooker.book1D("hSTimeCathode_p12", "Cathode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
0611 hSTimeCathodeByChamberType.push_back(
0612 ibooker.book1D("hSTimeCathode_p13", "Cathode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
0613 hSTimeCathodeByChamberType.push_back(
0614 ibooker.book1D("hSTimeCathode_p11a", "Cathode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
0615 hSTimeCathodeByChamberType.push_back(
0616 ibooker.book1D("hSTimeCathode_p21", "Cathode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
0617 hSTimeCathodeByChamberType.push_back(
0618 ibooker.book1D("hSTimeCathode_p22", "Cathode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
0619 hSTimeCathodeByChamberType.push_back(
0620 ibooker.book1D("hSTimeCathode_p31", "Cathode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
0621 hSTimeCathodeByChamberType.push_back(
0622 ibooker.book1D("hSTimeCathode_p32", "Cathode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
0623 hSTimeCathodeByChamberType.push_back(
0624 ibooker.book1D("hSTimeCathode_p41", "Cathode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
0625 hSTimeCathodeByChamberType.push_back(
0626 ibooker.book1D("hSTimeCathode_p42", "Cathode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
0627
0628 hSTimeCombined = ibooker.book1D("hSTimeCombined", "Segment Time (anode+cathode times) [ns]", 200, -200, 200);
0629 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0630 "hSTimeCombined_m42", "Segment Time (anode+cathode times) Segment Time (ME -4/2) [ns]", 200, -200, 200));
0631 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0632 "hSTimeCombined_m41", "Segment Time (anode+cathode times) Segment Time (ME -4/1) [ns]", 200, -200, 200));
0633 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0634 "hSTimeCombined_m32", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
0635 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0636 "hSTimeCombined_m31", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
0637 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0638 "hSTimeCombined_m22", "Segment Time (anode+cathode times) Segment Time (ME -2/2) [ns]", 200, -200, 200));
0639 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0640 "hSTimeCombined_m21", "Segment Time (anode+cathode times) Segment Time (ME -2/1) [ns]", 200, -200, 200));
0641 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0642 "hSTimeCombined_m11a", "Segment Time (anode+cathode times) Segment Time (ME -1/1a) [ns]", 200, -200, 200));
0643 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0644 "hSTimeCombined_m13", "Segment Time (anode+cathode times) Segment Time (ME -1/3) [ns]", 200, -200, 200));
0645 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0646 "hSTimeCombined_m12", "Segment Time (anode+cathode times) Segment Time (ME -1/2) [ns]", 200, -200, 200));
0647 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0648 "hSTimeCombined_m11b", "Segment Time (anode+cathode times) Segment Time (ME -1/1b) [ns]", 200, -200, 200));
0649 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0650 "hSTimeCombined_p11b", "Segment Time (anode+cathode times) Segment Time (ME +1/1b) [ns]", 200, -200, 200));
0651 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0652 "hSTimeCombined_p12", "Segment Time (anode+cathode times) Segment Time (ME +1/2) [ns]", 200, -200, 200));
0653 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0654 "hSTimeCombined_p13", "Segment Time (anode+cathode times) Segment Time (ME +1/3) [ns]", 200, -200, 200));
0655 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0656 "hSTimeCombined_p11a", "Segment Time (anode+cathode times) Segment Time (ME +1/1a) [ns]", 200, -200, 200));
0657 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0658 "hSTimeCombined_p21", "Segment Time (anode+cathode times) Segment Time (ME +2/1) [ns]", 200, -200, 200));
0659 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0660 "hSTimeCombined_p22", "Segment Time (anode+cathode times) Segment Time (ME +2/2) [ns]", 200, -200, 200));
0661 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0662 "hSTimeCombined_p31", "Segment Time (anode+cathode times) Segment Time (ME +3/1) [ns]", 200, -200, 200));
0663 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0664 "hSTimeCombined_p32", "Segment Time (anode+cathode times) Segment Time (ME +3/2) [ns]", 200, -200, 200));
0665 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0666 "hSTimeCombined_p41", "Segment Time (anode+cathode times) Segment Time (ME +4/1) [ns]", 200, -200, 200));
0667 hSTimeCombinedByChamberType.push_back(ibooker.book1D(
0668 "hSTimeCombined_p42", "Segment Time (anode+cathode times) Segment Time (ME +4/2) [ns]", 200, -200, 200));
0669
0670 hSTimeDiffSerial =
0671 ibooker.book2D("hSTimeDiffSerial", "Anode Minus Cathode Segment Time [ns]", 601, -0.5, 600.5, 200, -50, 50);
0672 hSTimeAnodeSerial =
0673 ibooker.book2D("hSTimeAnodeSerial", "Anode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
0674 hSTimeCathodeSerial =
0675 ibooker.book2D("hSTimeCathodeSerial", "Cathode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
0676 hSTimeCombinedSerial = ibooker.book2D(
0677 "hSTimeCombinedSerial", "Segment Time (anode+cathode times) [ns]", 601, -0.5, 600.5, 200, -200, 200);
0678
0679 hSTimeVsZ = ibooker.book2D("hSTimeVsZ", "Segment Time vs. Z; [ns] vs. [cm]", 200, -1200, 1200, 200, -200, 200);
0680 hSTimeVsTOF =
0681 ibooker.book2D("hSTimeVsTOF", "Segment Time vs. Distance from IP; [ns] vs. [cm]", 180, 500, 1400, 200, -200, 200);
0682
0683
0684 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Resolution");
0685
0686 hSResid.push_back(ibooker.book1D(
0687 "hSResidm42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/2); Strip Widths", 100, -0.5, 0.5));
0688 hSResid.push_back(ibooker.book1D(
0689 "hSResidm41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/1); Strip Widths", 100, -0.5, 0.5));
0690 hSResid.push_back(ibooker.book1D(
0691 "hSResidm32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/2); Strip Widths", 100, -0.5, 0.5));
0692 hSResid.push_back(ibooker.book1D(
0693 "hSResidm31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/1); Strip Widths", 100, -0.5, 0.5));
0694 hSResid.push_back(ibooker.book1D(
0695 "hSResidm22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/2); Strip Widths", 100, -0.5, 0.5));
0696 hSResid.push_back(ibooker.book1D(
0697 "hSResidm21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/1); Strip Widths", 100, -0.5, 0.5));
0698 hSResid.push_back(ibooker.book1D(
0699 "hSResidm11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1a); Strip Widths", 100, -0.5, 0.5));
0700 hSResid.push_back(ibooker.book1D(
0701 "hSResidm13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/3); Strip Widths", 100, -0.5, 0.5));
0702 hSResid.push_back(ibooker.book1D(
0703 "hSResidm12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/2); Strip Widths", 100, -0.5, 0.5));
0704 hSResid.push_back(ibooker.book1D(
0705 "hSResidm11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1b); Strip Widths", 100, -0.5, 0.5));
0706 hSResid.push_back(ibooker.book1D(
0707 "hSResidp11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1b); Strip Widths", 100, -0.5, 0.5));
0708 hSResid.push_back(ibooker.book1D(
0709 "hSResidp12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/2); Strip Widths", 100, -0.5, 0.5));
0710 hSResid.push_back(ibooker.book1D(
0711 "hSResidp13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/3); Strip Widths", 100, -0.5, 0.5));
0712 hSResid.push_back(ibooker.book1D(
0713 "hSResidp11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1a); Strip Widths", 100, -0.5, 0.5));
0714 hSResid.push_back(ibooker.book1D(
0715 "hSResidp21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/1); Strip Widths", 100, -0.5, 0.5));
0716 hSResid.push_back(ibooker.book1D(
0717 "hSResidp22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/2); Strip Widths", 100, -0.5, 0.5));
0718 hSResid.push_back(ibooker.book1D(
0719 "hSResidp31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/1); Strip Widths", 100, -0.5, 0.5));
0720 hSResid.push_back(ibooker.book1D(
0721 "hSResidp32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/2); Strip Widths", 100, -0.5, 0.5));
0722 hSResid.push_back(ibooker.book1D(
0723 "hSResidp41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/1); Strip Widths", 100, -0.5, 0.5));
0724 hSResid.push_back(ibooker.book1D(
0725 "hSResidp42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/2); Strip Widths", 100, -0.5, 0.5));
0726
0727
0728 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Efficiency");
0729
0730
0731
0732 hSnum = ibooker.book1D("hSnum", "CSC w rechits in 2+ layers && segment(s)", 20, 0.5, 20.5);
0733 hSden = ibooker.book1D("hSden", "CSC w rechits in 2+ layers", 20, 0.5, 20.5);
0734 hRHnum = ibooker.book1D("hRHnum", "CSC w segment(s) && rechits in 6 layers", 20, 0.5, 20.5);
0735 hRHden = ibooker.book1D("hRHden", "CSC w segment(s)", 20, 0.5, 20.5);
0736 applyCSClabels(hSnum, EXTENDED, X);
0737 applyCSClabels(hSden, EXTENDED, X);
0738 applyCSClabels(hRHnum, EXTENDED, X);
0739 applyCSClabels(hRHden, EXTENDED, X);
0740
0741
0742
0743 hSSTE2 = ibooker.book2D("hSSTE2", "hSSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
0744 hRHSTE2 = ibooker.book2D("hRHSTE2", "hRHSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
0745 hStripSTE2 = ibooker.book2D("hStripSTE2", "hStripSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
0746 hWireSTE2 = ibooker.book2D("hWireSTE2", "hWireSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
0747 hEffDenominator = ibooker.book2D("hEffDenominator", "hEffDenominator", 36, 0.5, 36.5, 20, 0.5, 20.5);
0748
0749
0750
0751
0752
0753
0754 hSensitiveAreaEvt =
0755 ibooker.book2D("hSensitiveAreaEvt", "Events Passing Selection for Efficiency", 36, 0.5, 36.5, 20, 0.5, 20.5);
0756
0757
0758 ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/BXMonitor");
0759
0760 hALCTgetBX = ibooker.book1D("hALCTgetBX", "ALCT position in ALCT-L1A match window [BX]", 7, -0.5, 6.5);
0761
0762 hALCTgetBXSerial =
0763 ibooker.book2D("hALCTgetBXSerial", "ALCT position in ALCT-L1A match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
0764 hALCTgetBXSerial->setAxisTitle("Chamber Serial Number");
0765 hALCTgetBX2DNumerator = ibooker.book2D(
0766 "hALCTgetBX2DNumerator", "ALCT position in ALCT-L1A match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
0767
0768 hALCTgetBX2Denominator =
0769 ibooker.book2D("hALCTgetBX2Denominator", "Number of ALCT Digis checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0770
0771 hALCTgetBX2Denominator->setAxisTitle("Chamber #");
0772 hALCTMatch = ibooker.book1D("hALCTMatch", "ALCT position in ALCT-CLCT match window [BX]", 7, -0.5, 6.5);
0773
0774 hALCTMatchSerial = ibooker.book2D(
0775 "hALCTMatchSerial", "ALCT position in ALCT-CLCT match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
0776 hALCTMatchSerial->setAxisTitle("Chamber Serial Number");
0777 hALCTMatch2DNumerator = ibooker.book2D(
0778 "hALCTMatch2DNumerator", "ALCT position in ALCT-CLCT match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
0779
0780 hALCTMatch2Denominator =
0781 ibooker.book2D("hALCTMatch2Denominator", "Number of ALCT-CLCT matches checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0782
0783 hALCTMatch2Denominator->setAxisTitle("Chamber #");
0784 hCLCTL1A = ibooker.book1D("hCLCTL1A", "L1A - CLCTpreTrigger at TMB [BX]", 40, 149.5, 189.5);
0785
0786 hCLCTL1ASerial =
0787 ibooker.book2D("hCLCTL1ASerial", "L1A - CLCTpreTrigger at TMB [BX]", 601, -0.5, 600.5, 40, 149.5, 189.5);
0788 hCLCTL1ASerial->setAxisTitle("Chamber Serial Number");
0789 hCLCTL1A2DNumerator =
0790 ibooker.book2D("hCLCTL1A2DNumerator", "L1A - CLCTpreTrigger at TMB [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
0791
0792 hCLCTL1A2Denominator =
0793 ibooker.book2D("hCLCTL1A2Denominator", "Number of TMB CLCTs checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0794
0795
0796 applyCSClabels(hOWiresAndCLCT, EXTENDED, Y);
0797 applyCSClabels(hOWires, EXTENDED, Y);
0798 applyCSClabels(hOStrips, EXTENDED, Y);
0799 applyCSClabels(hOStripsAndWiresAndCLCT, EXTENDED, Y);
0800 applyCSClabels(hORecHits, EXTENDED, Y);
0801 applyCSClabels(hOSegments, EXTENDED, Y);
0802
0803
0804
0805 applyCSClabels(hSSTE2, EXTENDED, Y);
0806 applyCSClabels(hEffDenominator, EXTENDED, Y);
0807
0808 applyCSClabels(hRHSTE2, EXTENDED, Y);
0809
0810
0811 applyCSClabels(hStripSTE2, EXTENDED, Y);
0812
0813 applyCSClabels(hWireSTE2, EXTENDED, Y);
0814 applyCSClabels(hSensitiveAreaEvt, EXTENDED, Y);
0815
0816 applyCSClabels(hALCTgetBX2Denominator, EXTENDED, Y);
0817
0818 applyCSClabels(hALCTMatch2Denominator, EXTENDED, Y);
0819
0820 applyCSClabels(hCLCTL1A2Denominator, EXTENDED, Y);
0821 }
0822
0823
0824
0825
0826 void CSCOfflineMonitor::analyze(const edm::Event& event, const edm::EventSetup& eventSetup) {
0827 edm::Handle<CSCWireDigiCollection> wires;
0828 edm::Handle<CSCStripDigiCollection> strips;
0829 edm::Handle<CSCALCTDigiCollection> alcts;
0830 edm::Handle<CSCCLCTDigiCollection> clcts;
0831 event.getByToken(sd_token, strips);
0832 event.getByToken(wd_token, wires);
0833 event.getByToken(al_token, alcts);
0834 event.getByToken(cl_token, clcts);
0835
0836
0837 edm::ESHandle<CSCGeometry> cscGeom;
0838
0839 cscGeom = eventSetup.getHandle(cscGeomToken_);
0840
0841
0842 edm::Handle<CSCRecHit2DCollection> recHits;
0843 event.getByToken(rh_token, recHits);
0844
0845
0846 edm::Handle<CSCSegmentCollection> cscSegments;
0847 event.getByToken(se_token, cscSegments);
0848
0849 doOccupancies(strips, wires, recHits, cscSegments, clcts);
0850 doStripDigis(strips);
0851 doWireDigis(wires);
0852 doRecHits(recHits, strips, cscGeom);
0853 doSegments(cscSegments, cscGeom);
0854 doResolution(cscSegments, cscGeom);
0855 doPedestalNoise(strips, cscGeom);
0856 doEfficiencies(wires, strips, recHits, cscSegments, cscGeom);
0857 doBXMonitor(alcts, clcts, event, eventSetup);
0858 }
0859
0860
0861
0862
0863
0864
0865
0866 void CSCOfflineMonitor::doOccupancies(edm::Handle<CSCStripDigiCollection> strips,
0867 edm::Handle<CSCWireDigiCollection> wires,
0868 edm::Handle<CSCRecHit2DCollection> recHits,
0869 edm::Handle<CSCSegmentCollection> cscSegments,
0870 edm::Handle<CSCCLCTDigiCollection> clcts) {
0871 bool clcto[2][4][4][36];
0872 bool wireo[2][4][4][36];
0873 bool stripo[2][4][4][36];
0874 bool rechito[2][4][4][36];
0875 bool segmento[2][4][4][36];
0876
0877 bool hasWires = false;
0878 bool hasStrips = false;
0879 bool hasRecHits = false;
0880 bool hasSegments = false;
0881
0882 for (int e = 0; e < 2; e++) {
0883 for (int s = 0; s < 4; s++) {
0884 for (int r = 0; r < 4; r++) {
0885 for (int c = 0; c < 36; c++) {
0886 clcto[e][s][r][c] = false;
0887 wireo[e][s][r][c] = false;
0888 stripo[e][s][r][c] = false;
0889 rechito[e][s][r][c] = false;
0890 segmento[e][s][r][c] = false;
0891 }
0892 }
0893 }
0894 }
0895
0896
0897 for (CSCCLCTDigiCollection::DigiRangeIterator j = clcts->begin(); j != clcts->end(); j++) {
0898 CSCDetId id = (CSCDetId)(*j).first;
0899 int kEndcap = id.endcap();
0900 int kRing = id.ring();
0901 int kStation = id.station();
0902 int kChamber = id.chamber();
0903 const CSCCLCTDigiCollection::Range& range = (*j).second;
0904 for (CSCCLCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
0905
0906 if ((*digiIt).isValid()) {
0907
0908 if (kStation == 1 && kRing == 1 && (*digiIt).getKeyStrip() > 128)
0909 kRing = 4;
0910 clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
0911 }
0912 }
0913 }
0914
0915
0916 for (CSCWireDigiCollection::DigiRangeIterator wi = wires->begin(); wi != wires->end(); wi++) {
0917 CSCDetId id = (CSCDetId)(*wi).first;
0918 int kEndcap = id.endcap();
0919 int kRing = id.ring();
0920 int kStation = id.station();
0921 int kChamber = id.chamber();
0922 std::vector<CSCWireDigi>::const_iterator wireIt = (*wi).second.first;
0923 std::vector<CSCWireDigi>::const_iterator lastWire = (*wi).second.second;
0924 for (; wireIt != lastWire; ++wireIt) {
0925 if (!wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
0926 wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
0927 hOWires->Fill(kChamber, typeIndex(id, 2));
0928 hOWireSerial->Fill(chamberSerial(id));
0929 hasWires = true;
0930 if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1])
0931 hOWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
0932
0933 if (kStation == 1 && kRing == 1 && clcto[kEndcap - 1][kStation - 1][3][kChamber - 1]) {
0934 CSCDetId idME11a = CSCDetId(kEndcap, kStation, 4, kChamber);
0935 hOWiresAndCLCT->Fill(kChamber, typeIndex(idME11a, 2));
0936 }
0937 }
0938 }
0939 }
0940
0941
0942 for (CSCStripDigiCollection::DigiRangeIterator si = strips->begin(); si != strips->end(); si++) {
0943 CSCDetId id = (CSCDetId)(*si).first;
0944 int kEndcap = id.endcap();
0945 int kRing = id.ring();
0946 int kStation = id.station();
0947 int kChamber = id.chamber();
0948 std::vector<CSCStripDigi>::const_iterator stripIt = (*si).second.first;
0949 std::vector<CSCStripDigi>::const_iterator lastStrip = (*si).second.second;
0950 for (; stripIt != lastStrip; ++stripIt) {
0951 std::vector<int> myADCVals = stripIt->getADCCounts();
0952 bool thisStripFired = false;
0953 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
0954 float threshold = 13.3;
0955 float diff = 0.;
0956 for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
0957 diff = (float)myADCVals[iCount] - thisPedestal;
0958 if (diff > threshold) {
0959 thisStripFired = true;
0960 }
0961 }
0962 if (thisStripFired) {
0963 if (!stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
0964 stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
0965 hOStrips->Fill(kChamber, typeIndex(id, 2));
0966 hOStripSerial->Fill(chamberSerial(id));
0967 hasStrips = true;
0968 if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
0969
0970
0971 if (wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] ||
0972 (kRing == 4 && wireo[kEndcap - 1][kStation - 1][0][kChamber - 1])) {
0973 hOStripsAndWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
0974 }
0975 }
0976 }
0977 }
0978 }
0979 }
0980
0981
0982 CSCRecHit2DCollection::const_iterator recIt;
0983 for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
0984 CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
0985 int kEndcap = idrec.endcap();
0986 int kRing = idrec.ring();
0987 int kStation = idrec.station();
0988 int kChamber = idrec.chamber();
0989 if (!rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
0990 rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
0991 hORecHitsSerial->Fill(chamberSerial(idrec));
0992 hORecHits->Fill(kChamber, typeIndex(idrec, 2));
0993 hasRecHits = true;
0994 }
0995 }
0996
0997
0998 for (CSCSegmentCollection::const_iterator segIt = cscSegments->begin(); segIt != cscSegments->end(); segIt++) {
0999 CSCDetId id = (CSCDetId)(*segIt).cscDetId();
1000 int kEndcap = id.endcap();
1001 int kRing = id.ring();
1002 int kStation = id.station();
1003 int kChamber = id.chamber();
1004 if (!segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
1005 segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
1006 hOSegmentsSerial->Fill(chamberSerial(id));
1007 hOSegments->Fill(kChamber, typeIndex(id, 2));
1008 hasSegments = true;
1009 }
1010 }
1011
1012
1013 hCSCOccupancy->Fill(1);
1014 if (hasWires)
1015 hCSCOccupancy->Fill(3);
1016 if (hasStrips)
1017 hCSCOccupancy->Fill(5);
1018 if (hasWires && hasStrips)
1019 hCSCOccupancy->Fill(7);
1020 if (hasRecHits)
1021 hCSCOccupancy->Fill(9);
1022 if (hasSegments)
1023 hCSCOccupancy->Fill(11);
1024 }
1025
1026
1027
1028
1029
1030
1031
1032 void CSCOfflineMonitor::doWireDigis(edm::Handle<CSCWireDigiCollection> wires) {
1033 int nWireGroupsTotal = 0;
1034 for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1035 CSCDetId id = (CSCDetId)(*dWDiter).first;
1036 std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1037 std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1038 for (; wireIter != lWire; ++wireIter) {
1039 int myWire = wireIter->getWireGroup();
1040 int myTBin = wireIter->getTimeBin();
1041 nWireGroupsTotal++;
1042 hWireTBin[typeIndex(id) - 1]->Fill(myTBin);
1043 hWireNumber[typeIndex(id) - 1]->Fill(myWire);
1044 }
1045 }
1046
1047 hWirenGroupsTotal->Fill(nWireGroupsTotal);
1048 hWirenGroupsTotalHi->Fill(nWireGroupsTotal);
1049 }
1050
1051
1052
1053
1054
1055
1056
1057 void CSCOfflineMonitor::doStripDigis(edm::Handle<CSCStripDigiCollection> strips) {
1058 int nStripsFired = 0;
1059 for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1060 CSCDetId id = (CSCDetId)(*dSDiter).first;
1061 std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1062 std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1063 for (; stripIter != lStrip; ++stripIter) {
1064 int myStrip = stripIter->getStrip();
1065 std::vector<int> myADCVals = stripIter->getADCCounts();
1066 bool thisStripFired = false;
1067 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1068 float threshold = 13.3;
1069 float diff = 0.;
1070 for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1071 diff = (float)myADCVals[iCount] - thisPedestal;
1072 if (diff > threshold) {
1073 thisStripFired = true;
1074 }
1075 }
1076 if (thisStripFired) {
1077 nStripsFired++;
1078 hStripNumber[typeIndex(id) - 1]->Fill(myStrip);
1079 }
1080 }
1081 }
1082
1083 hStripNFired->Fill(nStripsFired);
1084 hStripNFiredHi->Fill(nStripsFired);
1085
1086
1087 }
1088
1089
1090
1091
1092
1093
1094
1095 void CSCOfflineMonitor::doPedestalNoise(edm::Handle<CSCStripDigiCollection> strips,
1096 edm::ESHandle<CSCGeometry> cscGeom) {
1097 for (CSCStripDigiCollection::DigiRangeIterator dPNiter = strips->begin(); dPNiter != strips->end(); dPNiter++) {
1098 CSCDetId id = (CSCDetId)(*dPNiter).first;
1099 int kStation = id.station();
1100 int kRing = id.ring();
1101 std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
1102 std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
1103 for (; pedIt != lStrip; ++pedIt) {
1104 int myStrip = pedIt->getStrip();
1105 std::vector<int> myADCVals = pedIt->getADCCounts();
1106 float TotalADC = getSignal(*strips, id, myStrip);
1107 bool thisStripFired = false;
1108 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1109 float thisSignal =
1110 (1. / 6) * (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1111 float threshold = 13.3;
1112
1113
1114
1115 if ((kStation == 1 && kRing == 4) && cscGeom->gangedStrips()) {
1116 kRing = 1;
1117 if (myStrip <= 16)
1118 myStrip += 64;
1119 }
1120
1121 if (TotalADC > threshold) {
1122 thisStripFired = true;
1123 }
1124 if (!thisStripFired) {
1125 float ADC = thisSignal - thisPedestal;
1126 hStripPed[typeIndex(id) - 1]->Fill(ADC);
1127 }
1128 }
1129 }
1130 }
1131
1132
1133
1134
1135
1136
1137
1138 void CSCOfflineMonitor::doRecHits(edm::Handle<CSCRecHit2DCollection> recHits,
1139 edm::Handle<CSCStripDigiCollection> strips,
1140 edm::ESHandle<CSCGeometry> cscGeom) {
1141
1142 int nRecHits = recHits->size();
1143
1144
1145
1146
1147
1148 CSCRecHit2DCollection::const_iterator dRHIter;
1149 for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
1150
1151 CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
1152
1153
1154 LocalPoint rhitlocal = (*dRHIter).localPosition();
1155
1156
1157
1158
1159 float stpos = (*dRHIter).positionWithinStrip();
1160 float sterr = (*dRHIter).errorWithinStrip();
1161
1162
1163
1164 int adcsize = dRHIter->nStrips() * dRHIter->nTimeBins();
1165 float rHSumQ = 0;
1166 float sumsides = 0;
1167 for (unsigned int i = 0; i < dRHIter->nStrips(); i++) {
1168 for (unsigned int j = 0; j < dRHIter->nTimeBins() - 1; j++) {
1169 rHSumQ += dRHIter->adcs(i, j);
1170 if (i != 1)
1171 sumsides += dRHIter->adcs(i, j);
1172 }
1173 }
1174
1175 float rHratioQ = sumsides / rHSumQ;
1176 if (adcsize != 12)
1177 rHratioQ = -99;
1178
1179
1180 float rHtime = (*dRHIter).tpeak();
1181 float rHtimeAnode = (*dRHIter).wireTime();
1182
1183
1184 const CSCLayer* csclayer = cscGeom->layer(idrec);
1185
1186
1187 GlobalPoint rhitglobal = csclayer->toGlobal(rhitlocal);
1188 float grecx = rhitglobal.x();
1189 float grecy = rhitglobal.y();
1190
1191
1192 int sIndex = idrec.station() + ((idrec.endcap() - 1) * 4);
1193 int tIndex = typeIndex(idrec);
1194 hRHSumQ[tIndex - 1]->Fill(rHSumQ);
1195 hRHRatioQ[tIndex - 1]->Fill(rHratioQ);
1196 hRHstpos[tIndex - 1]->Fill(stpos);
1197 hRHsterr[tIndex - 1]->Fill(sterr);
1198 hRHTiming[tIndex - 1]->Fill(rHtime);
1199 hRHTimingAnode[tIndex - 1]->Fill(rHtimeAnode);
1200 hRHGlobal[sIndex - 1]->Fill(grecx, grecy);
1201
1202 }
1203
1204
1205 hRHnrechits->Fill(nRecHits);
1206 hRHnrechitsHi->Fill(nRecHits);
1207 }
1208
1209
1210
1211
1212
1213
1214
1215 void CSCOfflineMonitor::doSegments(edm::Handle<CSCSegmentCollection> cscSegments, edm::ESHandle<CSCGeometry> cscGeom) {
1216
1217 int nSegments = cscSegments->size();
1218
1219 for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1220 CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1221 float chisq = (*dSiter).chi2();
1222 int nhits = (*dSiter).nRecHits();
1223 int nDOF = 2 * nhits - 4;
1224 float nChi2 = chisq / nDOF;
1225 double chisqProb = ChiSquaredProbability((double)chisq, nDOF);
1226 LocalPoint localPos = (*dSiter).localPosition();
1227 LocalVector segDir = (*dSiter).localDirection();
1228
1229
1230 float timeCathode = 0;
1231 float timeAnode = 0;
1232 float timeCombined = 0;
1233 std::vector<float> cathodeTimes;
1234 std::vector<float> anodeTimes;
1235
1236 std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1237 for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1238 if (!((*iRH).isValid()))
1239 continue;
1240 cathodeTimes.push_back((*iRH).tpeak());
1241 anodeTimes.push_back((*iRH).wireTime());
1242 }
1243
1244
1245 for (unsigned int i = 0; i < cathodeTimes.size(); i++)
1246 timeCathode += cathodeTimes[i] / cathodeTimes.size();
1247
1248
1249 float anodeMaxDiff;
1250 bool modified = false;
1251 std::vector<float>::iterator anodeMaxHit;
1252 do {
1253 if (anodeTimes.empty())
1254 continue;
1255 timeAnode = 0;
1256 anodeMaxDiff = 0;
1257 modified = false;
1258
1259
1260 for (unsigned int j = 0; j < anodeTimes.size(); j++)
1261 timeAnode += anodeTimes[j] / anodeTimes.size();
1262
1263
1264 for (unsigned int j = 0; j < anodeTimes.size(); j++) {
1265 if (fabs(anodeTimes[j] - timeAnode) > anodeMaxDiff) {
1266 anodeMaxHit = anodeTimes.begin() + j;
1267 anodeMaxDiff = fabs(anodeTimes[j] - timeAnode);
1268 }
1269 }
1270
1271
1272 if (anodeMaxDiff > 26) {
1273 modified = true;
1274 anodeTimes.erase(anodeMaxHit);
1275 }
1276 } while (modified);
1277
1278
1279 if (cathodeTimes.size() + anodeTimes.size() > 0)
1280 timeCombined = (timeCathode * cathodeTimes.size() + timeAnode * anodeTimes.size()) /
1281 (cathodeTimes.size() + anodeTimes.size());
1282
1283
1284 float globX = 0.;
1285 float globY = 0.;
1286 float globZ = 0.;
1287 float globTOF = 0.;
1288 float globTheta = 0.;
1289 float globPhi = 0.;
1290 const CSCChamber* cscchamber = cscGeom->chamber(id);
1291 if (cscchamber) {
1292 GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
1293 globX = globalPosition.x();
1294 globY = globalPosition.y();
1295 globZ = globalPosition.z();
1296 globTOF = sqrt(globX * globX + globY * globY + globZ * globZ);
1297 GlobalVector globalDirection = cscchamber->toGlobal(segDir);
1298 globTheta = globalDirection.theta();
1299 globPhi = globalDirection.phi();
1300 }
1301
1302
1303 int tIndex = typeIndex(id);
1304 hSnhitsAll->Fill(nhits);
1305 hSnhits[tIndex - 1]->Fill(nhits);
1306 hSChiSqAll->Fill(nChi2);
1307 hSChiSq[tIndex - 1]->Fill(nChi2);
1308 hSChiSqProbAll->Fill(chisqProb);
1309 hSChiSqProb[tIndex - 1]->Fill(chisqProb);
1310 hSGlobalTheta->Fill(globTheta);
1311 hSGlobalPhi->Fill(globPhi);
1312 hSTimeDiff->Fill(timeAnode - timeCathode);
1313 hSTimeDiffByChamberType[tIndex - 1]->Fill(timeAnode - timeCathode);
1314 hSTimeAnode->Fill(timeAnode);
1315 hSTimeAnodeByChamberType[tIndex - 1]->Fill(timeAnode);
1316 hSTimeCathode->Fill(timeCathode);
1317 hSTimeCathodeByChamberType[tIndex - 1]->Fill(timeCathode);
1318 hSTimeCombined->Fill(timeCombined);
1319 hSTimeCombinedByChamberType[tIndex - 1]->Fill(timeCombined);
1320 hSTimeDiffSerial->Fill(chamberSerial(id), timeAnode - timeCathode);
1321 hSTimeAnodeSerial->Fill(chamberSerial(id), timeAnode);
1322 hSTimeCathodeSerial->Fill(chamberSerial(id), timeCathode);
1323 hSTimeCombinedSerial->Fill(chamberSerial(id), timeCombined);
1324 hSTimeVsZ->Fill(globZ, timeCombined);
1325 hSTimeVsTOF->Fill(globTOF, timeCombined);
1326
1327 }
1328
1329 hSnSegments->Fill(nSegments);
1330 }
1331
1332
1333
1334
1335
1336
1337 void CSCOfflineMonitor::doResolution(edm::Handle<CSCSegmentCollection> cscSegments,
1338 edm::ESHandle<CSCGeometry> cscGeom) {
1339 for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1340 CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1341
1342
1343 std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1344 int nRH = (*dSiter).nRecHits();
1345 int jRH = 0;
1346 CLHEP::HepMatrix sp(6, 1);
1347 CLHEP::HepMatrix se(6, 1);
1348 for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1349 jRH++;
1350 CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
1351
1352 int kRing = idRH.ring();
1353 int kStation = idRH.station();
1354
1355 int kLayer = idRH.layer();
1356
1357
1358 int centerid = iRH->nStrips() / 2 + 1;
1359 int centerStrip = iRH->channels(centerid - 1);
1360
1361
1362 if (nRH == 6) {
1363 float stpos = (*iRH).positionWithinStrip();
1364 se(kLayer, 1) = (*iRH).errorWithinStrip();
1365
1366 if (kStation == 1 && (kRing == 1 || kRing == 4))
1367 sp(kLayer, 1) = stpos + centerStrip;
1368 else {
1369 if (kLayer == 1 || kLayer == 3 || kLayer == 5)
1370 sp(kLayer, 1) = stpos + centerStrip;
1371 if (kLayer == 2 || kLayer == 4 || kLayer == 6)
1372 sp(kLayer, 1) = stpos - 0.5 + centerStrip;
1373 }
1374 }
1375 }
1376
1377
1378
1379 if (nRH == 6) {
1380 float expected = fitX(sp, se);
1381 float residual = expected - sp(3, 1);
1382
1383 hSResid[typeIndex(id) - 1]->Fill(residual);
1384 }
1385
1386
1387
1388 }
1389 }
1390
1391
1392
1393
1394
1395
1396 float CSCOfflineMonitor::fitX(const CLHEP::HepMatrix& points, const CLHEP::HepMatrix& errors) {
1397 float S = 0;
1398 float Sx = 0;
1399 float Sy = 0;
1400 float Sxx = 0;
1401 float Sxy = 0;
1402 float sigma2 = 0;
1403
1404 for (int i = 1; i < 7; i++) {
1405 if (i != 3) {
1406 sigma2 = errors(i, 1) * errors(i, 1);
1407 S = S + (1 / sigma2);
1408 Sy = Sy + (points(i, 1) / sigma2);
1409 Sx = Sx + ((i) / sigma2);
1410 Sxx = Sxx + (i * i) / sigma2;
1411 Sxy = Sxy + (((i)*points(i, 1)) / sigma2);
1412 }
1413 }
1414
1415 float delta = S * Sxx - Sx * Sx;
1416 float intercept = (Sxx * Sy - Sx * Sxy) / delta;
1417 float slope = (S * Sxy - Sx * Sy) / delta;
1418
1419 return (intercept + slope * 3);
1420 }
1421
1422
1423
1424
1425
1426
1427
1428
1429 float CSCOfflineMonitor::getSignal(const CSCStripDigiCollection& stripdigis, CSCDetId idCS, int centerStrip) {
1430 float SigADC[5];
1431 float TotalADC = 0;
1432 SigADC[0] = 0;
1433 SigADC[1] = 0;
1434 SigADC[2] = 0;
1435 SigADC[3] = 0;
1436 SigADC[4] = 0;
1437
1438
1439 CSCStripDigiCollection::DigiRangeIterator sIt;
1440
1441 for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++) {
1442 CSCDetId id = (CSCDetId)(*sIt).first;
1443 if (id == idCS) {
1444
1445 vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
1446 vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
1447 for (; digiItr != last; ++digiItr) {
1448 int thisStrip = digiItr->getStrip();
1449 if (thisStrip == (centerStrip)) {
1450 std::vector<int> myADCVals = digiItr->getADCCounts();
1451 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1452 float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1453 SigADC[0] = thisSignal - 6 * thisPedestal;
1454 }
1455
1456 if (thisStrip == (centerStrip + 1)) {
1457 std::vector<int> myADCVals = digiItr->getADCCounts();
1458 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1459 float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1460 SigADC[1] = thisSignal - 6 * thisPedestal;
1461 }
1462 if (thisStrip == (centerStrip + 2)) {
1463 std::vector<int> myADCVals = digiItr->getADCCounts();
1464 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1465 float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1466 SigADC[2] = thisSignal - 6 * thisPedestal;
1467 }
1468 if (thisStrip == (centerStrip - 1)) {
1469 std::vector<int> myADCVals = digiItr->getADCCounts();
1470 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1471 float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1472 SigADC[3] = thisSignal - 6 * thisPedestal;
1473 }
1474 if (thisStrip == (centerStrip - 2)) {
1475 std::vector<int> myADCVals = digiItr->getADCCounts();
1476 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1477 float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1478 SigADC[4] = thisSignal - 6 * thisPedestal;
1479 }
1480 }
1481 TotalADC = 0.2 * (SigADC[0] + SigADC[1] + SigADC[2] + SigADC[3] + SigADC[4]);
1482 }
1483 }
1484 return TotalADC;
1485 }
1486
1487
1488
1489
1490
1491
1492 void CSCOfflineMonitor::doEfficiencies(edm::Handle<CSCWireDigiCollection> wires,
1493 edm::Handle<CSCStripDigiCollection> strips,
1494 edm::Handle<CSCRecHit2DCollection> recHits,
1495 edm::Handle<CSCSegmentCollection> cscSegments,
1496 edm::ESHandle<CSCGeometry> cscGeom) {
1497 bool allWires[2][4][4][36][6];
1498 bool allStrips[2][4][4][36][6];
1499 bool AllRecHits[2][4][4][36][6];
1500 bool AllSegments[2][4][4][36];
1501
1502
1503 for (int iE = 0; iE < 2; iE++) {
1504 for (int iS = 0; iS < 4; iS++) {
1505 for (int iR = 0; iR < 4; iR++) {
1506 for (int iC = 0; iC < 36; iC++) {
1507 AllSegments[iE][iS][iR][iC] = false;
1508
1509 for (int iL = 0; iL < 6; iL++) {
1510 allWires[iE][iS][iR][iC][iL] = false;
1511 allStrips[iE][iS][iR][iC][iL] = false;
1512 AllRecHits[iE][iS][iR][iC][iL] = false;
1513 }
1514 }
1515 }
1516 }
1517 }
1518
1519
1520 for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1521 CSCDetId idrec = (CSCDetId)(*dWDiter).first;
1522 std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1523 std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1524 for (; wireIter != lWire; ++wireIter) {
1525 allWires[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1526 true;
1527 break;
1528 }
1529 }
1530
1531
1532 for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1533 CSCDetId idrec = (CSCDetId)(*dSDiter).first;
1534 std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1535 std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1536 for (; stripIter != lStrip; ++stripIter) {
1537 std::vector<int> myADCVals = stripIter->getADCCounts();
1538 bool thisStripFired = false;
1539 float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1540 float threshold = 13.3;
1541 float diff = 0.;
1542 for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1543 diff = (float)myADCVals[iCount] - thisPedestal;
1544 if (diff > threshold) {
1545 thisStripFired = true;
1546 break;
1547 }
1548 }
1549 if (thisStripFired) {
1550 allStrips[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1551 true;
1552 break;
1553 }
1554 }
1555 }
1556
1557
1558 for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
1559
1560 CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
1561 AllRecHits[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1562 true;
1563 }
1564
1565 std::vector<uint> seg_ME2(2, 0);
1566 std::vector<uint> seg_ME3(2, 0);
1567 std::vector<pair<CSCDetId, CSCSegment> > theSegments(4);
1568
1569 for (CSCSegmentCollection::const_iterator segEffIt = cscSegments->begin(); segEffIt != cscSegments->end();
1570 segEffIt++) {
1571 CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
1572
1573
1574
1575 AllSegments[idseg.endcap() - 1][idseg.station() - 1][idseg.ring() - 1][idseg.chamber() - 1] = true;
1576
1577
1578
1579 if (2 == idseg.station() || 3 == idseg.station()) {
1580 uint seg_tmp;
1581 if (2 == idseg.station()) {
1582 ++seg_ME2[idseg.endcap() - 1];
1583 seg_tmp = seg_ME2[idseg.endcap() - 1];
1584 } else {
1585 ++seg_ME3[idseg.endcap() - 1];
1586 seg_tmp = seg_ME3[idseg.endcap() - 1];
1587 }
1588
1589 if (1 == seg_tmp && 6 == (*segEffIt).nRecHits() && (*segEffIt).chi2() / (*segEffIt).degreesOfFreedom() < 3.) {
1590 pair<CSCDetId, CSCSegment> specSeg = make_pair((CSCDetId)(*segEffIt).cscDetId(), *segEffIt);
1591 theSegments[2 * (idseg.endcap() - 1) + (idseg.station() - 2)] = specSeg;
1592 }
1593 }
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610 }
1611
1612 for (int iE = 0; iE < 2; iE++) {
1613 for (int iS = 0; iS < 4; iS++) {
1614 for (int iR = 0; iR < 4; iR++) {
1615 for (int iC = 0; iC < 36; iC++) {
1616 int NumberOfLayers = 0;
1617 for (int iL = 0; iL < 6; iL++) {
1618 if (AllRecHits[iE][iS][iR][iC][iL]) {
1619 NumberOfLayers++;
1620 }
1621 }
1622
1623
1624
1625 int bin = CSCDetId::iChamberType(iS + 1, iR + 1);
1626 if (iE > 0) {
1627 bin = 11 - bin;
1628 } else {
1629 bin += 10;
1630 }
1631
1632 if (NumberOfLayers > 1) {
1633
1634 if (AllSegments[iE][iS][iR][iC]) {
1635
1636 hSnum->Fill(bin);
1637 }
1638
1639 hSden->Fill(bin);
1640
1641 }
1642 if (AllSegments[iE][iS][iR][iC]) {
1643 if (NumberOfLayers == 6) {
1644
1645 hRHnum->Fill(bin);
1646 ;
1647 }
1648
1649 hRHden->Fill(bin);
1650 ;
1651 }
1652 }
1653 }
1654 }
1655 }
1656
1657
1658 std::vector<pair<CSCDetId, CSCSegment>*> theSeg;
1659 if (1 == seg_ME2[0])
1660 theSeg.push_back(&theSegments[0]);
1661 if (1 == seg_ME3[0])
1662 theSeg.push_back(&theSegments[1]);
1663 if (1 == seg_ME2[1])
1664 theSeg.push_back(&theSegments[2]);
1665 if (1 == seg_ME3[1])
1666 theSeg.push_back(&theSegments[3]);
1667
1668 if (!theSeg.empty()) {
1669 std::map<int, GlobalPoint> extrapolatedPoint;
1670 std::map<int, GlobalPoint>::iterator it;
1671 const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
1672
1673 for (unsigned int nCh = 0; nCh < ChamberContainer.size(); nCh++) {
1674 const CSCChamber* cscchamber = ChamberContainer[nCh];
1675 pair<CSCDetId, CSCSegment>* thisSegment = nullptr;
1676 for (uint iSeg = 0; iSeg < theSeg.size(); ++iSeg) {
1677 if (cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()) {
1678 if (1 == cscchamber->id().station() || 3 == cscchamber->id().station()) {
1679 if (2 == theSeg[iSeg]->first.station()) {
1680 thisSegment = theSeg[iSeg];
1681 }
1682 } else if (2 == cscchamber->id().station() || 4 == cscchamber->id().station()) {
1683 if (3 == theSeg[iSeg]->first.station()) {
1684 thisSegment = theSeg[iSeg];
1685 }
1686 }
1687 }
1688 }
1689
1690 if (thisSegment) {
1691 CSCSegment* seg = &(thisSegment->second);
1692 const CSCChamber* segChamber = cscGeom->chamber(thisSegment->first);
1693 LocalPoint localCenter(0., 0., 0);
1694 GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
1695
1696 it = extrapolatedPoint.find(int(cscchamberCenter.z()));
1697 if (it == extrapolatedPoint.end()) {
1698 GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
1699 GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
1700 double paramaterLine = lineParametrization(segPos.z(), cscchamberCenter.z(), segDir.z());
1701 double xExtrapolated = extrapolate1D(segPos.x(), segDir.x(), paramaterLine);
1702 double yExtrapolated = extrapolate1D(segPos.y(), segDir.y(), paramaterLine);
1703 GlobalPoint globP(xExtrapolated, yExtrapolated, cscchamberCenter.z());
1704 extrapolatedPoint[int(cscchamberCenter.z())] = globP;
1705 }
1706
1707 LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
1708 const CSCLayer* layer_p = cscchamber->layer(1);
1709 const CSCLayerGeometry* layerGeom = layer_p->geometry();
1710 const std::array<const float, 4>& layerBounds = layerGeom->parameters();
1711 float shiftFromEdge = 15.;
1712 float shiftFromDeadZone = 10.;
1713
1714 bool pass = withinSensitiveRegion(extrapolatedPointLocal,
1715 layerBounds,
1716 cscchamber->id().station(),
1717 cscchamber->id().ring(),
1718 shiftFromEdge,
1719 shiftFromDeadZone);
1720 if (pass) {
1721
1722
1723
1724
1725
1726 int nRHLayers = 0;
1727 for (int iL = 0; iL < 6; ++iL) {
1728 if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1729 [cscchamber->id().chamber() - 1][iL]) {
1730 ++nRHLayers;
1731 }
1732 }
1733
1734
1735
1736 float verticalScale =
1737 9. + cscchamber->id().endcap() + (cscchamber->specs()->chamberType()) * (cscchamber->id().zendcap());
1738
1739 hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()), verticalScale);
1740 if (nRHLayers > 1) {
1741
1742 hEffDenominator->Fill(float(cscchamber->id().chamber()), verticalScale);
1743
1744 if (AllSegments[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1745 [cscchamber->id().chamber() - 1]) {
1746 hSSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale));
1747 }
1748
1749 for (int iL = 0; iL < 6; ++iL) {
1750 float weight = 1. / 6.;
1751
1752
1753 if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1754 [cscchamber->id().chamber() - 1][iL]) {
1755 hRHSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1756 }
1757
1758 if (allWires[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1759 [cscchamber->id().chamber() - 1][iL]) {
1760
1761 hWireSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1762 }
1763
1764 if (allStrips[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1765 [cscchamber->id().chamber() - 1][iL]) {
1766
1767 hStripSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1768 }
1769 }
1770 }
1771 }
1772 }
1773 }
1774 }
1775
1776 }
1777
1778
1779
1780
1781
1782
1783
1784 void CSCOfflineMonitor::doBXMonitor(edm::Handle<CSCALCTDigiCollection> alcts,
1785 edm::Handle<CSCCLCTDigiCollection> clcts,
1786 const edm::Event& event,
1787 const edm::EventSetup& eventSetup) {
1788
1789
1790 for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
1791 const CSCDetId& idALCT = (*j).first;
1792 const CSCALCTDigiCollection::Range& range = (*j).second;
1793 for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1794
1795 if ((*digiIt).isValid()) {
1796 hALCTgetBX->Fill((*digiIt).getBX());
1797 hALCTgetBXSerial->Fill(chamberSerial(idALCT), (*digiIt).getBX());
1798 hALCTgetBX2DNumerator->Fill(idALCT.chamber(), typeIndex(idALCT, 2), (*digiIt).getBX());
1799 hALCTgetBX2Denominator->Fill(idALCT.chamber(), typeIndex(idALCT, 2));
1800 }
1801 }
1802 }
1803
1804
1805
1806 edm::ESHandle<CSCCrateMap> hcrate;
1807
1808 hcrate = eventSetup.getHandle(hcrateToken_);
1809
1810 const CSCCrateMap* pcrate = hcrate.product();
1811
1812
1813 edm::Handle<FEDRawDataCollection> rawdata;
1814 if (!(event.getByToken(rd_token, rawdata))) {
1815 edm::LogWarning("CSCOfflineMonitor") << " FEDRawDataCollection not available";
1816 return;
1817 }
1818
1819 bool goodEvent = false;
1820 unsigned long dccBinCheckMask = 0x06080016;
1821 unsigned int examinerMask = 0x1FEBF3F6;
1822 unsigned int errorMask = 0x0;
1823
1824
1825
1826 std::vector<unsigned int> cscFEDids;
1827
1828 for (unsigned int id = FEDNumbering::MINCSCFEDID; id <= FEDNumbering::MAXCSCFEDID; ++id)
1829 {
1830 cscFEDids.push_back(id);
1831 }
1832
1833 for (unsigned int id = FEDNumbering::MINCSCDDUFEDID; id <= FEDNumbering::MAXCSCDDUFEDID; ++id)
1834 {
1835 cscFEDids.push_back(id);
1836 }
1837
1838 for (unsigned int i = 0; i < cscFEDids.size(); i++)
1839 {
1840 unsigned int id = cscFEDids[i];
1841 bool isDDU_FED = ((id >= FEDNumbering::MINCSCDDUFEDID) && (id <= FEDNumbering::MAXCSCDDUFEDID)) ? true : false;
1842
1843
1844
1845
1846
1847 const FEDRawData& fedData = rawdata->FEDData(id);
1848 unsigned long length = fedData.size();
1849
1850 if (length >= 32) {
1851 CSCDCCExaminer* examiner = nullptr;
1852 std::stringstream examiner_out, examiner_err;
1853 goodEvent = true;
1854 examiner = new CSCDCCExaminer();
1855 if (examinerMask & 0x40000)
1856 examiner->crcCFEB(true);
1857 if (examinerMask & 0x8000)
1858 examiner->crcTMB(true);
1859 if (examinerMask & 0x0400)
1860 examiner->crcALCT(true);
1861 examiner->setMask(examinerMask);
1862 const short unsigned int* data = (short unsigned int*)fedData.data();
1863
1864 int res = examiner->check(data, long(fedData.size() / 2));
1865 if (res < 0) {
1866 goodEvent = false;
1867 } else {
1868 goodEvent = !(examiner->errors() & dccBinCheckMask);
1869 }
1870
1871 if (goodEvent) {
1872
1873
1874 CSCDCCExaminer* ptrExaminer = examiner;
1875
1876 std::vector<CSCDDUEventData> fed_Data;
1877 std::vector<CSCDDUEventData>* ptr_fedData = &fed_Data;
1878
1879 if (isDDU_FED)
1880 {
1881 CSCDDUEventData single_dduData((short unsigned int*)fedData.data(), ptrExaminer);
1882 fed_Data.push_back(single_dduData);
1883
1884 } else
1885 {
1886 CSCDCCEventData dccData((short unsigned int*)fedData.data(), ptrExaminer);
1887 fed_Data = dccData.dduData();
1888 }
1889
1890
1891 const std::vector<CSCDDUEventData>& dduData = *ptr_fedData;
1892
1893
1894 CSCDetId layer(1, 1, 1, 1, 1);
1895 for (unsigned int iDDU = 0; iDDU < dduData.size(); ++iDDU) {
1896
1897
1898 if (dduData[iDDU].trailer().errorstat() & errorMask) {
1899 LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! "
1900 << std::hex << dduData[iDDU].trailer().errorstat();
1901 continue;
1902 }
1903
1904
1905 const std::vector<CSCEventData>& cscData = dduData[iDDU].cscData();
1906
1907 for (unsigned int iCSC = 0; iCSC < cscData.size(); ++iCSC) {
1908
1909
1910 int vmecrate = cscData[iCSC].dmbHeader()->crateID();
1911 int dmb = cscData[iCSC].dmbHeader()->dmbID();
1912
1913 int icfeb = 0;
1914 int ilayer = 0;
1915
1916 if ((vmecrate >= 1) && (vmecrate <= 60) && (dmb >= 1) && (dmb <= 10) && (dmb != 6)) {
1917 layer = pcrate->detId(vmecrate, dmb, icfeb, ilayer);
1918 } else {
1919 LogTrace("CSCOfflineMonitor") << " detID input out of range!!! ";
1920 LogTrace("CSCOfflineMonitor") << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
1921 continue;
1922 }
1923
1924
1925 int nalct = cscData[iCSC].dmbHeader()->nalct();
1926 bool goodALCT = false;
1927
1928 if (nalct && cscData[iCSC].alctHeader()) {
1929 if (cscData[iCSC].alctHeader()->check()) {
1930 goodALCT = true;
1931 }
1932 }
1933
1934
1935 int nclct = cscData[iCSC].dmbHeader()->nclct();
1936 bool goodTMB = false;
1937 if (nclct && cscData[iCSC].tmbData()) {
1938 if (cscData[iCSC].tmbHeader()->check()) {
1939 if (cscData[iCSC].comparatorData()->check())
1940 goodTMB = true;
1941 }
1942 }
1943
1944 if (goodTMB && goodALCT) {
1945 const CSCTMBHeader* tmbHead = cscData[iCSC].tmbHeader();
1946 std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
1947 if (clcts.empty() || !(clcts[0].isValid()))
1948 continue;
1949
1950 if (layer.station() == 1 && layer.ring() == 1 && clcts[0].getKeyStrip() > 128) {
1951 layer = CSCDetId(layer.endcap(), layer.station(), 4, layer.chamber());
1952 }
1953 hALCTMatch->Fill(tmbHead->ALCTMatchTime());
1954 hALCTMatchSerial->Fill(chamberSerial(layer), tmbHead->ALCTMatchTime());
1955
1956
1957 if (tmbHead->ALCTMatchTime() != 6) {
1958 hALCTMatch2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), tmbHead->ALCTMatchTime());
1959 hALCTMatch2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1960 }
1961
1962 int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount() - clcts[0].getFullBX();
1963 if (TMB_CLCTpre_rel_L1A > 3563)
1964 TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
1965 if (TMB_CLCTpre_rel_L1A < 0)
1966 TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
1967
1968 hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
1969 hCLCTL1ASerial->Fill(chamberSerial(layer), TMB_CLCTpre_rel_L1A);
1970 hCLCTL1A2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), TMB_CLCTpre_rel_L1A);
1971 hCLCTL1A2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1972
1973 }
1974 }
1975 }
1976 }
1977 if (examiner != nullptr)
1978 delete examiner;
1979 }
1980 }
1981
1982 return;
1983 }
1984
1985 bool CSCOfflineMonitor::withinSensitiveRegion(LocalPoint localPos,
1986 const std::array<const float, 4>& layerBounds,
1987 int station,
1988 int ring,
1989 float shiftFromEdge,
1990 float shiftFromDeadZone) {
1991
1992 bool pass = false;
1993
1994 float y_center = 0.;
1995 double yUp = layerBounds[3] + y_center;
1996 double yDown = -layerBounds[3] + y_center;
1997 double xBound1Shifted = layerBounds[0] - shiftFromEdge;
1998 double xBound2Shifted = layerBounds[1] - shiftFromEdge;
1999 double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
2000 double lineConst = yUp - lineSlope * xBound2Shifted;
2001 double yBorder = lineSlope * abs(localPos.x()) + lineConst;
2002
2003
2004 std::vector<float> deadZoneCenter(6);
2005 float cutZone = shiftFromDeadZone;
2006
2007 if (station > 1 && station < 5) {
2008 if (2 == ring) {
2009 deadZoneCenter[0] = -162.48;
2010 deadZoneCenter[1] = -81.8744;
2011 deadZoneCenter[2] = -21.18165;
2012 deadZoneCenter[3] = 39.51105;
2013 deadZoneCenter[4] = 100.2939;
2014 deadZoneCenter[5] = 160.58;
2015
2016 if (localPos.y() > yBorder &&
2017 ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2018 (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2019 (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone) ||
2020 (localPos.y() > deadZoneCenter[3] + cutZone && localPos.y() < deadZoneCenter[4] - cutZone) ||
2021 (localPos.y() > deadZoneCenter[4] + cutZone && localPos.y() < deadZoneCenter[5] - cutZone))) {
2022 pass = true;
2023 }
2024 } else if (1 == ring) {
2025 if (2 == station) {
2026 deadZoneCenter[0] = -95.80;
2027 deadZoneCenter[1] = -27.47;
2028 deadZoneCenter[2] = 33.67;
2029 deadZoneCenter[3] = 90.85;
2030 } else if (3 == station) {
2031 deadZoneCenter[0] = -89.305;
2032 deadZoneCenter[1] = -39.705;
2033 deadZoneCenter[2] = 20.195;
2034 deadZoneCenter[3] = 77.395;
2035 } else if (4 == station) {
2036 deadZoneCenter[0] = -75.645;
2037 deadZoneCenter[1] = -26.055;
2038 deadZoneCenter[2] = 23.855;
2039 deadZoneCenter[3] = 70.575;
2040 }
2041 if (localPos.y() > yBorder &&
2042 ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2043 (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2044 (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2045 pass = true;
2046 }
2047 }
2048 } else if (1 == station) {
2049 if (3 == ring) {
2050 deadZoneCenter[0] = -83.155;
2051 deadZoneCenter[1] = -22.7401;
2052 deadZoneCenter[2] = 27.86665;
2053 deadZoneCenter[3] = 81.005;
2054 if (localPos.y() > yBorder &&
2055 ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2056 (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2057 (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2058 pass = true;
2059 }
2060 } else if (2 == ring) {
2061 deadZoneCenter[0] = -86.285;
2062 deadZoneCenter[1] = -32.88305;
2063 deadZoneCenter[2] = 32.867423;
2064 deadZoneCenter[3] = 88.205;
2065 if (localPos.y() > (yBorder) &&
2066 ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2067 (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2068 (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2069 pass = true;
2070 }
2071 } else {
2072 deadZoneCenter[0] = -81.0;
2073 deadZoneCenter[1] = 81.0;
2074 if (localPos.y() > (yBorder) &&
2075 (localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone)) {
2076 pass = true;
2077 }
2078 }
2079 }
2080 return pass;
2081 }
2082
2083 int CSCOfflineMonitor::typeIndex(CSCDetId id, int flag) {
2084
2085
2086 if (flag == 1) {
2087 int index = 0;
2088 if (id.station() == 1)
2089 index = id.ring();
2090 else
2091 index = id.station() * 2 + id.ring();
2092 if (id.endcap() == 1)
2093 index = index + 10;
2094 if (id.endcap() == 2)
2095 index = 11 - index;
2096 return index;
2097 }
2098
2099 else if (flag == 2) {
2100 int index = 0;
2101 if (id.station() == 1 && id.ring() != 4)
2102 index = id.ring() + 1;
2103 if (id.station() == 1 && id.ring() == 4)
2104 index = 1;
2105 if (id.station() != 1)
2106 index = id.station() * 2 + id.ring();
2107 if (id.endcap() == 1)
2108 index = index + 10;
2109 if (id.endcap() == 2)
2110 index = 11 - index;
2111 return index;
2112 }
2113
2114 else
2115 return 0;
2116 }
2117
2118 int CSCOfflineMonitor::chamberSerial(CSCDetId id) {
2119 int st = id.station();
2120 int ri = id.ring();
2121 int ch = id.chamber();
2122 int ec = id.endcap();
2123 int kSerial = ch;
2124 if (st == 1 && ri == 1)
2125 kSerial = ch;
2126 if (st == 1 && ri == 2)
2127 kSerial = ch + 36;
2128 if (st == 1 && ri == 3)
2129 kSerial = ch + 72;
2130 if (st == 1 && ri == 4)
2131 kSerial = ch;
2132 if (st == 2 && ri == 1)
2133 kSerial = ch + 108;
2134 if (st == 2 && ri == 2)
2135 kSerial = ch + 126;
2136 if (st == 3 && ri == 1)
2137 kSerial = ch + 162;
2138 if (st == 3 && ri == 2)
2139 kSerial = ch + 180;
2140 if (st == 4 && ri == 1)
2141 kSerial = ch + 216;
2142 if (st == 4 && ri == 2)
2143 kSerial = ch + 234;
2144 if (ec == 2)
2145 kSerial = kSerial + 300;
2146 return kSerial;
2147 }
2148
2149 void CSCOfflineMonitor::applyCSClabels(MonitorElement* me, LabelType t, AxisType a) {
2150 if (me != nullptr) {
2151 me->setAxisTitle("Chamber #");
2152 if (t == EXTENDED) {
2153 me->setBinLabel(1, "ME -4/2", a);
2154 me->setBinLabel(2, "ME -4/1", a);
2155 me->setBinLabel(3, "ME -3/2", a);
2156 me->setBinLabel(4, "ME -3/1", a);
2157 me->setBinLabel(5, "ME -2/2", a);
2158 me->setBinLabel(6, "ME -2/1", a);
2159 me->setBinLabel(7, "ME -1/3", a);
2160 me->setBinLabel(8, "ME -1/2", a);
2161 me->setBinLabel(9, "ME -1/1b", a);
2162 me->setBinLabel(10, "ME -1/1a", a);
2163 me->setBinLabel(11, "ME +1/1a", a);
2164 me->setBinLabel(12, "ME +1/1b", a);
2165 me->setBinLabel(13, "ME +1/2", a);
2166 me->setBinLabel(14, "ME +1/3", a);
2167 me->setBinLabel(15, "ME +2/1", a);
2168 me->setBinLabel(16, "ME +2/2", a);
2169 me->setBinLabel(17, "ME +3/1", a);
2170 me->setBinLabel(18, "ME +3/2", a);
2171 me->setBinLabel(19, "ME +4/1", a);
2172 me->setBinLabel(20, "ME +4/2", a);
2173 } else if (t == SMALL) {
2174 me->setBinLabel(1, "ME -4/1", a);
2175 me->setBinLabel(2, "ME -3/2", a);
2176 me->setBinLabel(3, "ME -3/1", a);
2177 me->setBinLabel(4, "ME -2/2", a);
2178 me->setBinLabel(5, "ME -2/1", a);
2179 me->setBinLabel(6, "ME -1/3", a);
2180 me->setBinLabel(7, "ME -1/2", a);
2181 me->setBinLabel(8, "ME -1/1b", a);
2182 me->setBinLabel(9, "ME -1/1a", a);
2183 me->setBinLabel(10, "ME +1/1a", a);
2184 me->setBinLabel(11, "ME +1/1b", a);
2185 me->setBinLabel(12, "ME +1/2", a);
2186 me->setBinLabel(13, "ME +1/3", a);
2187 me->setBinLabel(14, "ME +2/1", a);
2188 me->setBinLabel(15, "ME +2/2", a);
2189 me->setBinLabel(16, "ME +3/1", a);
2190 me->setBinLabel(17, "ME +3/2", a);
2191 me->setBinLabel(18, "ME +4/1", a);
2192 }
2193 }
2194 }
2195
2196 DEFINE_FWK_MODULE(CSCOfflineMonitor);
