Project CMSSW displayed by LXR CMSSW_15_0_X_2024-12-11-2300/​HLTrigger/​Tools/​bin/​hltTimingSummary.cpp	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_0_X_2024-12-11-2300 CMSSW_15_0_X_2024-12-10-2300 CMSSW_15_0_X_2024-12-09-2300 CMSSW_15_0_X_2024-12-08-2300 CMSSW_15_0_X_2024-12-06-2300 CMSSW_15_0_X_2024-12-05-2300 Revert   Change

File indexing completed on 2024-04-06 12:18:46

 #include <TROOT.h>
 #include <TFile.h>
 #include <THashList.h>
 #include <TH2D.h>
 #include <TAttText.h>
 #include <TCanvas.h>
 #include <TStyle.h>
 #include <TTree.h>
 #include <TBranch.h>
 #include <TSystem.h>
 #include <THStack.h>
 
 #include <boost/program_options.hpp>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <string>
 
 #include "DataFormats/HLTReco/interface/HLTPerformanceInfo.h"
 #include "DataFormats/Provenance/interface/EventAuxiliary.h"
 #include "FWCore/FWLite/interface/FWLiteEnabler.h"
 #include "DataFormats/Common/interface/Wrapper.h"
 
 //--- Created by:
 //--- Bryan Dahmes (Bryan.Michael.Dahmes@cern.ch), January 2007
 //--- Modified by: Elim Cheung (elim.yee.lam.cheung@cern.ch) Jun 2011
 //--- Modified by: Alejandro Gomez (alejandro.gomez@cern.ch) Sep 2011
 
 // This function is for optimization purposes only (not used)
 void printTiming(double cpu, double real) {
   std::cout << "Timing info: " << cpu << " (cpu) and " << real << " (wall) seconds" << std::endl;
 }
 
 bool useEvent(int evt, std::vector<int> skip) {
   for (unsigned int i = 0; i < skip.size(); i++)
     if (evt == skip.at(i))
       return false;
   return true;
 }
 
 //TRUE - this event has at least one path passed (event accepted)
 //FALSE - this event fails all paths (event rejected)
 bool acceptedEvt(std::vector<double> pathStatus) {
   for (unsigned int i = 0; i < pathStatus.size(); i++)
     if (pathStatus.at(i) == -1)
       return true;
   return false;
 }
 
 //TRUE - the target module is included in time calculation
 //FALSE - the target module is skipped by user
 bool useModuleByName(HLTPerformanceInfo::Module module, std::vector<std::string> skip) {
   for (unsigned int i = 0; i < skip.size(); i++)
     if (module.name() == skip.at(i))
       return false;
   return true;
 }
 
 //TRUE - the target path is included in time calculation
 //FALSE - the target path is skipped by user
 bool usePathByName(HLTPerformanceInfo::Path path, std::vector<std::string> skip) {
   for (unsigned int i = 0; i < skip.size(); i++)
     if (path.name() == skip.at(i))
       return false;
   return true;
 }
 
 //initialize the following parameters
 void initialize(HLTPerformanceInfo hltPerf,
                 std::vector<std::string> skipMod,
                 std::vector<std::string> skipPath,
                 std::vector<bool>* mod,                            //useModule
                 std::vector<bool>* path,                           //usePath
                 std::vector<std::vector<bool> >* mip,              //useModInPath
                 std::vector<std::string>* mNames,                  //moduleNames
                 std::vector<std::string>* pNames,                  //pathNames
                 std::vector<std::vector<std::string> >* mipNames,  //moduleInPathNames
                 int& nmods,
                 int& npaths,                                //numberOfModules/Paths
                 std::vector<int>* nmips,                    //numberOfModulesInPath
                 std::vector<std::vector<int> >* mIdx,       //modulesIndexByPath
                 std::vector<std::vector<bool> >* unique,    //uniqueModules
                 std::vector<std::vector<int> >* mipMapper,  //globalModuleInPathMapper
                 std::vector<int>* mIdxInt,                  //modInxInterested
                 std::vector<std::string> mInt,
                 std::vector<int>* modExist) {  //moduleExistence
 
   //--- Start fresh ---//
   mod->clear();
   mip->clear();
   std::vector<std::string> names;
   names.clear();  //setting useModuleInPathNames
   std::vector<std::string> uniqueModInSkipPaths;
   uniqueModInSkipPaths.clear();
   nmods = 0;
   npaths = 0;
 
   //--- Path initialization ---//
   for (size_t piter = 0; piter < hltPerf.numberOfPaths(); ++piter) {
     const HLTPerformanceInfo::Path p = hltPerf.getPath(piter);
     int ctr = 0;
     std::vector<bool> pathMod;
     pathMod.clear();  //setting useModuleInPath
     std::vector<int> modIdx;
     modIdx.clear();  //setting moduleIndexByPath
     std::vector<bool> onlyOne;
     onlyOne.clear();                   //setting uniqueModules
     if (usePathByName(p, skipPath)) {  //check if path (p) is skipped by user
       for (size_t mm = 0; mm < hltPerf.getPath(piter).numberOfModules(); ++mm) {
         const HLTPerformanceInfo::Module& modIter = hltPerf.getModuleOnPath(mm, piter);
         if (useModuleByName(modIter, skipMod)) {  //check if module (modIter) is skipped by user
           pathMod.push_back(true);
           names.push_back(modIter.name());
           modIdx.push_back(hltPerf.moduleIndexInPath(modIter.name().c_str(), hltPerf.getPath(piter).name().c_str()));
           onlyOne.push_back(hltPerf.uniqueModule(modIter.name().c_str()));
           ctr++;
         } else {
           pathMod.push_back(false);
         }
       }
     } else if (!usePathByName(p, skipPath)) {
       for (size_t mm = 0; mm < hltPerf.getPath(piter).numberOfModules(); ++mm) {
         const HLTPerformanceInfo::Module& modIter = hltPerf.getModuleOnPath(mm, piter);
         if (useModuleByName(modIter, skipMod)) {
           if (hltPerf.uniqueModule(modIter.name().c_str())) {
             uniqueModInSkipPaths.push_back(modIter.name());  //modIter is unique in skipped path
           }
         }
       }
     }
 
     if (ctr > 0) {  // Path (p) has at least one valid module
       path->push_back(true);
       pNames->push_back(p.name());
       mipNames->push_back(names);
       mIdx->push_back(modIdx);
       unique->push_back(onlyOne);
       nmips->push_back(ctr);
       std::vector<int> mip2mIdx(ctr, -1);
       mipMapper->push_back(mip2mIdx);
       npaths++;
     } else {
       path->push_back(false);
     }
     mip->push_back(pathMod);
     names.clear();
   }
 
   //--- Module initialization ---//
   for (size_t i = 0; i < hltPerf.numberOfModules(); ++i) {
     const HLTPerformanceInfo::Module& myModule = hltPerf.getModule(i);
     if (useModuleByName(myModule, skipMod)) {                 //check if myModule is skipped by user
       if (useModuleByName(myModule, uniqueModInSkipPaths)) {  //check if myModule is unique in skipped path(s)
         mod->push_back(true);
         mNames->push_back(myModule.name());
         //Loop through module in path to find myModule (setting global mapper)
         for (unsigned int i = 0; i < unsigned(npaths); i++)
           for (unsigned int j = 0; j < unsigned(nmips->at(i)); j++)
             if (mipNames->at(i).at(j) == myModule.name())
               mipMapper->at(i).at(j) = nmods;
         nmods++;
       } else {
         mod->push_back(false);
       }
     } else {
       mod->push_back(false);
     }
   }
 
   modExist->resize(nmods, 0);
   //count how many times each module exists (may not be executed)
   for (unsigned int i = 0; i < unsigned(npaths); i++) {
     for (unsigned int j = 0; j < unsigned(nmips->at(i)); j++) {
       int mipIndex = mipMapper->at(i).at(j);
       modExist->at(mipIndex)++;
     }
   }
 
   //mIdxInt is a list of index where each modInterested is located
   for (unsigned i = 0; i < mInt.size(); i++) {
     std::vector<std::string>::iterator modpointer = std::find(mNames->begin(), mNames->end(), mInt.at(i));
     if (modpointer != mNames->end()) {
       std::vector<std::string>::size_type indexValue = (modpointer - mNames->begin());
       mIdxInt->push_back(indexValue);
     }
   }
 }
 
 double getTime(HLTPerformanceInfo::Module mod, bool useCPU) {
   if (useCPU)
     return mod.cputime();
   return mod.time();
 }
 
 double calculateMiPTime(std::vector<double> modTimes, double pathStatus, int mipIndex, int mIdx) {
   double time = -1.;
   if (mipIndex >= 0)  // Assures us that the module is in the path
     if ((pathStatus == -1.) || (pathStatus >= double(mIdx)))
       time = modTimes.at(mipIndex);
   return time;
 }
 
 TH1D* createSummaryHistogram(
     std::string name, std::string title, unsigned int nbins, std::vector<std::string> labels, std::string yaxis) {
   TH1D* histo = new TH1D(name.c_str(), title.c_str(), int(nbins), 0., double(nbins));
   for (unsigned int i = 0; i < nbins; i++)
     histo->GetXaxis()->SetBinLabel(i + 1, labels.at(i).c_str());
 
   histo->SetMinimum(0.);
   histo->GetYaxis()->SetTitle(yaxis.c_str());
   return histo;
 }
 
 std::vector<TH1D*> createEventHistograms(std::string name,
                                          std::string title,
                                          unsigned int nHistos,
                                          std::vector<std::string> nameTag,
                                          int nbins,
                                          double min,
                                          double max) {
   std::vector<TH1D*> histos;
   histos.clear();
   for (unsigned int i = 0; i < nHistos; i++) {
     std::string fullName = name + "_" + nameTag.at(i);
     std::string fullTitle = title + " " + nameTag.at(i);
     TH1D* histo = new TH1D(fullName.c_str(), fullTitle.c_str(), nbins, min, max);
     histo->GetXaxis()->SetTitle("msec");
     histo->StatOverflows(kTRUE);
     histos.push_back(histo);
   }
   return histos;
 }
 
 bool isFilterModule(HLTPerformanceInfo::Module module, std::vector<std::string> modList) {
   for (unsigned int i = 0; i < modList.size(); i++)
     if (module.name() == modList.at(i))
       return true;
   return false;
 }
 
 /*
 void plot1D(TH1D* histo, TCanvas* canvas, bool doPlot, int YScale) {
 
   // Standard 1D defaults
   double defaultSize   = 0.04 ; 
   double defaultMargin = 0.10 ; 
 
   if (histo->GetEntries()==0) YScale=0; 
   canvas->SetLogy(YScale);  
 
   histo->SetLabelSize(defaultSize) ; 
   canvas->SetBottomMargin(defaultMargin) ; 
   canvas->SetLeftMargin(defaultMargin) ;
  
   // Try to calculate new size...
   double realXsize = canvas->GetXsizeReal() *
     (1.0 - (canvas->GetLeftMargin() + canvas->GetRightMargin())) ; 
   double realYsize = canvas->GetYsizeReal() *
     (1.0 - (canvas->GetTopMargin() + canvas->GetBottomMargin())) ;
 
   double realBinSize = realXsize / double(histo->GetNbinsX()) ;
   double realBinAsYfraction = realBinSize / realYsize ;
   double newSize = realBinAsYfraction * 0.90 ; 
     
   THashList* hLabels = histo->GetXaxis()->GetLabels() ;
   if (hLabels!=0) {
     double charSize = std::min(defaultSize,newSize) ;        
     histo->LabelsOption("v","x") ;
     //--- Loop through the bins to get the largest bin name size ---//
     int nIter = 0 ; 
     bool properMargin = false ;
     double maxSize = defaultMargin ;
     while (!properMargin) {
       nIter++ ; 
       for (int i=1; i<=histo->GetNbinsX(); i++) {
     std::string label = histo->GetXaxis()->GetBinLabel(i) ;
     double labelSize = 0.40 * label.size() * charSize ;
     if (labelSize > maxSize) maxSize = labelSize ;
       }
       properMargin = true ; 
       if ((nIter < 10)&&(maxSize > 0.65)) {
     properMargin = false ;
     charSize = charSize*0.95 ;
     maxSize = defaultMargin ; 
       }
     }
 
     histo->SetLabelSize(charSize,"X") ;
     canvas->SetBottomMargin(maxSize) ; 
   }
 
   if (doPlot) {
     histo->Draw() ;
     canvas->Update() ;        
   }
 }
 
 void plot1D(TH1D* h1, TH1D* h2, TCanvas* canvas, bool doPlot, int YScale) {
 
   // Standard 1D defaults
   double defaultSize   = 0.04 ; 
   double defaultMargin = 0.10 ; 
 
   if (h1->GetEntries()==0) YScale=0; 
   canvas->SetLogy(YScale);
 
   h1->SetLabelSize(defaultSize) ; 
   h2->SetLabelSize(defaultSize) ; 
   canvas->SetBottomMargin(defaultMargin) ; 
   canvas->SetLeftMargin(defaultMargin) ; 
 
   // Try to calculate new size...
   double realXsize = canvas->GetXsizeReal() *
     (1.0 - (canvas->GetLeftMargin() + canvas->GetRightMargin())) ; 
   double realYsize = canvas->GetYsizeReal() *
     (1.0 - (canvas->GetTopMargin() + canvas->GetBottomMargin())) ;
 
   double realBinSize = realXsize / double(h1->GetNbinsX()) ;
   double realBinAsYfraction = realBinSize / realYsize ;
   double newSize = realBinAsYfraction * 0.90 ; 
 
   THashList* hLabels = h1->GetXaxis()->GetLabels() ; 
   if (hLabels!=0) {
     double charSize = std::min(defaultSize,newSize) ;
     h1->LabelsOption("v","x") ;
     h2->LabelsOption("v","x") ;
     //--- Loop through the bins to get the largest bin name size ---//
     int nIter = 0 ; 
     bool properMargin = false ;
     double maxSize = defaultMargin ;
     while (!properMargin) {
       nIter++ ; 
       for (int i=1; i<=h1->GetNbinsX(); i++) {
     std::string label = h1->GetXaxis()->GetBinLabel(i) ;
     double labelSize = 0.40 * label.size() * charSize ;
     if (labelSize > maxSize) maxSize = labelSize ;
       }
       properMargin = true ; 
       if ((nIter < 10)&&(maxSize > 0.65)) {
     properMargin = false ;
     charSize = charSize*0.95 ;
     maxSize = defaultMargin ; 
       }
     }
     h1->SetLabelSize(charSize,"X") ;
     h2->SetLabelSize(charSize,"X") ;
     canvas->SetBottomMargin(maxSize) ; 
   }
 
   if (doPlot) {
     h1->Draw() ;
     h2->SetFillColor(2);  h2->Draw("same") ; 
     canvas->Update() ;
   }
 }
 
 void plot2D(TH2D* histo, TCanvas* canvas, bool doPlot) {
   histo->SetMaximum(1.) ; histo->SetMinimum(0.) ;
   histo->SetStats(kFALSE) ; 
 
   // Defaults
   double defaultXsize = 0.04 ; 
   double defaultYsize = 0.04 ; 
   double defaultLeftMargin   = 0.10 ; 
   double defaultBottomMargin = 0.10 ; 
 
   histo->SetLabelSize(defaultXsize,"X") ; 
   histo->SetLabelSize(defaultYsize,"Y") ; 
   canvas->SetLeftMargin(defaultLeftMargin) ; 
   canvas->SetBottomMargin(defaultBottomMargin) ; 
 
   // Try to calculate new size...
   double realXsize = canvas->GetXsizeReal() *
     (1.0 - (canvas->GetLeftMargin() + canvas->GetRightMargin())) ; 
   double realYsize = canvas->GetYsizeReal() *
     (1.0 - (canvas->GetTopMargin() + canvas->GetBottomMargin())) ;
 
   double realXbinSize = realXsize / double(histo->GetNbinsX()) ;
   double realXbinAsYfraction = realXbinSize / realYsize ;
   double newXsize = realXbinAsYfraction * 0.90 ; 
 
   double realYbinSize = realXsize / double(histo->GetNbinsY()) ;
   double realYbinAsXfraction = realYbinSize / realXsize ;
   double newYsize = realYbinAsXfraction * 0.90 ; 
 
   THashList* hLabels = histo->GetXaxis()->GetLabels() ; 
   if (hLabels!=0) {
 
     double xCharSize = std::min(defaultXsize,newXsize) ;
     double yCharSize = std::min(defaultYsize,newYsize) ;
     histo->LabelsOption("v","x") ;
     //--- Loop through the bins to get the largest bin name size ---//
     int nIter = 0 ; 
     bool properMargin = false ;
     double xMaxSize = defaultBottomMargin ;
     while (!properMargin) {
       nIter++ ; 
       for (int i=1; i<=histo->GetNbinsX(); i++) {
     std::string label = histo->GetXaxis()->GetBinLabel(i) ;
     double labelSize = 0.40 * label.size() * xCharSize ;
     if (labelSize > xMaxSize) xMaxSize = labelSize ;
       }
       properMargin = true ; 
       if ((nIter < 10)&&(xMaxSize > 0.65)) {
     properMargin = false ;
     xCharSize = xCharSize*0.95 ;
     xMaxSize = defaultBottomMargin ; 
       }
     }
 
     nIter = 0 ; properMargin = false ;
     double yMaxSize = defaultLeftMargin ; 
     while (!properMargin) {
       nIter++ ; 
       for (int i=1; i<=histo->GetNbinsX(); i++) {
     std::string label = histo->GetXaxis()->GetBinLabel(i) ;
     double labelSize = 0.40 * label.size() * yCharSize ;
     if (labelSize > yMaxSize) yMaxSize = labelSize ;
       }
       properMargin = true ; 
       if ((nIter < 10)&&(yMaxSize > 0.65)) {
     properMargin = false ;
     yCharSize = yCharSize*0.95 ;
     yMaxSize = defaultLeftMargin ; 
       }
     }
 
     histo->SetLabelSize(xCharSize,"X") ;
     histo->SetLabelSize(yCharSize,"Y") ;
     canvas->SetBottomMargin(xMaxSize) ; 
     canvas->SetLeftMargin(yMaxSize) ; 
   }
 
   if (doPlot) {
     histo->Draw("colz") ; canvas->Update() ;
   }
 }
 
 void plotMany(std::vector<TH1D*> histo, TCanvas* canvas, bool doPlot, int YScale) {
     
   for (unsigned int i=0; i<histo.size(); i++)
     plot1D(histo.at(i),canvas,doPlot, YScale) ;
 }
 
 void plotMany(std::vector<TH1D*> h1, std::vector<TH1D*> h2,
               TCanvas* canvas, bool doPlot, int YScale) {
     
   for (unsigned int i=0; i<h1.size(); i++)
     plot1D(h1.at(i),h2.at(i),canvas,doPlot, YScale) ;
 }
 
 void plotMany(std::vector< std::vector<TH1D*> > hvec,TCanvas* canvas, bool doPlot, int YScale) {
 
  // Standard 1D defaults
   double defaultSize   = 0.04 ; 
   double defaultMargin = 0.10 ; 
   unsigned numCases = hvec.size();
   unsigned nPaths = hvec.at(0).size();
 
   canvas->SetLogy(YScale);
 
   for (unsigned int i=0; i<nPaths; i++){
     for (unsigned k=0; k<numCases; k++) {
       hvec.at(k).at(i)->SetLabelSize(defaultSize) ;      
     }
     canvas->SetBottomMargin(defaultMargin) ; 
     canvas->SetLeftMargin(defaultMargin) ; 
 
     // Try to calculate new size...
     double realXsize = canvas->GetXsizeReal() *
       (1.0 - (canvas->GetLeftMargin() + canvas->GetRightMargin())) ; 
     double realYsize = canvas->GetYsizeReal() *
       (1.0 - (canvas->GetTopMargin() + canvas->GetBottomMargin())) ;
     
     double realBinSize = realXsize / double(hvec.at(0).at(i)->GetNbinsX()) ;
     double realBinAsYfraction = realBinSize / realYsize ;
     double newSize = realBinAsYfraction * 0.90;
 
     THashList* hLabels = hvec.at(0).at(i)->GetXaxis()->GetLabels();
     if (hLabels!=0) {
       double charSize = std::min(defaultSize,newSize) ;
       for (unsigned k=0; k<numCases; k++) {
     hvec.at(k).at(i)->LabelsOption("v","x") ;    
       }
       //--- Loop through the bins to get the largest bin name size ---//
       int nIter = 0 ; 
       bool properMargin = false ;
       double maxSize = defaultMargin ;
       while (!properMargin) {
     nIter++ ; 
     for (int p=1; p<=hvec.at(0).at(i)->GetNbinsX(); p++) {
       std::string label = hvec.at(0).at(i)->GetXaxis()->GetBinLabel(p) ;
       double labelSize = 0.40 * label.size() * charSize ;
       if (labelSize > maxSize) maxSize = labelSize ;
     }
     properMargin = true ; 
     if ((nIter < 10)&&(maxSize > 0.65)) {
       properMargin = false ;
       charSize = charSize*0.95 ;
       maxSize = defaultMargin;
     }
       }
       
       for (unsigned k=0; k<numCases; k++) {
     hvec.at(k).at(i)->SetLabelSize(charSize,"X") ;
       }
       canvas->SetBottomMargin(maxSize) ;
     }
     
     if (doPlot) {
       hvec.at(0).at(i)->Draw() ;
       THStack *hs= new THStack("hs", "test");
       for (unsigned k=1; k<numCases; k++){
     hs->Add(hvec.at(k).at(i));
       }
       hs->Draw("same") ; 
       canvas->Update() ;
     }
   }
 }
 
 void plotModuleInPath(std::vector< std::vector<TH1D*> > histo, TCanvas* canvas,
                       int nPaths, std::vector<int> nMiPs, bool doPlot, bool scale) {
 
   for (unsigned int i=0; i<unsigned(nPaths); i++)
     for (unsigned int j=0; j<unsigned(nMiPs.at(i)); j++)
       plot1D(histo.at(i).at(j),canvas,doPlot, scale) ;
 }
 */
 void slowestModules(TH1D* histo,
                     std::vector<std::string>* mods,
                     std::vector<double>* time,
                     int nMods,
                     std::vector<std::string> mNames) {
   mods->clear();
   mods->resize(3, "none");
   time->clear();
   time->resize(3, -1.);
 
   for (unsigned int i = 0; i < unsigned(nMods); i++) {
     bool foundMax = false;
     for (unsigned int j = 0; j < 3; j++) {
       if (!foundMax && (histo->GetBinContent(i + 1) > time->at(j))) {
         // Quick check to see if module already in list
         bool inList = false;
         for (unsigned int k = 0; k < j; k++)
           if (mNames.at(i) == mods->at(k))
             inList = true;
 
         if (!inList) {
           foundMax = true;
           if (j == 0) {
             time->at(2) = time->at(1);
             mods->at(2) = mods->at(1);
             time->at(1) = time->at(0);
             mods->at(1) = mods->at(0);
           }
           if (j == 1) {
             time->at(2) = time->at(1);
             mods->at(2) = mods->at(1);
           }
 
           time->at(j) = histo->GetBinContent(i + 1);
           mods->at(j) = mNames.at(i);
         }
       }
     }
   }
 }
 
 void slowestModules(std::vector<TH1D*> histo,
                     std::vector<std::string>* path,
                     std::vector<std::string>* mip,
                     std::vector<double>* time,
                     int nPaths,
                     std::vector<int> nmips,
                     std::vector<std::string> pNames,
                     std::vector<std::vector<std::string> > mipNames) {
   path->clear();
   path->resize(3, "none");
   mip->clear();
   mip->resize(3, "none");
   time->clear();
   time->resize(3, -1.);
 
   for (unsigned int i = 0; i < unsigned(nPaths); i++) {
     for (unsigned int j = 0; j < unsigned(nmips.at(i)); j++) {
       bool foundMax = false;
       for (unsigned int k = 0; k < 3; k++) {
         if (!foundMax && (histo.at(i)->GetBinContent(j + 1) > time->at(k))) {
           // Quick check to see if module already in list
           bool inList = false;
           for (unsigned int l = 0; l < k; l++)
             if (mipNames.at(i).at(j) == mip->at(l))
               inList = true;
 
           if (!inList) {
             foundMax = true;
             if (k == 0) {
               time->at(2) = time->at(1);
               path->at(2) = path->at(1);
               mip->at(2) = mip->at(1);
               time->at(1) = time->at(0);
               path->at(1) = path->at(0);
               mip->at(1) = mip->at(0);
             }
             if (k == 1) {
               time->at(2) = time->at(1);
               path->at(2) = path->at(1);
               mip->at(2) = mip->at(1);
             }
 
             time->at(k) = histo.at(i)->GetBinContent(j + 1);
             path->at(k) = pNames.at(i);
             mip->at(k) = mipNames.at(i).at(j);
           }
         }
       }
     }
   }
 }
 
 int main(int argc, char** argv) {
   // Debugging/optimization utilities
   //     edm::CPUTimer myTimer ;
   //     myTimer.reset() ; myTimer.start() ;
 
   //-- Load libraries ---//
   gSystem->Load("libFWCoreFWLite");
   FWLiteEnabler::enable();
 
   //--- Default arguments ---//
   std::string filename = "hlt.root";
   std::string outbase = "hltTimingSummary";
   std::string outname = outbase + ".root";
   std::string sumname;
   std::vector<std::string> skipTimingMod;
   skipTimingMod.clear();
   std::vector<std::string> skipTimingPath;
   skipTimingPath.clear();
   std::vector<std::string> squareOne;
   squareOne.clear();
   std::string strSpecificTotalTime;
   std::string excludeModName, excludePathName, startHere;
   std::string modPrintName;
   std::vector<std::string> modInterested;
   modInterested.clear();
 
   //--- Boolean flags ---//
   bool writeSummary = false;
   bool takeCPUtime = false;
 
   //  int LogYScale = 0;
   //  int LinYScale = 0;
   double userMaxTime = -1.;
   double userBinWidth = -1.;
   bool skipFirstEvent = false;
   std::vector<std::pair<double, double> > specificTotalTime;
   int numberOfspecificTotalTime = 0;
 
   //--- Parameters to flag certain slow events ---//
   double totalTimeThreshold = -1.;
   double pathTimeThreshold = -1.;
   double moduleTimeThreshold = -1.;
 
   //--- Get parameters from command line ---//
   boost::program_options::options_description desc("Available options for hltTimingSummary");
   desc.add_options()("help,h", "Print this help message")(
       "infile,i", boost::program_options::value<std::string>(), "Input file name (Default is hlt.root)")(
       "outfile,o",
       boost::program_options::value<std::string>(),
       "Sets output files to <UserName>.root (default is hltTimingSummary)")(
       "summary,s",
       "Creates user-friendly timing summary file <UserName>-summary.txt.  See \"-o\" option for <UserName>")(
       "cpu,c", "Results presented as CPU time (in msec).  Default is wall clock.")(
       "time,t",
       boost::program_options::value<double>(),
       "All relevant histogram time axes run from 0 to <UserValue> (in msec)")(
       "bin,b",
       boost::program_options::value<double>(),
       "Bin size (in msec) for relevant timing histograms, specified by the user")(
       "noFirst,f", "Skip ANY event where a module is run for the first time (By default, run over all events)")
       //("logY,y",
       // "plot log scale y-axis for those plots that have events as entries")
       ("recalc,r",
        boost::program_options::value<std::string>(),
        "Recalculate rejection factor starting from specified list of filters/modules")(
           "excludeMod,e",
           boost::program_options::value<std::string>(),
           "Exclude a list of modules from the timing calculation")(
           "excludePath,x",
           boost::program_options::value<std::string>(),
           "Exclude a list of paths from the timing calculation")(
           "timelimit,l",
           boost::program_options::value<double>(),
           "Events where total time exceeds user-specified limit (in msec) listed in summary file")(
           "modPrint,g",
           boost::program_options::value<std::string>(),
           "Print event and run number of the user's input modules")(
           "pathlimit,a",
           boost::program_options::value<double>(),
           "Events where any path time exceeds user-specified limit (in msec) listed in summary file")(
           "modulelimit,m",
           boost::program_options::value<double>(),
           "Events where any module time exceeds user-specified limit (in msec) listed in summary file")(
           "timeSpecific,q",
           boost::program_options::value<std::string>(),
           "Overplots events with total time exceeds user-specified limit (in msec) for each pathTime: "
           "minTime,maxTimeAminTime,maxTimeA... Example:23,45A200,300");
 
   std::string usage = "\nSample hltTimingSummary usage::\n";
   usage += "\"hltTimingSummary -t 50 -b 5 -r filter1 -p 1\" ";
   usage += "inputs hlt.root, outputs hltTimingsummary.root,\n";
   usage += "                         Timing histograms run from 0 to 50 msec with 5 msec bins.\n";
   usage += "                         Rejection factor recalculated for paths including filter1.\n";
   usage += "\"hltTimingSummary -i in.root -f -e exclude.txt -o out -s\" ";
   usage += "inputs in.root, outputs out.root, out-summary.txt\n";
   usage += "                         Also skips events where modules are first run, and excludes \n";
   usage += "                         the modules listed in exclude.txt from timing calculations.\n\n";
   usage += "NOTE: To exclude files or use filters, the following formats are acceptable:\n";
   usage += "      - A comma-separated list of modules (e.g. \"hltTimingSummary -e a,b,c\")\n";
   usage += "      - A text file, where each excluded module appears on its own line\n";
   usage += "        (e.g. \"hltTimingSummary -r file.txt\")\n";
 
   boost::program_options::positional_options_description pos;
   boost::program_options::variables_map vmap;
 
   try {
     boost::program_options::store(
         boost::program_options::command_line_parser(argc, argv).options(desc).positional(pos).run(), vmap);
   } catch (boost::program_options::error const& x) {
     std::cerr << "Unable to parse options:\n" << x.what() << "\n\n";
     std::cerr << desc << usage << std::endl;
     return 1;
   }
 
   boost::program_options::notify(vmap);
   if (vmap.count("help")) {
     std::cout << desc << usage << std::endl;
     return 1;
   }
   if (vmap.count("infile")) {
     filename = vmap["infile"].as<std::string>();
   }
   if (vmap.count("outfile")) {
     outbase = vmap["outfile"].as<std::string>();
     outname = outbase + ".root";
   }
   if (vmap.count("summary") || vmap.count("timelimit") || vmap.count("pathlimit") || vmap.count("modulelimit")) {
     writeSummary = true;
     sumname = outbase + "-summary.txt";
     if (!vmap.count("summary"))
       std::cout << "Summary option not specified but time limit option(s) included.  Summary file will be generated."
                 << std::endl;
     if (vmap.count("timelimit"))
       totalTimeThreshold = vmap["timelimit"].as<double>();
     if (vmap.count("pathlimit"))
       pathTimeThreshold = vmap["pathlimit"].as<double>();
     if (vmap.count("modulelimit"))
       moduleTimeThreshold = vmap["modulelimit"].as<double>();
   }
   if (vmap.count("cpu")) {
     takeCPUtime = true;
     std::cout << "NOTE: You have elected to display results using CPU time." << std::endl;
     std::cout << "      Due to resolution effects in CPUTimer, event histogram results " << std::endl;
     std::cout << "      may not reflect reality.  **Use at your own risk**" << std::endl << std::endl;
   }
   if (vmap.count("time")) {
     userMaxTime = vmap["time"].as<double>();
   }
   if (vmap.count("bin")) {
     userBinWidth = vmap["bin"].as<double>();
   }
   if (vmap.count("noFirst")) {
     skipFirstEvent = true;
   }
   //if (vmap.count("logY")) {
   //  LogYScale = 1 ;
   //}
   if (vmap.count("recalc")) {
     startHere = vmap["recalc"].as<std::string>();
     std::ifstream filterFile(startHere.c_str());
     if (filterFile.is_open()) {  //--- Filter modules listed in a file ---//
       while (!filterFile.eof()) {
         std::string skipped;
         getline(filterFile, skipped);
         //--- Special: remove any trailing whitespace ---//
         size_t spos = skipped.find_first_not_of(' ');
         size_t epos = skipped.find_last_not_of(' ');
         if (spos != std::string::npos && epos != std::string::npos) {
           skipped = skipped.substr(spos, epos);
           squareOne.push_back(skipped);
         }
       }
     } else {  //--- Assume the file is a comma-separated list of modules ---//
       size_t strStart = 0;
       for (size_t itr = startHere.find(',', 0); itr != std::string::npos; itr = startHere.find(',', itr)) {
         std::string skipped = startHere.substr(strStart, (itr - strStart));
         itr++;
         strStart = itr;
         squareOne.push_back(skipped);
       }
       //--- Fill the last entry ---//
       squareOne.push_back(startHere.substr(strStart, startHere.length()));
     }
   }
   if (vmap.count("excludeMod")) {
     excludeModName = vmap["excludeMod"].as<std::string>();
 
     std::ifstream excludeModFile(excludeModName.c_str());
     if (excludeModFile.is_open()) {  //--- Excluded modules listed in a file ---//
       while (!excludeModFile.eof()) {
         std::string skipped;
         getline(excludeModFile, skipped);
         //--- Special: remove any trailing whitespace ---//
         size_t spos = skipped.find_first_not_of(' ');
         size_t epos = skipped.find_last_not_of(' ');
         if (spos != std::string::npos && epos != std::string::npos) {
           skipped = skipped.substr(spos, epos + 1);
           skipTimingMod.push_back(skipped);
         }
       }
     } else {  //--- Assume the file is a comma-separated list of modules ---//
       size_t strStart = 0;
       for (size_t itr = excludeModName.find(',', 0); itr != std::string::npos; itr = excludeModName.find(',', itr)) {
         std::string skipped = excludeModName.substr(strStart, (itr - strStart));
         itr++;
         strStart = itr;
         skipTimingMod.push_back(skipped);
       }
       //--- Fill the last entry ---//
       skipTimingMod.push_back(excludeModName.substr(strStart, excludeModName.length()));
     }
   }
 
   if (vmap.count("excludePath")) {
     excludePathName = vmap["excludePath"].as<std::string>();
 
     std::ifstream excludePathFile(excludePathName.c_str());
     if (excludePathFile.is_open()) {  //--- Excluded paths listed in a file ---//
       while (!excludePathFile.eof()) {
         std::string skipped;
         getline(excludePathFile, skipped);
         //--- Special: remove any trailing whitespace ---//
         size_t spos = skipped.find_first_not_of(' ');
         size_t epos = skipped.find_last_not_of(' ');
         if (spos != std::string::npos && epos != std::string::npos) {
           skipped = skipped.substr(spos, epos + 1);
           skipTimingPath.push_back(skipped);
         }
       }
     } else {  //--- Assume the file is a comma-separated list of paths ---//
       size_t strStart = 0;
       for (size_t itr = excludePathName.find(',', 0); itr != std::string::npos; itr = excludePathName.find(',', itr)) {
         std::string skipped = excludePathName.substr(strStart, (itr - strStart));
         itr++;
         strStart = itr;
         skipTimingPath.push_back(skipped);
       }
       //--- Fill the last entry ---//
       skipTimingPath.push_back(excludePathName.substr(strStart, excludePathName.length()));
     }
   }
 
   if (vmap.count("modPrint")) {
     modPrintName = vmap["modPrint"].as<std::string>();
 
     std::ifstream modPrintFile(modPrintName.c_str());
     if (modPrintFile.is_open()) {  //--- Excluded modules listed in a file ---//
       while (!modPrintFile.eof()) {
         std::string modname;
         getline(modPrintFile, modname);
         //--- Special: remove any trailing whitespace ---//
         size_t spos = modname.find_first_not_of(' ');
         size_t epos = modname.find_last_not_of(' ');
         if (spos != std::string::npos && epos != std::string::npos) {
           modname = modname.substr(spos, epos + 1);
           modInterested.push_back(modname);
         }
       }
     } else {  //--- Assume the file is a comma-separated list of modules ---//
       size_t strStart = 0;
       for (size_t itr = modPrintName.find(',', 0); itr != std::string::npos; itr = modPrintName.find(',', itr)) {
         std::string modname = modPrintName.substr(strStart, (itr - strStart));
         itr++;
         strStart = itr;
         modInterested.push_back(modname);
       }
       //--- Fill the last entry ---//
       modInterested.push_back(modPrintName.substr(strStart, modPrintName.length()));
     }
   }
 
   if (vmap.count("timeSpecific")) {
     strSpecificTotalTime = vmap["timeSpecific"].as<std::string>();
 
     unsigned int strStart = 0;
     numberOfspecificTotalTime = 0;
 
     for (size_t itr = strSpecificTotalTime.find('A', 0); itr != std::string::npos;
          itr = strSpecificTotalTime.find('A', itr)) {
       std::string strSpecificTimePair = strSpecificTotalTime.substr(strStart, (itr - strStart));
       size_t commaPos = strSpecificTimePair.find(',', 0);
       std::pair<double, double> specificTimePair;
       specificTimePair.first = atof(strSpecificTimePair.substr(0, commaPos).c_str());
       specificTimePair.second =
           atof(strSpecificTimePair.substr(commaPos + 1, strSpecificTimePair.length() - 1 - commaPos).c_str());
       specificTotalTime.push_back(specificTimePair);
       numberOfspecificTotalTime++;
       itr++;
       strStart = itr;
     }
     //--- Fill the last entry ---//
     std::string strSpecificTimePair = strSpecificTotalTime.substr(strStart, strSpecificTotalTime.length() - strStart);
     size_t commaPos = strSpecificTimePair.find(',', 0);
     std::pair<double, double> specificTimePair;
     specificTimePair.first = atof(strSpecificTimePair.substr(0, commaPos).c_str());
     specificTimePair.second =
         atof(strSpecificTimePair.substr(commaPos + 1, strSpecificTimePair.length() - 1 - commaPos).c_str());
     specificTotalTime.push_back(specificTimePair);
     numberOfspecificTotalTime++;
   }
 
   //--- Sanity check ---//
   for (unsigned int i = 0; i < skipTimingMod.size(); i++) {
     for (unsigned int j = 0; j < squareOne.size(); j++) {
       if (skipTimingMod.at(i) == squareOne.at(j)) {
         std::cout << "NOTE: You requested that " << squareOne.at(j)
                   << " be treated as a filter, but you also want it excluded from calculations" << std::endl;
         std::cout << "Please select either \"filter\" or \"exclude\" for this module." << std::endl;
         return 2;
       }
     }
   }
 
   std::cout << "Opening file " << filename << std::endl;
   TFile* file = TFile::Open(filename.c_str());
   if (file == nullptr) {
     std::cout << "*** Error opening file: " << filename << " ***" << std::endl;
     std::cout << "\n\n" << desc << usage << std::endl;
     return 1;
   }
 
   TTree* events = dynamic_cast<TTree*>(file->Get("Events"));
   assert(events);
 
   //--- Find the HLTPerformanceInfo branch ---//
   TIter iter(events->GetListOfBranches());
   std::string hltPerfInfoBranchName;
   TBranch* cand;
   TBranch::ResetCount();
   while ((cand = (TBranch*)iter())) {
     std::string branchName = cand->GetName();
     size_t loc = branchName.find("HLTPerformanceInfo");
     // Fixes proposed by Chris Jones and Dan Riley
     if (loc != std::string::npos)
       hltPerfInfoBranchName = branchName;
   }
 
   TBranch* TBPerfInfo = events->GetBranch(hltPerfInfoBranchName.c_str());
 
   assert(TBPerfInfo);
   // Additions suggested by Chris Jones and Dan Riley
   edm::Wrapper<HLTPerformanceInfo>* HLTPerformanceWrapper = nullptr;
   TBPerfInfo->SetAddress((void*)&HLTPerformanceWrapper);
 
   //--- Additions necessary to get the actual run/event number ---//
   TBranch* TBEvtAux = events->GetBranch("EventAuxiliary");
   assert(TBEvtAux);
   edm::EventAuxiliary* EvtAuxWrapper = new edm::EventAuxiliary;
   TBEvtAux->SetAddress((void*)&EvtAuxWrapper);
 
   //--- Prepare the output ---//
   TFile* outFile = new TFile(outname.c_str(), "recreate");
   std::ofstream txtfile;
   std::ofstream sumfile;
   if (!writeSummary) {
     std::cout << "Output to file: " << outname << std::endl;
   } else {
     //if ( writeSummary ) sumfile.open(sumname.c_str()) ;
     sumfile.open(sumname.c_str());
   }
 
   int n_evts = events->GetEntries();
   // HACK for testing purposes
   // n_evts = 100 ;
 
   //--- Events to be skipped ---//
   std::vector<int> skipEvents;
 
   //--- Variables used to set the scale for histograms ---//
   double longestEventTime = 0.;
   int longestEvent = -1;
   double sumTime = 0.;
   double sumTimeSq = 0.;
   double xmin = 0.;
   double xmax = 0.;
 
   //--- Need to initialize everything ---//
   std::vector<bool> useModule;
   std::vector<bool> usePath;
   std::vector<std::vector<bool> > useModuleInPath;
   std::vector<std::string> moduleNames;
   std::vector<std::string> pathNames;
   std::vector<std::vector<std::string> > moduleInPathNames;
   int numberOfModules = 0;
   int numberOfPaths = 0;
   std::vector<int> numberOfModulesInPath;
   std::vector<std::vector<int> > moduleIndexByPath;
   std::vector<std::vector<bool> > uniqueModule;
   std::vector<double> moduleIn;
   std::vector<std::vector<int> > numberOfModulesExecution;
   std::vector<int> moduleExistence;
 
   std::vector<std::vector<double> > eventModuleTime;
   std::vector<std::vector<double> > eventPathStatus;
   std::vector<std::vector<double> > moduleInPathIn;
   std::vector<std::vector<double> > moduleInPathOut;
 
   std::vector<double> moduleTimeSummaryVector;
   std::vector<double> pathTimeSummaryVector;
   std::vector<std::vector<double> > specificPathTimeSummaryVector;
   std::vector<double> incPathTimeSummaryVector;
   std::vector<std::vector<int> > globalModuleInPathMapper;
   std::vector<std::vector<double> > moduleInPathTimeSummaryVector;
 
   std::vector<double> longestEventTimeByModule;
   std::vector<int> longestEventByModule;
   std::vector<int> pathFilterModule;
 
   std::vector<std::pair<unsigned int, unsigned long long> > slowEventSummaryVector;
   std::vector<std::pair<unsigned int, unsigned long long> > slowPathSummaryVector;
   std::vector<std::pair<unsigned int, unsigned long long> > slowModuleSummaryVector;
   std::vector<int> modIdxInterested;
   std::vector<std::vector<std::pair<unsigned int, unsigned long long> > > slowModInterestedVector;
 
   //--- One loop through all events ---//
   bool init = false;
   int nSkips = 0;
   std::vector<double> eventTime(n_evts, 0.);
 
   for (int ievt = 0; ievt < n_evts; ievt++) {
     // These count the true order of modules, paths
     int pCtr = 0;
     int mCtr = 0;
     // These count the index of modules, paths (for timing calculation)
     int pIdx = 0;
     int mIdx = 0;
 
     // Initialization
     if (!init) {
       init = true;
       TBPerfInfo->GetEntry(ievt);
       initialize((*(HLTPerformanceWrapper->product())),
                  skipTimingMod,
                  skipTimingPath,
                  &useModule,
                  &usePath,
                  &useModuleInPath,
                  &moduleNames,
                  &pathNames,
                  &moduleInPathNames,
                  numberOfModules,
                  numberOfPaths,
                  &numberOfModulesInPath,
                  &moduleIndexByPath,
                  &uniqueModule,
                  &globalModuleInPathMapper,
                  &modIdxInterested,
                  modInterested,
                  &moduleExistence);
 
       pathTimeSummaryVector.resize(numberOfPaths, 0.);
       std::vector<double> specificPathTimeSummaryVectorAtK(numberOfPaths, 0.);
       for (int k = 0; k < numberOfspecificTotalTime; k++) {
         specificPathTimeSummaryVector.push_back(specificPathTimeSummaryVectorAtK);
       }
       //      std::pair<unsigned int,unsigned int> pair ;
       std::vector<std::pair<unsigned int, unsigned long long> > slowModInterestedVectorAtK;
       for (unsigned k = 0; k < modInterested.size(); k++) {
         slowModInterestedVector.push_back(slowModInterestedVectorAtK);
       }
       incPathTimeSummaryVector.resize(numberOfPaths, 0.);
       moduleTimeSummaryVector.resize(numberOfModules, 0.);
       moduleIn.resize(numberOfModules, 0.);
       longestEventTimeByModule.resize(numberOfModules, 0.);
       longestEventByModule.resize(numberOfModules, -1);
       pathFilterModule.resize(numberOfPaths, -1);
 
       // Event vectors...all have MODIFIED module, path structure
       std::vector<std::vector<double> > dMiP;
       std::vector<double> dMod(numberOfModules, -1.);
       std::vector<int> dModIdx(numberOfModules, 0);
       pCtr = 0;
       pIdx = 0;
 
       for (size_t piter = 0; piter < (*HLTPerformanceWrapper)->numberOfPaths(); ++piter) {
         HLTPerformanceInfo::Path p = (*HLTPerformanceWrapper)->getPath(piter);
         if (usePath.at(pCtr)) {
           // Determine the index of the filter modules in each path
           if (!squareOne.empty()) {
             mCtr = 0;
             mIdx = 0;
             // loop over modules on path
             for (size_t i = 0; i < (*HLTPerformanceWrapper)->getPath(piter).numberOfModules(); ++i) {
               const HLTPerformanceInfo::Module& myModule =
                   (*HLTPerformanceWrapper)->getModule((*HLTPerformanceWrapper)->getPath(piter).getModuleIndex(i));
               if (useModuleInPath.at(pCtr).at(mCtr)) {
                 if (isFilterModule(myModule, squareOne)) {
                   if (pathFilterModule.at(pIdx) >= 0) {
                     std::cout << "WARNING: Filter already set for path " << p.name() << ".  Resetting to "
                               << myModule.name() << std::endl;
                   }
                   pathFilterModule.at(pIdx) = mIdx;
                 }
                 mIdx++;
               }
               mCtr++;
             }
           }
 
           std::vector<double> nMiPs(numberOfModulesInPath.at(pIdx), -1.);
           std::vector<double> zMiPs(numberOfModulesInPath.at(pIdx), 0.);
           dMiP.push_back(nMiPs);
           moduleInPathTimeSummaryVector.push_back(zMiPs);
           moduleInPathIn.push_back(zMiPs);
           moduleInPathOut.push_back(zMiPs);
           pIdx++;
         }
         pCtr++;
       }
 
       eventModuleTime.resize(n_evts, dMod);
       numberOfModulesExecution.resize(n_evts, dModIdx);
       std::vector<double> dPath(numberOfPaths, -1.);
       eventPathStatus.resize(n_evts, dPath);
       skipEvents.resize(numberOfModules, -1);
     }  //end initialization/checking
 
     // Get the event
     TBPerfInfo->GetEntry(ievt);
 
     // Check if we should skip the event
     mCtr = 0;
     mIdx = 0;
     bool useThisEvent = true;
     if (skipFirstEvent && (nSkips < numberOfModules)) {
       for (size_t i = 0; i < (*HLTPerformanceWrapper)->numberOfModules(); ++i) {
         const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModule(i);
         if (useModule.at(mCtr++)) {
           // Due to the resolution problems with CPUTimer,
           // ALWAYS determine event skipping using wall clock time
           if (getTime((myModule), false) > 0) {
             if (skipEvents.at(mIdx) < 0) {
               skipEvents.at(mIdx) = ievt;
               if (useThisEvent)
                 nSkips++;
               useThisEvent = false;
             }
           }
           mIdx++;
         }
       }
     }
 
     if (!useThisEvent)
       continue;
 
     //for all paths, count how many times the each module is executed
     pCtr = 0;
     pIdx = 0;
     for (size_t piter = 0; piter < (*HLTPerformanceWrapper)->numberOfPaths(); ++piter) {
       const HLTPerformanceInfo::Path p = (*HLTPerformanceWrapper)->getPath(piter);
       if (usePath.at(pCtr)) {
         mCtr = 0;
         mIdx = 0;
         for (size_t mm = 0; mm < (*HLTPerformanceWrapper)->getPath(piter).numberOfModules(); ++mm) {
           if (useModuleInPath.at(pCtr).at(mCtr)) {
             if (moduleIndexByPath.at(pIdx).at(mIdx) <= int(p.status().index())) {
               int globalModuleIndex = globalModuleInPathMapper.at(pIdx).at(mIdx);
               numberOfModulesExecution.at(ievt).at(globalModuleIndex)++;
               mIdx++;
             }
           }
           mCtr++;
         }
         pIdx++;
       }
       pCtr++;
     }
 
     // Determine module times, module success/failure
     pCtr = 0;
     pIdx = 0;
     std::vector<bool> eventCounted(numberOfModules, false);
     for (size_t piter = 0; piter < (*HLTPerformanceWrapper)->numberOfPaths(); ++piter) {
       const HLTPerformanceInfo::Path p = (*HLTPerformanceWrapper)->getPath(piter);
 
       if (usePath.at(pCtr)) {
         if (p.status().accept())
           eventPathStatus.at(ievt).at(pIdx) = -1;
 
         mCtr = 0;
         mIdx = 0;
         for (size_t mm = 0; mm < (*HLTPerformanceWrapper)->getPath(piter).numberOfModules(); ++mm) {
           const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModuleOnPath(mm, piter);
           if (useModuleInPath.at(pCtr).at(mCtr)) {
             if (moduleIndexByPath.at(pIdx).at(mIdx) <= int(p.status().index())) {
               int globalModuleIndex = globalModuleInPathMapper.at(pIdx).at(mIdx);
               if (numberOfModulesExecution.at(ievt).at(globalModuleIndex) > 0) {
                 moduleInPathTimeSummaryVector.at(pIdx).at(mIdx) += getTime(myModule, takeCPUtime);
                 pathTimeSummaryVector.at(pIdx) += getTime((myModule), takeCPUtime);
               }
               if (moduleExistence.at(globalModuleIndex) == 1)
                 incPathTimeSummaryVector.at(pIdx) += getTime((myModule), takeCPUtime);
 
               // Determine success/failure
               moduleInPathIn.at(pIdx).at(mIdx)++;
 
               if (globalModuleIndex >= 0) {
                 if (!eventCounted.at(unsigned(globalModuleIndex))) {
                   eventCounted.at(unsigned(globalModuleIndex)) = true;
                   moduleIn.at(unsigned(globalModuleIndex))++;
                 }
               }
 
               bool modulePassed = false;
               if (p.status().accept())
                 modulePassed = true;  //path passed (i.e. all modules in path passed)
               if (moduleIndexByPath.at(pIdx).at(mIdx) < int(p.status().index()))
                 modulePassed = true;
               if (modulePassed) {
                 moduleInPathOut.at(pIdx).at(mIdx)++;
               } else if (moduleIndexByPath.at(pIdx).at(mIdx) == int(p.status().index()) && !p.status().accept()) {
                 eventPathStatus.at(ievt).at(pIdx) = double(mIdx);
               }
               mIdx++;
             }
           } else {
             if ((int(p.status().index()) == mCtr) && !p.status().accept()) {  // Path dies at excluded module
               // The mIdx is pointing to the next "used" module, have not gotten there yet
               eventPathStatus.at(ievt).at(pIdx) = double(mIdx) - 0.5;
             }
           }
           mCtr++;
         }
         pIdx++;
       }
       pCtr++;
     }
 
     //---Total Time, Module Time, Event Module Time, Longest Event Time Calculation---//
     mCtr = 0;
     mIdx = 0;
     for (size_t i = 0; i < (*HLTPerformanceWrapper)->numberOfModules(); ++i) {
       const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModule(i);
       if (useModule.at(mCtr++)) {
         if (numberOfModulesExecution.at(ievt).at(mIdx) > 0) {
           moduleTimeSummaryVector.at(mIdx) += getTime((myModule), takeCPUtime);
           eventModuleTime.at(ievt).at(mIdx) = getTime((myModule), takeCPUtime);
           eventTime.at(ievt) += getTime((myModule), takeCPUtime);  // Calculate total time from used modules
           // Determine the event where a given module took the most time
           if ((1000. * getTime((myModule), takeCPUtime)) > longestEventTimeByModule.at(mIdx)) {
             longestEventTimeByModule.at(mIdx) = 1000. * getTime((myModule), takeCPUtime);
             longestEventByModule.at(mIdx) = ievt;
           }
         } else {
           eventModuleTime.at(ievt).at(mIdx) = 0.;
         }
         mIdx++;
       }
     }
 
     if (eventTime.at(ievt) > longestEventTime) {
       longestEventTime = eventTime.at(ievt);
       longestEvent = ievt;
     }
 
     sumTime += eventTime.at(ievt);
     sumTimeSq += eventTime.at(ievt) * eventTime.at(ievt);
   }
 
   int xscale = 4;
   if (longestEventTime == 0) {
     std::cout << "No modules appear to have run in any path.  Exiting..." << std::endl;
     return 2;
   }
 
   if (userMaxTime > 0) {
     xmax = userMaxTime;
   } else if (n_evts > 1) {
     // Remove the slowest event, compute mean, std. dev. from subset of data
     double subMean = (sumTime - longestEventTime) / double(n_evts - 1);
     double subRmsSq = (sumTimeSq - longestEventTime * longestEventTime) / double(n_evts - 1);
     double subSigma = sqrt(subRmsSq - subMean * subMean);
     double subReasMaxTime = subMean + 3. * subSigma;
 
     while (pow(10, xscale--) > subReasMaxTime)
       ;
     xscale += 2;
     xmax = pow(10, xscale + 3);
 
     if ((xmax / 5.) > (subReasMaxTime * 1000.))
       xmax = xmax / 5.;
     if ((xmax / 2.) > (subReasMaxTime * 1000.))
       xmax = xmax / 2.;
   }
 
   // Determine how many events are skipped
   std::vector<int> reducedSkipEvents;
   for (unsigned int i = 0; i < skipEvents.size(); i++) {
     if (skipEvents.at(i) < 0)
       continue;
     bool newSkippedEvent = true;
     for (unsigned int j = 0; j < reducedSkipEvents.size(); j++) {
       if (reducedSkipEvents.at(j) == skipEvents.at(i))
         newSkippedEvent = false;
       if (!newSkippedEvent)
         break;
     }
     if (newSkippedEvent)
       reducedSkipEvents.push_back(skipEvents.at(i));
   }
 
   if (skipFirstEvent)
     std::cout << "Skipping a total of " << reducedSkipEvents.size() << " events for module initialization" << std::endl;
 
   // Create histograms
   int numberOfXbins = 100;
   if (userBinWidth > 0) {
     int nBins = int((xmax - xmin) / userBinWidth);
     if ((xmax - xmin - nBins * userBinWidth) == 0.) {
       numberOfXbins = nBins;
     } else {
       numberOfXbins = nBins + 1;
       xmax = xmin + numberOfXbins * userBinWidth;
     }
   }
 
   // Output for the user
   double binWidth = (xmax - xmin) / double(numberOfXbins);
   std::cout << "Timing histograms span the range (" << xmin << "," << xmax << ") msec.  Bin spacing: " << binWidth
             << " msec" << std::endl;
 
   TH1D* totalTime = new TH1D("totalTime", "Total time for all modules per event", numberOfXbins, xmin, xmax);
   totalTime->StatOverflows(kTRUE);
   totalTime->GetXaxis()->SetTitle("msec");
 
   TH1D* acceptedTotalTime =
       new TH1D("acceptedTotalTime", "Total time for all modules per accepted event", numberOfXbins, xmin, xmax);
   acceptedTotalTime->StatOverflows(kTRUE);
   acceptedTotalTime->GetXaxis()->SetTitle("msec");
 
   TH1D* rejectedTotalTime =
       new TH1D("rejectedTotalTime", "Total time for all modules per rejected event", numberOfXbins, xmin, xmax);
   rejectedTotalTime->StatOverflows(kTRUE);
   rejectedTotalTime->GetXaxis()->SetTitle("msec");
 
   TH1D* moduleTimeSummary =
       createSummaryHistogram("moduleTimeSummary", "Average time per module", numberOfModules, moduleNames, "msec");
   TH1D* moduleScaledTimeSummary = createSummaryHistogram(
       "moduleScaledTimeSummary", "Average running time per module", numberOfModules, moduleNames, "msec");
   TH1D* pathTimeSummary =
       createSummaryHistogram("pathTimeSummary", "Average time per path", numberOfPaths, pathNames, "msec");
 
   std::vector<TH1D*> specificPathTimeSummary;
   if (numberOfspecificTotalTime > 0) {
     for (int k = 0; k < numberOfspecificTotalTime; k++) {
       char nameBuffer[1000], titleBuffer[1000];
       snprintf(nameBuffer,
                1000,
                "specificPathTimeSummary_from_%.0f_ms_to_%.0f_ms",
                specificTotalTime.at(k).first,
                specificTotalTime.at(k).second);
       snprintf(titleBuffer,
                1000,
                "Average path time for event with total time from %.0f ms to %.0f ms",
                specificTotalTime.at(k).first,
                specificTotalTime.at(k).second);
       std::string name = nameBuffer;
       std::string title = titleBuffer;
       TH1D* specificPathTimeSummaryAtK = createSummaryHistogram(name, title, numberOfPaths, pathNames, "msec");
       specificPathTimeSummary.push_back(specificPathTimeSummaryAtK);
     }
   }
 
   TH1D* incPathTimeSummary = createSummaryHistogram(
       "incPathTimeSummary", "Average incremental time per path", numberOfPaths, pathNames, "msec");
   TH1D* pathSuccessFraction =
       createSummaryHistogram("pathSuccessFraction", "Path success rate (%)", numberOfPaths, pathNames, "");
   TH1D* uniquePathSuccessFraction = createSummaryHistogram(
       "uniquePathSuccessFraction", "Fraction (%) of events passing due to a single path", numberOfPaths, pathNames, "");
   TH1D* pathRejection =
       createSummaryHistogram("pathRejection", "Rejection for each path", numberOfPaths, pathNames, "");
   TH1D* pathRejectAll =
       createSummaryHistogram("pathRejectAll", "Rejection for each path", numberOfPaths, pathNames, "");
 
   std::vector<TH1D*> moduleInPathTimeSummary;
   std::vector<TH1D*> cumulativeModuleInPathTimeSummary;
   std::vector<TH1D*> moduleInPathScaledTimeSummary;
   std::vector<TH1D*> moduleInPathRejection;
   std::vector<TH1D*> moduleInPathRejectAll;
   std::vector<TH1D*> moduleInPathRejectTime;
   std::vector<TH1D*> failedModule;
   for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
     std::string name = "moduleInPathTimeSummary_" + pathNames.at(i);
     std::string title = "Average module time for path " + pathNames.at(i);
     TH1D* histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "msec");
     moduleInPathTimeSummary.push_back(histo);
 
     name = "cumulativeModuleInPathTimeSummary_" + pathNames.at(i);
     title = "Cumulative Average module time for path " + pathNames.at(i);
     histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "msec");
     cumulativeModuleInPathTimeSummary.push_back(histo);
 
     name = "moduleInPathScaledTimeSummary_" + pathNames.at(i);
     title = "Average module running time for path " + pathNames.at(i);
     histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "msec");
     moduleInPathScaledTimeSummary.push_back(histo);
     name = "moduleInPathRejection_" + pathNames.at(i);
     title = "Rejection per module for path " + pathNames.at(i);
     histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "");
     moduleInPathRejection.push_back(histo);
     name = "moduleInPathRejectAll_" + pathNames.at(i);
     title = "Full rejection per module for path " + pathNames.at(i);
     histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "");
     moduleInPathRejectAll.push_back(histo);
     name = "moduleInPathRejectTime_" + pathNames.at(i);
     title = "(Rejection / avg. running time) per module for path " + pathNames.at(i);
     histo = createSummaryHistogram(name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), "(msec)^{-1}");
     moduleInPathRejectTime.push_back(histo);
 
     name = "failedModule_" + pathNames.at(i);
     title = "Failure fraction (%) by module for path " + pathNames.at(i);
     histo = new TH1D(
         name.c_str(), title.c_str(), (1 + numberOfModulesInPath.at(i)), -1., double(numberOfModulesInPath.at(i)));
     histo->GetXaxis()->SetBinLabel(1, "SUCCESS");
     histo->SetMinimum(0.);
     for (unsigned int j = 0; j < unsigned(numberOfModulesInPath.at(i)); j++)
       histo->GetXaxis()->SetBinLabel(j + 2, moduleInPathNames.at(i).at(j).c_str());
     failedModule.push_back(histo);
   }
 
   pathTimeSummary->GetYaxis()->SetTitle("msec");
   for (int k = 0; k < numberOfspecificTotalTime; k++) {
     specificPathTimeSummary.at(k)->GetYaxis()->SetTitle("msec");
   }
   incPathTimeSummary->GetYaxis()->SetTitle("msec");
 
   // If events are skipped, recompute total number of events
   int numberOfEvents = n_evts - reducedSkipEvents.size();
 
   // Fill summary histograms
   for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
     if (pathTimeSummaryVector.at(i) > 0.) {
       pathTimeSummary->Fill(double(i), (1000. * pathTimeSummaryVector.at(i) / double(numberOfEvents)));
     } else {
       pathTimeSummary->Fill(double(i), 0.);
     }
 
     if (incPathTimeSummaryVector.at(i) > 0) {
       incPathTimeSummary->Fill(double(i), (1000. * incPathTimeSummaryVector.at(i) / double(numberOfEvents)));
     } else {
       incPathTimeSummary->Fill(double(i), 0.);
     }
 
     std::vector<double> failures(numberOfModulesInPath.at(i), 0.);
     for (unsigned int j = 0; j < unsigned(numberOfModulesInPath.at(i)); j++) {
       moduleInPathTimeSummary.at(i)->Fill(double(j),
                                           (1000. * moduleInPathTimeSummaryVector.at(i).at(j) / double(numberOfEvents)));
 
       double cumulativeModuleInPathTime = 0.;
       for (unsigned int h = 0; h <= j; h++) {
         cumulativeModuleInPathTime += 1000. * moduleInPathTimeSummaryVector.at(i).at(h) / double(numberOfEvents);
       }
       cumulativeModuleInPathTimeSummary.at(i)->Fill(double(j), cumulativeModuleInPathTime);
 
       double avgScaledModuleTime = 1000. * moduleInPathTimeSummaryVector.at(i).at(j);
       if (moduleInPathIn.at(i).at(j) > 0) {
         avgScaledModuleTime = avgScaledModuleTime / double(moduleInPathIn.at(i).at(j));
       }
       moduleInPathScaledTimeSummary.at(i)->Fill(double(j), avgScaledModuleTime);
 
       double moduleRejection = moduleInPathIn.at(i).at(j);
       if (moduleInPathOut.at(i).at(j) > 0) {
         moduleRejection = moduleRejection / moduleInPathOut.at(i).at(j);
       } else {
         moduleInPathRejectAll.at(i)->Fill(double(j), moduleRejection);
       }
 
       moduleInPathRejection.at(i)->Fill(double(j), moduleRejection);
       if (avgScaledModuleTime > 0) {
         moduleInPathRejectTime.at(i)->Fill(double(j), moduleRejection / avgScaledModuleTime);
       } else {
         moduleInPathRejectTime.at(i)->Fill(double(j), -1.);
       }
       failedModule.at(i)->Fill(
           double(j), (100. * (moduleInPathIn.at(i).at(j) - moduleInPathOut.at(i).at(j)) / double(numberOfEvents)));
     }
 
     failedModule.at(i)->Fill(
         -1., 100. * (moduleInPathOut.at(i).at(numberOfModulesInPath.at(i) - 1) / double(numberOfEvents)));
 
     // Calculate the path rejection, allowing for filter modules
     double pathEventsIn = double(numberOfEvents);
     if (pathFilterModule.at(i) >= 0)
       pathEventsIn = moduleInPathOut.at(i).at(unsigned(pathFilterModule.at(i)));
     double pathEventsOut = moduleInPathOut.at(i).at(numberOfModulesInPath.at(i) - 1);
 
     pathSuccessFraction->Fill(double(i), (100. * pathEventsOut / pathEventsIn));
     double rejectionFactor = pathEventsIn;
     if (pathEventsOut > 0) {
       rejectionFactor = rejectionFactor / pathEventsOut;
     } else {
       pathRejectAll->Fill(double(i), rejectionFactor);
     }
     pathRejection->Fill(double(i), rejectionFactor);
   }
   for (unsigned int i = 0; i < unsigned(numberOfModules); i++) {
     if (moduleTimeSummaryVector.at(i) > 0) {
       moduleTimeSummary->Fill(double(i), (1000. * moduleTimeSummaryVector.at(i) / double(numberOfEvents)));
     } else {
       moduleTimeSummary->Fill(double(i), 0.);
     }
     double scaledTime = 1000. * moduleTimeSummaryVector.at(i);
     if (moduleIn.at(i) > 0)
       scaledTime = scaledTime / moduleIn.at(i);
     moduleScaledTimeSummary->Fill(double(i), scaledTime);
   }
 
   std::vector<TH1D*> pathTime =
       createEventHistograms("pathTime", "Per event time for path", numberOfPaths, pathNames, numberOfXbins, xmin, xmax);
 
   std::vector<std::vector<TH1D*> > specificPathTime;
   if (numberOfspecificTotalTime > 0) {
     specificPathTime.push_back(pathTime);
     for (int k = 0; k < numberOfspecificTotalTime; k++) {
       char nameBuffer[1000], titleBuffer[1000];
       snprintf(nameBuffer,
                1000,
                "specificPathTime_from_%.0f_ms_to_%.0f_ms",
                specificTotalTime.at(k).first,
                specificTotalTime.at(k).second);
       snprintf(titleBuffer,
                1000,
                "Per event time for path from %.0f msec to %.0f msec",
                specificTotalTime.at(k).first,
                specificTotalTime.at(k).second);
       std::string name = nameBuffer;
       std::string title = titleBuffer;
       std::vector<TH1D*> specificPathTimeAtK =
           createEventHistograms(name, title, numberOfPaths, pathNames, numberOfXbins, xmin, xmax);
       specificPathTime.push_back(specificPathTimeAtK);
     }
   }
 
   std::vector<TH1D*> incPathTime = createEventHistograms(
       "incPathTime", "Per event incremental time for path", numberOfPaths, pathNames, numberOfXbins, xmin, xmax);
   std::vector<TH1D*> moduleTime = createEventHistograms(
       "moduleTime", "Time per event for module", numberOfModules, moduleNames, numberOfXbins, xmin, xmax);
   std::vector<TH1D*> moduleScaledTime = createEventHistograms(
       "moduleScaledTime", "Running time per event for module", numberOfModules, moduleNames, numberOfXbins, xmin, xmax);
 
   std::vector<std::vector<TH1D*> > moduleInPathScaledTime;
   for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
     std::string name = "moduleInPathScaledTime_" + pathNames.at(i);
     std::string title = "Running time per event for path " + pathNames.at(i) + ", module";
     std::vector<TH1D*> mipScaledTime = createEventHistograms(
         name, title, numberOfModulesInPath.at(i), moduleInPathNames.at(i), numberOfXbins, xmin, xmax);
     moduleInPathScaledTime.push_back(mipScaledTime);
   }
 
   TH2D* pathVsPathSummary = new TH2D("pathVsPathSummary",
                                      "Relative path success",
                                      numberOfPaths,
                                      0.,
                                      double(numberOfPaths),
                                      numberOfPaths,
                                      0.,
                                      double(numberOfPaths));
   std::vector<std::vector<double> > pVp;
   std::vector<double> nPathSuccess(numberOfPaths, 0.);
   std::vector<double> uniquePathSuccessVector(numberOfPaths, 0.);
   for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
     pVp.push_back(nPathSuccess);
     pathVsPathSummary->GetXaxis()->SetBinLabel(i + 1, pathNames.at(i).c_str());
     pathVsPathSummary->GetYaxis()->SetBinLabel(i + 1, pathNames.at(i).c_str());
   }
 
   //determine in the specificPathTimeSummaryVector
   for (unsigned int ievt = 0; ievt < unsigned(n_evts); ievt++) {
     int pCtr = 0;
     int pIdx = 0;
     int mCtr = 0;
     int mIdx = 0;
 
     // Get the event
     TBPerfInfo->GetEntry(ievt);
 
     // Check if we should skip the event
     mCtr = 0;
     mIdx = 0;
     bool useThisEvent = true;
     if (skipFirstEvent && (nSkips < numberOfModules)) {
       for (size_t i = 0; i < (*HLTPerformanceWrapper)->numberOfModules(); ++i) {
         const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModule(i);
         if (useModule.at(mCtr++)) {
           // Due to the resolution problems with CPUTimer,
           // ALWAYS determine event skipping using wall clock time
           if (getTime((myModule), false) > 0) {
             if (skipEvents.at(mIdx) < 0) {
               skipEvents.at(mIdx) = ievt;
               if (useThisEvent)
                 nSkips++;
               useThisEvent = false;
             }
           }
           mIdx++;
         }
       }
     }
 
     if (!useThisEvent)
       continue;
 
     if (numberOfspecificTotalTime > 0) {
       for (int k = 0; k < numberOfspecificTotalTime; k++) {
         if (1000. * eventTime.at(ievt) > specificTotalTime.at(k).first &&
             1000. * eventTime.at(ievt) < specificTotalTime.at(k).second) {
           pCtr = 0;
           pIdx = 0;
           for (size_t piter = 0; piter < (*HLTPerformanceWrapper)->numberOfPaths(); ++piter) {
             const HLTPerformanceInfo::Path p = (*HLTPerformanceWrapper)->getPath(piter);
             if (usePath.at(pCtr)) {
               mCtr = 0;
               mIdx = 0;
               for (size_t mm = 0; mm < (*HLTPerformanceWrapper)->getPath(piter).numberOfModules(); ++mm) {
                 const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModuleOnPath(mm, piter);
                 if (useModuleInPath.at(pCtr).at(mCtr)) {
                   if (moduleIndexByPath.at(pIdx).at(mIdx) <= int(p.status().index())) {
                     specificPathTimeSummaryVector.at(k).at(pIdx) += getTime((myModule), takeCPUtime);
                     mIdx++;
                   }
                 }
                 mCtr++;
               }
               pIdx++;
             }
             pCtr++;
           }
         }
       }
     }
   }
 
   // Fill event histograms
   for (unsigned int ievt = 0; ievt < unsigned(n_evts); ievt++) {
     // Needed to get run/event numbers
     TBEvtAux->GetEntry(ievt);
     //std::pair<int,int> eventInfo ;
     std::pair<unsigned int, unsigned long long> eventInfo;
     eventInfo.first = EvtAuxWrapper->id().run();
     eventInfo.second = EvtAuxWrapper->id().event();
 
     if (!useEvent(ievt, reducedSkipEvents))
       continue;
 
     if (acceptedEvt(eventPathStatus.at(ievt))) {
       acceptedTotalTime->Fill(1000. * eventTime.at(ievt));
     } else if (!acceptedEvt(eventPathStatus.at(ievt))) {
       rejectedTotalTime->Fill(1000. * eventTime.at(ievt));
     }
     totalTime->Fill(1000. * eventTime.at(ievt));
     if ((totalTimeThreshold > 0) && ((1000. * eventTime.at(ievt)) > totalTimeThreshold))
       slowEventSummaryVector.push_back(eventInfo);
 
     // Vector to determine which modules actually ran in the event
     std::vector<bool> moduleRan(numberOfModules, false);
     bool slowPathFound = false;
 
     for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
       double eventPathTime = 0.;
       double eventIncPathTime = 0.;
 
       for (unsigned int j = 0; j < unsigned(numberOfModulesInPath.at(i)); j++) {
         double mipTime = calculateMiPTime(
             eventModuleTime.at(ievt), eventPathStatus.at(ievt).at(i), globalModuleInPathMapper.at(i).at(j), j);
 
         if (mipTime >= 0) {
           eventPathTime += mipTime;
           int globalModuleIndex = globalModuleInPathMapper.at(i).at(j);
           moduleRan.at(unsigned(globalModuleIndex)) = true;
           moduleInPathScaledTime.at(i).at(j)->Fill(1000. * mipTime);
           //if (uniqueModule.at(i).at(j)) eventIncPathTime += mipTime ;
           if (moduleExistence.at(globalModuleIndex) == 1)
             eventIncPathTime += mipTime;
         }
       }
 
       pathTime.at(i)->Fill(1000. * eventPathTime);
       if (numberOfspecificTotalTime > 0) {
         specificPathTime.at(0).at(i) = pathTime.at(i);
         for (int k = 0; k < numberOfspecificTotalTime; k++) {
           if (1000. * eventTime.at(ievt) > specificTotalTime.at(k).first &&
               1000. * eventTime.at(ievt) < specificTotalTime.at(k).second) {
             specificPathTime.at(k + 1).at(i)->SetFillColor(2 + numberOfspecificTotalTime - (k + 1));
             specificPathTime.at(k + 1).at(i)->Fill(1000. * eventPathTime);
           }
         }
       }
 
       incPathTime.at(i)->Fill(1000. * eventIncPathTime);
       if ((pathTimeThreshold > 0) && ((1000. * eventPathTime) > pathTimeThreshold)) {
         if (!slowPathFound) {
           slowPathFound = true;
           slowPathSummaryVector.push_back(eventInfo);
         }
       }
       // Determine relative path success
       if (eventPathStatus.at(ievt).at(i) == -1)
         nPathSuccess.at(i)++;
       bool uniqueSuccess = false;
       if (eventPathStatus.at(ievt).at(i) == -1) {
         uniqueSuccess = true;
         for (unsigned int j = 0; j < unsigned(numberOfPaths); j++) {
           if (eventPathStatus.at(ievt).at(j) == -1) {
             pVp.at(i).at(j)++;
             if (i != j)
               uniqueSuccess = false;
           }
         }
       }
       if (uniqueSuccess)
         uniquePathSuccessVector.at(i)++;
     }
 
     bool slowModuleFound = false;
     for (int i = 0; i < numberOfModules; i++) {
       moduleTime.at(i)->Fill(1000. * eventModuleTime.at(ievt).at(i));
       if ((moduleTimeThreshold > 0) && ((1000. * eventModuleTime.at(ievt).at(i)) > moduleTimeThreshold)) {
         if (!slowModuleFound) {
           slowModuleSummaryVector.push_back(eventInfo);
           slowModuleFound = true;
         }
       }
       // if (eventModuleTime.at(ievt).at(i) > 0)
       if (moduleRan.at(i)) {
         moduleScaledTime.at(i)->Fill(1000. * eventModuleTime.at(ievt).at(i));
         for (unsigned int k = 0; k < unsigned(modIdxInterested.size()); k++) {
           if ((i == modIdxInterested.at(k)) && (moduleTimeThreshold > 0) &&
               ((1000. * eventModuleTime.at(ievt).at(i)) > moduleTimeThreshold))
             slowModInterestedVector.at(k).push_back(eventInfo);
         }
       }
     }
   }
 
   //count for number of specific events
   std::vector<int> n_specificEvts;
   for (int k = 0; k < numberOfspecificTotalTime; k++) {
     int evtCtr = 0;
     for (unsigned int ievt = 0; ievt < unsigned(n_evts); ievt++) {
       if (1000. * eventTime.at(ievt) > specificTotalTime.at(k).first &&
           1000. * eventTime.at(ievt) < specificTotalTime.at(k).second) {
         evtCtr++;
       }
     }
     n_specificEvts.push_back(evtCtr);
   }
 
   for (unsigned int i = 0; i < unsigned(numberOfPaths); i++) {
     //fill in specificPathTimeSummary
     if (numberOfspecificTotalTime > 0) {
       for (int k = 0; k < numberOfspecificTotalTime; k++) {
         if (specificPathTimeSummaryVector.at(k).at(i) > 0.) {
           specificPathTimeSummary.at(k)->SetLineColor(2 + numberOfspecificTotalTime - (k + 1));
           specificPathTimeSummary.at(k)->Fill(
               double(i), (1000. * specificPathTimeSummaryVector.at(k).at(i) / double(n_specificEvts.at(k))));
         } else {
           specificPathTimeSummary.at(k)->Fill(double(i), 0.);
         }
       }
     }
 
     uniquePathSuccessFraction->Fill(double(i), 100. * uniquePathSuccessVector.at(i) / double(numberOfEvents));
     for (unsigned int j = 0; j < unsigned(numberOfPaths); j++)
       pathVsPathSummary->Fill(double(i), double(j), (pVp.at(i).at(j) / nPathSuccess.at(i)));
   }
 
   //--- Dump results ---//
   std::vector<std::string> tocList;
   if (writeSummary) {
     sumfile << "hltTimingSummary output at a glance: " << std::endl;
     sumfile << std::endl;
     sumfile << "Input file: " << filename << std::endl;
     sumfile << "Output root file name: " << outname << std::endl;
     sumfile << std::endl;
 
     if (takeCPUtime) {
       sumfile << "NOTE: Results obtained using CPU time." << std::endl;
       sumfile << "      Due to resolution effects in CPUTimer, event histograms may not reflect reality." << std::endl;
       sumfile << "      Please be aware of these limitations when drawing your conclusions." << std::endl << std::endl;
     }
 
     if (numberOfspecificTotalTime > 0) {
       sumfile << "There are " << numberOfspecificTotalTime;
       if (numberOfspecificTotalTime == 1)
         sumfile << " range ";
       else
         sumfile << " ranges ";
       sumfile << "of specific total time: " << std::endl;
       for (int i = 0; i < numberOfspecificTotalTime; i++) {
         sumfile << "[ " << specificTotalTime.at(i).first << ", " << specificTotalTime.at(i).second << "]";
         if (i == numberOfspecificTotalTime - 1)
           sumfile << "\n";
         else
           sumfile << ", ";
       }
       sumfile << std::endl;
     }
 
     if (skipFirstEvent) {
       sumfile << "Skipping " << reducedSkipEvents.size() << " event(s) due to module initialization:" << std::endl;
       sumfile << "Event";
       if (reducedSkipEvents.size() > 1)
         sumfile << "s";
       for (unsigned int i = 0; i < reducedSkipEvents.size(); i++) {
         if (i != 0)
           sumfile << ",";
         sumfile << " " << reducedSkipEvents.at(i);
       }
       sumfile << std::endl;
       sumfile << std::endl;
     }
     if (!skipTimingMod.empty()) {
       sumfile << "Not including any information from the following excluded modules: " << std::endl;
       for (unsigned int i = 0; i < skipTimingMod.size(); i++)
         sumfile << skipTimingMod.at(i) << std::endl;
       sumfile << std::endl;
     }
 
     if (!squareOne.empty()) {
       sumfile << "The following module(s) were defined as filters by the user: " << std::endl;
       for (unsigned int i = 0; i < squareOne.size(); i++) {
         sumfile << squareOne.at(i) << ", found in path(s) ";
         int pCtr = 0;
         for (size_t piter = 0; piter < (*HLTPerformanceWrapper)->numberOfPaths(); ++piter) {
           const HLTPerformanceInfo::Path p = (*HLTPerformanceWrapper)->getPath(piter);
           for (size_t j = 0; j < (*HLTPerformanceWrapper)->numberOfModules(); ++j) {
             const HLTPerformanceInfo::Module& myModule = (*HLTPerformanceWrapper)->getModule(j);
             if (myModule.name() == squareOne.at(i)) {
               if (pCtr > 0)
                 sumfile << ", ";
               sumfile << p.name();
               pCtr++;
             }
           }
         }
         sumfile << std::endl;
       }
       sumfile << std::endl;
     }
 
     if (!slowEventSummaryVector.empty()) {
       sumfile << "The following " << slowEventSummaryVector.size();
       if (slowEventSummaryVector.size() == 1)
         sumfile << " event ";
       else
         sumfile << " events ";
       sumfile << "took longer than " << totalTimeThreshold << " msec to run: " << std::endl;
       sumfile << "(formatted for usage within the PoolSource module,i.e, Run:Event)" << std::endl;
       sumfile << std::endl;
       sumfile << "eventsToProcess = cms.untracked.VEventRange(" << std::endl;
       for (unsigned int i = 0; i < slowEventSummaryVector.size(); i++) {
         sumfile << "'" << slowEventSummaryVector.at(i).first << ":" << slowEventSummaryVector.at(i).second << "',"
                 << std::endl;
       }
       sumfile << ")" << std::endl;
       sumfile << std::endl;
     }
 
     if (!slowPathSummaryVector.empty()) {
       sumfile << "The following " << slowPathSummaryVector.size();
       if (slowPathSummaryVector.size() == 1)
         sumfile << " event ";
       else
         sumfile << " events ";
       sumfile << "had at least one path that took more than " << totalTimeThreshold << " msec to run: " << std::endl;
 
       sumfile << "(formatted for usage within the PoolSource module,i.e, Run:Event)" << std::endl;
       sumfile << std::endl;
       sumfile << "eventsToProcess = cms.untracked.VEventRange(" << std::endl;
       for (unsigned int i = 0; i < slowPathSummaryVector.size(); i++) {
         sumfile << "'" << slowPathSummaryVector.at(i).first << ":" << slowPathSummaryVector.at(i).second << "',"
                 << std::endl;
       }
       sumfile << ")" << std::endl;
       sumfile << std::endl;
     }
 
     if (!slowModuleSummaryVector.empty()) {
       sumfile << "The following " << slowModuleSummaryVector.size();
       if (slowModuleSummaryVector.size() == 1)
         sumfile << " event ";
       else
         sumfile << " events ";
       sumfile << "had at least one module that took more than " << moduleTimeThreshold << " msec to run: " << std::endl;
       sumfile << "(formatted for usage within the PoolSource module,i.e, Run:Event)" << std::endl;
       sumfile << std::endl;
       sumfile << "eventsToProcess = cms.untracked.VEventRange(" << std::endl;
       for (unsigned int i = 0; i < slowModuleSummaryVector.size(); i++) {
         sumfile << "'" << slowModuleSummaryVector.at(i).first << ":" << slowModuleSummaryVector.at(i).second << "',"
                 << std::endl;
       }
       sumfile << ")" << std::endl;
       sumfile << std::endl;
     }
 
     if (!slowModInterestedVector.empty()) {
       for (unsigned i = 0; i < slowModInterestedVector.size(); i++) {
         sumfile << "The following " << slowModInterestedVector.at(i).size() - 1;
         if (slowModInterestedVector.at(i).size() - 1 == 1)
           sumfile << " event ";
         else
           sumfile << " events ";
         sumfile << "had the module " << modInterested.at(i) << " that took more than " << moduleTimeThreshold
                 << " msec to run: " << std::endl;
         sumfile << "(formatted for usage within the PoolSource module,i.e, Run:Event)" << std::endl;
         sumfile << std::endl;
         sumfile << "eventsToProcess = cms.untracked.VEventRange(" << std::endl;
         for (unsigned int j = 1; j < slowModInterestedVector.at(i).size(); j++) {
           sumfile << "'" << slowModInterestedVector.at(i).at(j).first << ":"
                   << slowModInterestedVector.at(i).at(j).second << "'," << std::endl;
         }
         sumfile << ")" << std::endl;
         sumfile << std::endl;
       }
     }
 
     char value[330];
     sumfile << "Average path times are as follows (all in msec): " << std::endl;
     for (int i = 1; i <= pathTimeSummary->GetNbinsX(); i++) {
       snprintf(value, sizeof(value), "%9.4f", pathTimeSummary->GetBinContent(i));
       sumfile << value << " (path " << pathTimeSummary->GetXaxis()->GetBinLabel(i) << ")";
       sumfile << std::endl;
     }
     sumfile << std::endl;
 
     snprintf(value, sizeof(value), "%9.4f", (1000. * longestEventTime));
     sumfile << "The slowest event (" << longestEvent << ") took " << value << " msec" << std::endl;
     sumfile << std::endl;
 
     std::vector<std::string> slowPath;
     slowPath.clear();
     std::vector<std::string> slowMinP;
     slowMinP.clear();
     std::vector<double> slowTime;
     slowTime.clear();
 
     sumfile << "The three slowest modules (running in any path) are: " << std::endl;
     slowestModules(moduleTimeSummary, &slowMinP, &slowTime, numberOfModules, moduleNames);
 
     for (unsigned int i = 0; i < 3; i++) {
       if (slowTime.at(i) > 0) {
         snprintf(value, sizeof(value), "%9.4f", slowTime.at(i));
         sumfile << "Module " << slowMinP.at(i) << ", with average per event time: " << value << " msec" << std::endl;
       }
     }
     sumfile << std::endl;
 
     sumfile << "The three slowest modules (by path) are: " << std::endl;
     slowestModules(moduleInPathTimeSummary,
                    &slowPath,
                    &slowMinP,
                    &slowTime,
                    numberOfPaths,
                    numberOfModulesInPath,
                    pathNames,
                    moduleInPathNames);
 
     for (unsigned int i = 0; i < 3; i++) {
       if (slowTime.at(i) > 0) {
         snprintf(value, sizeof(value), "%9.4f", slowTime.at(i));
         sumfile << "Module " << slowMinP.at(i) << " in path " << slowPath.at(i)
                 << ", with average per event time: " << value << " msec" << std::endl;
       }
     }
     sumfile << std::endl;
 
     slowPath.clear();
     slowMinP.clear();
     slowTime.clear();
     sumfile << "The three slowest RUNNING modules (by path) are: " << std::endl;
     slowestModules(moduleInPathScaledTimeSummary,
                    &slowPath,
                    &slowMinP,
                    &slowTime,
                    numberOfPaths,
                    numberOfModulesInPath,
                    pathNames,
                    moduleInPathNames);
 
     for (unsigned int i = 0; i < 3; i++) {
       if (slowTime.at(i) > 0) {
         snprintf(value, sizeof(value), "%9.4f", slowTime.at(i));
         sumfile << "Module " << slowMinP.at(i) << " in path " << slowPath.at(i)
                 << ", with average running time: " << value << " msec" << std::endl;
       }
     }
     sumfile << std::endl;
 
     sumfile << "A given module took the longest time to run in the following events:" << std::endl;
     for (unsigned int i = 0; i < unsigned(numberOfModules); i++) {
       if (longestEventTimeByModule.at(i) > 0) {
         snprintf(value, sizeof(value), "%9.4f", longestEventTimeByModule.at(i));
         sumfile << "Module " << moduleNames.at(i) << " was slowest in event " << longestEventByModule.at(i)
                 << ", with time: " << value << " msec" << std::endl;
       }
     }
     sumfile << std::endl;
 
     sumfile << "Timing histograms run from " << xmin << " to " << xmax << " msec";
     if (userMaxTime > 0)
       sumfile << ", which was specified by the user";
     sumfile << std::endl;
     sumfile << "The bin width for the timing histograms is " << (xmax - xmin) / double(numberOfXbins) << " msec";
     if (userBinWidth > 0)
       sumfile << ", which was specified by the user";
     sumfile << std::endl;
 
     double oflow = 100. * totalTime->GetBinContent(numberOfXbins + 1) / totalTime->GetEntries();
     sumfile << oflow << "% (" << totalTime->GetBinContent(numberOfXbins + 1) << "/" << totalTime->GetEntries()
             << ") of all events fall outside the ";
     if (userMaxTime > 0)
       sumfile << "(user-specified) ";
     sumfile << "timing range" << std::endl;
     sumfile << std::endl;
     sumfile << "NOTE: The mean and rms values are calculated for all events (that INCLUDES overflows)" << std::endl;
   }
 
   txtfile.close();
   sumfile.close();
   outFile->Write();
   outFile->Close();
   file->Close();
 
   return 0;
 }

This page was automatically generated by the 2.2.1 LXR engine. The LXR team