#include <HLTMonBitSummary.h>

Inheritance diagram for HLTMonBitSummary:

Public Member Functions
	HLTMonBitSummary (const edm::ParameterSet &)

	~HLTMonBitSummary ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)

virtual void	beginJob ()

virtual void	beginRun (const edm::Run &r, const edm::EventSetup &)

virtual void	configSelector (const std::vector< std::string > &selectTriggers, std::vector< std::string > &theSelectTriggers)

virtual void	endJob ()

Private Attributes
bool	configFlag_

std::vector< unsigned int >	count_

DQMStore *	dbe_

std::string	denominator_

std::string	denominatorWild_

std::string	directory_

std::vector< std::string >	dummyFilters_

std::string	esPathsKey_

bool	filterFlag_

std::vector< std::string >	filterTypes_

MonitorElement *	h1_

MonitorElement *	h2_

std::string	histLabel_

bool	hltchange_

HLTConfigProvider	hltConfig_

std::vector< std::string >	HLTPathDenomName_

std::vector< std::string >	HLTPathDenomNamePreVal_

std::vector< std::string >	HLTPathNamesConfig_

std::vector< std::string >	HLTPathNamesConfigPreVal_

std::vector< std::string >	HLTPathNamesKey_

std::vector< unsigned int >	HLTPathsByIndex_

std::vector< std::string >	HLTPathsByName_

std::vector< MonitorElement * >	hSubFilterCount

std::vector< MonitorElement * >	hSubFilterEff

edm::InputTag	inputTag_

edm::EDGetTokenT < edm::TriggerResults >	inputToken_

unsigned int	ndenomAccept_

unsigned int	nValidConfigTriggers_

unsigned int	nValidTriggers_

MonitorElement *	pf_

MonitorElement *	ratio_

unsigned int	total_

std::vector< std::vector< uint > >	triggerFilterIndices_

std::vector< std::vector < std::string > >	triggerFilters_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 29 of file HLTMonBitSummary.h.

Constructor & Destructor Documentation

HLTMonBitSummary::HLTMonBitSummary ( const edm::ParameterSet & iConfig )

explicit

Definition at line 40 of file HLTMonBitSummary.cc.

References configFlag_, dbe_, denominator_, denominatorWild_, directory_, dummyFilters_, esPathsKey_, filterFlag_, filterTypes_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), histLabel_, hltchange_, inputToken_, NULL, cppFunctionSkipper::operator, DQMStore::setVerbose(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                  :
   inputTag_ (iConfig.getParameter<edm::InputTag> ("TriggerResultsTag")),
   HLTPathNamesConfigPreVal_(iConfig.getParameter<std::vector<std::string > >("HLTPaths")),
   total_(0),
   nValidTriggers_(0),
   nValidConfigTriggers_(0),
   ndenomAccept_(0)
 {
   denominatorWild_ = iConfig.getUntrackedParameter<std::string>("denominatorWild","");
   denominator_ = iConfig.getUntrackedParameter<std::string>("denominator");
   directory_ = iConfig.getUntrackedParameter<std::string>("directory","HLT/Generic/Summary");
   histLabel_ = iConfig.getUntrackedParameter<std::string>("histLabel","Generic");
   //  out_ = iConfig.getUntrackedParameter<std::string>("out","");
   dummyFilters_.clear();
   filterTypes_ = iConfig.getUntrackedParameter<std::vector<std::string > >("filterTypes",dummyFilters_);
   esPathsKey_ = iConfig.getUntrackedParameter<std::string>("eventSetupPathsKey","");
 
   configFlag_ = false;
   filterFlag_ = false;
   hltchange_ = false;
 
   dbe_ = NULL;
   dbe_ = edm::Service < DQMStore > ().operator->();
   dbe_->setVerbose(0);
 
   //set Token(-s)
   inputToken_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag> ("TriggerResultsTag"));
 }

HLTMonBitSummary::~HLTMonBitSummary ( )

Definition at line 70 of file HLTMonBitSummary.cc.

70 {}

Member Function Documentation

void HLTMonBitSummary::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 295 of file HLTMonBitSummary.cc.

References plotTTrigFromHistos::binNumber(), configFlag_, count_, denominator_, edm::HandleBase::failedToGet(), MonitorElement::Fill(), filterFlag_, filterTypes_, MonitorElement::getBinContent(), edm::Event::getByToken(), h1_, h2_, HLTPathsByIndex_, HLTPathsByName_, hSubFilterCount, hSubFilterEff, i, inputTag_, inputToken_, align::invalid, j, LogDebug, ndenomAccept_, nValidConfigTriggers_, nValidTriggers_, pf_, ratio_, zeeHLT_cff::report, cmsHarvester::sep, MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, total_, triggerFilterIndices_, triggerFilters_, edm::TriggerNames::triggerIndex(), and edm::Event::triggerNames().

 {
   if(configFlag_) return;
      
   total_++;    
   const std::string invalid("@@invalid@@");
 
   // get hold of TriggerResults Object
   edm::Handle<edm::TriggerResults> trh;
   iEvent.getByToken(inputToken_, trh);
   
   if (trh.failedToGet()) {
      edm::LogError("HLTMonBitSummary")<<" could not get: "<<inputTag_;
      return;
   }
 
   // get hold of trigger names - based on TriggerResults object!
   const edm::TriggerNames & triggerNames = iEvent.triggerNames(*trh);
 
   unsigned int lastModule = 0;
 
   //std::cout << " Was at least one path run? " << trh->wasrun() << std::endl;;
   //std::cout << " Has at least one path accepted the event? " << trh->accept() << std::endl;
   //std::cout << " Has any path encountered an error? " << trh->error() << std::endl;
   //std::cout << " Number of paths stored =  " << trh->size() << std::endl;  
 
   for (unsigned int trig=0; trig < nValidTriggers_; trig++) {
     //convert *all* trigger names (from config and key) to trigger index properly  
     HLTPathsByIndex_[trig]=triggerNames.triggerIndex(HLTPathsByName_[trig]);
   }
   
   //get filter information for config triggers only
   for (unsigned int trig=0; trig < nValidConfigTriggers_; trig++) {
     //std::cout << "Trigger Name = " << HLTPathNamesConfig_[trig] << ", HLTPathsByIndex_ = " << HLTPathsByIndex_[trig] << std::endl; 
     //std::cout << "Trigger Name = " << HLTPathNamesConfig_[trig] << ", trh->index = " << lastModule << " " << trh->accept(HLTPathsByIndex_[trig]) << std::endl; 
     
     //check if trigger exists in TriggerResults
     if(!filterTypes_.empty() && !filterFlag_ && HLTPathsByIndex_[trig] < trh->size()) {
       lastModule = trh->index(HLTPathsByIndex_[trig]);
     
       //go through the list of filters
       for(unsigned int filt = 0; filt < triggerFilters_[trig].size()-1; filt++){
     //  cout << "triggerFilters_["<<trig<<"]["<<filt+1<<"] = " << triggerFilters_[trig][filt+1] 
     //       << " , triggerFilterIndices = " << triggerFilterIndices_[trig][filt+1]
     //       << " , lastModule = " << lastModule << std::endl;
     
     int binNumber = hSubFilterCount[trig]->getTH1F()->GetXaxis()->FindBin(triggerFilters_[trig][filt+1].c_str());      
     
     //check if filter passed
     if(trh->accept(HLTPathsByIndex_[trig])){
       hSubFilterCount[trig]->Fill(binNumber-1);//binNumber1 = 0 = first filter
     }
     //otherwise the module that issued the decision is the first fail
     //so that all the ones before it passed
     else if(triggerFilterIndices_[trig][filt+1] < lastModule){
       hSubFilterCount[trig]->Fill(binNumber-1);
     }
     
     //hSubFilterCount[trig]->Fill(-1);
     
     float eff = (float)hSubFilterCount[trig]->getBinContent(binNumber) / (float)total_ ;
     float efferr = sqrt(eff*(1-eff)/ (float)total_);
     hSubFilterEff[trig]->setBinContent(binNumber,eff);
     hSubFilterEff[trig]->setBinError(binNumber,efferr);
 
       }//filt
     } 
   }
   
   //and check validity name (should not be necessary)
   std::vector<bool> validity(nValidTriggers_);
   for (unsigned int i=0; i!=nValidTriggers_; i++) {
     validity[i]=( (HLTPathsByIndex_[i]<trh->size()) && (HLTPathsByName_[i]!=invalid) );
   }
    
   
   //---------------------B i t   P l o t t i n g   S e c t i o n --------------------//
   //---------------------------------------------------------------------------------//
   
   //convert also for the denominator and check validity
   uint denominatorIndex = 0;
   bool denominatorValidity= false;
   if (denominator_!="") {
     denominatorIndex=triggerNames.triggerIndex(denominator_);
     denominatorValidity= (denominatorIndex <trh->size());
   }
   
   std::stringstream report;
   std::string sep=" ";
   bool atLeastOne=false;
   
   //check whether the denominator fired
   bool denomAccept=false;
   if (ratio_ && denominatorValidity) {
     denomAccept=trh->accept(denominatorIndex);
     if(denomAccept) ndenomAccept_++;
   }
 
   for (unsigned int i=0; i!=nValidTriggers_; i++) {
     if (!validity[i]) continue;
     bool iAccept=trh->accept(HLTPathsByIndex_[i]);
     if (iAccept) {
       report<<sep<<HLTPathsByName_[i];
       count_[i]++;
       sep=", ";
       atLeastOne=true;
       //trigger has fired. make an entry in both 1D and profile plots
       h1_->Fill(i);
       //make the entry in the 2D plot : UPPER diagonal terms = AND of the two triggers
       for (unsigned int j=i; j!=nValidTriggers_; j++) {
     if (!validity[j]) continue;
     if (trh->accept(HLTPathsByIndex_[j]))
       h2_->Fill(i,j);    
       }//loop on second trigger for AND terms
     }//trigger[i]=true
        
     float pf_eff = (float)h1_->getBinContent(i+1) / (float)total_ ;
     float pf_efferr = sqrt(pf_eff*(1-pf_eff) / (float)total_);
     pf_->setBinContent(i+1,pf_eff);
     pf_->setBinError(i+1,pf_efferr);
 
     //make proper entries in the ratio plot
     if (ratio_ && denomAccept){
       float ratio_eff = (float)h1_->getBinContent(i+1) / (float)ndenomAccept_ ;
       float ratio_efferr = sqrt(ratio_eff*(1-ratio_eff) / (float)ndenomAccept_);
       ratio_->setBinContent(i+1,ratio_eff);
       ratio_->setBinError(i+1,ratio_efferr);
     }
 
     
     //make proper entry inthe 2D plot: LOWER diagonal terms = OR of the two triggers
     for (unsigned int j=0; j!=i; j++) {
       if (!validity[j]) continue;
       bool jAccept=trh->accept(HLTPathsByIndex_[j]);
       if (iAccept || jAccept)
     h2_->Fill(i,j);
      }//loop on second trigger for OR terms
     
   }//loop on first trigger
 
   if (atLeastOne){
     LogDebug("BitPlotting|BitReport")<<report.str();
   }
   
   //   edm::LogError("BitPlotting")<<"# entries:"<<h1_->getTH1F()->GetEntries();
   
   //-----------------E n d  o f  B i t P l o t t i n g   S e c t i o n-----------------//
        
 }

void HLTMonBitSummary::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 444 of file HLTMonBitSummary.cc.

References DQMStore::book1D(), DQMStore::book2D(), dbe_, denominator_, directory_, h1_, h2_, histLabel_, bookConverter::max, min(), pf_, ratio_, and DQMStore::setCurrentFolder().

                                 {  
 
   if(dbe_){
     if (directory_ != "" && directory_.substr(directory_.length()-1,1) != "/" ) directory_ = directory_+"/" ;
   
     float min = -0.5;
     float max = 400-0.5;
     //uint nBin = HLTPathsByName_.size();
     uint nBin = 400;
    
     dbe_->setCurrentFolder(directory_);
 
     h1_ = dbe_->book1D("PassingBits_Summary_"+histLabel_,"PassingBits_Summary_"+histLabel_, nBin, min, max);
     h2_ = dbe_->book2D("PassingBits_Correlation_"+histLabel_,"PassingBits_Correlation_"+histLabel_,nBin,min,max, nBin,min,max);
     pf_ = dbe_->book1D("Efficiency_Summary_"+histLabel_,"Efficiency_Summary_"+histLabel_, nBin, min, max);
     if (denominator_!="")
       //ratio_ = dbe_->book1D(std::string("Ratio_"+denominator_),std::string("Ratio_"+denominator_),nBin,min,max);
       ratio_ = dbe_->book1D("HLTRate_"+histLabel_,"HLTRate_"+histLabel_,nBin,min,max);
     else 
       ratio_=0;
 
   }
 
 }

void HLTMonBitSummary::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 76 of file HLTMonBitSummary.cc.

References DQMStore::book1D(), configFlag_, configSelector(), count_, dbe_, denominator_, denominatorWild_, directory_, esPathsKey_, edm::hlt::Exception, filterFlag_, filterTypes_, edm::EventSetup::get(), MonitorElement::getTH1F(), MonitorElement::getTH2F(), h1_, h2_, hltchange_, hltConfig_, HLTPathDenomName_, HLTPathDenomNamePreVal_, HLTPathNamesConfig_, HLTPathNamesConfigPreVal_, HLTPathNamesKey_, HLTPathsByIndex_, HLTPathsByName_, hSubFilterCount, hSubFilterEff, i, HLTConfigProvider::init(), inputTag_, j, gen::k, LogDebug, HLTConfigProvider::moduleIndex(), HLTConfigProvider::moduleLabels(), edm::moduleName(), HLTConfigProvider::moduleType(), nValidConfigTriggers_, nValidTriggers_, pf_, edm::InputTag::process(), ratio_, edm::RunBase::run(), DQMStore::setCurrentFolder(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, total_, triggerFilterIndices_, and triggerFilters_.

                                                                               {
 
   //initialize the hlt configuration from the process name if not blank
   std::string processName = inputTag_.process();
   if (processName != ""){
 
     //Grab paths from EventSetup via AlCaRecoTriggerBitsRcd if configured - copied from HLTHighLevel
     if (esPathsKey_.size()) {
       // Get map of strings to concatenated list of names of HLT paths from EventSetup:
       edm::ESHandle<AlCaRecoTriggerBits> triggerBits;
       iSetup.get<AlCaRecoTriggerBitsRcd>().get(triggerBits);
       typedef std::map<std::string, std::string> TriggerMap;
       const TriggerMap &triggerMap = triggerBits->m_alcarecoToTrig;
 
       TriggerMap::const_iterator listIter = triggerMap.find(esPathsKey_);
     
       if (listIter == triggerMap.end()) {
     throw cms::Exception("Configuration")
       //<< " HLTHighLevel [instance: " << *moduleLabel() << " - path: " << *pathName()
       //<< "]: "
       <<" No triggerList with key " << esPathsKey_ << " in AlCaRecoTriggerBitsRcd";
       }
       
       // We must avoid a std::map<std::stringvector<std::string> > in DB for performance reason,
       // so the paths are mapped into one string that we have to decompose:
       HLTPathNamesKey_ = triggerBits->decompose(listIter->second);
     }
     
     bool initOK = false;
     initOK = hltConfig_.init(r, iSetup, processName, hltchange_);
     //Otherwise read paths from configuration
     HLTPathNamesConfig_.clear();
     if(HLTPathNamesConfigPreVal_.size()){
       //run trigger config selection
       if (initOK) {
     configSelector(HLTPathNamesConfigPreVal_, HLTPathNamesConfig_);
       }
       else{
     edm::LogError("HLTMonBitSummary") << "HLTConfigProvider initialization with process name " 
                       << processName << " failed." << std::endl;
       }
     }
     
     //check if the two vectors have any common elements    
     std::vector<int> removePaths;
     for(size_t i=0; i<HLTPathNamesKey_.size(); ++i){
       for(size_t j=0; j<HLTPathNamesConfig_.size(); ++j){
     if(HLTPathNamesConfig_[j] == HLTPathNamesKey_[i]) removePaths.push_back(i); 
       }
     }
     reverse(removePaths.begin(),removePaths.end());    
     if(removePaths.size()){
       for(unsigned int k=0; k<removePaths.size(); ++k)
     HLTPathNamesKey_.erase(HLTPathNamesKey_.begin()+removePaths[k]);
     }
 
 
     //combine two vectors
     HLTPathsByName_.clear();
     HLTPathsByName_.reserve(HLTPathNamesConfig_.size() + HLTPathNamesKey_.size());
     HLTPathsByName_.insert(HLTPathsByName_.end(),HLTPathNamesConfig_.begin(),HLTPathNamesConfig_.end());
     HLTPathsByName_.insert(HLTPathsByName_.end(),HLTPathNamesKey_.begin(),HLTPathNamesKey_.end());
 
     count_.resize(HLTPathsByName_.size());
     HLTPathsByIndex_.resize(HLTPathsByName_.size());
 
     
     if( (nValidTriggers_ != HLTPathsByName_.size() || hltchange_) && total_!=0 ){
       edm::LogWarning("HLTMonBitSummary") << "A change in the HLT configuration has been found." 
                       << std::endl
                       << "BitSummary histograms do not support changing configurations."
                       << std::endl
                       << "Processing of events halted.";
       configFlag_ = true;
     }
 
     if(!configFlag_){
 
       nValidTriggers_ = HLTPathsByName_.size();
       nValidConfigTriggers_ = HLTPathNamesConfig_.size();
 
       //get all the filters -
       //only if filterTypes_ is nonempty and only on HLTPathNamesConfig_ paths
       if(initOK){ 
     if(!filterTypes_.empty()){
       triggerFilters_.clear();
       triggerFilterIndices_.clear();
       for( size_t i = 0; i < nValidConfigTriggers_; i++) {
         // create a row [triggername,filter1name, filter2name, etc.] 
         triggerFilters_.push_back(std::vector <std::string>());  
         // create a row [0, filter1index, filter2index, etc.]
         triggerFilterIndices_.push_back(std::vector <uint>()); 
       
         std::vector<std::string> moduleNames = hltConfig_.moduleLabels( HLTPathNamesConfig_[i] ); 
       
         triggerFilters_[i].push_back(HLTPathNamesConfig_[i]);//first entry is trigger name      
         triggerFilterIndices_[i].push_back(0);
       
         int numModule = 0, numFilters = 0;
         std::string moduleName, moduleType;
         unsigned int moduleIndex;
       
         //print module name
         std::vector<std::string>::const_iterator iDumpModName;
         for (iDumpModName = moduleNames.begin();iDumpModName != moduleNames.end();iDumpModName++) {
           moduleName = *iDumpModName;
           moduleType = hltConfig_.moduleType(moduleName);
           moduleIndex = hltConfig_.moduleIndex(HLTPathNamesConfig_[i], moduleName);
           LogDebug ("HLTMonBitSummary") << "Module"      << numModule
                          << " is called " << moduleName
                          << " , type = "  << moduleType
                          << " , index = " << moduleIndex
                          << std::endl;
           numModule++;
           for(size_t k = 0; k < filterTypes_.size(); k++) {
         if(moduleType == filterTypes_[k]) {
           numFilters++;
           triggerFilters_[i].push_back(moduleName);
           triggerFilterIndices_[i].push_back(moduleIndex);
         }
           }
         }//end for modulesName
       }//end for nValidConfigTriggers_
     }
       }
       else{
     edm::LogError("HLTMonBitSummary") << "HLTConfigProvider initialization has failed."
                       << " Could not get filter names." << std::endl;
     filterFlag_ = true;
       }
 
       //check denominator
       HLTPathDenomName_.clear();
       HLTPathDenomNamePreVal_.clear();
       if( denominatorWild_.size() != 0 ) HLTPathDenomNamePreVal_.push_back(denominatorWild_);
       if(initOK){
     configSelector(HLTPathDenomNamePreVal_, HLTPathDenomName_);
       }
       //HLTriggerSelector denomSelect(r, iSetup, inputTag_,HLTPathDenomName_);
       //HLTPathDenomName_.swap(denomSelect.theSelectTriggers);
       //for (unsigned int i = 0; i < HLTPathDenomName_.size(); i++)
       //  std::cout << "testing denom: " << HLTPathDenomName_[i] << std::endl;
       if(HLTPathDenomName_.size()==1) denominator_ = HLTPathDenomName_[0];
     }
   }//end if process
 
        
   if(dbe_ && !configFlag_){
 
     int nbin = nValidConfigTriggers_;
     
     dbe_->setCurrentFolder(directory_);
 
     //int nbin_sub = 5;
     int nbin_sub = 8;
     
     // Count histos for efficiency plots
     if(!filterTypes_.empty() && !filterFlag_){
       dbe_->setCurrentFolder(directory_ + "Trigger_Filters/");
       //hCountSummary = dbe_->book1D("hCountSummary", "Count Summary", nbin+1, -0.5, 0.5+(double)nbin);
     
       hSubFilterCount.clear();
       hSubFilterEff.clear();
 
       for( int trig = 0; trig < nbin; trig++ ) {
     // count plots for subfilter
     //hSubFilterCount[trig] = dbe_->book1D("Filters_" + triggerFilters_[trig][0], 
     hSubFilterCount.push_back(dbe_->book1D("Filters_" + triggerFilters_[trig][0], 
                          "Filters_" + triggerFilters_[trig][0],
                          nbin_sub+1, -0.5, 0.5+(double)nbin_sub));
       
     for(int filt = 0; filt < (int)triggerFilters_[trig].size()-1; filt++){
       hSubFilterCount[trig]->setBinLabel(filt+1, triggerFilters_[trig][filt+1]);
     }
       }
 
       dbe_->setCurrentFolder(directory_ + "Trigger_Efficiencies/");
       for( int trig = 0; trig < nbin; trig++ ) {
     //hSubFilterEff[trig] = dbe_->book1D("Efficiency_" + triggerFilters_[trig][0], 
     hSubFilterEff.push_back(dbe_->book1D("Efficiency_" + triggerFilters_[trig][0], 
                        "Efficiency_" + triggerFilters_[trig][0],
                        nbin_sub+1, -0.5, 0.5+(double)nbin_sub));
       
     for(int filt = 0; filt < (int)triggerFilters_[trig].size()-1; filt++){
       hSubFilterEff[trig]->setBinLabel(filt+1,triggerFilters_[trig][filt+1]);
     }
       }
     }
       
     //--------------B i t   P l o t t i n g   s e c t i o n ---------------//
     //---------------------------------------------------------------------//
 
     std::stringstream rNs;
     rNs<<r.run();
     std::string rN = rNs.str();
     LogDebug("HLTMonBitSummary")<<"this is the beginning of a NEW run: "<< r.run();
 
     //h1_->Reset();
     // h2_->Reset();
     //pf_->Reset();
     //if (ratio_) ratio_->Reset();
 
     for (uint i=0; i < nValidTriggers_ && i < 400 ; ++i){
       h1_->getTH1F()->GetXaxis()->SetBinLabel(i+1,HLTPathsByName_[i].c_str());
       h2_->getTH2F()->GetXaxis()->SetBinLabel(i+1,HLTPathsByName_[i].c_str());
       h2_->getTH2F()->GetYaxis()->SetBinLabel(i+1,HLTPathsByName_[i].c_str());
       pf_->getTH1F()->GetXaxis()->SetBinLabel(i+1,HLTPathsByName_[i].c_str());
       if (ratio_)
     ratio_->getTH1F()->GetXaxis()->SetBinLabel(i+1,(HLTPathsByName_[i]+" & "+denominator_).c_str());
     }
     
     //------------------------End Of BitPlotting section -------------------------//
   }
      
 }

void HLTMonBitSummary::configSelector	(	const std::vector< std::string > &	selectTriggers,
		std::vector< std::string > &	theSelectTriggers
	)

privatevirtual

Definition at line 489 of file HLTMonBitSummary.cc.

References spr::find(), hltConfig_, i, j, and HLTConfigProvider::triggerNames().

Referenced by beginRun().

                                                                                                                           {
   //get the configuration
   std::vector<std::string> validTriggerNames = hltConfig_.triggerNames(); 
   
   bool goodToGo = false;
   //remove all path names that are not valid
   while(!goodToGo && selectTriggers.size()!=0){
     goodToGo=true;
     for ( auto j=selectTriggers.begin();j!=selectTriggers.end();++j){
       //bool goodOne = false;
       //check if trigger name is valid
       //use of wildcard
       TPRegexp wildCard(*j);
       //std::cout << "wildCard.GetPattern() = " << wildCard.GetPattern() << std::endl;
       for (unsigned int i = 0; i != validTriggerNames.size(); ++i){
     if (TString(validTriggerNames[i]).Contains(wildCard)){ 
       //goodOne = true;
       if (find(theSelectTriggers.begin(),
            theSelectTriggers.end(), 
            validTriggerNames[i])==theSelectTriggers.end()){
         //std::cout << "wildcard trigger = " << validTriggerNames[i] << std::endl;
         theSelectTriggers.push_back( validTriggerNames[i] ); //add it after duplicate check.
       }
     }
       }
     }
   }//while
 }

void HLTMonBitSummary::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 470 of file HLTMonBitSummary.cc.

References count_, HLTPathsByName_, i, LogDebug, zeeHLT_cff::report, and total_.

                               {  
     
   std::stringstream report;
   report <<" out of: "<<total_<<" events.\n";
   if(!count_.empty()){
     for (uint i=0; i!=HLTPathsByName_.size();i++){
       report<<HLTPathsByName_[i]<<" passed: "<<count_[i]<<" times.\n";
       count_[i]=0;
     }
   }
   
   edm::LogInfo("HLTMonBitSummary|BitSummary")<<report.str();
   LogDebug("HLTMonBitSummary|BitSummary")<<report.str();
   total_=0;
   //  if( out_.size() != 0 ) edm::Service<DQMStore>()->save(out_);
   
 }