Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-09-03 22:28:16

0001 /*
0002  *  Offline DQM module for CSC local reconstruction - based on CSCValidation
0003  *
0004  */
0005 
0006 #include "DQMOffline/Muon/interface/CSCOfflineMonitor.h"
0007 
0008 using namespace std;
0009 
0010 ///////////////////
0011 //  CONSTRUCTOR  //
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& /* iSetup */) {
0028   // occupancies
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   // wire digis
0057   ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Digis");
0058 
0059   // For low multiplicities (e.g. low or no pileup)
0060   hWirenGroupsTotal =
0061       ibooker.book1D("hWirenGroupsTotal", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 250.);  // 1 bin is 1
0062   // For high multiplcities (e.g. with pileup)
0063   hWirenGroupsTotalHi =
0064       ibooker.book1D("hWirenGroupsTotalHi", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 1000.);  // i bin is 4
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   // strip digis
0128 
0129   // For low multiplicities (e.g. low or no pileup)
0130   hStripNFired = ibooker.book1D(
0131       "hStripNFired", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 400, 0., 400.);  // 1 bin is 1
0132   // For high multiplcities (e.g. with pileup)
0133   hStripNFiredHi = ibooker.book1D(
0134       "hStripNFiredHi", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 500, 0., 2000.);  // 1 bin is 4
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   // pedestal noise
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   // rechits
0222   ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/recHits");
0223 
0224   // For low multiplicities (e.g. low or no pileup)
0225   hRHnrechits = ibooker.book1D("hRHnrechits", "RecHits per Event; # of RecHits", 100, 0., 100.);  // 1 bin is 1
0226   // For high multiplcities (e.g. with pileup)
0227   hRHnrechitsHi = ibooker.book1D("hRHnrechitsHi", "RecHits per Event; # of RecHits", 250, 0., 1000.);  // 1 bin is 4
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   // segments
0411   ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Segments");
0412 
0413   hSnSegments = ibooker.book1D("hSnSegments", "Segments per Event; # of Segments", 100, 0., 100.);  // 1 bin is 1
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   // resolution
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   // efficiency
0728   ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Efficiency");
0729 
0730   //      hSSTE = ibooker.book1D("hSSTE","hSSTE",40,0.5,40.5);
0731   //      hRHSTE = ibooker.book1D("hRHSTE","hRHSTE",40,0.5,40.5);
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   //      hSEff = ibooker.book1D("hSEff","Segment Efficiency",20,0.5,20.5);
0742   //      hRHEff = ibooker.book1D("hRHEff","recHit Efficiency",20,0.5,20.5);
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   //      hSEff2 = ibooker.book2D("hSEff2","Segment Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
0749   //      hRHEff2 = ibooker.book2D("hRHEff2","recHit Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
0750   //      hStripReadoutEff2 = ibooker.book2D("hStripReadoutEff2","strip readout ratio [(strip+clct+wires)/(clct+wires)] 2D",36,0.5,36.5, 20, 0.5, 20.5);
0751   //      hStripReadoutEff2->setAxisTitle("Chamber #");
0752   //      hStripEff2 = ibooker.book2D("hStripEff2","strip Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
0753   //      hWireEff2 = ibooker.book2D("hWireEff2","wire Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
0754   hSensitiveAreaEvt =
0755       ibooker.book2D("hSensitiveAreaEvt", "Events Passing Selection for Efficiency", 36, 0.5, 36.5, 20, 0.5, 20.5);
0756 
0757   // bx monitor for trigger synchronization
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   //      hALCTgetBXChamberMeans = ibooker.book1D("hALCTgetBXChamberMeans","Chamber Mean ALCT position in ALCT-L1A match window [BX]",60,0,6);
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   //      hALCTgetBX2DMeans = ibooker.book2D("hALCTgetBX2DMeans","ALCT position in ALCT-L1A match window [BX]",36,0.5,36.5,20,0.5,20.5);
0768   hALCTgetBX2Denominator =
0769       ibooker.book2D("hALCTgetBX2Denominator", "Number of ALCT Digis checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0770   //      hALCTgetBX2DMeans->setAxisTitle("Chamber #");
0771   hALCTgetBX2Denominator->setAxisTitle("Chamber #");
0772   hALCTMatch = ibooker.book1D("hALCTMatch", "ALCT position in ALCT-CLCT match window [BX]", 7, -0.5, 6.5);
0773   //      hALCTMatchChamberMeans = ibooker.book1D("hALCTMatchChamberMeans","Chamber Mean ALCT position in ALCT-CLCT match window [BX]",60,0,6);
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   //      hALCTMatch2DMeans = ibooker.book2D("hALCTMatch2DMeans","ALCT position in ALCT-CLCT match window [BX]",36,0.5,36.5,20,0.5,20.5);
0780   hALCTMatch2Denominator =
0781       ibooker.book2D("hALCTMatch2Denominator", "Number of ALCT-CLCT matches checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0782   //      hALCTMatch2DMeans->setAxisTitle("Chamber #");
0783   hALCTMatch2Denominator->setAxisTitle("Chamber #");
0784   hCLCTL1A = ibooker.book1D("hCLCTL1A", "L1A - CLCTpreTrigger at TMB [BX]", 40, 149.5, 189.5);
0785   //      hCLCTL1AChamberMeans = ibooker.book1D("hCLCTL1AChamberMeans","Chamber Mean L1A - CLCTpreTrigger at TMB [BX]",90,150,159);
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   //      hCLCTL1A2DMeans = ibooker.book2D("hCLCTL1A2DMeans","L1A - CLCTpreTrigger at TMB [BX]",36,0.5,36.5,20,0.5,20.5);
0792   hCLCTL1A2Denominator =
0793       ibooker.book2D("hCLCTL1A2Denominator", "Number of TMB CLCTs checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
0794 
0795   // labels
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   //      applyCSClabels(hSEff, EXTENDED, X);
0803   //      applyCSClabels(hRHEff, EXTENDED, X);
0804   //      applyCSClabels(hSEff2, SMALL, Y);
0805   applyCSClabels(hSSTE2, EXTENDED, Y);
0806   applyCSClabels(hEffDenominator, EXTENDED, Y);
0807   //      applyCSClabels(hRHEff2, SMALL, Y);
0808   applyCSClabels(hRHSTE2, EXTENDED, Y);
0809   //      applyCSClabels(hStripReadoutEff2, EXTENDED, Y);
0810   //      applyCSClabels(hStripEff2, SMALL, Y);
0811   applyCSClabels(hStripSTE2, EXTENDED, Y);
0812   //      applyCSClabels(hWireEff2, SMALL, Y);
0813   applyCSClabels(hWireSTE2, EXTENDED, Y);
0814   applyCSClabels(hSensitiveAreaEvt, EXTENDED, Y);
0815   //      applyCSClabels(hALCTgetBX2DMeans, EXTENDED, Y);
0816   applyCSClabels(hALCTgetBX2Denominator, EXTENDED, Y);
0817   //      applyCSClabels(hALCTMatch2DMeans, EXTENDED, Y);
0818   applyCSClabels(hALCTMatch2Denominator, EXTENDED, Y);
0819   //      applyCSClabels(hCLCTL1A2DMeans, EXTENDED, Y);
0820   applyCSClabels(hCLCTL1A2Denominator, EXTENDED, Y);
0821 }
0822 
0823 ////////////////
0824 //  Analysis  //
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   // Get the CSC Geometry :
0837   edm::ESHandle<CSCGeometry> cscGeom;
0838 
0839   cscGeom = eventSetup.getHandle(cscGeomToken_);
0840 
0841   // Get the RecHits collection :
0842   edm::Handle<CSCRecHit2DCollection> recHits;
0843   event.getByToken(rh_token, recHits);
0844 
0845   // get CSC segment collection
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 // look at Occupancies
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   //clcts
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       // Valid digi in the chamber (or in neighbouring chamber)
0906       if ((*digiIt).isValid()) {
0907         //Check whether this CLCT came from ME11a
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   //wires
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         //Also check for a CLCT in ME11a if you're in ME11 already
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     }  //end for loop
0939   }
0940 
0941   //strips
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             // check if there is a wire digi in this chamber too
0970             // for ME 1/4 check for a wire in ME 1/1
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           }  //end clct and wire digi check
0976         }
0977       }  //end if (thisStripFired)
0978     }
0979   }
0980 
0981   //rechits
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   //segments
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   //Overall CSC Occupancy
1013   hCSCOccupancy->Fill(1);
1014   if (hasWires)
1015     hCSCOccupancy->Fill(3);
1016   if (hasStrips)
1017     hCSCOccupancy->Fill(5);
1018   if (hasWires && hasStrips)
1019     hCSCOccupancy->Fill(7);
1020   if (hasRecHits)
1021     hCSCOccupancy->Fill(9);
1022   if (hasSegments)
1023     hCSCOccupancy->Fill(11);
1024 }
1025 
1026 // ==============================================
1027 //
1028 // look at WIRE DIGIs
1029 //
1030 // ==============================================
1031 
1032 void CSCOfflineMonitor::doWireDigis(edm::Handle<CSCWireDigiCollection> wires) {
1033   int nWireGroupsTotal = 0;
1034   for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1035     CSCDetId id = (CSCDetId)(*dWDiter).first;
1036     std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1037     std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1038     for (; wireIter != lWire; ++wireIter) {
1039       int myWire = wireIter->getWireGroup();
1040       int myTBin = wireIter->getTimeBin();
1041       nWireGroupsTotal++;
1042       hWireTBin[typeIndex(id) - 1]->Fill(myTBin);
1043       hWireNumber[typeIndex(id) - 1]->Fill(myWire);
1044     }
1045   }  // end wire loop
1046 
1047   hWirenGroupsTotal->Fill(nWireGroupsTotal);
1048   hWirenGroupsTotalHi->Fill(nWireGroupsTotal);
1049 }
1050 
1051 // ==============================================
1052 //
1053 // look at STRIP DIGIs
1054 //
1055 // ==============================================
1056 
1057 void CSCOfflineMonitor::doStripDigis(edm::Handle<CSCStripDigiCollection> strips) {
1058   int nStripsFired = 0;
1059   for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1060     CSCDetId id = (CSCDetId)(*dSDiter).first;
1061     std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1062     std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1063     for (; stripIter != lStrip; ++stripIter) {
1064       int myStrip = stripIter->getStrip();
1065       std::vector<int> myADCVals = stripIter->getADCCounts();
1066       bool thisStripFired = false;
1067       float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1068       float threshold = 13.3;
1069       float diff = 0.;
1070       for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1071         diff = (float)myADCVals[iCount] - thisPedestal;
1072         if (diff > threshold) {
1073           thisStripFired = true;
1074         }
1075       }
1076       if (thisStripFired) {
1077         nStripsFired++;
1078         hStripNumber[typeIndex(id) - 1]->Fill(myStrip);
1079       }
1080     }
1081   }  // end strip loop
1082 
1083   hStripNFired->Fill(nStripsFired);
1084   hStripNFiredHi->Fill(nStripsFired);
1085 
1086   // fill n per event
1087 }
1088 
1089 //=======================================================
1090 //
1091 // Look at the Pedestal Noise Distributions
1092 //
1093 //=======================================================
1094 
1095 void CSCOfflineMonitor::doPedestalNoise(edm::Handle<CSCStripDigiCollection> strips,
1096                                         edm::ESHandle<CSCGeometry> cscGeom) {
1097   for (CSCStripDigiCollection::DigiRangeIterator dPNiter = strips->begin(); dPNiter != strips->end(); dPNiter++) {
1098     CSCDetId id = (CSCDetId)(*dPNiter).first;
1099     int kStation = id.station();
1100     int kRing = id.ring();
1101     std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
1102     std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
1103     for (; pedIt != lStrip; ++pedIt) {
1104       int myStrip = pedIt->getStrip();
1105       std::vector<int> myADCVals = pedIt->getADCCounts();
1106       float TotalADC = getSignal(*strips, id, myStrip);
1107       bool thisStripFired = false;
1108       float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1109       float thisSignal =
1110           (1. / 6) * (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1111       float threshold = 13.3;
1112 
1113       // Why is this code block even here? Doesn't use myStrip after setting it (converts channel to strip
1114       // for ganged ME11A
1115       if ((kStation == 1 && kRing == 4) && cscGeom->gangedStrips()) {
1116         kRing = 1;
1117         if (myStrip <= 16)
1118           myStrip += 64;  // no trapping for any bizarreness
1119       }
1120 
1121       if (TotalADC > threshold) {
1122         thisStripFired = true;
1123       }
1124       if (!thisStripFired) {
1125         float ADC = thisSignal - thisPedestal;
1126         hStripPed[typeIndex(id) - 1]->Fill(ADC);
1127       }
1128     }
1129   }
1130 }
1131 
1132 // ==============================================
1133 //
1134 // look at RECHITs
1135 //
1136 // ==============================================
1137 
1138 void CSCOfflineMonitor::doRecHits(edm::Handle<CSCRecHit2DCollection> recHits,
1139                                   edm::Handle<CSCStripDigiCollection> strips,
1140                                   edm::ESHandle<CSCGeometry> cscGeom) {
1141   // Get the RecHits collection :
1142   int nRecHits = recHits->size();
1143 
1144   // ---------------------
1145   // Loop over rechits
1146   // ---------------------
1147   // Build iterator for rechits and loop :
1148   CSCRecHit2DCollection::const_iterator dRHIter;
1149   for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
1150     // Find chamber with rechits in CSC
1151     CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
1152 
1153     // Store rechit as a Local Point:
1154     LocalPoint rhitlocal = (*dRHIter).localPosition();
1155     //float xreco = rhitlocal.x();
1156     //float yreco = rhitlocal.y();
1157 
1158     // Get the reconstucted strip position and error
1159     float stpos = (*dRHIter).positionWithinStrip();
1160     float sterr = (*dRHIter).errorWithinStrip();
1161 
1162     /// Find the charge associated with this hit
1163 
1164     int adcsize = dRHIter->nStrips() * dRHIter->nTimeBins();
1165     float rHSumQ = 0;
1166     float sumsides = 0;
1167     for (unsigned int i = 0; i < dRHIter->nStrips(); i++) {
1168       for (unsigned int j = 0; j < dRHIter->nTimeBins() - 1; j++) {
1169         rHSumQ += dRHIter->adcs(i, j);
1170         if (i != 1)
1171           sumsides += dRHIter->adcs(i, j);  // skip central strip
1172       }
1173     }
1174 
1175     float rHratioQ = sumsides / rHSumQ;
1176     if (adcsize != 12)
1177       rHratioQ = -99;
1178 
1179     // Get the signal timing of this hit
1180     float rHtime = (*dRHIter).tpeak();          //calculated from cathode SCA bins
1181     float rHtimeAnode = (*dRHIter).wireTime();  // calculated from anode wire bx
1182 
1183     // Get pointer to the layer:
1184     const CSCLayer* csclayer = cscGeom->layer(idrec);
1185 
1186     // Transform hit position from local chamber geometry to global CMS geom
1187     GlobalPoint rhitglobal = csclayer->toGlobal(rhitlocal);
1188     float grecx = rhitglobal.x();
1189     float grecy = rhitglobal.y();
1190 
1191     // Fill some histograms
1192     int sIndex = idrec.station() + ((idrec.endcap() - 1) * 4);
1193     int tIndex = typeIndex(idrec);
1194     hRHSumQ[tIndex - 1]->Fill(rHSumQ);
1195     hRHRatioQ[tIndex - 1]->Fill(rHratioQ);
1196     hRHstpos[tIndex - 1]->Fill(stpos);
1197     hRHsterr[tIndex - 1]->Fill(sterr);
1198     hRHTiming[tIndex - 1]->Fill(rHtime);
1199     hRHTimingAnode[tIndex - 1]->Fill(rHtimeAnode);
1200     hRHGlobal[sIndex - 1]->Fill(grecx, grecy);
1201 
1202   }  //end rechit loop
1203 
1204   //  if (nRecHits == 0) nRecHits = -1; // I see no point in doing this
1205   hRHnrechits->Fill(nRecHits);
1206   hRHnrechitsHi->Fill(nRecHits);
1207 }
1208 
1209 // ==============================================
1210 //
1211 // look at SEGMENTs
1212 //
1213 // ===============================================
1214 
1215 void CSCOfflineMonitor::doSegments(edm::Handle<CSCSegmentCollection> cscSegments, edm::ESHandle<CSCGeometry> cscGeom) {
1216   // get CSC segment collection
1217   int nSegments = cscSegments->size();
1218 
1219   for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1220     CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1221     float chisq = (*dSiter).chi2();
1222     int nhits = (*dSiter).nRecHits();
1223     int nDOF = 2 * nhits - 4;
1224     float nChi2 = chisq / nDOF;
1225     double chisqProb = ChiSquaredProbability((double)chisq, nDOF);
1226     LocalPoint localPos = (*dSiter).localPosition();
1227     LocalVector segDir = (*dSiter).localDirection();
1228 
1229     // prepare to calculate segment times
1230     float timeCathode = 0;   //average from cathode information alone
1231     float timeAnode = 0;     //average from pruned anode information alone
1232     float timeCombined = 0;  //average from cathode hits and pruned anode list
1233     std::vector<float> cathodeTimes;
1234     std::vector<float> anodeTimes;
1235     // Get the CSC recHits that contribute to this segment.
1236     std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1237     for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1238       if (!((*iRH).isValid()))
1239         continue;  // only interested in valid hits
1240       cathodeTimes.push_back((*iRH).tpeak());
1241       anodeTimes.push_back((*iRH).wireTime());
1242     }  //end rechit loop
1243 
1244     // Calculate cathode average
1245     for (unsigned int i = 0; i < cathodeTimes.size(); i++)
1246       timeCathode += cathodeTimes[i] / cathodeTimes.size();
1247 
1248     // Prune the anode list to deal with the late tail
1249     float anodeMaxDiff;
1250     bool modified = false;
1251     std::vector<float>::iterator anodeMaxHit;
1252     do {
1253       if (anodeTimes.empty())
1254         continue;
1255       timeAnode = 0;
1256       anodeMaxDiff = 0;
1257       modified = false;
1258 
1259       // Find the average
1260       for (unsigned int j = 0; j < anodeTimes.size(); j++)
1261         timeAnode += anodeTimes[j] / anodeTimes.size();
1262 
1263       // Find the maximum outlier hit
1264       for (unsigned int j = 0; j < anodeTimes.size(); j++) {
1265         if (fabs(anodeTimes[j] - timeAnode) > anodeMaxDiff) {
1266           anodeMaxHit = anodeTimes.begin() + j;
1267           anodeMaxDiff = fabs(anodeTimes[j] - timeAnode);
1268         }
1269       }
1270 
1271       // Cut hit if its greater than some time away
1272       if (anodeMaxDiff > 26) {
1273         modified = true;
1274         anodeTimes.erase(anodeMaxHit);
1275       }
1276     } while (modified);
1277 
1278     // Calculate combined anode and cathode time average
1279     if (cathodeTimes.size() + anodeTimes.size() > 0)
1280       timeCombined = (timeCathode * cathodeTimes.size() + timeAnode * anodeTimes.size()) /
1281                      (cathodeTimes.size() + anodeTimes.size());
1282 
1283     // global transformation
1284     float globX = 0.;
1285     float globY = 0.;
1286     float globZ = 0.;
1287     float globTOF = 0.;
1288     float globTheta = 0.;
1289     float globPhi = 0.;
1290     const CSCChamber* cscchamber = cscGeom->chamber(id);
1291     if (cscchamber) {
1292       GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
1293       globX = globalPosition.x();
1294       globY = globalPosition.y();
1295       globZ = globalPosition.z();
1296       globTOF = sqrt(globX * globX + globY * globY + globZ * globZ);
1297       GlobalVector globalDirection = cscchamber->toGlobal(segDir);
1298       globTheta = globalDirection.theta();
1299       globPhi = globalDirection.phi();
1300     }
1301 
1302     // Fill histos
1303     int tIndex = typeIndex(id);
1304     hSnhitsAll->Fill(nhits);
1305     hSnhits[tIndex - 1]->Fill(nhits);
1306     hSChiSqAll->Fill(nChi2);
1307     hSChiSq[tIndex - 1]->Fill(nChi2);
1308     hSChiSqProbAll->Fill(chisqProb);
1309     hSChiSqProb[tIndex - 1]->Fill(chisqProb);
1310     hSGlobalTheta->Fill(globTheta);
1311     hSGlobalPhi->Fill(globPhi);
1312     hSTimeDiff->Fill(timeAnode - timeCathode);
1313     hSTimeDiffByChamberType[tIndex - 1]->Fill(timeAnode - timeCathode);
1314     hSTimeAnode->Fill(timeAnode);
1315     hSTimeAnodeByChamberType[tIndex - 1]->Fill(timeAnode);
1316     hSTimeCathode->Fill(timeCathode);
1317     hSTimeCathodeByChamberType[tIndex - 1]->Fill(timeCathode);
1318     hSTimeCombined->Fill(timeCombined);
1319     hSTimeCombinedByChamberType[tIndex - 1]->Fill(timeCombined);
1320     hSTimeDiffSerial->Fill(chamberSerial(id), timeAnode - timeCathode);
1321     hSTimeAnodeSerial->Fill(chamberSerial(id), timeAnode);
1322     hSTimeCathodeSerial->Fill(chamberSerial(id), timeCathode);
1323     hSTimeCombinedSerial->Fill(chamberSerial(id), timeCombined);
1324     hSTimeVsZ->Fill(globZ, timeCombined);
1325     hSTimeVsTOF->Fill(globTOF, timeCombined);
1326 
1327   }  // end segment loop
1328 
1329   hSnSegments->Fill(nSegments);
1330 }
1331 
1332 // ==============================================
1333 //
1334 // look at hit Resolution
1335 //
1336 // ==============================================
1337 void CSCOfflineMonitor::doResolution(edm::Handle<CSCSegmentCollection> cscSegments,
1338                                      edm::ESHandle<CSCGeometry> cscGeom) {
1339   for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1340     CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1341     //
1342     // try to get the CSC recHits that contribute to this segment.
1343     std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1344     int nRH = (*dSiter).nRecHits();
1345     int jRH = 0;
1346     CLHEP::HepMatrix sp(6, 1);
1347     CLHEP::HepMatrix se(6, 1);
1348     for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1349       jRH++;
1350       CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
1351       //int kEndcap  = idRH.endcap();
1352       int kRing = idRH.ring();
1353       int kStation = idRH.station();
1354       //int kChamber = idRH.chamber();
1355       int kLayer = idRH.layer();
1356 
1357       /// Find the strip containing this hit
1358       int centerid = iRH->nStrips() / 2 + 1;
1359       int centerStrip = iRH->channels(centerid - 1);
1360 
1361       // If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
1362       if (nRH == 6) {
1363         float stpos = (*iRH).positionWithinStrip();
1364         se(kLayer, 1) = (*iRH).errorWithinStrip();
1365         // Take into account half-strip staggering of layers (ME1/1 has no staggering)
1366         if (kStation == 1 && (kRing == 1 || kRing == 4))
1367           sp(kLayer, 1) = stpos + centerStrip;
1368         else {
1369           if (kLayer == 1 || kLayer == 3 || kLayer == 5)
1370             sp(kLayer, 1) = stpos + centerStrip;
1371           if (kLayer == 2 || kLayer == 4 || kLayer == 6)
1372             sp(kLayer, 1) = stpos - 0.5 + centerStrip;
1373         }
1374       }
1375     }
1376 
1377     // Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
1378     //    float residual = -99.; // used to fill always
1379     if (nRH == 6) {
1380       float expected = fitX(sp, se);
1381       float residual = expected - sp(3, 1);
1382 
1383       hSResid[typeIndex(id) - 1]->Fill(residual);  // fill here so stats make sense
1384     }
1385 
1386     //  hSResid[typeIndex(id)-1]->Fill(residual); // used to fill here but then stats distorted by underflows
1387 
1388   }  // end segment loop
1389 }
1390 
1391 //-------------------------------------------------------------------------------------
1392 // Fits a straight line to a set of 5 points with errors.  Functions assumes 6 points
1393 // and removes hit in layer 3.  It then returns the expected position value in layer 3
1394 // based on the fit.
1395 //-------------------------------------------------------------------------------------
1396 float CSCOfflineMonitor::fitX(const CLHEP::HepMatrix& points, const CLHEP::HepMatrix& errors) {
1397   float S = 0;
1398   float Sx = 0;
1399   float Sy = 0;
1400   float Sxx = 0;
1401   float Sxy = 0;
1402   float sigma2 = 0;
1403 
1404   for (int i = 1; i < 7; i++) {
1405     if (i != 3) {
1406       sigma2 = errors(i, 1) * errors(i, 1);
1407       S = S + (1 / sigma2);
1408       Sy = Sy + (points(i, 1) / sigma2);
1409       Sx = Sx + ((i) / sigma2);
1410       Sxx = Sxx + (i * i) / sigma2;
1411       Sxy = Sxy + (((i)*points(i, 1)) / sigma2);
1412     }
1413   }
1414 
1415   float delta = S * Sxx - Sx * Sx;
1416   float intercept = (Sxx * Sy - Sx * Sxy) / delta;
1417   float slope = (S * Sxy - Sx * Sy) / delta;
1418 
1419   return (intercept + slope * 3);
1420 }
1421 
1422 //---------------------------------------------------------------------------------------
1423 // Given a set of digis, the CSCDetId, and the central strip of your choosing, returns
1424 // the avg. Signal-Pedestal for 6 time bin x 5 strip .
1425 //
1426 // Author: P. Jindal
1427 //---------------------------------------------------------------------------------------
1428 
1429 float CSCOfflineMonitor::getSignal(const CSCStripDigiCollection& stripdigis, CSCDetId idCS, int centerStrip) {
1430   float SigADC[5];
1431   float TotalADC = 0;
1432   SigADC[0] = 0;
1433   SigADC[1] = 0;
1434   SigADC[2] = 0;
1435   SigADC[3] = 0;
1436   SigADC[4] = 0;
1437 
1438   // Loop over strip digis
1439   CSCStripDigiCollection::DigiRangeIterator sIt;
1440 
1441   for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++) {
1442     CSCDetId id = (CSCDetId)(*sIt).first;
1443     if (id == idCS) {
1444       // First, find the Signal-Pedestal for center strip
1445       vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
1446       vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
1447       for (; digiItr != last; ++digiItr) {
1448         int thisStrip = digiItr->getStrip();
1449         if (thisStrip == (centerStrip)) {
1450           std::vector<int> myADCVals = digiItr->getADCCounts();
1451           float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1452           float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1453           SigADC[0] = thisSignal - 6 * thisPedestal;
1454         }
1455         // Now,find the Signal-Pedestal for neighbouring 4 strips
1456         if (thisStrip == (centerStrip + 1)) {
1457           std::vector<int> myADCVals = digiItr->getADCCounts();
1458           float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1459           float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1460           SigADC[1] = thisSignal - 6 * thisPedestal;
1461         }
1462         if (thisStrip == (centerStrip + 2)) {
1463           std::vector<int> myADCVals = digiItr->getADCCounts();
1464           float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1465           float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1466           SigADC[2] = thisSignal - 6 * thisPedestal;
1467         }
1468         if (thisStrip == (centerStrip - 1)) {
1469           std::vector<int> myADCVals = digiItr->getADCCounts();
1470           float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1471           float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1472           SigADC[3] = thisSignal - 6 * thisPedestal;
1473         }
1474         if (thisStrip == (centerStrip - 2)) {
1475           std::vector<int> myADCVals = digiItr->getADCCounts();
1476           float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1477           float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1478           SigADC[4] = thisSignal - 6 * thisPedestal;
1479         }
1480       }
1481       TotalADC = 0.2 * (SigADC[0] + SigADC[1] + SigADC[2] + SigADC[3] + SigADC[4]);
1482     }
1483   }
1484   return TotalADC;
1485 }
1486 
1487 //----------------------------------------------------------------------------
1488 // Calculate basic efficiencies for recHits and Segments
1489 // Author: S. Stoynev
1490 //----------------------------------------------------------------------------
1491 
1492 void CSCOfflineMonitor::doEfficiencies(edm::Handle<CSCWireDigiCollection> wires,
1493                                        edm::Handle<CSCStripDigiCollection> strips,
1494                                        edm::Handle<CSCRecHit2DCollection> recHits,
1495                                        edm::Handle<CSCSegmentCollection> cscSegments,
1496                                        edm::ESHandle<CSCGeometry> cscGeom) {
1497   bool allWires[2][4][4][36][6];
1498   bool allStrips[2][4][4][36][6];
1499   bool AllRecHits[2][4][4][36][6];
1500   bool AllSegments[2][4][4][36];
1501 
1502   //bool MultiSegments[2][4][4][36];
1503   for (int iE = 0; iE < 2; iE++) {
1504     for (int iS = 0; iS < 4; iS++) {
1505       for (int iR = 0; iR < 4; iR++) {
1506         for (int iC = 0; iC < 36; iC++) {
1507           AllSegments[iE][iS][iR][iC] = false;
1508           //MultiSegments[iE][iS][iR][iC] = false;
1509           for (int iL = 0; iL < 6; iL++) {
1510             allWires[iE][iS][iR][iC][iL] = false;
1511             allStrips[iE][iS][iR][iC][iL] = false;
1512             AllRecHits[iE][iS][iR][iC][iL] = false;
1513           }
1514         }
1515       }
1516     }
1517   }
1518 
1519   // Wires
1520   for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1521     CSCDetId idrec = (CSCDetId)(*dWDiter).first;
1522     std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1523     std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1524     for (; wireIter != lWire; ++wireIter) {
1525       allWires[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1526           true;
1527       break;
1528     }
1529   }
1530 
1531   //---- STRIPS
1532   for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1533     CSCDetId idrec = (CSCDetId)(*dSDiter).first;
1534     std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1535     std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1536     for (; stripIter != lStrip; ++stripIter) {
1537       std::vector<int> myADCVals = stripIter->getADCCounts();
1538       bool thisStripFired = false;
1539       float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1540       float threshold = 13.3;
1541       float diff = 0.;
1542       for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1543         diff = (float)myADCVals[iCount] - thisPedestal;
1544         if (diff > threshold) {
1545           thisStripFired = true;
1546           break;
1547         }
1548       }
1549       if (thisStripFired) {
1550         allStrips[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1551             true;
1552         break;
1553       }
1554     }
1555   }
1556 
1557   // Rechits
1558   for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
1559     //CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
1560     CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
1561     AllRecHits[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1562         true;
1563   }
1564 
1565   std::vector<uint> seg_ME2(2, 0);
1566   std::vector<uint> seg_ME3(2, 0);
1567   std::vector<pair<CSCDetId, CSCSegment> > theSegments(4);
1568   // Segments
1569   for (CSCSegmentCollection::const_iterator segEffIt = cscSegments->begin(); segEffIt != cscSegments->end();
1570        segEffIt++) {
1571     CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
1572     //if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
1573     //MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
1574     //}
1575     AllSegments[idseg.endcap() - 1][idseg.station() - 1][idseg.ring() - 1][idseg.chamber() - 1] = true;
1576     // "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
1577     // station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
1578     // station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
1579     if (2 == idseg.station() || 3 == idseg.station()) {
1580       uint seg_tmp;
1581       if (2 == idseg.station()) {
1582         ++seg_ME2[idseg.endcap() - 1];
1583         seg_tmp = seg_ME2[idseg.endcap() - 1];
1584       } else {
1585         ++seg_ME3[idseg.endcap() - 1];
1586         seg_tmp = seg_ME3[idseg.endcap() - 1];
1587       }
1588       // is the segment good
1589       if (1 == seg_tmp && 6 == (*segEffIt).nRecHits() && (*segEffIt).chi2() / (*segEffIt).degreesOfFreedom() < 3.) {
1590         pair<CSCDetId, CSCSegment> specSeg = make_pair((CSCDetId)(*segEffIt).cscDetId(), *segEffIt);
1591         theSegments[2 * (idseg.endcap() - 1) + (idseg.station() - 2)] = specSeg;
1592       }
1593     }
1594     /*
1595     if(2==idseg.station()){
1596     ++seg_ME2[idseg.endcap() -1];
1597        if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1598            pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1599            theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1600        }
1601     }
1602     else if(3==idseg.station()){
1603     ++seg_ME3[idseg.endcap() -1];
1604     if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1605          pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1606      theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1607        }
1608     }
1609     */
1610   }
1611   // Simple efficiency calculations
1612   for (int iE = 0; iE < 2; iE++) {
1613     for (int iS = 0; iS < 4; iS++) {
1614       for (int iR = 0; iR < 4; iR++) {
1615         for (int iC = 0; iC < 36; iC++) {
1616           int NumberOfLayers = 0;
1617           for (int iL = 0; iL < 6; iL++) {
1618             if (AllRecHits[iE][iS][iR][iC][iL]) {
1619               NumberOfLayers++;
1620             }
1621           }
1622 
1623           // set bin = 1-10 for ME-42, ME-41,...ME-11B, ME-11A,
1624           //           11-20 for ME+11A, ME+11B, ... ME+41, ME+42
1625           int bin = CSCDetId::iChamberType(iS + 1, iR + 1);  // 1-10 for ME11A...ME42
1626           if (iE > 0) {                                      // in this loop iE=1 is -z endcap
1627             bin = 11 - bin;
1628           } else {  // in this loop iE=0 is +z endcap
1629             bin += 10;
1630           }
1631 
1632           if (NumberOfLayers > 1) {
1633             //if(!(MultiSegments[iE][iS][iR][iC])){
1634             if (AllSegments[iE][iS][iR][iC]) {
1635               //---- Efficient segment evenents
1636               hSnum->Fill(bin);
1637             }
1638             //---- All segment events (normalization)
1639             hSden->Fill(bin);
1640             //}
1641           }
1642           if (AllSegments[iE][iS][iR][iC]) {
1643             if (NumberOfLayers == 6) {
1644               //---- Efficient rechit events
1645               hRHnum->Fill(bin);
1646               ;
1647             }
1648             //---- All rechit events (normalization)
1649             hRHden->Fill(bin);
1650             ;
1651           }
1652         }
1653       }
1654     }
1655   }
1656 
1657   // pick a segment only if there are no others in the station
1658   std::vector<pair<CSCDetId, CSCSegment>*> theSeg;
1659   if (1 == seg_ME2[0])
1660     theSeg.push_back(&theSegments[0]);
1661   if (1 == seg_ME3[0])
1662     theSeg.push_back(&theSegments[1]);
1663   if (1 == seg_ME2[1])
1664     theSeg.push_back(&theSegments[2]);
1665   if (1 == seg_ME3[1])
1666     theSeg.push_back(&theSegments[3]);
1667 
1668   if (!theSeg.empty()) {
1669     std::map<int, GlobalPoint> extrapolatedPoint;
1670     std::map<int, GlobalPoint>::iterator it;
1671     const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
1672     // Pick which chamber with which segment to test
1673     for (unsigned int nCh = 0; nCh < ChamberContainer.size(); nCh++) {
1674       const CSCChamber* cscchamber = ChamberContainer[nCh];
1675       pair<CSCDetId, CSCSegment>* thisSegment = nullptr;
1676       for (uint iSeg = 0; iSeg < theSeg.size(); ++iSeg) {
1677         if (cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()) {
1678           if (1 == cscchamber->id().station() || 3 == cscchamber->id().station()) {
1679             if (2 == theSeg[iSeg]->first.station()) {
1680               thisSegment = theSeg[iSeg];
1681             }
1682           } else if (2 == cscchamber->id().station() || 4 == cscchamber->id().station()) {
1683             if (3 == theSeg[iSeg]->first.station()) {
1684               thisSegment = theSeg[iSeg];
1685             }
1686           }
1687         }
1688       }
1689       // this chamber is to be tested with thisSegment
1690       if (thisSegment) {
1691         CSCSegment* seg = &(thisSegment->second);
1692         const CSCChamber* segChamber = cscGeom->chamber(thisSegment->first);
1693         LocalPoint localCenter(0., 0., 0);
1694         GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
1695         // try to save some time (extrapolate a segment to a certain position only once)
1696         it = extrapolatedPoint.find(int(cscchamberCenter.z()));
1697         if (it == extrapolatedPoint.end()) {
1698           GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
1699           GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
1700           double paramaterLine = lineParametrization(segPos.z(), cscchamberCenter.z(), segDir.z());
1701           double xExtrapolated = extrapolate1D(segPos.x(), segDir.x(), paramaterLine);
1702           double yExtrapolated = extrapolate1D(segPos.y(), segDir.y(), paramaterLine);
1703           GlobalPoint globP(xExtrapolated, yExtrapolated, cscchamberCenter.z());
1704           extrapolatedPoint[int(cscchamberCenter.z())] = globP;
1705         }
1706         // Where does the extrapolated point lie in the (tested) chamber local frame? Here:
1707         LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
1708         const CSCLayer* layer_p = cscchamber->layer(1);  //layer 1
1709         const CSCLayerGeometry* layerGeom = layer_p->geometry();
1710         const std::array<const float, 4>& layerBounds = layerGeom->parameters();
1711         float shiftFromEdge = 15.;  //cm
1712         float shiftFromDeadZone = 10.;
1713         // is the extrapolated point within a sensitive region
1714         bool pass = withinSensitiveRegion(extrapolatedPointLocal,
1715                                           layerBounds,
1716                                           cscchamber->id().station(),
1717                                           cscchamber->id().ring(),
1718                                           shiftFromEdge,
1719                                           shiftFromDeadZone);
1720         if (pass) {  // the extrapolation point of the segment lies within sensitive region of that chamber
1721           // how many rechit layers are there in the chamber?
1722           // 0 - maybe the muon died or is deflected at large angle? do not use that case
1723           // 1 - could be noise...
1724           // 2 or more - this is promissing; this is our definition of a reliable signal; use it below
1725           // is other definition better?
1726           int nRHLayers = 0;
1727           for (int iL = 0; iL < 6; ++iL) {
1728             if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1729                           [cscchamber->id().chamber() - 1][iL]) {
1730               ++nRHLayers;
1731             }
1732           }
1733 
1734           // set verticalScale to 1-10 for ME-42...ME-11A,
1735           //                     11-20 for ME+11A...ME+42
1736           float verticalScale =
1737               9. + cscchamber->id().endcap() + (cscchamber->specs()->chamberType()) * (cscchamber->id().zendcap());
1738 
1739           hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()), verticalScale);
1740           if (nRHLayers > 1) {  // this chamber contains a reliable signal
1741             // this is the denominator for all efficiencies
1742             hEffDenominator->Fill(float(cscchamber->id().chamber()), verticalScale);
1743             // Segment efficiency
1744             if (AllSegments[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1745                            [cscchamber->id().chamber() - 1]) {
1746               hSSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale));
1747             }
1748 
1749             for (int iL = 0; iL < 6; ++iL) {
1750               float weight = 1. / 6.;
1751               // should account for the weight in the efficiency...
1752               // Rechit efficiency
1753               if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1754                             [cscchamber->id().chamber() - 1][iL]) {
1755                 hRHSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1756               }
1757               // Wire efficiency
1758               if (allWires[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1759                           [cscchamber->id().chamber() - 1][iL]) {
1760                 // one shold account for the weight in the efficiency...
1761                 hWireSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1762               }
1763               // Strip efficiency
1764               if (allStrips[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1765                            [cscchamber->id().chamber() - 1][iL]) {
1766                 // one shold account for the weight in the efficiency...
1767                 hStripSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1768               }
1769             }
1770           }
1771         }
1772       }
1773     }
1774   }
1775   //
1776 }
1777 
1778 // ==============================================
1779 //
1780 // Look at BX level trigger synchronization
1781 //
1782 // ==============================================
1783 
1784 void CSCOfflineMonitor::doBXMonitor(edm::Handle<CSCALCTDigiCollection> alcts,
1785                                     edm::Handle<CSCCLCTDigiCollection> clcts,
1786                                     const edm::Event& event,
1787                                     const edm::EventSetup& eventSetup) {
1788   // Loop over ALCTDigis
1789 
1790   for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
1791     const CSCDetId& idALCT = (*j).first;
1792     const CSCALCTDigiCollection::Range& range = (*j).second;
1793     for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1794       // Valid digi in the chamber (or in neighbouring chamber)
1795       if ((*digiIt).isValid()) {
1796         hALCTgetBX->Fill((*digiIt).getBX());
1797         hALCTgetBXSerial->Fill(chamberSerial(idALCT), (*digiIt).getBX());
1798         hALCTgetBX2DNumerator->Fill(idALCT.chamber(), typeIndex(idALCT, 2), (*digiIt).getBX());
1799         hALCTgetBX2Denominator->Fill(idALCT.chamber(), typeIndex(idALCT, 2));
1800       }
1801     }
1802   }  // end ALCT Digi loop
1803 
1804   // Loop over raw data to get TMBHeader information
1805   // Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
1806   edm::ESHandle<CSCCrateMap> hcrate;
1807 
1808   hcrate = eventSetup.getHandle(hcrateToken_);
1809 
1810   const CSCCrateMap* pcrate = hcrate.product();
1811 
1812   // Try to get raw data
1813   edm::Handle<FEDRawDataCollection> rawdata;
1814   if (!(event.getByToken(rd_token, rawdata))) {
1815     edm::LogWarning("CSCOfflineMonitor") << " FEDRawDataCollection not available";
1816     return;
1817   }
1818 
1819   bool goodEvent = false;
1820   unsigned long dccBinCheckMask = 0x06080016;
1821   unsigned int examinerMask = 0x1FEBF3F6;
1822   unsigned int errorMask = 0x0;
1823 
1824   // For new CSC readout layout, which doesn't include DCCs need to loop over DDU FED IDs.
1825   // DCC IDs are included for backward compatibility with old data
1826   std::vector<unsigned int> cscFEDids;
1827 
1828   for (unsigned int id = FEDNumbering::MINCSCFEDID; id <= FEDNumbering::MAXCSCFEDID; ++id)  // loop over DCCs
1829   {
1830     cscFEDids.push_back(id);
1831   }
1832 
1833   for (unsigned int id = FEDNumbering::MINCSCDDUFEDID; id <= FEDNumbering::MAXCSCDDUFEDID; ++id)  // loop over DDUs
1834   {
1835     cscFEDids.push_back(id);
1836   }
1837 
1838   for (unsigned int i = 0; i < cscFEDids.size(); i++)  // loop over all CSC FEDs (DCCs and DDUs)
1839   {
1840     unsigned int id = cscFEDids[i];
1841     bool isDDU_FED = ((id >= FEDNumbering::MINCSCDDUFEDID) && (id <= FEDNumbering::MAXCSCDDUFEDID)) ? true : false;
1842 
1843     /// uncomment this for regional unpacking
1844     /// if (id!=SOME_ID) continue;
1845 
1846     /// Take a reference to this FED's data
1847     const FEDRawData& fedData = rawdata->FEDData(id);
1848     unsigned long length = fedData.size();
1849 
1850     if (length >= 32) {  ///if fed has data then unpack it
1851       CSCDCCExaminer* examiner = nullptr;
1852       std::stringstream examiner_out, examiner_err;
1853       goodEvent = true;
1854       examiner = new CSCDCCExaminer();
1855       if (examinerMask & 0x40000)
1856         examiner->crcCFEB(true);
1857       if (examinerMask & 0x8000)
1858         examiner->crcTMB(true);
1859       if (examinerMask & 0x0400)
1860         examiner->crcALCT(true);
1861       examiner->setMask(examinerMask);
1862       const short unsigned int* data = (short unsigned int*)fedData.data();
1863 
1864       int res = examiner->check(data, long(fedData.size() / 2));
1865       if (res < 0) {
1866         goodEvent = false;
1867       } else {
1868         goodEvent = !(examiner->errors() & dccBinCheckMask);
1869       }
1870 
1871       if (goodEvent) {
1872         ///get a pointer to data and pass it to constructor for unpacking
1873 
1874         CSCDCCExaminer* ptrExaminer = examiner;
1875 
1876         std::vector<CSCDDUEventData> fed_Data;
1877         std::vector<CSCDDUEventData>* ptr_fedData = &fed_Data;
1878 
1879         if (isDDU_FED)  // Use new DDU FED readout mode
1880         {
1881           CSCDDUEventData single_dduData((short unsigned int*)fedData.data(), ptrExaminer);
1882           fed_Data.push_back(single_dduData);
1883 
1884         } else  // Use old DCC FED readout mode
1885         {
1886           CSCDCCEventData dccData((short unsigned int*)fedData.data(), ptrExaminer);
1887           fed_Data = dccData.dduData();
1888         }
1889 
1890         ///get a reference to dduData
1891         const std::vector<CSCDDUEventData>& dduData = *ptr_fedData;
1892 
1893         /// set default detid to that for E=+z, S=1, R=1, C=1, L=1
1894         CSCDetId layer(1, 1, 1, 1, 1);
1895         for (unsigned int iDDU = 0; iDDU < dduData.size(); ++iDDU) {  // loop over DDUs
1896           /// skip the DDU if its data has serious errors
1897           /// define a mask for serious errors
1898           if (dduData[iDDU].trailer().errorstat() & errorMask) {
1899             LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! "
1900                                                     << std::hex << dduData[iDDU].trailer().errorstat();
1901             continue;  // to next iteration of DDU loop
1902           }
1903 
1904           ///get a reference to chamber data
1905           const std::vector<CSCEventData>& cscData = dduData[iDDU].cscData();
1906 
1907           for (unsigned int iCSC = 0; iCSC < cscData.size(); ++iCSC) {  // loop over CSCs
1908 
1909             ///first process chamber-wide digis such as LCT
1910             int vmecrate = cscData[iCSC].dmbHeader()->crateID();
1911             int dmb = cscData[iCSC].dmbHeader()->dmbID();
1912 
1913             int icfeb = 0;   /// default value for all digis not related to cfebs
1914             int ilayer = 0;  /// layer=0 flags entire chamber
1915 
1916             if ((vmecrate >= 1) && (vmecrate <= 60) && (dmb >= 1) && (dmb <= 10) && (dmb != 6)) {
1917               layer = pcrate->detId(vmecrate, dmb, icfeb, ilayer);
1918             } else {
1919               LogTrace("CSCOfflineMonitor") << " detID input out of range!!! ";
1920               LogTrace("CSCOfflineMonitor") << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
1921               continue;  // to next iteration of iCSC loop
1922             }
1923 
1924             /// check alct data integrity
1925             int nalct = cscData[iCSC].dmbHeader()->nalct();
1926             bool goodALCT = false;
1927             //if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
1928             if (nalct && cscData[iCSC].alctHeader()) {
1929               if (cscData[iCSC].alctHeader()->check()) {
1930                 goodALCT = true;
1931               }
1932             }
1933 
1934             ///check tmb data integrity
1935             int nclct = cscData[iCSC].dmbHeader()->nclct();
1936             bool goodTMB = false;
1937             if (nclct && cscData[iCSC].tmbData()) {
1938               if (cscData[iCSC].tmbHeader()->check()) {
1939                 if (cscData[iCSC].comparatorData()->check())
1940                   goodTMB = true;
1941               }
1942             }
1943 
1944             if (goodTMB && goodALCT) {
1945               const CSCTMBHeader* tmbHead = cscData[iCSC].tmbHeader();
1946               std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
1947               if (clcts.empty() || !(clcts[0].isValid()))
1948                 continue;
1949               // Check if the CLCT was in ME11a (ring 4)
1950               if (layer.station() == 1 && layer.ring() == 1 && clcts[0].getKeyStrip() > 128) {
1951                 layer = CSCDetId(layer.endcap(), layer.station(), 4, layer.chamber());
1952               }
1953               hALCTMatch->Fill(tmbHead->ALCTMatchTime());
1954               hALCTMatchSerial->Fill(chamberSerial(layer), tmbHead->ALCTMatchTime());
1955               // Only fill big 2D display if ALCTMatchTime !=6, since this bin is polluted by the CLCT only triggers
1956               // One will have to look at the serial plots to see if the are a lot of entries here
1957               if (tmbHead->ALCTMatchTime() != 6) {
1958                 hALCTMatch2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), tmbHead->ALCTMatchTime());
1959                 hALCTMatch2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1960               }
1961 
1962               int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount() - clcts[0].getFullBX();
1963               if (TMB_CLCTpre_rel_L1A > 3563)
1964                 TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
1965               if (TMB_CLCTpre_rel_L1A < 0)
1966                 TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
1967 
1968               hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
1969               hCLCTL1ASerial->Fill(chamberSerial(layer), TMB_CLCTpre_rel_L1A);
1970               hCLCTL1A2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), TMB_CLCTpre_rel_L1A);
1971               hCLCTL1A2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1972 
1973             }  // end if goodTMB and goodALCT
1974           }    // end loop CSCData
1975         }      // end loop DDU
1976       }        // end if good event
1977       if (examiner != nullptr)
1978         delete examiner;
1979     }  // end if non-zero fed data
1980   }    // end DCC loop for NON-REFERENCE
1981 
1982   return;
1983 }
1984 
1985 bool CSCOfflineMonitor::withinSensitiveRegion(LocalPoint localPos,
1986                                               const std::array<const float, 4>& layerBounds,
1987                                               int station,
1988                                               int ring,
1989                                               float shiftFromEdge,
1990                                               float shiftFromDeadZone) {
1991   //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
1992   bool pass = false;
1993 
1994   float y_center = 0.;
1995   double yUp = layerBounds[3] + y_center;
1996   double yDown = -layerBounds[3] + y_center;
1997   double xBound1Shifted = layerBounds[0] - shiftFromEdge;  //
1998   double xBound2Shifted = layerBounds[1] - shiftFromEdge;  //
1999   double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
2000   double lineConst = yUp - lineSlope * xBound2Shifted;
2001   double yBorder = lineSlope * abs(localPos.x()) + lineConst;
2002 
2003   //bool withinChamberOnly = false;// false = "good region"; true - boundaries only
2004   std::vector<float> deadZoneCenter(6);
2005   float cutZone = shiftFromDeadZone;  //cm
2006   //---- hardcoded... not good
2007   if (station > 1 && station < 5) {
2008     if (2 == ring) {
2009       deadZoneCenter[0] = -162.48;
2010       deadZoneCenter[1] = -81.8744;
2011       deadZoneCenter[2] = -21.18165;
2012       deadZoneCenter[3] = 39.51105;
2013       deadZoneCenter[4] = 100.2939;
2014       deadZoneCenter[5] = 160.58;
2015 
2016       if (localPos.y() > yBorder &&
2017           ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2018            (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2019            (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone) ||
2020            (localPos.y() > deadZoneCenter[3] + cutZone && localPos.y() < deadZoneCenter[4] - cutZone) ||
2021            (localPos.y() > deadZoneCenter[4] + cutZone && localPos.y() < deadZoneCenter[5] - cutZone))) {
2022         pass = true;
2023       }
2024     } else if (1 == ring) {
2025       if (2 == station) {
2026         deadZoneCenter[0] = -95.80;
2027         deadZoneCenter[1] = -27.47;
2028         deadZoneCenter[2] = 33.67;
2029         deadZoneCenter[3] = 90.85;
2030       } else if (3 == station) {
2031         deadZoneCenter[0] = -89.305;
2032         deadZoneCenter[1] = -39.705;
2033         deadZoneCenter[2] = 20.195;
2034         deadZoneCenter[3] = 77.395;
2035       } else if (4 == station) {
2036         deadZoneCenter[0] = -75.645;
2037         deadZoneCenter[1] = -26.055;
2038         deadZoneCenter[2] = 23.855;
2039         deadZoneCenter[3] = 70.575;
2040       }
2041       if (localPos.y() > yBorder &&
2042           ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2043            (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2044            (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2045         pass = true;
2046       }
2047     }
2048   } else if (1 == station) {
2049     if (3 == ring) {
2050       deadZoneCenter[0] = -83.155;
2051       deadZoneCenter[1] = -22.7401;
2052       deadZoneCenter[2] = 27.86665;
2053       deadZoneCenter[3] = 81.005;
2054       if (localPos.y() > yBorder &&
2055           ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2056            (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2057            (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2058         pass = true;
2059       }
2060     } else if (2 == ring) {
2061       deadZoneCenter[0] = -86.285;
2062       deadZoneCenter[1] = -32.88305;
2063       deadZoneCenter[2] = 32.867423;
2064       deadZoneCenter[3] = 88.205;
2065       if (localPos.y() > (yBorder) &&
2066           ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2067            (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2068            (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2069         pass = true;
2070       }
2071     } else {
2072       deadZoneCenter[0] = -81.0;
2073       deadZoneCenter[1] = 81.0;
2074       if (localPos.y() > (yBorder) &&
2075           (localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone)) {
2076         pass = true;
2077       }
2078     }
2079   }
2080   return pass;
2081 }
2082 
2083 int CSCOfflineMonitor::typeIndex(CSCDetId id, int flag) {
2084   // linearized index based on endcap, station, and ring
2085 
2086   if (flag == 1) {
2087     int index = 0;
2088     if (id.station() == 1)
2089       index = id.ring();
2090     else
2091       index = id.station() * 2 + id.ring();
2092     if (id.endcap() == 1)
2093       index = index + 10;
2094     if (id.endcap() == 2)
2095       index = 11 - index;
2096     return index;
2097   }
2098 
2099   else if (flag == 2) {
2100     int index = 0;
2101     if (id.station() == 1 && id.ring() != 4)
2102       index = id.ring() + 1;
2103     if (id.station() == 1 && id.ring() == 4)
2104       index = 1;
2105     if (id.station() != 1)
2106       index = id.station() * 2 + id.ring();
2107     if (id.endcap() == 1)
2108       index = index + 10;
2109     if (id.endcap() == 2)
2110       index = 11 - index;
2111     return index;
2112   }
2113 
2114   else
2115     return 0;
2116 }
2117 
2118 int CSCOfflineMonitor::chamberSerial(CSCDetId id) {
2119   int st = id.station();
2120   int ri = id.ring();
2121   int ch = id.chamber();
2122   int ec = id.endcap();
2123   int kSerial = ch;
2124   if (st == 1 && ri == 1)
2125     kSerial = ch;
2126   if (st == 1 && ri == 2)
2127     kSerial = ch + 36;
2128   if (st == 1 && ri == 3)
2129     kSerial = ch + 72;
2130   if (st == 1 && ri == 4)
2131     kSerial = ch;
2132   if (st == 2 && ri == 1)
2133     kSerial = ch + 108;
2134   if (st == 2 && ri == 2)
2135     kSerial = ch + 126;
2136   if (st == 3 && ri == 1)
2137     kSerial = ch + 162;
2138   if (st == 3 && ri == 2)
2139     kSerial = ch + 180;
2140   if (st == 4 && ri == 1)
2141     kSerial = ch + 216;
2142   if (st == 4 && ri == 2)
2143     kSerial = ch + 234;  // from 2014
2144   if (ec == 2)
2145     kSerial = kSerial + 300;
2146   return kSerial;
2147 }
2148 
2149 void CSCOfflineMonitor::applyCSClabels(MonitorElement* me, LabelType t, AxisType a) {
2150   if (me != nullptr) {
2151     me->setAxisTitle("Chamber #");
2152     if (t == EXTENDED) {
2153       me->setBinLabel(1, "ME -4/2", a);
2154       me->setBinLabel(2, "ME -4/1", a);
2155       me->setBinLabel(3, "ME -3/2", a);
2156       me->setBinLabel(4, "ME -3/1", a);
2157       me->setBinLabel(5, "ME -2/2", a);
2158       me->setBinLabel(6, "ME -2/1", a);
2159       me->setBinLabel(7, "ME -1/3", a);
2160       me->setBinLabel(8, "ME -1/2", a);
2161       me->setBinLabel(9, "ME -1/1b", a);
2162       me->setBinLabel(10, "ME -1/1a", a);
2163       me->setBinLabel(11, "ME +1/1a", a);
2164       me->setBinLabel(12, "ME +1/1b", a);
2165       me->setBinLabel(13, "ME +1/2", a);
2166       me->setBinLabel(14, "ME +1/3", a);
2167       me->setBinLabel(15, "ME +2/1", a);
2168       me->setBinLabel(16, "ME +2/2", a);
2169       me->setBinLabel(17, "ME +3/1", a);
2170       me->setBinLabel(18, "ME +3/2", a);
2171       me->setBinLabel(19, "ME +4/1", a);
2172       me->setBinLabel(20, "ME +4/2", a);
2173     } else if (t == SMALL) {
2174       me->setBinLabel(1, "ME -4/1", a);
2175       me->setBinLabel(2, "ME -3/2", a);
2176       me->setBinLabel(3, "ME -3/1", a);
2177       me->setBinLabel(4, "ME -2/2", a);
2178       me->setBinLabel(5, "ME -2/1", a);
2179       me->setBinLabel(6, "ME -1/3", a);
2180       me->setBinLabel(7, "ME -1/2", a);
2181       me->setBinLabel(8, "ME -1/1b", a);
2182       me->setBinLabel(9, "ME -1/1a", a);
2183       me->setBinLabel(10, "ME +1/1a", a);
2184       me->setBinLabel(11, "ME +1/1b", a);
2185       me->setBinLabel(12, "ME +1/2", a);
2186       me->setBinLabel(13, "ME +1/3", a);
2187       me->setBinLabel(14, "ME +2/1", a);
2188       me->setBinLabel(15, "ME +2/2", a);
2189       me->setBinLabel(16, "ME +3/1", a);
2190       me->setBinLabel(17, "ME +3/2", a);
2191       me->setBinLabel(18, "ME +4/1", a);
2192     }
2193   }
2194 }
2195 
2196 DEFINE_FWK_MODULE(CSCOfflineMonitor);