Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:07:55 

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   summary_->setBinLabel(LOOSEBAD, "loose shower mismatch", 1);
0064 
0065   errorSummaryNum_ = ibooker.book1D("errorSummaryNum",
0066                                     summaryTitle_.c_str(),
0067                                     numErrBins_,
0068                                     1,
0069                                     numErrBins_ + 1);  // range to match bin numbering
0070   errorSummaryNum_->setBinLabel(RBXRANGE, "BX range mismatch", 1);
0071   errorSummaryNum_->setBinLabel(RNSHOWER, "shower collection size mismatch", 1);
0072   errorSummaryNum_->setBinLabel(RSHOWER, "mismatching showers", 1);
0073   errorSummaryNum_->setBinLabel(RNOMINAL, "nominal shower mismatch", 1);
0074   errorSummaryNum_->setBinLabel(RTIGHT, "tight shower mismatch", 1);
0075   errorSummaryNum_->setBinLabel(RLOOSE, "loose shower mismatch", 1);
0076 
0077   // Change the label for those bins that will be ignored
0078   for (int i = 1; i <= errorSummaryNum_->getNbinsX(); i++) {
0079     if (incBin_[i] == false) {
0080       errorSummaryNum_->setBinLabel(i, "Ignored", 1);
0081     }
0082   }
0083   // Setting canExtend to false is needed to get the correct behaviour when running multithreaded.
0084   // Otherwise, when merging the histgrams of the threads, TH1::Merge sums bins that have the same label in one bin.
0085   // This needs to come after the calls to setBinLabel.
0086   errorSummaryNum_->getTH1F()->GetXaxis()->SetCanExtend(false);
0087 
0088   errorSummaryDen_ = ibooker.book1D(
0089       "errorSummaryDen", "denominators", numErrBins_, 1, numErrBins_ + 1);  // range to match bin numbering
0090   errorSummaryDen_->setBinLabel(RBXRANGE, "# events", 1);
0091   errorSummaryDen_->setBinLabel(RNSHOWER, "# shower collections", 1);
0092   for (int i = RSHOWER; i <= errorSummaryDen_->getNbinsX(); ++i) {
0093     errorSummaryDen_->setBinLabel(i, "# showers", 1);
0094   }
0095   // Needed for correct histogram summing in multithreaded running.
0096   errorSummaryDen_->getTH1F()->GetXaxis()->SetCanExtend(false);
0097 
0098   showerColl1BxRange_ =
0099       ibooker.book1D("showerBxRangeColl1", (showerColl1Title_ + " mismatching BX range").c_str(), 11, -5.5, 5.5);
0100   showerColl1BxRange_->setAxisTitle("BX range", 1);
0101   showerColl1nShowers_ =
0102       ibooker.book1D("nShowerColl1", (showerColl1Title_ + " mismatching shower multiplicity").c_str(), 37, -0.5, 36.5);
0103   showerColl1nShowers_->setAxisTitle("Shower multiplicity", 1);
0104   showerColl1ShowerTypeVsProcessor_ =
0105       ibooker.book2D("showerColl1ShowerTypeVsProcessor",
0106                      showerColl1Title_ + " mismatching shower type occupancy per sector",
0107                      12,
0108                      1,
0109                      13,
0110                      3,
0111                      1,
0112                      4);
0113   showerColl1ShowerTypeVsProcessor_->setAxisTitle("Processor", 1);
0114   showerColl1ShowerTypeVsProcessor_->setBinLabel(12, "+6", 1);
0115   showerColl1ShowerTypeVsProcessor_->setBinLabel(11, "+5", 1);
0116   showerColl1ShowerTypeVsProcessor_->setBinLabel(10, "+4", 1);
0117   showerColl1ShowerTypeVsProcessor_->setBinLabel(9, "+3", 1);
0118   showerColl1ShowerTypeVsProcessor_->setBinLabel(8, "+2", 1);
0119   showerColl1ShowerTypeVsProcessor_->setBinLabel(7, "+1", 1);
0120   showerColl1ShowerTypeVsProcessor_->setBinLabel(6, "-6", 1);
0121   showerColl1ShowerTypeVsProcessor_->setBinLabel(5, "-5", 1);
0122   showerColl1ShowerTypeVsProcessor_->setBinLabel(4, "-4", 1);
0123   showerColl1ShowerTypeVsProcessor_->setBinLabel(3, "-3", 1);
0124   showerColl1ShowerTypeVsProcessor_->setBinLabel(2, "-2", 1);
0125   showerColl1ShowerTypeVsProcessor_->setBinLabel(1, "-1", 1);
0126   showerColl1ShowerTypeVsProcessor_->setAxisTitle("Shower type", 2);
0127   showerColl1ShowerTypeVsProcessor_->setBinLabel(IDX_LOOSE_SHOWER, "OneLoose", 2);
0128   showerColl1ShowerTypeVsProcessor_->setBinLabel(IDX_TIGHT_SHOWER, "OneTight", 2);
0129   showerColl1ShowerTypeVsProcessor_->setBinLabel(IDX_NOMINAL_SHOWER, "OneNominal", 2);
0130   showerColl1ShowerTypeVsBX_ = ibooker.book2D("showerColl1ShowerTypeVsBX",
0131                                               showerColl1Title_ + " mismatching shower type occupancy per BX",
0132                                               7,
0133                                               -3.5,
0134                                               3.5,
0135                                               3,
0136                                               1,
0137                                               4);
0138   showerColl1ShowerTypeVsBX_->setAxisTitle("BX", 1);
0139   showerColl1ShowerTypeVsBX_->setAxisTitle("Shower type", 2);
0140   showerColl1ShowerTypeVsBX_->setBinLabel(IDX_LOOSE_SHOWER, "OneLoose", 2);
0141   showerColl1ShowerTypeVsBX_->setBinLabel(IDX_TIGHT_SHOWER, "OneTight", 2);
0142   showerColl1ShowerTypeVsBX_->setBinLabel(IDX_NOMINAL_SHOWER, "OneNominal", 2);
0143   showerColl1ProcessorVsBX_ = ibooker.book2D("showerColl1ProcessorVsBX",
0144                                              showerColl1Title_ + " mismatching shower BX occupancy per sector",
0145                                              7,
0146                                              -3.5,
0147                                              3.5,
0148                                              12,
0149                                              1,
0150                                              13);
0151   showerColl1ProcessorVsBX_->setAxisTitle("BX", 1);
0152   showerColl1ProcessorVsBX_->setAxisTitle("Processor", 2);
0153   showerColl1ProcessorVsBX_->setBinLabel(12, "+6", 2);
0154   showerColl1ProcessorVsBX_->setBinLabel(11, "+5", 2);
0155   showerColl1ProcessorVsBX_->setBinLabel(10, "+4", 2);
0156   showerColl1ProcessorVsBX_->setBinLabel(9, "+3", 2);
0157   showerColl1ProcessorVsBX_->setBinLabel(8, "+2", 2);
0158   showerColl1ProcessorVsBX_->setBinLabel(7, "+1", 2);
0159   showerColl1ProcessorVsBX_->setBinLabel(6, "-6", 2);
0160   showerColl1ProcessorVsBX_->setBinLabel(5, "-5", 2);
0161   showerColl1ProcessorVsBX_->setBinLabel(4, "-4", 2);
0162   showerColl1ProcessorVsBX_->setBinLabel(3, "-3", 2);
0163   showerColl1ProcessorVsBX_->setBinLabel(2, "-2", 2);
0164   showerColl1ProcessorVsBX_->setBinLabel(1, "-1", 2);
0165 
0166   showerColl2BxRange_ =
0167       ibooker.book1D("showerBxRangeColl2", (showerColl2Title_ + " mismatching BX range").c_str(), 11, -5.5, 5.5);
0168   showerColl2BxRange_->setAxisTitle("BX range", 1);
0169   showerColl2nShowers_ =
0170       ibooker.book1D("nShowerColl2", (showerColl2Title_ + " mismatching shower multiplicity").c_str(), 37, -0.5, 36.5);
0171   showerColl2nShowers_->setAxisTitle("Shower multiplicity", 1);
0172   showerColl2ShowerTypeVsProcessor_ =
0173       ibooker.book2D("showerColl2ShowerTypeVsProcessor",
0174                      showerColl2Title_ + " mismatching shower type occupancy per sector",
0175                      12,
0176                      1,
0177                      13,
0178                      3,
0179                      1,
0180                      4);
0181   showerColl2ShowerTypeVsProcessor_->setAxisTitle("Processor", 1);
0182   showerColl2ShowerTypeVsProcessor_->setBinLabel(12, "+6", 1);
0183   showerColl2ShowerTypeVsProcessor_->setBinLabel(11, "+5", 1);
0184   showerColl2ShowerTypeVsProcessor_->setBinLabel(10, "+4", 1);
0185   showerColl2ShowerTypeVsProcessor_->setBinLabel(9, "+3", 1);
0186   showerColl2ShowerTypeVsProcessor_->setBinLabel(8, "+2", 1);
0187   showerColl2ShowerTypeVsProcessor_->setBinLabel(7, "+1", 1);
0188   showerColl2ShowerTypeVsProcessor_->setBinLabel(6, "-6", 1);
0189   showerColl2ShowerTypeVsProcessor_->setBinLabel(5, "-5", 1);
0190   showerColl2ShowerTypeVsProcessor_->setBinLabel(4, "-4", 1);
0191   showerColl2ShowerTypeVsProcessor_->setBinLabel(3, "-3", 1);
0192   showerColl2ShowerTypeVsProcessor_->setBinLabel(2, "-2", 1);
0193   showerColl2ShowerTypeVsProcessor_->setBinLabel(1, "-1", 1);
0194   showerColl2ShowerTypeVsProcessor_->setAxisTitle("Shower type", 2);
0195   showerColl2ShowerTypeVsProcessor_->setBinLabel(IDX_LOOSE_SHOWER, "OneLoose", 2);
0196   showerColl2ShowerTypeVsProcessor_->setBinLabel(IDX_TIGHT_SHOWER, "OneTight", 2);
0197   showerColl2ShowerTypeVsProcessor_->setBinLabel(IDX_NOMINAL_SHOWER, "OneNominal", 2);
0198   showerColl2ShowerTypeVsBX_ = ibooker.book2D("showerColl2ShowerTypeVsBX",
0199                                               showerColl2Title_ + " mismatching shower type occupancy per BX",
0200                                               7,
0201                                               -3.5,
0202                                               3.5,
0203                                               3,
0204                                               1,
0205                                               4);
0206   showerColl2ShowerTypeVsBX_->setAxisTitle("BX", 1);
0207   showerColl2ShowerTypeVsBX_->setAxisTitle("Shower type", 2);
0208   showerColl2ShowerTypeVsBX_->setBinLabel(IDX_TIGHT_SHOWER, "OneLoose", 2);
0209   showerColl2ShowerTypeVsBX_->setBinLabel(IDX_TIGHT_SHOWER, "OneTight", 2);
0210   showerColl2ShowerTypeVsBX_->setBinLabel(IDX_NOMINAL_SHOWER, "OneNominal", 2);
0211   showerColl2ProcessorVsBX_ = ibooker.book2D("showerColl2ProcessorVsBX",
0212                                              showerColl2Title_ + " mismatching shower BX occupancy per sector",
0213                                              7,
0214                                              -3.5,
0215                                              3.5,
0216                                              12,
0217                                              1,
0218                                              13);
0219   showerColl2ProcessorVsBX_->setAxisTitle("BX", 1);
0220   showerColl2ProcessorVsBX_->setAxisTitle("Processor", 2);
0221   showerColl2ProcessorVsBX_->setBinLabel(12, "+6", 2);
0222   showerColl2ProcessorVsBX_->setBinLabel(11, "+5", 2);
0223   showerColl2ProcessorVsBX_->setBinLabel(10, "+4", 2);
0224   showerColl2ProcessorVsBX_->setBinLabel(9, "+3", 2);
0225   showerColl2ProcessorVsBX_->setBinLabel(8, "+2", 2);
0226   showerColl2ProcessorVsBX_->setBinLabel(7, "+1", 2);
0227   showerColl2ProcessorVsBX_->setBinLabel(6, "-6", 2);
0228   showerColl2ProcessorVsBX_->setBinLabel(5, "-5", 2);
0229   showerColl2ProcessorVsBX_->setBinLabel(4, "-4", 2);
0230   showerColl2ProcessorVsBX_->setBinLabel(3, "-3", 2);
0231   showerColl2ProcessorVsBX_->setBinLabel(2, "-2", 2);
0232   showerColl2ProcessorVsBX_->setBinLabel(1, "-1", 2);
0233 }
0234 
0235 void L1TStage2RegionalMuonShowerComp::analyze(const edm::Event& e, const edm::EventSetup& c) {
0236   if (verbose_) {
0237     edm::LogInfo("L1TStage2RegionalMuonShowerComp") << "L1TStage2RegionalMuonShowerComp: analyze..." << std::endl;
0238   }
0239 
0240   edm::Handle<l1t::RegionalMuonShowerBxCollection> showerBxColl1;
0241   edm::Handle<l1t::RegionalMuonShowerBxCollection> showerBxColl2;
0242   e.getByToken(showerToken1_, showerBxColl1);
0243   e.getByToken(showerToken2_, showerBxColl2);
0244 
0245   errorSummaryDen_->Fill(RBXRANGE);
0246   int bxRange1 = showerBxColl1->getLastBX() - showerBxColl1->getFirstBX() + 1;
0247   int bxRange2 = showerBxColl2->getLastBX() - showerBxColl2->getFirstBX() + 1;
0248   if (bxRange1 != bxRange2) {
0249     summary_->Fill(BXRANGEBAD);
0250     if (incBin_[RBXRANGE])
0251       errorSummaryNum_->Fill(RBXRANGE);
0252     int bx;
0253     for (bx = showerBxColl1->getFirstBX(); bx <= showerBxColl1->getLastBX(); ++bx) {
0254       showerColl1BxRange_->Fill(bx);
0255     }
0256     for (bx = showerBxColl2->getFirstBX(); bx <= showerBxColl2->getLastBX(); ++bx) {
0257       showerColl2BxRange_->Fill(bx);
0258     }
0259   } else {
0260     summary_->Fill(BXRANGEGOOD);
0261   }
0262 
0263   for (int iBx = showerBxColl1->getFirstBX(); iBx <= showerBxColl1->getLastBX(); ++iBx) {
0264     // don't analyse if this BX does not exist in the second collection
0265     if (iBx < showerBxColl2->getFirstBX() || iBx > showerBxColl2->getLastBX())
0266       continue;
0267 
0268     l1t::RegionalMuonShowerBxCollection::const_iterator showerIt1;
0269     l1t::RegionalMuonShowerBxCollection::const_iterator showerIt2;
0270 
0271     errorSummaryDen_->Fill(RNSHOWER);
0272 
0273     // check number of showers
0274     if (showerBxColl1->size(iBx) != showerBxColl2->size(iBx)) {
0275       summary_->Fill(NSHOWERBAD);
0276       if (incBin_[RNSHOWER])
0277         errorSummaryNum_->Fill(RNSHOWER);
0278       showerColl1nShowers_->Fill(showerBxColl1->size(iBx));
0279       showerColl2nShowers_->Fill(showerBxColl2->size(iBx));
0280 
0281       if (showerBxColl1->size(iBx) > showerBxColl2->size(iBx)) {
0282         showerIt1 = showerBxColl1->begin(iBx) + showerBxColl2->size(iBx);
0283         for (; showerIt1 != showerBxColl1->end(iBx); ++showerIt1) {
0284           if (showerIt1->isOneNominalInTime()) {
0285             showerColl1ShowerTypeVsProcessor_->Fill(
0286                 IDX_NOMINAL_SHOWER,
0287                 showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0288             showerColl1ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0289           }
0290           if (showerIt1->isOneTightInTime()) {
0291             showerColl1ShowerTypeVsProcessor_->Fill(
0292                 IDX_TIGHT_SHOWER,
0293                 showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0294             showerColl1ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0295           }
0296           if (showerIt1->isOneLooseInTime()) {
0297             showerColl1ShowerTypeVsProcessor_->Fill(
0298                 IDX_LOOSE_SHOWER,
0299                 showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0300             showerColl1ShowerTypeVsBX_->Fill(IDX_LOOSE_SHOWER, iBx);
0301           }
0302           showerColl1ProcessorVsBX_->Fill(
0303               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0304         }
0305       } else {
0306         showerIt2 = showerBxColl2->begin(iBx) + showerBxColl1->size(iBx);
0307         for (; showerIt2 != showerBxColl2->end(iBx); ++showerIt2) {
0308           if (showerIt2->isOneNominalInTime()) {
0309             showerColl2ShowerTypeVsProcessor_->Fill(
0310                 IDX_NOMINAL_SHOWER,
0311                 showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0312             showerColl2ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0313           }
0314           if (showerIt2->isOneTightInTime()) {
0315             showerColl2ShowerTypeVsProcessor_->Fill(
0316                 IDX_TIGHT_SHOWER,
0317                 showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0318             showerColl2ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0319           }
0320           if (showerIt2->isOneLooseInTime()) {
0321             showerColl2ShowerTypeVsProcessor_->Fill(
0322                 IDX_LOOSE_SHOWER,
0323                 showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0324             showerColl2ShowerTypeVsBX_->Fill(IDX_LOOSE_SHOWER, iBx);
0325           }
0326           showerColl2ProcessorVsBX_->Fill(
0327               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0328         }
0329       }
0330     } else {
0331       summary_->Fill(NSHOWERGOOD);
0332     }
0333 
0334     showerIt1 = showerBxColl1->begin(iBx);
0335     showerIt2 = showerBxColl2->begin(iBx);
0336     while (showerIt1 != showerBxColl1->end(iBx) && showerIt2 != showerBxColl2->end(iBx)) {
0337       summary_->Fill(SHOWERALL);
0338       for (int i = RSHOWER; i <= errorSummaryDen_->getNbinsX(); ++i) {
0339         errorSummaryDen_->Fill(i);
0340       }
0341 
0342       bool showerMismatch = false;     // All shower mismatches
0343       bool showerSelMismatch = false;  // Shower mismatches excluding ignored bins
0344       if (showerIt1->isOneNominalInTime() != showerIt2->isOneNominalInTime()) {
0345         showerMismatch = true;
0346         summary_->Fill(NOMINALBAD);
0347         if (incBin_[RNOMINAL]) {
0348           showerSelMismatch = true;
0349           errorSummaryNum_->Fill(RNOMINAL);
0350         }
0351       }
0352       if (showerIt1->isOneTightInTime() != showerIt2->isOneTightInTime()) {
0353         showerMismatch = true;
0354         summary_->Fill(TIGHTBAD);
0355         if (incBin_[RTIGHT]) {
0356           showerSelMismatch = true;
0357           errorSummaryNum_->Fill(RTIGHT);
0358         }
0359       }
0360       if (showerIt1->isOneLooseInTime() != showerIt2->isOneLooseInTime()) {
0361         showerMismatch = true;
0362         summary_->Fill(LOOSEBAD);
0363         if (incBin_[RLOOSE]) {
0364           showerSelMismatch = true;
0365           errorSummaryNum_->Fill(RLOOSE);
0366         }
0367       }
0368       if (incBin_[RSHOWER] && showerSelMismatch) {
0369         errorSummaryNum_->Fill(RSHOWER);
0370       }
0371 
0372       if (showerMismatch) {
0373         if (showerIt1->isOneNominalInTime()) {
0374           showerColl1ShowerTypeVsProcessor_->Fill(
0375               IDX_NOMINAL_SHOWER,
0376               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0377           showerColl1ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0378         }
0379         if (showerIt1->isOneTightInTime()) {
0380           showerColl1ShowerTypeVsProcessor_->Fill(
0381               IDX_TIGHT_SHOWER,
0382               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0383           showerColl1ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0384         }
0385         if (showerIt1->isOneLooseInTime()) {
0386           showerColl1ShowerTypeVsProcessor_->Fill(
0387               IDX_LOOSE_SHOWER,
0388               showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0389           showerColl1ShowerTypeVsBX_->Fill(IDX_LOOSE_SHOWER, iBx);
0390         }
0391         showerColl1ProcessorVsBX_->Fill(
0392             showerIt1->processor() + 1 + (showerIt1->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0393 
0394         if (showerIt2->isOneNominalInTime()) {
0395           showerColl2ShowerTypeVsProcessor_->Fill(
0396               IDX_NOMINAL_SHOWER,
0397               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0398           showerColl2ShowerTypeVsBX_->Fill(IDX_NOMINAL_SHOWER, iBx);
0399         }
0400         if (showerIt2->isOneTightInTime()) {
0401           showerColl2ShowerTypeVsProcessor_->Fill(
0402               IDX_TIGHT_SHOWER,
0403               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0404           showerColl2ShowerTypeVsBX_->Fill(IDX_TIGHT_SHOWER, iBx);
0405         }
0406         if (showerIt2->isOneLooseInTime()) {
0407           showerColl2ShowerTypeVsProcessor_->Fill(
0408               IDX_LOOSE_SHOWER,
0409               showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0));
0410           showerColl2ShowerTypeVsBX_->Fill(IDX_LOOSE_SHOWER, iBx);
0411         }
0412         showerColl2ProcessorVsBX_->Fill(
0413             showerIt2->processor() + 1 + (showerIt2->trackFinderType() == l1t::tftype::emtf_pos ? 6 : 0), iBx);
0414 
0415       } else {
0416         summary_->Fill(SHOWERGOOD);
0417       }
0418 
0419       ++showerIt1;
0420       ++showerIt2;
0421     }
0422   }
0423 }
[ 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!