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