Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 14:32:52

0001 /** \file GlobalRecHitsAnalyzer.cc
0002  *  
0003  *  See header file for description of class
0004  *
0005  *  \author M. Strang SUNY-Buffalo
0006  *  Testing by Ken Smith
0007  */
0008 #include "Validation/GlobalRecHits/interface/GlobalRecHitsHistogrammer.h"
0009 #include "DQMServices/Core/interface/DQMStore.h"
0010 using namespace std;
0011 
0012 GlobalRecHitsHistogrammer::GlobalRecHitsHistogrammer(const edm::ParameterSet& iPSet)
0013     : fName(""), verbosity(0), frequency(0), label(""), getAllProvenances(false), printProvenanceInfo(false), count(0) {
0014   std::string MsgLoggerCat = "GlobalRecHitsAnalyzer_GlobalRecHitsAnalyzer";
0015 
0016   // get information from parameter set
0017   fName = iPSet.getUntrackedParameter<std::string>("Name");
0018   verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
0019   frequency = iPSet.getUntrackedParameter<int>("Frequency");
0020   outputfile = iPSet.getParameter<std::string>("outputFile");
0021   doOutput = iPSet.getParameter<bool>("DoOutput");
0022   edm::ParameterSet m_Prov = iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
0023   getAllProvenances = m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
0024   printProvenanceInfo = m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");
0025 
0026   //get Labels to use to extract information
0027   GlobalRecHitSrc_ = iPSet.getParameter<edm::InputTag>("GlobalRecHitSrc");
0028   GlobalRecHitSrc_Token_ = consumes<PGlobalRecHit>(iPSet.getParameter<edm::InputTag>("GlobalRecHitSrc"));
0029   // ECalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalEBSrc");
0030   //ECalUncalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalUncalEBSrc");
0031   //ECalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalEESrc");
0032   //ECalUncalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalUncalEESrc");
0033   //ECalESSrc_ = iPSet.getParameter<edm::InputTag>("ECalESSrc");
0034   //HCalSrc_ = iPSet.getParameter<edm::InputTag>("HCalSrc");
0035   //SiStripSrc_ = iPSet.getParameter<edm::InputTag>("SiStripSrc");
0036   //SiPxlSrc_ = iPSet.getParameter<edm::InputTag>("SiPxlSrc");
0037   //MuDTSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSrc");
0038   //MuDTSimSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSimSrc");
0039   //MuCSCSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCSrc");
0040   //MuRPCSrc_ = iPSet.getParameter<edm::InputTag>("MuRPCSrc");
0041   //MuRPCSimSrc_ = iPSet.getParameter<edm::InputTag>("MuRPCSimSrc");
0042 
0043   //conf_ = iPSet;
0044 
0045   // use value of first digit to determine default output level (inclusive)
0046   // 0 is none, 1 is basic, 2 is fill output, 3 is gather output
0047   verbosity %= 10;
0048 
0049   // create persistent object
0050   // produces<PGlobalRecHit>(label);
0051 
0052   // print out Parameter Set information being used
0053   if (verbosity >= 0) {
0054     edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
0055                                << "Initialized as EDProducer with parameter values:\n"
0056                                << "    Name           = " << fName << "\n"
0057                                << "    Verbosity      = " << verbosity << "\n"
0058                                << "    Frequency      = " << frequency << "\n"
0059                                << "    OutputFile     = " << outputfile << "\n"
0060                                << "    DoOutput      = " << doOutput << "\n"
0061                                << "    GetProv        = " << getAllProvenances << "\n"
0062                                << "    PrintProv      = " << printProvenanceInfo << "\n"
0063                                << "    Global Src     = " << GlobalRecHitSrc_ << "\n"
0064                                << "===============================\n";
0065   }
0066 }
0067 
0068 GlobalRecHitsHistogrammer::~GlobalRecHitsHistogrammer() {}
0069 
0070 void GlobalRecHitsHistogrammer::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) {
0071   //monitor elements
0072 
0073   //Si Strip
0074   string SiStripString[19] = {"TECW1",
0075                               "TECW2",
0076                               "TECW3",
0077                               "TECW4",
0078                               "TECW5",
0079                               "TECW6",
0080                               "TECW7",
0081                               "TECW8",
0082                               "TIBL1",
0083                               "TIBL2",
0084                               "TIBL3",
0085                               "TIBL4",
0086                               "TIDW1",
0087                               "TIDW2",
0088                               "TIDW3",
0089                               "TOBL1",
0090                               "TOBL2",
0091                               "TOBL3",
0092                               "TOBL4"};
0093 
0094   for (int i = 0; i < 19; ++i) {
0095     mehSiStripn[i] = nullptr;
0096     mehSiStripResX[i] = nullptr;
0097     mehSiStripResY[i] = nullptr;
0098   }
0099 
0100   string hcharname, hchartitle;
0101   ibooker.setCurrentFolder("GlobalRecHitsV/SiStrips");
0102   for (int amend = 0; amend < 19; ++amend) {
0103     hcharname = "hSiStripn_" + SiStripString[amend];
0104     hchartitle = SiStripString[amend] + "  rechits";
0105     mehSiStripn[amend] = ibooker.book1D(hcharname, hchartitle, 20, 0., 20.);
0106     mehSiStripn[amend]->setAxisTitle("Number of hits in " + SiStripString[amend], 1);
0107     mehSiStripn[amend]->setAxisTitle("Count", 2);
0108 
0109     hcharname = "hSiStripResX_" + SiStripString[amend];
0110     hchartitle = SiStripString[amend] + " rechit x resolution";
0111     mehSiStripResX[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
0112     mehSiStripResX[amend]->setAxisTitle("X-resolution in " + SiStripString[amend], 1);
0113     mehSiStripResX[amend]->setAxisTitle("Count", 2);
0114 
0115     hcharname = "hSiStripResY_" + SiStripString[amend];
0116     hchartitle = SiStripString[amend] + " rechit y resolution";
0117     mehSiStripResY[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
0118     mehSiStripResY[amend]->setAxisTitle("Y-resolution in " + SiStripString[amend], 1);
0119     mehSiStripResY[amend]->setAxisTitle("Count", 2);
0120   }
0121 
0122   //HCal
0123   //string hcharname, hchartitle;
0124   string HCalString[4] = {"HB", "HE", "HF", "HO"};
0125   float HCalnUpper[4] = {3000., 3000., 3000., 2000.};
0126   float HCalnLower[4] = {2000., 2000., 2000., 1000.};
0127   for (int j = 0; j < 4; ++j) {
0128     mehHcaln[j] = nullptr;
0129     mehHcalRes[j] = nullptr;
0130   }
0131 
0132   ibooker.setCurrentFolder("GlobalRecHitsV/HCals");
0133   for (int amend = 0; amend < 4; ++amend) {
0134     hcharname = "hHcaln_" + HCalString[amend];
0135     hchartitle = HCalString[amend] + "  rechits";
0136     mehHcaln[amend] = ibooker.book1D(hcharname, hchartitle, 500, HCalnLower[amend], HCalnUpper[amend]);
0137 
0138     mehHcaln[amend]->setAxisTitle("Number of RecHits", 1);
0139     mehHcaln[amend]->setAxisTitle("Count", 2);
0140 
0141     hcharname = "hHcalRes_" + HCalString[amend];
0142     hchartitle = HCalString[amend] + "  rechit resolution";
0143     mehHcalRes[amend] = ibooker.book1D(hcharname, hchartitle, 25, -2., 2.);
0144     mehHcalRes[amend]->setAxisTitle("RecHit E - SimHit E", 1);
0145     mehHcalRes[amend]->setAxisTitle("Count", 2);
0146   }
0147 
0148   //Ecal
0149   string ECalString[3] = {"EB", "EE", "ES"};
0150   int ECalnBins[3] = {700, 100, 50};
0151   float ECalnUpper[3] = {20000., 62000., 300.};
0152   float ECalnLower[3] = {6000., 60000., 100.};
0153   int ECalResBins[3] = {200, 200, 200};
0154   float ECalResUpper[3] = {1., 0.3, .0002};
0155   float ECalResLower[3] = {-1., -0.3, -.0002};
0156   for (int i = 0; i < 3; ++i) {
0157     mehEcaln[i] = nullptr;
0158     mehEcalRes[i] = nullptr;
0159   }
0160 
0161   ibooker.setCurrentFolder("GlobalRecHitsV/ECals");
0162   for (int amend = 0; amend < 3; ++amend) {
0163     hcharname = "hEcaln_" + ECalString[amend];
0164     hchartitle = ECalString[amend] + "  rechits";
0165     mehEcaln[amend] = ibooker.book1D(hcharname, hchartitle, ECalnBins[amend], ECalnLower[amend], ECalnUpper[amend]);
0166 
0167     mehEcaln[amend]->setAxisTitle("Number of RecHits", 1);
0168     mehEcaln[amend]->setAxisTitle("Count", 2);
0169 
0170     hcharname = "hEcalRes_" + ECalString[amend];
0171     hchartitle = ECalString[amend] + "  rechit resolution";
0172     mehEcalRes[amend] =
0173         ibooker.book1D(hcharname, hchartitle, ECalResBins[amend], ECalResLower[amend], ECalResUpper[amend]);
0174 
0175     mehEcalRes[amend]->setAxisTitle("RecHit E - SimHit E", 1);
0176     mehEcalRes[amend]->setAxisTitle("Count", 2);
0177   }
0178 
0179   //Si Pixels
0180   string SiPixelString[7] = {"BRL1", "BRL2", "BRL3", "FWD1n", "FWD1p", "FWD2n", "FWD2p"};
0181   for (int j = 0; j < 7; ++j) {
0182     mehSiPixeln[j] = nullptr;
0183     mehSiPixelResX[j] = nullptr;
0184     mehSiPixelResY[j] = nullptr;
0185   }
0186 
0187   ibooker.setCurrentFolder("GlobalRecHitsV/SiPixels");
0188   for (int amend = 0; amend < 7; ++amend) {
0189     hcharname = "hSiPixeln_" + SiPixelString[amend];
0190     hchartitle = SiPixelString[amend] + " rechits";
0191     mehSiPixeln[amend] = ibooker.book1D(hcharname, hchartitle, 20, 0., 20.);
0192     mehSiPixeln[amend]->setAxisTitle("Number of hits in " + SiPixelString[amend], 1);
0193     mehSiPixeln[amend]->setAxisTitle("Count", 2);
0194 
0195     hcharname = "hSiPixelResX_" + SiPixelString[amend];
0196     hchartitle = SiPixelString[amend] + " rechit x resolution";
0197     mehSiPixelResX[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
0198     mehSiPixelResX[amend]->setAxisTitle("X-resolution in " + SiPixelString[amend], 1);
0199     mehSiPixelResX[amend]->setAxisTitle("Count", 2);
0200 
0201     hcharname = "hSiPixelResY_" + SiPixelString[amend];
0202     hchartitle = SiPixelString[amend] + " rechit y resolution";
0203     mehSiPixelResY[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
0204     mehSiPixelResY[amend]->setAxisTitle("Y-resolution in " + SiPixelString[amend], 1);
0205     mehSiPixelResY[amend]->setAxisTitle("Count", 2);
0206   }
0207 
0208   //Muons
0209   ibooker.setCurrentFolder("GlobalRecHitsV/Muons");
0210   mehDtMuonn = nullptr;
0211   mehCSCn = nullptr;
0212   mehRPCn = nullptr;
0213 
0214   //std::vector<MonitorElement *> me_List = {mehDtMuonn, mehCSCn, mehRPCn};
0215   string n_List[3] = {"hDtMuonn", "hCSCn", "hRPCn"};
0216   //float hist_prop[3] = [25., 0., 50.];
0217   string hist_string[3] = {"Dt", "CSC", "RPC"};
0218 
0219   for (int amend = 0; amend < 3; ++amend) {
0220     hchartitle = hist_string[amend] + " rechits";
0221     if (amend == 0) {
0222       mehDtMuonn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
0223       mehDtMuonn->setAxisTitle("Number of Rechits", 1);
0224       mehDtMuonn->setAxisTitle("Count", 2);
0225     }
0226     if (amend == 1) {
0227       mehCSCn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
0228       mehCSCn->setAxisTitle("Number of Rechits", 1);
0229       mehCSCn->setAxisTitle("Count", 2);
0230     }
0231     if (amend == 2) {
0232       mehRPCn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
0233       mehRPCn->setAxisTitle("Number of Rechits", 1);
0234       mehRPCn->setAxisTitle("Count", 2);
0235     }
0236   }
0237 
0238   mehDtMuonRes = nullptr;
0239   mehCSCResRDPhi = nullptr;
0240   mehRPCResX = nullptr;
0241 
0242   hcharname = "hDtMuonRes";
0243   hchartitle = "DT wire distance resolution";
0244   mehDtMuonRes = ibooker.book1D(hcharname, hchartitle, 200, -0.2, 0.2);
0245 
0246   hcharname = "CSCResRDPhi";
0247   hchartitle = "CSC perp*dphi resolution";
0248   mehCSCResRDPhi = ibooker.book1D(hcharname, hchartitle, 200, -0.2, 0.2);
0249 
0250   hcharname = "hRPCResX";
0251   hchartitle = "RPC rechits x resolution";
0252   mehRPCResX = ibooker.book1D(hcharname, hchartitle, 50, -5., 5.);
0253 }
0254 
0255 void GlobalRecHitsHistogrammer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0256   std::string MsgLoggerCat = "GlobalRecHitsHistogrammer_analyze";
0257 
0258   // keep track of number of events processed
0259   ++count;
0260 
0261   // get event id information
0262   edm::RunNumber_t nrun = iEvent.id().run();
0263   edm::EventNumber_t nevt = iEvent.id().event();
0264 
0265   if (verbosity > 0) {
0266     edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count << " events total)";
0267   } else if (verbosity == 0) {
0268     if (nevt % frequency == 0 || nevt == 1) {
0269       edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count
0270                                  << " events total)";
0271     }
0272   }
0273 
0274   // clear event holders
0275   //clear();  Not in example I'm using, thus I comment it out.
0276 
0277   // look at information available in the event
0278   if (getAllProvenances) {
0279     std::vector<const edm::StableProvenance*> AllProv;
0280     iEvent.getAllStableProvenance(AllProv);
0281 
0282     if (verbosity >= 0)
0283       edm::LogInfo(MsgLoggerCat) << "Number of Provenances = " << AllProv.size();
0284 
0285     if (printProvenanceInfo && (verbosity >= 0)) {
0286       TString eventout("\nProvenance info:\n");
0287 
0288       for (unsigned int i = 0; i < AllProv.size(); ++i) {
0289         eventout += "\n       ******************************";
0290         eventout += "\n       Module       : ";
0291         //eventout += (AllProv[i]->product).moduleLabel();
0292         eventout += AllProv[i]->moduleLabel();
0293         eventout += "\n       ProductID    : ";
0294         //eventout += (AllProv[i]->product).productID_.id_;
0295         eventout += AllProv[i]->productID().id();
0296         eventout += "\n       ClassName    : ";
0297         //eventout += (AllProv[i]->product).fullClassName_;
0298         eventout += AllProv[i]->className();
0299         eventout += "\n       InstanceName : ";
0300         //eventout += (AllProv[i]->product).productInstanceName_;
0301         eventout += AllProv[i]->productInstanceName();
0302         eventout += "\n       BranchName   : ";
0303         //eventout += (AllProv[i]->product).branchName_;
0304         eventout += AllProv[i]->branchName();
0305       }
0306       eventout += "\n       ******************************\n";
0307       edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0308       printProvenanceInfo = false;
0309     }
0310     getAllProvenances = false;
0311   }
0312 
0313   edm::Handle<PGlobalRecHit> srcGlobalRecHits;
0314   iEvent.getByToken(GlobalRecHitSrc_Token_, srcGlobalRecHits);
0315   if (!srcGlobalRecHits.isValid()) {
0316     edm::LogWarning(MsgLoggerCat) << "Unable to find PGlobalRecHit in event!";
0317     return;
0318   }
0319 
0320   int nEBCalRecHits = srcGlobalRecHits->getnEBCalRecHits();
0321   int nEECalRecHits = srcGlobalRecHits->getnEECalRecHits();
0322   int nESCalRecHits = srcGlobalRecHits->getnESCalRecHits();
0323 
0324   int nHBCalRecHits = srcGlobalRecHits->getnHBCalRecHits();
0325   int nHECalRecHits = srcGlobalRecHits->getnHECalRecHits();
0326   int nHOCalRecHits = srcGlobalRecHits->getnHOCalRecHits();
0327   int nHFCalRecHits = srcGlobalRecHits->getnHFCalRecHits();
0328 
0329   int nTIBL1RecHits = srcGlobalRecHits->getnTIBL1RecHits();
0330   int nTIBL2RecHits = srcGlobalRecHits->getnTIBL2RecHits();
0331   int nTIBL3RecHits = srcGlobalRecHits->getnTIBL3RecHits();
0332   int nTIBL4RecHits = srcGlobalRecHits->getnTIBL4RecHits();
0333   int nTOBL1RecHits = srcGlobalRecHits->getnTOBL1RecHits();
0334   int nTOBL2RecHits = srcGlobalRecHits->getnTOBL2RecHits();
0335   int nTOBL3RecHits = srcGlobalRecHits->getnTOBL3RecHits();
0336   int nTOBL4RecHits = srcGlobalRecHits->getnTOBL4RecHits();
0337   int nTIDW1RecHits = srcGlobalRecHits->getnTIDW1RecHits();
0338   int nTIDW2RecHits = srcGlobalRecHits->getnTIDW2RecHits();
0339   int nTIDW3RecHits = srcGlobalRecHits->getnTIDW3RecHits();
0340   int nTECW1RecHits = srcGlobalRecHits->getnTECW1RecHits();
0341   int nTECW2RecHits = srcGlobalRecHits->getnTECW2RecHits();
0342   int nTECW3RecHits = srcGlobalRecHits->getnTECW3RecHits();
0343   int nTECW4RecHits = srcGlobalRecHits->getnTECW4RecHits();
0344   int nTECW5RecHits = srcGlobalRecHits->getnTECW5RecHits();
0345   int nTECW6RecHits = srcGlobalRecHits->getnTECW6RecHits();
0346   int nTECW7RecHits = srcGlobalRecHits->getnTECW7RecHits();
0347   int nTECW8RecHits = srcGlobalRecHits->getnTECW8RecHits();
0348 
0349   int nBRL1RecHits = srcGlobalRecHits->getnBRL1RecHits();
0350   int nBRL2RecHits = srcGlobalRecHits->getnBRL2RecHits();
0351   int nBRL3RecHits = srcGlobalRecHits->getnBRL3RecHits();
0352   int nFWD1nRecHits = srcGlobalRecHits->getnFWD1nRecHits();
0353   int nFWD1pRecHits = srcGlobalRecHits->getnFWD1pRecHits();
0354   int nFWD2nRecHits = srcGlobalRecHits->getnFWD2nRecHits();
0355   int nFWD2pRecHits = srcGlobalRecHits->getnFWD2pRecHits();
0356 
0357   int nDTRecHits = srcGlobalRecHits->getnDTRecHits();
0358 
0359   int nCSCRecHits = srcGlobalRecHits->getnCSCRecHits();
0360 
0361   int nRPCRecHits = srcGlobalRecHits->getnRPCRecHits();
0362 
0363   // get Ecal info
0364   std::vector<PGlobalRecHit::ECalRecHit> EECalRecHits = srcGlobalRecHits->getEECalRecHits();
0365   mehEcaln[0]->Fill((float)nEECalRecHits);
0366   for (unsigned int i = 0; i < EECalRecHits.size(); ++i) {
0367     mehEcalRes[0]->Fill(EECalRecHits[i].RE - EECalRecHits[i].SHE);
0368   }
0369 
0370   std::vector<PGlobalRecHit::ECalRecHit> EBCalRecHits = srcGlobalRecHits->getEBCalRecHits();
0371   mehEcaln[1]->Fill((float)nEBCalRecHits);
0372   for (unsigned int i = 0; i < EBCalRecHits.size(); ++i) {
0373     mehEcalRes[1]->Fill(EBCalRecHits[i].RE - EBCalRecHits[i].SHE);
0374   }
0375 
0376   std::vector<PGlobalRecHit::ECalRecHit> ESCalRecHits = srcGlobalRecHits->getESCalRecHits();
0377   mehEcaln[2]->Fill((float)nESCalRecHits);
0378   for (unsigned int i = 0; i < ESCalRecHits.size(); ++i) {
0379     mehEcalRes[2]->Fill(ESCalRecHits[i].RE - ESCalRecHits[i].SHE);
0380   }
0381 
0382   // Get HCal info
0383   std::vector<PGlobalRecHit::HCalRecHit> HBCalRecHits = srcGlobalRecHits->getHBCalRecHits();
0384   mehHcaln[0]->Fill((float)nHBCalRecHits);
0385   for (unsigned int i = 0; i < HBCalRecHits.size(); ++i) {
0386     mehHcalRes[0]->Fill(HBCalRecHits[i].REC - HBCalRecHits[i].SHE);
0387   }
0388 
0389   std::vector<PGlobalRecHit::HCalRecHit> HECalRecHits = srcGlobalRecHits->getHECalRecHits();
0390   mehHcaln[1]->Fill((float)nHECalRecHits);
0391   for (unsigned int i = 0; i < HECalRecHits.size(); ++i) {
0392     mehHcalRes[1]->Fill(HECalRecHits[i].REC - HECalRecHits[i].SHE);
0393   }
0394 
0395   std::vector<PGlobalRecHit::HCalRecHit> HOCalRecHits = srcGlobalRecHits->getHOCalRecHits();
0396   mehHcaln[2]->Fill((float)nHOCalRecHits);
0397   for (unsigned int i = 0; i < HOCalRecHits.size(); ++i) {
0398     mehHcalRes[2]->Fill(HOCalRecHits[i].REC - HOCalRecHits[i].SHE);
0399   }
0400 
0401   std::vector<PGlobalRecHit::HCalRecHit> HFCalRecHits = srcGlobalRecHits->getHFCalRecHits();
0402   mehHcaln[3]->Fill((float)nHFCalRecHits);
0403   for (unsigned int i = 0; i < HFCalRecHits.size(); ++i) {
0404     mehHcalRes[3]->Fill(HFCalRecHits[i].REC - HFCalRecHits[i].SHE);
0405   }
0406 
0407   // get SiStrip info
0408   std::vector<PGlobalRecHit::SiStripRecHit> TIBL1RecHits = srcGlobalRecHits->getTIBL1RecHits();
0409   mehSiStripn[0]->Fill((float)nTIBL1RecHits);
0410   for (unsigned int i = 0; i < TIBL1RecHits.size(); ++i) {
0411     mehSiStripResX[0]->Fill(TIBL1RecHits[i].RX - TIBL1RecHits[i].SX);
0412     mehSiStripResY[0]->Fill(TIBL1RecHits[i].RY - TIBL1RecHits[i].SY);
0413   }
0414 
0415   std::vector<PGlobalRecHit::SiStripRecHit> TIBL2RecHits = srcGlobalRecHits->getTIBL2RecHits();
0416   mehSiStripn[1]->Fill((float)nTIBL2RecHits);
0417   for (unsigned int i = 0; i < TIBL2RecHits.size(); ++i) {
0418     mehSiStripResX[1]->Fill(TIBL2RecHits[i].RX - TIBL2RecHits[i].SX);
0419     mehSiStripResY[1]->Fill(TIBL2RecHits[i].RY - TIBL2RecHits[i].SY);
0420   }
0421 
0422   std::vector<PGlobalRecHit::SiStripRecHit> TIBL3RecHits = srcGlobalRecHits->getTIBL3RecHits();
0423   mehSiStripn[2]->Fill((float)nTIBL3RecHits);
0424   for (unsigned int i = 0; i < TIBL3RecHits.size(); ++i) {
0425     mehSiStripResX[2]->Fill(TIBL3RecHits[i].RX - TIBL3RecHits[i].SX);
0426     mehSiStripResY[2]->Fill(TIBL3RecHits[i].RY - TIBL3RecHits[i].SY);
0427   }
0428 
0429   std::vector<PGlobalRecHit::SiStripRecHit> TIBL4RecHits = srcGlobalRecHits->getTIBL4RecHits();
0430   mehSiStripn[3]->Fill((float)nTIBL4RecHits);
0431   for (unsigned int i = 0; i < TIBL4RecHits.size(); ++i) {
0432     mehSiStripResX[3]->Fill(TIBL4RecHits[i].RX - TIBL4RecHits[i].SX);
0433     mehSiStripResY[3]->Fill(TIBL4RecHits[i].RY - TIBL4RecHits[i].SY);
0434   }
0435 
0436   std::vector<PGlobalRecHit::SiStripRecHit> TOBL1RecHits = srcGlobalRecHits->getTOBL1RecHits();
0437   mehSiStripn[4]->Fill((float)nTOBL1RecHits);
0438   for (unsigned int i = 0; i < TOBL1RecHits.size(); ++i) {
0439     mehSiStripResX[4]->Fill(TOBL1RecHits[i].RX - TOBL1RecHits[i].SX);
0440     mehSiStripResY[4]->Fill(TOBL1RecHits[i].RY - TOBL1RecHits[i].SY);
0441   }
0442 
0443   std::vector<PGlobalRecHit::SiStripRecHit> TOBL2RecHits = srcGlobalRecHits->getTOBL2RecHits();
0444   mehSiStripn[5]->Fill((float)nTOBL2RecHits);
0445   for (unsigned int i = 0; i < TOBL2RecHits.size(); ++i) {
0446     mehSiStripResX[5]->Fill(TOBL2RecHits[i].RX - TOBL2RecHits[i].SX);
0447     mehSiStripResY[5]->Fill(TOBL2RecHits[i].RY - TOBL2RecHits[i].SY);
0448   }
0449 
0450   std::vector<PGlobalRecHit::SiStripRecHit> TOBL3RecHits = srcGlobalRecHits->getTOBL3RecHits();
0451   mehSiStripn[6]->Fill((float)nTOBL3RecHits);
0452   for (unsigned int i = 0; i < TOBL3RecHits.size(); ++i) {
0453     mehSiStripResX[6]->Fill(TOBL3RecHits[i].RX - TOBL3RecHits[i].SX);
0454     mehSiStripResY[6]->Fill(TOBL3RecHits[i].RY - TOBL3RecHits[i].SY);
0455   }
0456 
0457   std::vector<PGlobalRecHit::SiStripRecHit> TOBL4RecHits = srcGlobalRecHits->getTOBL4RecHits();
0458   mehSiStripn[7]->Fill((float)nTOBL4RecHits);
0459   for (unsigned int i = 0; i < TOBL4RecHits.size(); ++i) {
0460     mehSiStripResX[7]->Fill(TOBL4RecHits[i].RX - TOBL4RecHits[i].SX);
0461     mehSiStripResY[7]->Fill(TOBL4RecHits[i].RY - TOBL4RecHits[i].SY);
0462   }
0463 
0464   std::vector<PGlobalRecHit::SiStripRecHit> TIDW1RecHits = srcGlobalRecHits->getTIDW1RecHits();
0465   mehSiStripn[8]->Fill((float)nTIDW1RecHits);
0466   for (unsigned int i = 0; i < TIDW1RecHits.size(); ++i) {
0467     mehSiStripResX[8]->Fill(TIDW1RecHits[i].RX - TIDW1RecHits[i].SX);
0468     mehSiStripResY[8]->Fill(TIDW1RecHits[i].RY - TIDW1RecHits[i].SY);
0469   }
0470 
0471   std::vector<PGlobalRecHit::SiStripRecHit> TIDW2RecHits = srcGlobalRecHits->getTIDW2RecHits();
0472   mehSiStripn[9]->Fill((float)nTIDW2RecHits);
0473   for (unsigned int i = 0; i < TIDW2RecHits.size(); ++i) {
0474     mehSiStripResX[9]->Fill(TIDW2RecHits[i].RX - TIDW2RecHits[i].SX);
0475     mehSiStripResY[9]->Fill(TIDW2RecHits[i].RY - TIDW2RecHits[i].SY);
0476   }
0477 
0478   std::vector<PGlobalRecHit::SiStripRecHit> TIDW3RecHits = srcGlobalRecHits->getTIDW3RecHits();
0479   mehSiStripn[10]->Fill((float)nTIDW3RecHits);
0480   for (unsigned int i = 0; i < TIDW3RecHits.size(); ++i) {
0481     mehSiStripResX[10]->Fill(TIDW3RecHits[i].RX - TIDW3RecHits[i].SX);
0482     mehSiStripResY[10]->Fill(TIDW3RecHits[i].RY - TIDW3RecHits[i].SY);
0483   }
0484 
0485   std::vector<PGlobalRecHit::SiStripRecHit> TECW1RecHits = srcGlobalRecHits->getTECW1RecHits();
0486   mehSiStripn[11]->Fill((float)nTECW1RecHits);
0487   for (unsigned int i = 0; i < TECW1RecHits.size(); ++i) {
0488     mehSiStripResX[11]->Fill(TECW1RecHits[i].RX - TECW1RecHits[i].SX);
0489     mehSiStripResY[11]->Fill(TECW1RecHits[i].RY - TECW1RecHits[i].SY);
0490   }
0491 
0492   std::vector<PGlobalRecHit::SiStripRecHit> TECW2RecHits = srcGlobalRecHits->getTECW2RecHits();
0493   mehSiStripn[12]->Fill((float)nTECW2RecHits);
0494   for (unsigned int i = 0; i < TECW2RecHits.size(); ++i) {
0495     mehSiStripResX[12]->Fill(TECW2RecHits[i].RX - TECW2RecHits[i].SX);
0496     mehSiStripResY[12]->Fill(TECW2RecHits[i].RY - TECW2RecHits[i].SY);
0497   }
0498 
0499   std::vector<PGlobalRecHit::SiStripRecHit> TECW3RecHits = srcGlobalRecHits->getTECW3RecHits();
0500   mehSiStripn[13]->Fill((float)nTECW3RecHits);
0501   for (unsigned int i = 0; i < TECW3RecHits.size(); ++i) {
0502     mehSiStripResX[13]->Fill(TECW3RecHits[i].RX - TECW3RecHits[i].SX);
0503     mehSiStripResY[13]->Fill(TECW3RecHits[i].RY - TECW3RecHits[i].SY);
0504   }
0505 
0506   std::vector<PGlobalRecHit::SiStripRecHit> TECW4RecHits = srcGlobalRecHits->getTECW4RecHits();
0507   mehSiStripn[14]->Fill((float)nTECW4RecHits);
0508   for (unsigned int i = 0; i < TECW4RecHits.size(); ++i) {
0509     mehSiStripResX[14]->Fill(TECW4RecHits[i].RX - TECW4RecHits[i].SX);
0510     mehSiStripResY[14]->Fill(TECW4RecHits[i].RY - TECW4RecHits[i].SY);
0511   }
0512 
0513   std::vector<PGlobalRecHit::SiStripRecHit> TECW5RecHits = srcGlobalRecHits->getTECW5RecHits();
0514   mehSiStripn[15]->Fill((float)nTECW5RecHits);
0515   for (unsigned int i = 0; i < TECW5RecHits.size(); ++i) {
0516     mehSiStripResX[15]->Fill(TECW5RecHits[i].RX - TECW5RecHits[i].SX);
0517     mehSiStripResY[15]->Fill(TECW5RecHits[i].RY - TECW5RecHits[i].SY);
0518   }
0519 
0520   std::vector<PGlobalRecHit::SiStripRecHit> TECW6RecHits = srcGlobalRecHits->getTECW6RecHits();
0521   mehSiStripn[16]->Fill((float)nTECW6RecHits);
0522   for (unsigned int i = 0; i < TECW6RecHits.size(); ++i) {
0523     mehSiStripResX[16]->Fill(TECW6RecHits[i].RX - TECW6RecHits[i].SX);
0524     mehSiStripResY[16]->Fill(TECW6RecHits[i].RY - TECW6RecHits[i].SY);
0525   }
0526 
0527   std::vector<PGlobalRecHit::SiStripRecHit> TECW7RecHits = srcGlobalRecHits->getTECW7RecHits();
0528   mehSiStripn[17]->Fill((float)nTECW7RecHits);
0529   for (unsigned int i = 0; i < TECW7RecHits.size(); ++i) {
0530     mehSiStripResX[17]->Fill(TECW7RecHits[i].RX - TECW7RecHits[i].SX);
0531     mehSiStripResY[17]->Fill(TECW7RecHits[i].RY - TECW7RecHits[i].SY);
0532   }
0533 
0534   std::vector<PGlobalRecHit::SiStripRecHit> TECW8RecHits = srcGlobalRecHits->getTECW8RecHits();
0535   mehSiStripn[18]->Fill((float)nTECW8RecHits);
0536   for (unsigned int i = 0; i < TECW8RecHits.size(); ++i) {
0537     mehSiStripResX[18]->Fill(TECW8RecHits[i].RX - TECW8RecHits[i].SX);
0538     mehSiStripResY[18]->Fill(TECW8RecHits[i].RY - TECW8RecHits[i].SY);
0539   }
0540 
0541   // get SiPixel info
0542   std::vector<PGlobalRecHit::SiPixelRecHit> BRL1RecHits = srcGlobalRecHits->getBRL1RecHits();
0543   mehSiPixeln[0]->Fill((float)nBRL1RecHits);
0544   for (unsigned int i = 0; i < BRL1RecHits.size(); ++i) {
0545     mehSiPixelResX[0]->Fill(BRL1RecHits[i].RX - BRL1RecHits[i].SX);
0546     mehSiPixelResY[0]->Fill(BRL1RecHits[i].RY - BRL1RecHits[i].SY);
0547   }
0548 
0549   std::vector<PGlobalRecHit::SiPixelRecHit> BRL2RecHits = srcGlobalRecHits->getBRL2RecHits();
0550   mehSiPixeln[1]->Fill((float)nBRL2RecHits);
0551   for (unsigned int i = 0; i < BRL2RecHits.size(); ++i) {
0552     mehSiPixelResX[1]->Fill(BRL2RecHits[i].RX - BRL2RecHits[i].SX);
0553     mehSiPixelResY[1]->Fill(BRL2RecHits[i].RY - BRL2RecHits[i].SY);
0554   }
0555 
0556   std::vector<PGlobalRecHit::SiPixelRecHit> BRL3RecHits = srcGlobalRecHits->getBRL3RecHits();
0557   mehSiPixeln[2]->Fill((float)nBRL3RecHits);
0558   for (unsigned int i = 0; i < BRL3RecHits.size(); ++i) {
0559     mehSiPixelResX[2]->Fill(BRL3RecHits[i].RX - BRL3RecHits[i].SX);
0560     mehSiPixelResY[2]->Fill(BRL3RecHits[i].RY - BRL3RecHits[i].SY);
0561   }
0562 
0563   std::vector<PGlobalRecHit::SiPixelRecHit> FWD1pRecHits = srcGlobalRecHits->getFWD1pRecHits();
0564   mehSiPixeln[3]->Fill((float)nFWD1pRecHits);
0565   for (unsigned int i = 0; i < FWD1pRecHits.size(); ++i) {
0566     mehSiPixelResX[3]->Fill(FWD1pRecHits[i].RX - FWD1pRecHits[i].SX);
0567     mehSiPixelResY[3]->Fill(FWD1pRecHits[i].RY - FWD1pRecHits[i].SY);
0568   }
0569 
0570   std::vector<PGlobalRecHit::SiPixelRecHit> FWD1nRecHits = srcGlobalRecHits->getFWD1nRecHits();
0571   mehSiPixeln[4]->Fill((float)nFWD1nRecHits);
0572   for (unsigned int i = 0; i < FWD1nRecHits.size(); ++i) {
0573     mehSiPixelResX[4]->Fill(FWD1nRecHits[i].RX - FWD1nRecHits[i].SX);
0574     mehSiPixelResY[4]->Fill(FWD1nRecHits[i].RY - FWD1nRecHits[i].SY);
0575   }
0576 
0577   std::vector<PGlobalRecHit::SiPixelRecHit> FWD2pRecHits = srcGlobalRecHits->getFWD2pRecHits();
0578   mehSiPixeln[5]->Fill((float)nFWD2pRecHits);
0579   for (unsigned int i = 0; i < FWD2pRecHits.size(); ++i) {
0580     mehSiPixelResX[5]->Fill(FWD2pRecHits[i].RX - FWD2pRecHits[i].SX);
0581     mehSiPixelResY[5]->Fill(FWD2pRecHits[i].RY - FWD2pRecHits[i].SY);
0582   }
0583 
0584   std::vector<PGlobalRecHit::SiPixelRecHit> FWD2nRecHits = srcGlobalRecHits->getFWD2nRecHits();
0585   mehSiPixeln[6]->Fill((float)nFWD2nRecHits);
0586   for (unsigned int i = 0; i < FWD2nRecHits.size(); ++i) {
0587     mehSiPixelResX[6]->Fill(FWD2nRecHits[i].RX - FWD2nRecHits[i].SX);
0588     mehSiPixelResY[6]->Fill(FWD2nRecHits[i].RY - FWD2nRecHits[i].SY);
0589   }
0590 
0591   // get DtMuon info
0592   std::vector<PGlobalRecHit::DTRecHit> DTRecHits = srcGlobalRecHits->getDTRecHits();
0593   mehDtMuonn->Fill((float)nDTRecHits);
0594   for (unsigned int i = 0; i < DTRecHits.size(); ++i) {
0595     mehDtMuonRes->Fill(DTRecHits[i].RHD - DTRecHits[i].SHD);
0596   }
0597 
0598   // get CSC info
0599   std::vector<PGlobalRecHit::CSCRecHit> CSCRecHits = srcGlobalRecHits->getCSCRecHits();
0600   mehCSCn->Fill((float)nCSCRecHits);
0601   for (unsigned int i = 0; i < CSCRecHits.size(); ++i) {
0602     mehCSCResRDPhi->Fill(CSCRecHits[i].RHPERP * (CSCRecHits[i].RHPHI - CSCRecHits[i].SHPHI));
0603   }
0604 
0605   // get RPC info
0606   std::vector<PGlobalRecHit::RPCRecHit> RPCRecHits = srcGlobalRecHits->getRPCRecHits();
0607   mehRPCn->Fill((float)nRPCRecHits);
0608   for (unsigned int i = 0; i < RPCRecHits.size(); ++i) {
0609     mehRPCResX->Fill(RPCRecHits[i].RHX - RPCRecHits[i].SHX);
0610   }
0611 
0612   if (verbosity > 0)
0613     edm::LogInfo(MsgLoggerCat) << "Done gathering data from event.";
0614 }