Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:32:20 

0001 /** \file GlobalDigisHistogrammer.cc
0002  *
0003  *  See header file for description of class
0004  *
0005  *  \author M. Strang SUNY-Buffalo
0006  */
0007 
0008 #include "Validation/GlobalDigis/interface/GlobalDigisHistogrammer.h"
0009 
0010 GlobalDigisHistogrammer::GlobalDigisHistogrammer(const edm::ParameterSet &iPSet)
0011     : fName(""),
0012       verbosity(0),
0013       frequency(0),
0014       label(""),
0015       getAllProvenances(false),
0016       printProvenanceInfo(false),
0017       theCSCStripPedestalSum(0),
0018       theCSCStripPedestalCount(0),
0019       count(0) {
0020   std::string MsgLoggerCat = "GlobalDigisHistogrammer_GlobalDigisHistogrammer";
0021 
0022   // get information from parameter set
0023   fName = iPSet.getUntrackedParameter<std::string>("Name");
0024   verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
0025   frequency = iPSet.getUntrackedParameter<int>("Frequency");
0026   outputfile = iPSet.getParameter<std::string>("outputFile");
0027   doOutput = iPSet.getParameter<bool>("DoOutput");
0028   edm::ParameterSet m_Prov = iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
0029   getAllProvenances = m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
0030   printProvenanceInfo = m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");
0031 
0032   // get Labels to use to extract information
0033   GlobalDigisSrc_ = iPSet.getParameter<edm::InputTag>("GlobalDigisSrc");
0034   // ECalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalEBSrc");
0035   // ECalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalEESrc");
0036   // ECalESSrc_ = iPSet.getParameter<edm::InputTag>("ECalESSrc");
0037   // HCalSrc_ = iPSet.getParameter<edm::InputTag>("HCalSrc");
0038   // SiStripSrc_ = iPSet.getParameter<edm::InputTag>("SiStripSrc");
0039   // SiPxlSrc_ = iPSet.getParameter<edm::InputTag>("SiPxlSrc");
0040   // MuDTSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSrc");
0041   // MuCSCStripSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCStripSrc");
0042   // MuCSCWireSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCWireSrc");
0043 
0044   // fix for consumes
0045   GlobalDigisSrc_Token_ = consumes<PGlobalDigi>(iPSet.getParameter<edm::InputTag>("GlobalDigisSrc"));
0046   // use value of first digit to determine default output level (inclusive)
0047   // 0 is none, 1 is basic, 2 is fill output, 3 is gather output
0048   verbosity %= 10;
0049 
0050   // create persistent object
0051   // produces<PGlobalDigi>(label);
0052 
0053   // print out Parameter Set information being used
0054   if (verbosity >= 0) {
0055     edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
0056                                << "Initialized as EDHistogrammer with parameter values:\n"
0057                                << "    Name          = " << fName << "\n"
0058                                << "    Verbosity     = " << verbosity << "\n"
0059                                << "    Frequency     = " << frequency << "\n"
0060                                << "    OutputFile    = " << outputfile << "\n"
0061                                << "    DoOutput      = " << doOutput << "\n"
0062                                << "    GetProv       = " << getAllProvenances << "\n"
0063                                << "    PrintProv     = " << printProvenanceInfo << "\n"
0064                                << "    Global Src    = " << GlobalDigisSrc_ << "\n"
0065 
0066                                << "===============================\n";
0067   }
0068 }
0069 
0070 // set default constants
0071 // ECal
0072 
0073 // ECalgainConv_[0] = 0.;
0074 // ECalgainConv_[1] = 1.;
0075 // ECalgainConv_[2] = 2.;
0076 // ECalgainConv_[3] = 12.;
0077 // ECalbarrelADCtoGeV_ = 0.035;
0078 // ECalendcapADCtoGeV_ = 0.06;
0079 
0080 void GlobalDigisHistogrammer::bookHistograms(DQMStore::IBooker &ibooker, edm::Run const &, edm::EventSetup const &) {
0081   // monitor elements
0082 
0083   // Si Strip  ***Done***
0084   std::string SiStripString[19] = {"TECW1",
0085                                    "TECW2",
0086                                    "TECW3",
0087                                    "TECW4",
0088                                    "TECW5",
0089                                    "TECW6",
0090                                    "TECW7",
0091                                    "TECW8",
0092                                    "TIBL1",
0093                                    "TIBL2",
0094                                    "TIBL3",
0095                                    "TIBL4",
0096                                    "TIDW1",
0097                                    "TIDW2",
0098                                    "TIDW3",
0099                                    "TOBL1",
0100                                    "TOBL2",
0101                                    "TOBL3",
0102                                    "TOBL4"};
0103 
0104   for (int i = 0; i < 19; ++i) {
0105     mehSiStripn[i] = nullptr;
0106     mehSiStripADC[i] = nullptr;
0107     mehSiStripStrip[i] = nullptr;
0108   }
0109 
0110   ibooker.setCurrentFolder("GlobalDigisV/SiStrips");
0111   for (int amend = 0; amend < 19; ++amend) {
0112     mehSiStripn[amend] =
0113         ibooker.book1D("hSiStripn_" + SiStripString[amend], SiStripString[amend] + "  Digis", 500, 0., 1000.);
0114 
0115     mehSiStripn[amend]->setAxisTitle("Number of Digis", 1);
0116     mehSiStripn[amend]->setAxisTitle("Count", 2);
0117     mehSiStripADC[amend] =
0118         ibooker.book1D("hSiStripADC_" + SiStripString[amend], SiStripString[amend] + " ADC", 150, 0.0, 300.);
0119 
0120     mehSiStripADC[amend]->setAxisTitle("ADC", 1);
0121     mehSiStripADC[amend]->setAxisTitle("Count", 2);
0122     mehSiStripStrip[amend] =
0123         ibooker.book1D("hSiStripStripADC_" + SiStripString[amend], SiStripString[amend] + " Strip", 200, 0.0, 800.);
0124     mehSiStripStrip[amend]->setAxisTitle("Strip Number", 1);
0125     mehSiStripStrip[amend]->setAxisTitle("Count", 2);
0126   }
0127 
0128   // HCal  **DONE**
0129   std::string HCalString[4] = {"HB", "HE", "HO", "HF"};
0130   float calnUpper[4] = {3000., 3000., 3000., 2000.};
0131   float calnLower[4] = {2000., 2000., 2000., 1000.};
0132   float SHEUpper[4] = {0.05, .05, 0.05, 20};
0133   float SHEvAEEUpper[4] = {5000, 5000, 5000, 20};
0134   float SHEvAEELower[4] = {-5000, -5000, -5000, -20};
0135   int SHEvAEEnBins[4] = {200, 200, 200, 40};
0136   double ProfileUpper[4] = {1., 1., 1., 20.};
0137 
0138   for (int i = 0; i < 4; ++i) {
0139     mehHcaln[i] = nullptr;
0140     mehHcalAEE[i] = nullptr;
0141     mehHcalSHE[i] = nullptr;
0142     mehHcalAEESHE[i] = nullptr;
0143     mehHcalSHEvAEE[i] = nullptr;
0144   }
0145 
0146   ibooker.setCurrentFolder("GlobalDigisV/HCals");
0147   for (int amend = 0; amend < 4; ++amend) {
0148     mehHcaln[amend] = ibooker.book1D(
0149         "hHcaln_" + HCalString[amend], HCalString[amend] + "  digis", 1000, calnLower[amend], calnUpper[amend]);
0150 
0151     mehHcaln[amend]->setAxisTitle("Number of Digis", 1);
0152     mehHcaln[amend]->setAxisTitle("Count", 2);
0153     mehHcalAEE[amend] = ibooker.book1D("hHcalAEE_" + HCalString[amend], HCalString[amend] + "Cal AEE", 60, -10., 50.);
0154 
0155     mehHcalAEE[amend]->setAxisTitle("Analog Equivalent Energy", 1);
0156     mehHcalAEE[amend]->setAxisTitle("Count", 2);
0157     mehHcalSHE[amend] =
0158         ibooker.book1D("hHcalSHE_" + HCalString[amend], HCalString[amend] + "Cal SHE", 100, 0.0, SHEUpper[amend]);
0159 
0160     mehHcalSHE[amend]->setAxisTitle("Simulated Hit Energy", 1);
0161     mehHcalSHE[amend]->setAxisTitle("Count", 2);
0162     mehHcalAEESHE[amend] = ibooker.book1D("hHcalAEESHE_" + HCalString[amend],
0163                                           HCalString[amend] + "Cal AEE/SHE",
0164                                           SHEvAEEnBins[amend],
0165                                           SHEvAEELower[amend],
0166                                           SHEvAEEUpper[amend]);
0167 
0168     mehHcalAEESHE[amend]->setAxisTitle("ADC / SHE", 1);
0169     mehHcalAEESHE[amend]->setAxisTitle("Count", 2);
0170 
0171     //************  Not sure how to do Profile ME **************
0172     mehHcalSHEvAEE[amend] = ibooker.bookProfile("hHcalSHEvAEE_" + HCalString[amend],
0173                                                 HCalString[amend] + "Cal SHE vs. AEE",
0174                                                 60,
0175                                                 (float)-10.,
0176                                                 (float)50.,
0177                                                 100,
0178                                                 (float)0.,
0179                                                 (float)ProfileUpper[amend],
0180                                                 "");
0181 
0182     mehHcalSHEvAEE[amend]->setAxisTitle("AEE / SHE", 1);
0183     mehHcalSHEvAEE[amend]->setAxisTitle("SHE", 2);
0184   }
0185 
0186   // Ecal **Done **
0187   std::string ECalString[2] = {"EB", "EE"};
0188 
0189   for (int i = 0; i < 2; ++i) {
0190     mehEcaln[i] = nullptr;
0191     mehEcalAEE[i] = nullptr;
0192     mehEcalSHE[i] = nullptr;
0193     mehEcalMaxPos[i] = nullptr;
0194     mehEcalMultvAEE[i] = nullptr;
0195     mehEcalSHEvAEESHE[i] = nullptr;
0196   }
0197 
0198   ibooker.setCurrentFolder("GlobalDigisV/ECals");
0199   for (int amend = 0; amend < 2; ++amend) {
0200     mehEcaln[amend] = ibooker.book1D("hEcaln_" + ECalString[amend], ECalString[amend] + "  digis", 300, 1000., 4000.);
0201 
0202     mehEcaln[amend]->setAxisTitle("Number of Digis", 1);
0203     mehEcaln[amend]->setAxisTitle("Count", 2);
0204     mehEcalAEE[amend] = ibooker.book1D("hEcalAEE_" + ECalString[amend], ECalString[amend] + "Cal AEE", 100, 0., 1.);
0205 
0206     mehEcalAEE[amend]->setAxisTitle("Analog Equivalent Energy", 1);
0207     mehEcalAEE[amend]->setAxisTitle("Count", 2);
0208     mehEcalSHE[amend] = ibooker.book1D("hEcalSHE_" + ECalString[amend], ECalString[amend] + "Cal SHE", 50, 0., 5.);
0209 
0210     mehEcalSHE[amend]->setAxisTitle("Simulated Hit Energy", 1);
0211     mehEcalSHE[amend]->setAxisTitle("Count", 2);
0212     mehEcalMaxPos[amend] =
0213         ibooker.book1D("hEcalMaxPos_" + ECalString[amend], ECalString[amend] + "Cal MaxPos", 10, 0., 10.);
0214 
0215     mehEcalMaxPos[amend]->setAxisTitle("Maximum Position", 1);
0216     mehEcalMaxPos[amend]->setAxisTitle("Count", 2);
0217 
0218     //************  Not sure how to do Profile ME **************
0219     mehEcalSHEvAEESHE[amend] = ibooker.bookProfile("hEcalSHEvAEESHE_" + ECalString[amend],
0220                                                    ECalString[amend] + "Cal SHE vs. AEE/SHE",
0221                                                    100,
0222                                                    (float)0.,
0223                                                    (float)10.,
0224                                                    50,
0225                                                    (float)0.,
0226                                                    (float)5.,
0227                                                    "");
0228 
0229     mehEcalSHEvAEESHE[amend]->setAxisTitle("AEE / SHE", 1);
0230     mehEcalSHEvAEESHE[amend]->setAxisTitle("SHE", 2);
0231     mehEcalMultvAEE[amend] = ibooker.bookProfile("hEcalMultvAEE_" + ECalString[amend],
0232                                                  ECalString[amend] + "Cal Multi vs. AEE",
0233                                                  100,
0234                                                  (float)0.,
0235                                                  (float)10.,
0236                                                  400,
0237                                                  (float)0.,
0238                                                  (float)4000.,
0239                                                  "");
0240     mehEcalMultvAEE[amend]->setAxisTitle("Analog Equivalent Energy", 1);
0241     mehEcalMultvAEE[amend]->setAxisTitle("Number of Digis", 2);
0242   }
0243 
0244   mehEcaln[2] = nullptr;
0245   mehEcaln[2] = ibooker.book1D("hEcaln_ES", "ESCAL  digis", 100, 0., 500.);
0246   mehEcaln[2]->setAxisTitle("Number of Digis", 1);
0247   mehEcaln[2]->setAxisTitle("Count", 2);
0248   std::string ADCNumber[3] = {"0", "1", "2"};
0249   for (int i = 0; i < 3; ++i) {
0250     mehEScalADC[i] = nullptr;
0251     mehEScalADC[i] = ibooker.book1D("hEcalADC" + ADCNumber[i] + "_ES", "ESCAL  ADC" + ADCNumber[i], 150, 950., 1500.);
0252 
0253     mehEScalADC[i]->setAxisTitle("ADC" + ADCNumber[i], 1);
0254     mehEScalADC[i]->setAxisTitle("Count", 2);
0255   }
0256 
0257   // Si Pixels ***DONE***
0258   std::string SiPixelString[7] = {"BRL1", "BRL2", "BRL3", "FWD1n", "FWD1p", "FWD2n", "FWD2p"};
0259 
0260   for (int j = 0; j < 7; ++j) {
0261     mehSiPixeln[j] = nullptr;
0262     mehSiPixelADC[j] = nullptr;
0263     mehSiPixelRow[j] = nullptr;
0264     mehSiPixelCol[j] = nullptr;
0265   }
0266 
0267   ibooker.setCurrentFolder("GlobalDigisV/SiPixels");
0268   for (int amend = 0; amend < 7; ++amend) {
0269     if (amend < 3) {
0270       mehSiPixeln[amend] =
0271           ibooker.book1D("hSiPixeln_" + SiPixelString[amend], SiPixelString[amend] + " Digis", 50, 0., 100.);
0272     } else {
0273       mehSiPixeln[amend] =
0274           ibooker.book1D("hSiPixeln_" + SiPixelString[amend], SiPixelString[amend] + " Digis", 25, 0., 50.);
0275     }
0276 
0277     mehSiPixeln[amend]->setAxisTitle("Number of Digis", 1);
0278     mehSiPixeln[amend]->setAxisTitle("Count", 2);
0279     mehSiPixelADC[amend] =
0280         ibooker.book1D("hSiPixelADC_" + SiPixelString[amend], SiPixelString[amend] + " ADC", 150, 0.0, 300.);
0281 
0282     mehSiPixelADC[amend]->setAxisTitle("ADC", 1);
0283     mehSiPixelADC[amend]->setAxisTitle("Count", 2);
0284     mehSiPixelRow[amend] =
0285         ibooker.book1D("hSiPixelRow_" + SiPixelString[amend], SiPixelString[amend] + " Row", 100, 0.0, 100.);
0286 
0287     mehSiPixelRow[amend]->setAxisTitle("Row Number", 1);
0288     mehSiPixelRow[amend]->setAxisTitle("Count", 2);
0289     mehSiPixelCol[amend] =
0290         ibooker.book1D("hSiPixelColumn_" + SiPixelString[amend], SiPixelString[amend] + " Column", 200, 0.0, 500.);
0291 
0292     mehSiPixelCol[amend]->setAxisTitle("Column Number", 1);
0293     mehSiPixelCol[amend]->setAxisTitle("Count", 2);
0294   }
0295 
0296   // Muons ***DONE****
0297   ibooker.setCurrentFolder("GlobalDigisV/Muons");
0298   std::string MuonString[4] = {"MB1", "MB2", "MB3", "MB4"};
0299 
0300   for (int i = 0; i < 4; ++i) {
0301     mehDtMuonn[i] = nullptr;
0302     mehDtMuonLayer[i] = nullptr;
0303     mehDtMuonTime[i] = nullptr;
0304     mehDtMuonTimevLayer[i] = nullptr;
0305   }
0306 
0307   for (int j = 0; j < 4; ++j) {
0308     mehDtMuonn[j] = ibooker.book1D("hDtMuonn_" + MuonString[j], MuonString[j] + "  digis", 25, 0., 50.);
0309 
0310     mehDtMuonn[j]->setAxisTitle("Number of Digis", 1);
0311     mehDtMuonn[j]->setAxisTitle("Count", 2);
0312     mehDtMuonLayer[j] = ibooker.book1D("hDtLayer_" + MuonString[j], MuonString[j] + "  Layer", 12, 1., 13.);
0313 
0314     mehDtMuonLayer[j]->setAxisTitle("4 * (SuperLayer - 1) + Layer", 1);
0315     mehDtMuonLayer[j]->setAxisTitle("Count", 2);
0316     mehDtMuonTime[j] = ibooker.book1D("hDtMuonTime_" + MuonString[j], MuonString[j] + "  Time", 300, 400., 1000.);
0317 
0318     mehDtMuonTime[j]->setAxisTitle("Time", 1);
0319     mehDtMuonTime[j]->setAxisTitle("Count", 2);
0320     mehDtMuonTimevLayer[j] = ibooker.bookProfile(
0321         "hDtMuonTimevLayer_" + MuonString[j], MuonString[j] + "  Time vs. Layer", 12, 1., 13., 300, 400., 1000., "");
0322 
0323     mehDtMuonTimevLayer[j]->setAxisTitle("4 * (SuperLayer - 1) + Layer", 1);
0324     mehDtMuonTimevLayer[j]->setAxisTitle("Time", 2);
0325   }
0326 
0327   //  ****  Have to do CSC and RPC now *****
0328   // CSC
0329   mehCSCStripn = nullptr;
0330   mehCSCStripn = ibooker.book1D("hCSCStripn", "CSC Strip digis", 25, 0., 50.);
0331   mehCSCStripn->setAxisTitle("Number of Digis", 1);
0332   mehCSCStripn->setAxisTitle("Count", 2);
0333 
0334   mehCSCStripADC = nullptr;
0335   mehCSCStripADC = ibooker.book1D("hCSCStripADC", "CSC Strip ADC", 110, 0., 1100.);
0336   mehCSCStripADC->setAxisTitle("ADC", 1);
0337   mehCSCStripADC->setAxisTitle("Count", 2);
0338 
0339   mehCSCWiren = nullptr;
0340   mehCSCWiren = ibooker.book1D("hCSCWiren", "CSC Wire digis", 25, 0., 50.);
0341   mehCSCWiren->setAxisTitle("Number of Digis", 1);
0342   mehCSCWiren->setAxisTitle("Count", 2);
0343 
0344   mehCSCWireTime = nullptr;
0345   mehCSCWiren = ibooker.book1D("hCSCWireTime", "CSC Wire Time", 10, 0., 10.);
0346   mehCSCWiren->setAxisTitle("Time", 1);
0347   mehCSCWiren->setAxisTitle("Count", 2);
0348 
0349 }  // close bookHistograms
0350 
0351 GlobalDigisHistogrammer::~GlobalDigisHistogrammer() {}
0352 
0353 void GlobalDigisHistogrammer::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
0354   std::string MsgLoggerCat = "GlobalDigisHistogrammer_analyze";
0355 
0356   // keep track of number of events processed
0357   ++count;
0358 
0359   // get event id information
0360   edm::RunNumber_t nrun = iEvent.id().run();
0361   edm::EventNumber_t nevt = iEvent.id().event();
0362 
0363   if (verbosity > 0) {
0364     edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count << " events total)";
0365   } else if (verbosity == 0) {
0366     if (nevt % frequency == 0 || nevt == 1) {
0367       edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count
0368                                  << " events total)";
0369     }
0370   }
0371 
0372   // clear event holders
0373   // clear();
0374 
0375   // look at information available in the event
0376   if (getAllProvenances) {
0377     std::vector<const edm::StableProvenance *> AllProv;
0378     iEvent.getAllStableProvenance(AllProv);
0379 
0380     if (verbosity >= 0)
0381       edm::LogInfo(MsgLoggerCat) << "Number of Provenances = " << AllProv.size();
0382 
0383     if (printProvenanceInfo && (verbosity >= 0)) {
0384       TString eventout("\nProvenance info:\n");
0385 
0386       for (unsigned int i = 0; i < AllProv.size(); ++i) {
0387         eventout += "\n       ******************************";
0388         eventout += "\n       Module       : ";
0389         // eventout += (AllProv[i]->product).moduleLabel();
0390         eventout += AllProv[i]->moduleLabel();
0391         eventout += "\n       ProductID    : ";
0392         // eventout += (AllProv[i]->product).productID_.id_;
0393         eventout += AllProv[i]->productID().id();
0394         eventout += "\n       ClassName    : ";
0395         // eventout += (AllProv[i]->product).fullClassName_;
0396         eventout += AllProv[i]->className();
0397         eventout += "\n       InstanceName : ";
0398         // eventout += (AllProv[i]->product).productInstanceName_;
0399         eventout += AllProv[i]->productInstanceName();
0400         eventout += "\n       BranchName   : ";
0401         // eventout += (AllProv[i]->product).branchName_;
0402         eventout += AllProv[i]->branchName();
0403       }
0404       eventout += "\n       ******************************\n";
0405       edm::LogInfo(MsgLoggerCat) << eventout << "\n";
0406       printProvenanceInfo = false;
0407       getAllProvenances = false;
0408     }
0409     edm::Handle<PGlobalDigi> srcGlobalDigis;
0410     iEvent.getByToken(GlobalDigisSrc_Token_, srcGlobalDigis);
0411     if (!srcGlobalDigis.isValid()) {
0412       edm::LogWarning(MsgLoggerCat) << "Unable to find PGlobalDigis in event!";
0413       return;
0414     }
0415 
0416     int nEBCalDigis = srcGlobalDigis->getnEBCalDigis();
0417     int nEECalDigis = srcGlobalDigis->getnEECalDigis();
0418     int nESCalDigis = srcGlobalDigis->getnESCalDigis();
0419 
0420     int nHBCalDigis = srcGlobalDigis->getnHBCalDigis();
0421     int nHECalDigis = srcGlobalDigis->getnHECalDigis();
0422     int nHOCalDigis = srcGlobalDigis->getnHOCalDigis();
0423     int nHFCalDigis = srcGlobalDigis->getnHFCalDigis();
0424 
0425     int nTIBL1Digis = srcGlobalDigis->getnTIBL1Digis();
0426     int nTIBL2Digis = srcGlobalDigis->getnTIBL2Digis();
0427     int nTIBL3Digis = srcGlobalDigis->getnTIBL3Digis();
0428     int nTIBL4Digis = srcGlobalDigis->getnTIBL4Digis();
0429     int nTOBL1Digis = srcGlobalDigis->getnTOBL1Digis();
0430     int nTOBL2Digis = srcGlobalDigis->getnTOBL2Digis();
0431     int nTOBL3Digis = srcGlobalDigis->getnTOBL3Digis();
0432     int nTOBL4Digis = srcGlobalDigis->getnTOBL4Digis();
0433     int nTIDW1Digis = srcGlobalDigis->getnTIDW1Digis();
0434     int nTIDW2Digis = srcGlobalDigis->getnTIDW2Digis();
0435     int nTIDW3Digis = srcGlobalDigis->getnTIDW3Digis();
0436     int nTECW1Digis = srcGlobalDigis->getnTECW1Digis();
0437     int nTECW2Digis = srcGlobalDigis->getnTECW2Digis();
0438     int nTECW3Digis = srcGlobalDigis->getnTECW3Digis();
0439     int nTECW4Digis = srcGlobalDigis->getnTECW4Digis();
0440     int nTECW5Digis = srcGlobalDigis->getnTECW5Digis();
0441     int nTECW6Digis = srcGlobalDigis->getnTECW6Digis();
0442     int nTECW7Digis = srcGlobalDigis->getnTECW7Digis();
0443     int nTECW8Digis = srcGlobalDigis->getnTECW8Digis();
0444 
0445     int nBRL1Digis = srcGlobalDigis->getnBRL1Digis();
0446     int nBRL2Digis = srcGlobalDigis->getnBRL2Digis();
0447     int nBRL3Digis = srcGlobalDigis->getnBRL3Digis();
0448     int nFWD1nDigis = srcGlobalDigis->getnFWD1nDigis();
0449     int nFWD1pDigis = srcGlobalDigis->getnFWD1pDigis();
0450     int nFWD2nDigis = srcGlobalDigis->getnFWD2nDigis();
0451     int nFWD2pDigis = srcGlobalDigis->getnFWD2pDigis();
0452 
0453     int nMB1Digis = srcGlobalDigis->getnMB1Digis();
0454     int nMB2Digis = srcGlobalDigis->getnMB2Digis();
0455     int nMB3Digis = srcGlobalDigis->getnMB3Digis();
0456     int nMB4Digis = srcGlobalDigis->getnMB4Digis();
0457 
0458     int nCSCstripDigis = srcGlobalDigis->getnCSCstripDigis();
0459 
0460     int nCSCwireDigis = srcGlobalDigis->getnCSCwireDigis();
0461 
0462     // get Ecal info
0463     std::vector<PGlobalDigi::ECalDigi> EECalDigis = srcGlobalDigis->getEECalDigis();
0464     mehEcaln[0]->Fill((float)nEECalDigis);
0465     for (unsigned int i = 0; i < EECalDigis.size(); ++i) {
0466       mehEcalAEE[0]->Fill(EECalDigis[i].AEE);
0467       mehEcalMaxPos[0]->Fill(EECalDigis[i].maxPos);
0468       mehEcalMultvAEE[0]->Fill(EECalDigis[i].AEE, (float)nEECalDigis, 1);
0469       if (EECalDigis[i].SHE != 0.) {
0470         mehEcalSHE[0]->Fill(EECalDigis[i].SHE);
0471         mehEcalSHEvAEESHE[0]->Fill(EECalDigis[i].AEE / EECalDigis[i].SHE, EECalDigis[i].SHE, 1);
0472       }
0473     }
0474 
0475     std::vector<PGlobalDigi::ECalDigi> EBCalDigis = srcGlobalDigis->getEBCalDigis();
0476     mehEcaln[1]->Fill((float)nEBCalDigis);
0477     for (unsigned int i = 0; i < EBCalDigis.size(); ++i) {
0478       mehEcalAEE[1]->Fill(EBCalDigis[i].AEE);
0479       mehEcalMaxPos[1]->Fill(EBCalDigis[i].maxPos);
0480       mehEcalMultvAEE[1]->Fill(EBCalDigis[i].AEE, (float)nEBCalDigis, 1);
0481       if (EBCalDigis[i].SHE != 0.) {
0482         mehEcalSHE[1]->Fill(EBCalDigis[i].SHE);
0483         mehEcalSHEvAEESHE[1]->Fill(EBCalDigis[i].AEE / EBCalDigis[i].SHE, EBCalDigis[i].SHE, 1);
0484       }
0485     }
0486 
0487     std::vector<PGlobalDigi::ESCalDigi> ESCalDigis = srcGlobalDigis->getESCalDigis();
0488     mehEcaln[2]->Fill((float)nESCalDigis);
0489     for (unsigned int i = 0; i < ESCalDigis.size(); ++i) {
0490       mehEScalADC[0]->Fill(ESCalDigis[i].ADC0);
0491       mehEScalADC[1]->Fill(ESCalDigis[i].ADC1);
0492       mehEScalADC[2]->Fill(ESCalDigis[i].ADC2);
0493     }
0494 
0495     // Get HCal info
0496     std::vector<PGlobalDigi::HCalDigi> HBCalDigis = srcGlobalDigis->getHBCalDigis();
0497     mehHcaln[0]->Fill((float)nHBCalDigis);
0498     for (unsigned int i = 0; i < HBCalDigis.size(); ++i) {
0499       mehHcalAEE[0]->Fill(HBCalDigis[i].AEE);
0500       if (HBCalDigis[i].SHE != 0.) {
0501         mehHcalSHE[0]->Fill(HBCalDigis[i].SHE);
0502         mehHcalAEESHE[0]->Fill(HBCalDigis[i].AEE / HBCalDigis[i].SHE);
0503         mehHcalSHEvAEE[0]->Fill(HBCalDigis[i].AEE, HBCalDigis[i].SHE, 1);
0504       }
0505     }
0506     std::vector<PGlobalDigi::HCalDigi> HECalDigis = srcGlobalDigis->getHECalDigis();
0507     mehHcaln[1]->Fill((float)nHECalDigis);
0508     for (unsigned int i = 0; i < HECalDigis.size(); ++i) {
0509       mehHcalAEE[1]->Fill(HECalDigis[i].AEE);
0510       if (HECalDigis[i].SHE != 0.) {
0511         mehHcalSHE[1]->Fill(HECalDigis[i].SHE);
0512         mehHcalAEESHE[1]->Fill(HECalDigis[i].AEE / HECalDigis[i].SHE);
0513         mehHcalSHEvAEE[1]->Fill(HECalDigis[i].AEE, HECalDigis[i].SHE, 1);
0514       }
0515     }
0516 
0517     std::vector<PGlobalDigi::HCalDigi> HOCalDigis = srcGlobalDigis->getHOCalDigis();
0518     mehHcaln[2]->Fill((float)nHOCalDigis);
0519     for (unsigned int i = 0; i < HOCalDigis.size(); ++i) {
0520       mehHcalAEE[2]->Fill(HOCalDigis[i].AEE);
0521       if (HOCalDigis[i].SHE != 0.) {
0522         mehHcalSHE[2]->Fill(HOCalDigis[i].SHE);
0523         mehHcalAEESHE[2]->Fill(HOCalDigis[i].AEE / HOCalDigis[i].SHE);
0524         mehHcalSHEvAEE[2]->Fill(HOCalDigis[i].AEE, HOCalDigis[i].SHE, 1);
0525       }
0526     }
0527 
0528     std::vector<PGlobalDigi::HCalDigi> HFCalDigis = srcGlobalDigis->getHFCalDigis();
0529     mehHcaln[3]->Fill((float)nHFCalDigis);
0530     for (unsigned int i = 0; i < HFCalDigis.size(); ++i) {
0531       mehHcalAEE[3]->Fill(HFCalDigis[i].AEE);
0532       if (HFCalDigis[i].SHE != 0.) {
0533         mehHcalSHE[3]->Fill(HFCalDigis[i].SHE);
0534         mehHcalAEESHE[3]->Fill(HFCalDigis[i].AEE / HFCalDigis[i].SHE);
0535         mehHcalSHEvAEE[3]->Fill(HFCalDigis[i].AEE, HFCalDigis[i].SHE, 1);
0536       }
0537     }
0538 
0539     // get SiStrip info
0540     std::vector<PGlobalDigi::SiStripDigi> TIBL1Digis = srcGlobalDigis->getTIBL1Digis();
0541     mehSiStripn[0]->Fill((float)nTIBL1Digis);
0542     for (unsigned int i = 0; i < TIBL1Digis.size(); ++i) {
0543       mehSiStripADC[0]->Fill(TIBL1Digis[i].ADC);
0544       mehSiStripStrip[0]->Fill(TIBL1Digis[i].STRIP);
0545     }
0546 
0547     std::vector<PGlobalDigi::SiStripDigi> TIBL2Digis = srcGlobalDigis->getTIBL2Digis();
0548     mehSiStripn[1]->Fill((float)nTIBL2Digis);
0549     for (unsigned int i = 0; i < TIBL2Digis.size(); ++i) {
0550       mehSiStripADC[1]->Fill(TIBL2Digis[i].ADC);
0551       mehSiStripStrip[1]->Fill(TIBL2Digis[i].STRIP);
0552     }
0553 
0554     std::vector<PGlobalDigi::SiStripDigi> TIBL3Digis = srcGlobalDigis->getTIBL3Digis();
0555     mehSiStripn[2]->Fill((float)nTIBL3Digis);
0556     for (unsigned int i = 0; i < TIBL3Digis.size(); ++i) {
0557       mehSiStripADC[2]->Fill(TIBL3Digis[i].ADC);
0558       mehSiStripStrip[2]->Fill(TIBL3Digis[i].STRIP);
0559     }
0560 
0561     std::vector<PGlobalDigi::SiStripDigi> TIBL4Digis = srcGlobalDigis->getTIBL4Digis();
0562     mehSiStripn[3]->Fill((float)nTIBL4Digis);
0563     for (unsigned int i = 0; i < TIBL4Digis.size(); ++i) {
0564       mehSiStripADC[3]->Fill(TIBL4Digis[i].ADC);
0565       mehSiStripStrip[3]->Fill(TIBL4Digis[i].STRIP);
0566     }
0567 
0568     std::vector<PGlobalDigi::SiStripDigi> TOBL1Digis = srcGlobalDigis->getTOBL1Digis();
0569     mehSiStripn[4]->Fill((float)nTOBL1Digis);
0570     for (unsigned int i = 0; i < TOBL1Digis.size(); ++i) {
0571       mehSiStripADC[4]->Fill(TOBL1Digis[i].ADC);
0572       mehSiStripStrip[4]->Fill(TOBL1Digis[i].STRIP);
0573     }
0574 
0575     std::vector<PGlobalDigi::SiStripDigi> TOBL2Digis = srcGlobalDigis->getTOBL2Digis();
0576     mehSiStripn[5]->Fill((float)nTOBL2Digis);
0577     for (unsigned int i = 0; i < TOBL2Digis.size(); ++i) {
0578       mehSiStripADC[5]->Fill(TOBL2Digis[i].ADC);
0579       mehSiStripStrip[5]->Fill(TOBL2Digis[i].STRIP);
0580     }
0581 
0582     std::vector<PGlobalDigi::SiStripDigi> TOBL3Digis = srcGlobalDigis->getTOBL3Digis();
0583     mehSiStripn[6]->Fill((float)nTOBL3Digis);
0584     for (unsigned int i = 0; i < TOBL3Digis.size(); ++i) {
0585       mehSiStripADC[6]->Fill(TOBL3Digis[i].ADC);
0586       mehSiStripStrip[6]->Fill(TOBL3Digis[i].STRIP);
0587     }
0588 
0589     std::vector<PGlobalDigi::SiStripDigi> TOBL4Digis = srcGlobalDigis->getTOBL4Digis();
0590     mehSiStripn[7]->Fill((float)nTOBL4Digis);
0591     for (unsigned int i = 0; i < TOBL4Digis.size(); ++i) {
0592       mehSiStripADC[7]->Fill(TOBL4Digis[i].ADC);
0593       mehSiStripStrip[7]->Fill(TOBL4Digis[i].STRIP);
0594     }
0595 
0596     std::vector<PGlobalDigi::SiStripDigi> TIDW1Digis = srcGlobalDigis->getTIDW1Digis();
0597     mehSiStripn[8]->Fill((float)nTIDW1Digis);
0598     for (unsigned int i = 0; i < TIDW1Digis.size(); ++i) {
0599       mehSiStripADC[8]->Fill(TIDW1Digis[i].ADC);
0600       mehSiStripStrip[8]->Fill(TIDW1Digis[i].STRIP);
0601     }
0602 
0603     std::vector<PGlobalDigi::SiStripDigi> TIDW2Digis = srcGlobalDigis->getTIDW2Digis();
0604     mehSiStripn[9]->Fill((float)nTIDW2Digis);
0605     for (unsigned int i = 0; i < TIDW2Digis.size(); ++i) {
0606       mehSiStripADC[9]->Fill(TIDW2Digis[i].ADC);
0607       mehSiStripStrip[9]->Fill(TIDW2Digis[i].STRIP);
0608     }
0609 
0610     std::vector<PGlobalDigi::SiStripDigi> TIDW3Digis = srcGlobalDigis->getTIDW3Digis();
0611     mehSiStripn[10]->Fill((float)nTIDW3Digis);
0612     for (unsigned int i = 0; i < TIDW3Digis.size(); ++i) {
0613       mehSiStripADC[10]->Fill(TIDW3Digis[i].ADC);
0614       mehSiStripStrip[10]->Fill(TIDW3Digis[i].STRIP);
0615     }
0616 
0617     std::vector<PGlobalDigi::SiStripDigi> TECW1Digis = srcGlobalDigis->getTECW1Digis();
0618     mehSiStripn[11]->Fill((float)nTECW1Digis);
0619     for (unsigned int i = 0; i < TECW1Digis.size(); ++i) {
0620       mehSiStripADC[11]->Fill(TECW1Digis[i].ADC);
0621       mehSiStripStrip[11]->Fill(TECW1Digis[i].STRIP);
0622     }
0623 
0624     std::vector<PGlobalDigi::SiStripDigi> TECW2Digis = srcGlobalDigis->getTECW2Digis();
0625     mehSiStripn[12]->Fill((float)nTECW2Digis);
0626     for (unsigned int i = 0; i < TECW2Digis.size(); ++i) {
0627       mehSiStripADC[12]->Fill(TECW2Digis[i].ADC);
0628       mehSiStripStrip[12]->Fill(TECW2Digis[i].STRIP);
0629     }
0630 
0631     std::vector<PGlobalDigi::SiStripDigi> TECW3Digis = srcGlobalDigis->getTECW3Digis();
0632     mehSiStripn[13]->Fill((float)nTECW3Digis);
0633     for (unsigned int i = 0; i < TECW3Digis.size(); ++i) {
0634       mehSiStripADC[13]->Fill(TECW3Digis[i].ADC);
0635       mehSiStripStrip[13]->Fill(TECW3Digis[i].STRIP);
0636     }
0637 
0638     std::vector<PGlobalDigi::SiStripDigi> TECW4Digis = srcGlobalDigis->getTECW4Digis();
0639     mehSiStripn[14]->Fill((float)nTECW4Digis);
0640     for (unsigned int i = 0; i < TECW4Digis.size(); ++i) {
0641       mehSiStripADC[14]->Fill(TECW4Digis[i].ADC);
0642       mehSiStripStrip[14]->Fill(TECW4Digis[i].STRIP);
0643     }
0644 
0645     std::vector<PGlobalDigi::SiStripDigi> TECW5Digis = srcGlobalDigis->getTECW5Digis();
0646     mehSiStripn[15]->Fill((float)nTECW5Digis);
0647     for (unsigned int i = 0; i < TECW5Digis.size(); ++i) {
0648       mehSiStripADC[15]->Fill(TECW5Digis[i].ADC);
0649       mehSiStripStrip[15]->Fill(TECW5Digis[i].STRIP);
0650     }
0651 
0652     std::vector<PGlobalDigi::SiStripDigi> TECW6Digis = srcGlobalDigis->getTECW6Digis();
0653     mehSiStripn[16]->Fill((float)nTECW6Digis);
0654     for (unsigned int i = 0; i < TECW6Digis.size(); ++i) {
0655       mehSiStripADC[16]->Fill(TECW6Digis[i].ADC);
0656       mehSiStripStrip[16]->Fill(TECW6Digis[i].STRIP);
0657     }
0658 
0659     std::vector<PGlobalDigi::SiStripDigi> TECW7Digis = srcGlobalDigis->getTECW7Digis();
0660     mehSiStripn[17]->Fill((float)nTECW7Digis);
0661     for (unsigned int i = 0; i < TECW7Digis.size(); ++i) {
0662       mehSiStripADC[17]->Fill(TECW7Digis[i].ADC);
0663       mehSiStripStrip[17]->Fill(TECW7Digis[i].STRIP);
0664     }
0665 
0666     std::vector<PGlobalDigi::SiStripDigi> TECW8Digis = srcGlobalDigis->getTECW8Digis();
0667     mehSiStripn[18]->Fill((float)nTECW8Digis);
0668     for (unsigned int i = 0; i < TECW8Digis.size(); ++i) {
0669       mehSiStripADC[18]->Fill(TECW8Digis[i].ADC);
0670       mehSiStripStrip[18]->Fill(TECW8Digis[i].STRIP);
0671     }
0672 
0673     // get SiPixel info
0674     std::vector<PGlobalDigi::SiPixelDigi> BRL1Digis = srcGlobalDigis->getBRL1Digis();
0675     mehSiPixeln[0]->Fill((float)nBRL1Digis);
0676     for (unsigned int i = 0; i < BRL1Digis.size(); ++i) {
0677       mehSiPixelADC[0]->Fill(BRL1Digis[i].ADC);
0678       mehSiPixelRow[0]->Fill(BRL1Digis[i].ROW);
0679       mehSiPixelCol[0]->Fill(BRL1Digis[i].COLUMN);
0680     }
0681 
0682     std::vector<PGlobalDigi::SiPixelDigi> BRL2Digis = srcGlobalDigis->getBRL2Digis();
0683     mehSiPixeln[1]->Fill((float)nBRL2Digis);
0684     for (unsigned int i = 0; i < BRL2Digis.size(); ++i) {
0685       mehSiPixelADC[1]->Fill(BRL2Digis[i].ADC);
0686       mehSiPixelRow[1]->Fill(BRL2Digis[i].ROW);
0687       mehSiPixelCol[1]->Fill(BRL2Digis[i].COLUMN);
0688     }
0689 
0690     std::vector<PGlobalDigi::SiPixelDigi> BRL3Digis = srcGlobalDigis->getBRL3Digis();
0691     mehSiPixeln[2]->Fill((float)nBRL3Digis);
0692     for (unsigned int i = 0; i < BRL3Digis.size(); ++i) {
0693       mehSiPixelADC[2]->Fill(BRL3Digis[i].ADC);
0694       mehSiPixelRow[2]->Fill(BRL3Digis[i].ROW);
0695       mehSiPixelCol[2]->Fill(BRL3Digis[i].COLUMN);
0696     }
0697 
0698     std::vector<PGlobalDigi::SiPixelDigi> FWD1pDigis = srcGlobalDigis->getFWD1pDigis();
0699     mehSiPixeln[3]->Fill((float)nFWD1pDigis);
0700     for (unsigned int i = 0; i < FWD1pDigis.size(); ++i) {
0701       mehSiPixelADC[3]->Fill(FWD1pDigis[i].ADC);
0702       mehSiPixelRow[3]->Fill(FWD1pDigis[i].ROW);
0703       mehSiPixelCol[3]->Fill(FWD1pDigis[i].COLUMN);
0704     }
0705 
0706     std::vector<PGlobalDigi::SiPixelDigi> FWD1nDigis = srcGlobalDigis->getFWD1nDigis();
0707     mehSiPixeln[4]->Fill((float)nFWD1nDigis);
0708     for (unsigned int i = 0; i < FWD1nDigis.size(); ++i) {
0709       mehSiPixelADC[4]->Fill(FWD1nDigis[i].ADC);
0710       mehSiPixelRow[4]->Fill(FWD1nDigis[i].ROW);
0711       mehSiPixelCol[4]->Fill(FWD1nDigis[i].COLUMN);
0712     }
0713 
0714     std::vector<PGlobalDigi::SiPixelDigi> FWD2pDigis = srcGlobalDigis->getFWD2pDigis();
0715     mehSiPixeln[5]->Fill((float)nFWD2pDigis);
0716     for (unsigned int i = 0; i < FWD2pDigis.size(); ++i) {
0717       mehSiPixelADC[5]->Fill(FWD2pDigis[i].ADC);
0718       mehSiPixelRow[5]->Fill(FWD2pDigis[i].ROW);
0719       mehSiPixelCol[5]->Fill(FWD2pDigis[i].COLUMN);
0720     }
0721 
0722     std::vector<PGlobalDigi::SiPixelDigi> FWD2nDigis = srcGlobalDigis->getFWD2nDigis();
0723     mehSiPixeln[6]->Fill((float)nFWD2nDigis);
0724     for (unsigned int i = 0; i < FWD2nDigis.size(); ++i) {
0725       mehSiPixelADC[6]->Fill(FWD2nDigis[i].ADC);
0726       mehSiPixelRow[6]->Fill(FWD2nDigis[i].ROW);
0727       mehSiPixelCol[6]->Fill(FWD2nDigis[i].COLUMN);
0728     }
0729 
0730     // get DtMuon info
0731     std::vector<PGlobalDigi::DTDigi> MB1Digis = srcGlobalDigis->getMB1Digis();
0732     mehDtMuonn[0]->Fill((float)nMB1Digis);
0733     for (unsigned int i = 0; i < MB1Digis.size(); ++i) {
0734       float layer = 4.0 * (MB1Digis[i].SLAYER - 1.0) + MB1Digis[i].LAYER;
0735       mehDtMuonLayer[0]->Fill(layer);
0736       mehDtMuonTime[0]->Fill(MB1Digis[i].TIME);
0737       mehDtMuonTimevLayer[0]->Fill(layer, MB1Digis[i].TIME, 1);
0738     }
0739 
0740     std::vector<PGlobalDigi::DTDigi> MB2Digis = srcGlobalDigis->getMB2Digis();
0741     mehDtMuonn[1]->Fill((float)nMB2Digis);
0742     for (unsigned int i = 0; i < MB2Digis.size(); ++i) {
0743       float layer = 4.0 * (MB2Digis[i].SLAYER - 1.0) + MB2Digis[i].LAYER;
0744       mehDtMuonLayer[1]->Fill(layer);
0745       mehDtMuonTime[1]->Fill(MB2Digis[i].TIME);
0746       mehDtMuonTimevLayer[1]->Fill(layer, MB2Digis[i].TIME, 1);
0747     }
0748 
0749     std::vector<PGlobalDigi::DTDigi> MB3Digis = srcGlobalDigis->getMB3Digis();
0750     mehDtMuonn[2]->Fill((float)nMB3Digis);
0751     for (unsigned int i = 0; i < MB3Digis.size(); ++i) {
0752       float layer = 4.0 * (MB3Digis[i].SLAYER - 1.0) + MB3Digis[i].LAYER;
0753       mehDtMuonLayer[2]->Fill(layer);
0754       mehDtMuonTime[2]->Fill(MB3Digis[i].TIME);
0755       mehDtMuonTimevLayer[2]->Fill(layer, MB3Digis[i].TIME, 1);
0756     }
0757 
0758     std::vector<PGlobalDigi::DTDigi> MB4Digis = srcGlobalDigis->getMB4Digis();
0759     mehDtMuonn[3]->Fill((float)nMB4Digis);
0760     for (unsigned int i = 0; i < MB4Digis.size(); ++i) {
0761       float layer = 4.0 * (MB4Digis[i].SLAYER - 1.0) + MB4Digis[i].LAYER;
0762       mehDtMuonLayer[3]->Fill(layer);
0763       mehDtMuonTime[3]->Fill(MB4Digis[i].TIME);
0764       mehDtMuonTimevLayer[3]->Fill(layer, MB4Digis[i].TIME, 1);
0765     }
0766 
0767     // get CSC Strip info
0768     std::vector<PGlobalDigi::CSCstripDigi> CSCstripDigis = srcGlobalDigis->getCSCstripDigis();
0769     mehCSCStripn->Fill((float)nCSCstripDigis);
0770     for (unsigned int i = 0; i < CSCstripDigis.size(); ++i) {
0771       mehCSCStripADC->Fill(CSCstripDigis[i].ADC);
0772     }
0773 
0774     // get CSC Wire info
0775     std::vector<PGlobalDigi::CSCwireDigi> CSCwireDigis = srcGlobalDigis->getCSCwireDigis();
0776     mehCSCWiren->Fill((float)nCSCwireDigis);
0777     for (unsigned int i = 0; i < CSCwireDigis.size(); ++i) {
0778       mehCSCWireTime->Fill(CSCwireDigis[i].TIME);
0779     }
0780     if (verbosity > 0)
0781       edm::LogInfo(MsgLoggerCat) << "Done gathering data from event.";
0782 
0783   }  // end loop through events
0784 }
0785 
0786 // define this as a plug-in
0787 // DEFINE_FWK_MODULE(GlobalDigisHistogrammer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!