Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2022-02-16 06:12:41 

0001 #include "DQM/L1TMonitor/interface/L1TStage2RegionalMuonShowerComp.h"
0002 
0003 L1TStage2RegionalMuonShowerComp::L1TStage2RegionalMuonShowerComp(const edm::ParameterSet& ps)
0004     : showerToken1_(consumes<l1t::RegionalMuonShowerBxCollection>(
0005           ps.getParameter<edm::InputTag>("regionalMuonShowerCollection1"))),
0006       showerToken2_(consumes<l1t::RegionalMuonShowerBxCollection>(
0007           ps.getParameter<edm::InputTag>("regionalMuonShowerCollection2"))),
0008       monitorDir_(ps.getUntrackedParameter<std::string>("monitorDir")),
0009       showerColl1Title_(ps.getUntrackedParameter<std::string>("regionalMuonShowerCollection1Title")),
0010       showerColl2Title_(ps.getUntrackedParameter<std::string>("regionalMuonShowerCollection2Title")),
0011       summaryTitle_(ps.getUntrackedParameter<std::string>("summaryTitle")),
0012       ignoreBin_(ps.getUntrackedParameter<std::vector<int>>("ignoreBin")),
0013       verbose_(ps.getUntrackedParameter<bool>("verbose")) {
0014   // First include all bins
0015   for (int i = 1; i <= numErrBins_; i++) {
0016     incBin_[i] = true;
0017   }
0018   // Then check the list of bins to ignore
0019   for (const auto& i : ignoreBin_) {
0020     if (i > 0 && i <= numErrBins_) {
0021       incBin_[i] = false;
0022     }
0023   }
0024 }
0025 
0026 L1TStage2RegionalMuonShowerComp::~L1TStage2RegionalMuonShowerComp() {}
0027 
0028 void L1TStage2RegionalMuonShowerComp::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0029   edm::ParameterSetDescription desc;
0030   desc.add<edm::InputTag>("regionalMuonShowerCollection1")->setComment("L1T RegionalMuonShower collection 1");
0031   desc.add<edm::InputTag>("regionalMuonShowerCollection2")->setComment("L1T RegionalMuonShower collection 2");
0032   desc.addUntracked<std::string>("monitorDir", "")
0033       ->setComment("Target directory in the DQM file. Will be created if not existing.");
0034   desc.addUntracked<std::string>("regionalMuonShowerCollection1Title", "Regional muon shower collection 1")
0035       ->setComment("Histogram title for first collection.");
0036   desc.addUntracked<std::string>("regionalMuonShowerCollection2Title", "Regional muon shower collection 2")
0037       ->setComment("Histogram title for second collection.");
0038   desc.addUntracked<std::string>("summaryTitle", "Summary")->setComment("Title of summary histogram.");
0039   desc.addUntracked<std::vector<int>>("ignoreBin", std::vector<int>())->setComment("List of bins to ignore");
0040   desc.addUntracked<bool>("verbose", false);
0041   descriptions.add("L1TStage2RegionalMuonShowerComp", desc);
0042 }
0043 
0044 void L1TStage2RegionalMuonShowerComp::bookHistograms(DQMStore::IBooker& ibooker,
0045                                                      const edm::Run&,
0046                                                      const edm::EventSetup&) {
0047   // Subsystem Monitoring and Muon Shower Output
0048   ibooker.setCurrentFolder(monitorDir_);
0049 
0050   summary_ = ibooker.book1D("summary",
0051                             summaryTitle_.c_str(),
0052                             numSummaryBins_,
0053                             1,
0054                             numSummaryBins_ + 1);  // range to match bin numbering
0055   summary_->setBinLabel(BXRANGEGOOD, "BX range match", 1);
0056   summary_->setBinLabel(BXRANGEBAD, "BX range mismatch", 1);
0057   summary_->setBinLabel(NSHOWERGOOD, "shower collection size match", 1);
0058   summary_->setBinLabel(NSHOWERBAD, "shower collection size mismatch", 1);
0059   summary_->setBinLabel(SHOWERALL, "# showers", 1);
0060   summary_->setBinLabel(SHOWERGOOD, "# matching showers", 1);
0061   summary_->setBinLabel(NOMINALBAD, "nominal shower mismatch", 1);
0062   summary_->setBinLabel(TIGHTBAD, "tight shower mismatch", 1);
0063 
0064   errorSummaryNum_ = ibooker.book1D("errorSummaryNum",
0065                                     summaryTitle_.c_str(),
0066                                     numErrBins_,
0067                                     1,
0068                                     numErrBins_ + 1);  // range to match bin numbering
0069   errorSummaryNum_->setBinLabel(RBXRANGE, "BX range mismatch", 1);
0070   errorSummaryNum_->setBinLabel(RNSHOWER, "shower collection size mismatch", 1);
0071   errorSummaryNum_->setBinLabel(RSHOWER, "mismatching showers", 1);
0072   errorSummaryNum_->setBinLabel(RNOMINAL, "nominal shower mismatch", 1);
0073   errorSummaryNum_->setBinLabel(RTIGHT, "tight shower mismatch", 1);
0074 
0075   // Change the label for those bins that will be ignored
0076   for (int i = 1; i <= errorSummaryNum_->getNbinsX(); i++) {
0077     if (incBin_[i] == false) {
0078       errorSummaryNum_->setBinLabel(i, "Ignored", 1);
0079     }
0080   }
0081   // Setting canExtend to false is needed to get the correct behaviour when running multithreaded.
0082   // Otherwise, when merging the histgrams of the threads, TH1::Merge sums bins that have the same label in one bin.
0083   // This needs to come after the calls to setBinLabel.
0084   errorSummaryNum_->getTH1F()->GetXaxis()->SetCanExtend(false);
0085 
0086   errorSummaryDen_ = ibooker.book1D(
0087       "errorSummaryDen", "denominators", numErrBins_, 1, numErrBins_ + 1);  // range to match bin numbering
0088   errorSummaryDen_->setBinLabel(RBXRANGE, "# events", 1);
0089   errorSummaryDen_->setBinLabel(RNSHOWER, "# shower collections", 1);
0090   for (int i = RSHOWER; i <= errorSummaryDen_->getNbinsX(); ++i) {
0091     errorSummaryDen_->setBinLabel(i, "# showers", 1);
0092   }
0093   // Needed for correct histogram summing in multithreaded running.
0094   errorSummaryDen_->getTH1F()->GetXaxis()->SetCanExtend(false);
0095 
0096   showerColl1BxRange_ =
0097       ibooker.book1D("showerBxRangeColl1", (showerColl1Title_ + " mismatching BX range").c_str(), 11, -5.5, 5.5);
0098   showerColl1BxRange_->setAxisTitle("BX range", 1);
0099   showerColl1nShowers_ =
0100       ibooker.book1D("nShowerColl1", (showerColl1Title_ + " mismatching shower multiplicity").c_str(), 37, -0.5, 36.5);
0101   showerColl1nShowers_->setAxisTitle("Shower multiplicity", 1);
0102   showerColl1ShowerTypeVsProcessor_ =
0103       ibooker.book2D("showerColl1ShowerTypeVsProcessor",
0104                      showerColl1Title_ + " mismatching shower type occupancy per sector",
0105                      12,
0106                      1,
0107                      13,
0108                      2,
0109                      1,
0110                      3);
0111   showerColl1ShowerTypeVsProcessor_->setAxisTitle("Processor", 1);
0112   showerColl1ShowerTypeVsProcessor_->setBinLabel(12, "+6", 1);
0113   showerColl1ShowerTypeVsProcessor_->setBinLabel(11, "+5", 1);
0114   showerColl1ShowerTypeVsProcessor_->setBinLabel(10, "+4", 1);
0115   showerColl1ShowerTypeVsProcessor_->setBinLabel(9, "+3", 1);
0116   showerColl1ShowerTypeVsProcessor_->setBinLabel(8, "+2", 1);
0117   showerColl1ShowerTypeVsProcessor_->setBinLabel(7, "+1", 1);
0118   showerColl1ShowerTypeVsProcessor_->setBinLabel(6, "-6", 1);
0119   showerColl1ShowerTypeVsProcessor_->setBinLabel(5, "-5", 1);
0120   showerColl1ShowerTypeVsProcessor_->setBinLabel(4, "-4", 1);
0121   showerColl1ShowerTypeVsProcessor_->setBinLabel(3, "-3", 1);
0122   showerColl1ShowerTypeVsProcessor_->setBinLabel(2, "-2", 1);
0123   showerColl1ShowerTypeVsProcessor_->setBinLabel(1, "-1", 1);
0124   showerColl1ShowerTypeVsProcessor_->setAxisTitle("Shower type", 2);
0125   showerColl1ShowerTypeVsProcessor_->setBinLabel(IDX_TIGHT_SHOWER, "Tight", 2);
0126   showerColl1ShowerTypeVsProcessor_->setBinLabel(IDX_NOMINAL_SHOWER, "Nominal", 2);
0127   showerColl1ShowerTypeVsBX_ = ibooker.book2D("showerColl1ShowerTypeVsBX",
0128                                               showerColl1Title_ + " mismatching shower type occupancy per BX",
0129                                               7,
0130                                               -3.5,
0131                                               3.5,
0132                                               2,
0133                                               1,
0134                                               3);
0135   showerColl1ShowerTypeVsBX_->setAxisTitle("BX", 1);
0136   showerColl1ShowerTypeVsBX_->setAxisTitle("Shower type", 2);
0137   showerColl1ShowerTypeVsBX_->setBinLabel(IDX_TIGHT_SHOWER, "Tight", 2);
0138   showerColl1ShowerTypeVsBX_->setBinLabel(IDX_NOMINAL_SHOWER, "Nominal", 2);
0139   showerColl1ProcessorVsBX_ = ibooker.book2D("showerColl1ProcessorVsBX",
0140                                              showerColl1Title_ + " mismatching shower BX occupancy per sector",
0141                                              7,
0142                                              -3.5,
0143                                              3.5,
0144                                              12,
0145                                              1,
0146                                              13);
0147   showerColl1ProcessorVsBX_->setAxisTitle("BX", 1);
0148   showerColl1ProcessorVsBX_->setAxisTitle("Processor", 2);
0149   showerColl1ProcessorVsBX_->setBinLabel(12, "+6", 2);
0150   showerColl1ProcessorVsBX_->setBinLabel(11, "+5", 2);
0151   showerColl1ProcessorVsBX_->setBinLabel(10, "+4", 2);
0152   showerColl1ProcessorVsBX_->setBinLabel(9, "+3", 2);
0153   showerColl1ProcessorVsBX_->setBinLabel(8, "+2", 2);
0154   showerColl1ProcessorVsBX_->setBinLabel(7, "+1", 2);
0155   showerColl1ProcessorVsBX_->setBinLabel(6, "-6", 2);
0156   showerColl1ProcessorVsBX_->setBinLabel(5, "-5", 2);
0157   showerColl1ProcessorVsBX_->setBinLabel(4, "-4", 2);
0158   showerColl1ProcessorVsBX_->setBinLabel(3, "-3", 2);
0159   showerColl1ProcessorVsBX_->setBinLabel(2, "-2", 2);
0160   showerColl1ProcessorVsBX_->setBinLabel(1, "-1", 2);
0161 
0162   showerColl2BxRange_ =
0163       ibooker.book1D("showerBxRangeColl2", (showerColl2Title_ + " mismatching BX range").c_str(), 11, -5.5, 5.5);
0164   showerColl2BxRange_->setAxisTitle("BX range", 1);
0165   showerColl2nShowers_ =
0166       ibooker.book1D("nShowerColl2", (showerColl2Title_ + " mismatching shower multiplicity").c_str(), 37, -0.5, 36.5);
0167   showerColl2nShowers_->setAxisTitle("Shower multiplicity", 1);
0168   showerColl2ShowerTypeVsProcessor_ =
0169       ibooker.book2D("showerColl2ShowerTypeVsProcessor",
0170                      showerColl2Title_ + " mismatching shower type occupancy per sector",
0171                      12,
0172                      1,
0173                      13,
0174                      2,
0175                      1,
0176                      3);
0177   showerColl2ShowerTypeVsProcessor_->setAxisTitle("Processor", 1);
0178   showerColl2ShowerTypeVsProcessor_->setBinLabel(12, "+6", 1);
0179   showerColl2ShowerTypeVsProcessor_->setBinLabel(11, "+5", 1);
0180   showerColl2ShowerTypeVsProcessor_->setBinLabel(10, "+4", 1);
0181   showerColl2ShowerTypeVsProcessor_->setBinLabel(9, "+3", 1);
0182   showerColl2ShowerTypeVsProcessor_->setBinLabel(8, "+2", 1);
0183   showerColl2ShowerTypeVsProcessor_->setBinLabel(7, "+1", 1);
0184   showerColl2ShowerTypeVsProcessor_->setBinLabel(6, "-6", 1);
0185   showerColl2ShowerTypeVsProcessor_->setBinLabel(5, "-5", 1);
0186   showerColl2ShowerTypeVsProcessor_->setBinLabel(4, "-4", 1);
0187   showerColl2ShowerTypeVsProcessor_->setBinLabel(3, "-3", 1);
0188   showerColl2ShowerTypeVsProcessor_->setBinLabel(2, "-2", 1);
0189   showerColl2ShowerTypeVsProcessor_->setBinLabel(1, "-1", 1);
0190   showerColl2ShowerTypeVsProcessor_->setAxisTitle("Shower type", 2);
0191   showerColl2ShowerTypeVsProcessor_->setBinLabel(IDX_TIGHT_SHOWER, "Tight", 2);
0192   showerColl2ShowerTypeVsProcessor_->setBinLabel(IDX_NOMINAL_SHOWER, "Nominal", 2);
0193   showerColl2ShowerTypeVsBX_ = ibooker.book2D("showerColl2ShowerTypeVsBX",
0194                                               showerColl2Title_ + " mismatching shower type occupancy per BX",
0195                                               7,
0196                                               -3.5,
0197                                               3.5,
0198                                               2,
0199                                               1,
0200                                               3);
0201   showerColl2ShowerTypeVsBX_->setAxisTitle("BX", 1);
0202   showerColl2ShowerTypeVsBX_->setAxisTitle("Shower type", 2);
0203   showerColl2ShowerTypeVsBX_->setBinLabel(IDX_TIGHT_SHOWER, "Tight", 2);
0204   showerColl2ShowerTypeVsBX_->setBinLabel(IDX_NOMINAL_SHOWER, "Nominal", 2);
0205   showerColl2ProcessorVsBX_ = ibooker.book2D("showerColl2ProcessorVsBX",
0206                                              showerColl2Title_ + " mismatching shower BX occupancy per sector",
0207                                              7,
0208                                              -3.5,
0209                                              3.5,
0210                                              12,
0211                                              1,
0212                                              13);
0213   showerColl2ProcessorVsBX_->setAxisTitle("BX", 1);
0214   showerColl2ProcessorVsBX_->setAxisTitle("Processor", 2);
0215   showerColl2ProcessorVsBX_->setBinLabel(12, "+6", 2);
0216   showerColl2ProcessorVsBX_->setBinLabel(11, "+5", 2);
0217   showerColl2ProcessorVsBX_->setBinLabel(10, "+4", 2);
0218   showerColl2ProcessorVsBX_->setBinLabel(9, "+3", 2);
0219   showerColl2ProcessorVsBX_->setBinLabel(8, "+2", 2);
0220   showerColl2ProcessorVsBX_->setBinLabel(7, "+1", 2);
0221   showerColl2ProcessorVsBX_->setBinLabel(6, "-6", 2);
0222   showerColl2ProcessorVsBX_->setBinLabel(5, "-5", 2);
0223   showerColl2ProcessorVsBX_->setBinLabel(4, "-4", 2);
0224   showerColl2ProcessorVsBX_->setBinLabel(3, "-3", 2);
0225   showerColl2ProcessorVsBX_->setBinLabel(2, "-2", 2);
0226   showerColl2ProcessorVsBX_->setBinLabel(1, "-1", 2);
0227 }
0228 
0229 void L1TStage2RegionalMuonShowerComp::analyze(const edm::Event& e, const edm::EventSetup& c) {
0230   if (verbose_) {
0231     edm::LogInfo("L1TStage2RegionalMuonShowerComp") << "L1TStage2RegionalMuonShowerComp: analyze..." << std::endl;
0232   }
0233 
0234   edm::Handle<l1t::RegionalMuonShowerBxCollection> showerBxColl1;
0235   edm::Handle<l1t::RegionalMuonShowerBxCollection> showerBxColl2;
0236   e.getByToken(showerToken1_, showerBxColl1);
0237   e.getByToken(showerToken2_, showerBxColl2);
0238 
0239   errorSummaryDen_->Fill(RBXRANGE);
0240   int bxRange1 = showerBxColl1->getLastBX() - showerBxColl1->getFirstBX() + 1;
0241   int bxRange2 = showerBxColl2->getLastBX() - showerBxColl2->getFirstBX() + 1;
0242   if (bxRange1 != bxRange2) {
0243     summary_->Fill(BXRANGEBAD);
0244     if (incBin_[RBXRANGE])
0245       errorSummaryNum_->Fill(RBXRANGE);
0246     int bx;
0247     for (bx = showerBxColl1->getFirstBX(); bx <= showerBxColl1->getLastBX(); ++bx) {
0248       showerColl1BxRange_->Fill(bx);
0249     }
0250     for (bx = showerBxColl2->getFirstBX(); bx <= showerBxColl2->getLastBX(); ++bx) {
0251       showerColl2BxRange_->Fill(bx);
0252     }
0253   } else {
0254     summary_->Fill(BXRANGEGOOD);
0255   }
0256 
0257   for (int iBx = showerBxColl1->getFirstBX(); iBx <= showerBxColl1->getLastBX(); ++iBx) {
0258     // don't analyse if this BX does not exist in the second collection
0259     if (iBx < showerBxColl2->getFirstBX() || iBx > showerBxColl2->getLastBX())
0260       continue;
0261 
0262     l1t::RegionalMuonShowerBxCollection::const_iterator showerIt1;
0263     l1t::RegionalMuonShowerBxCollection::const_iterator showerIt2;
0264 
0265     errorSummaryDen_->Fill(RNSHOWER);
0266 
0267     // check number of showers
0268     if (showerBxColl1->size(iBx) != showerBxColl2->size(iBx)) {
0269       summary_->Fill(NSHOWERBAD);
0270       if (incBin_[RNSHOWER])
0271         errorSummaryNum_->Fill(RNSHOWER);
0272       showerColl1nShowers_->Fill(showerBxColl1->size(iBx));
0273       showerColl2nShowers_->Fill(showerBxColl2->size(iBx));
0274 
0275       if (showerBxColl1->size(iBx) > showerBxColl2->size(iBx)) {
0276         showerIt1 = showerBxColl1->begin(iBx) + showerBxColl2->size(iBx);
0277         for (; showerIt1 != showerBxColl1->end(iBx); ++showerIt1) {
0278           if (showerIt1->isOneNominalInTime()) {
0279             showerColl1ShowerTypeVsProcessor_->Fill(
0280                 IDX_NOMINAL_SHOWER,
0281                 showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0282             showerColl1ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0283           }
0284           if (showerIt1->isOneTightInTime()) {
0285             showerColl1ShowerTypeVsProcessor_->Fill(
0286                 IDX_TIGHT_SHOWER,
0287                 showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0288             showerColl1ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0289           }
0290           showerColl1ProcessorVsBX_->Fill(
0291               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0292         }
0293       } else {
0294         showerIt2 = showerBxColl2->begin(iBx) + showerBxColl1->size(iBx);
0295         for (; showerIt2 != showerBxColl2->end(iBx); ++showerIt2) {
0296           if (showerIt2->isOneNominalInTime()) {
0297             showerColl2ShowerTypeVsProcessor_->Fill(
0298                 IDX_NOMINAL_SHOWER,
0299                 showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0300             showerColl2ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0301           }
0302           if (showerIt2->isOneTightInTime()) {
0303             showerColl2ShowerTypeVsProcessor_->Fill(
0304                 IDX_TIGHT_SHOWER,
0305                 showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0306             showerColl2ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0307           }
0308           showerColl2ProcessorVsBX_->Fill(
0309               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0310         }
0311       }
0312     } else {
0313       summary_->Fill(NSHOWERGOOD);
0314     }
0315 
0316     showerIt1 = showerBxColl1->begin(iBx);
0317     showerIt2 = showerBxColl2->begin(iBx);
0318     while (showerIt1 != showerBxColl1->end(iBx) && showerIt2 != showerBxColl2->end(iBx)) {
0319       summary_->Fill(SHOWERALL);
0320       for (int i = RSHOWER; i <= errorSummaryDen_->getNbinsX(); ++i) {
0321         errorSummaryDen_->Fill(i);
0322       }
0323 
0324       bool showerMismatch = false;     // All shower mismatches
0325       bool showerSelMismatch = false;  // Shower mismatches excluding ignored bins
0326       if (showerIt1->isOneNominalInTime() != showerIt2->isOneNominalInTime()) {
0327         showerMismatch = true;
0328         summary_->Fill(NOMINALBAD);
0329         if (incBin_[RNOMINAL]) {
0330           showerSelMismatch = true;
0331           errorSummaryNum_->Fill(RNOMINAL);
0332         }
0333       }
0334       if (showerIt1->isOneTightInTime() != showerIt2->isOneTightInTime()) {
0335         showerMismatch = true;
0336         summary_->Fill(TIGHTBAD);
0337         if (incBin_[RTIGHT]) {
0338           showerSelMismatch = true;
0339           errorSummaryNum_->Fill(RTIGHT);
0340         }
0341       }
0342       if (incBin_[RSHOWER] && showerSelMismatch) {
0343         errorSummaryNum_->Fill(RSHOWER);
0344       }
0345 
0346       if (showerMismatch) {
0347         if (showerIt1->isOneNominalInTime()) {
0348           showerColl1ShowerTypeVsProcessor_->Fill(
0349               IDX_NOMINAL_SHOWER,
0350               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0351           showerColl1ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0352         }
0353         if (showerIt1->isOneTightInTime()) {
0354           showerColl1ShowerTypeVsProcessor_->Fill(
0355               IDX_TIGHT_SHOWER,
0356               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0357           showerColl1ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0358         }
0359         showerColl1ProcessorVsBX_->Fill(
0360             showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0361 
0362         if (showerIt2->isOneNominalInTime()) {
0363           showerColl2ShowerTypeVsProcessor_->Fill(
0364               IDX_NOMINAL_SHOWER,
0365               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0366           showerColl2ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0367         }
0368         if (showerIt2->isOneTightInTime()) {
0369           showerColl2ShowerTypeVsProcessor_->Fill(
0370               IDX_TIGHT_SHOWER,
0371               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0372           showerColl2ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0373         }
0374         showerColl2ProcessorVsBX_->Fill(
0375             showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0376 
0377       } else {
0378         summary_->Fill(SHOWERGOOD);
0379       }
0380 
0381       ++showerIt1;
0382       ++showerIt2;
0383     }
0384   }
0385 }
[ 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!