Inheritance diagram for GeneralHLTOffline:

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

	~GeneralHLTOffline ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) 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 &) override

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

virtual void	bookHistograms (DQMStore::IBooker &, edm::Run const &iRun, edm::EventSetup const &iSetup) override

virtual void	dqmBeginRun (edm::Run const &iRun, edm::EventSetup const &iSetup) override

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

virtual void	fillHltMatrix (const std::string &, const std::string &, bool, bool, edm::Handle< trigger::TriggerEventWithRefs >, edm::Handle< trigger::TriggerEvent >)

virtual void	setupHltMatrix (DQMStore::IBooker &iBooker, const std::string &, int)

Private Attributes
std::vector< std::string >	AddedDatasets

std::map< std::string, MonitorElement * >	cpfilt_mini_

MonitorElement *	cppath_

std::map< std::string, MonitorElement * >	cppath_mini_

std::vector< std::string >	DataSetNames

bool	debugPrint

std::map< std::string, TH1F * >	hist_cpfilt_mini_

HLTConfigProvider	hlt_config_

std::string	hlt_menu_

std::string	hltTag

bool	outputPrint

std::map< std::string, std::vector< std::string > >	PathModules

std::vector< std::vector < std::string > >	PDsVectorPathsVector

std::string	plotDirectoryName

bool	streamA_found_

edm::EDGetTokenT < edm::TriggerResults >	triggerResultsToken

edm::EDGetTokenT < trigger::TriggerEvent >	triggerSummaryTokenAOD

edm::EDGetTokenT < trigger::TriggerEventWithRefs >	triggerSummaryTokenRAW

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Description: [one line class summary] Implementation: [Notes on implementation]

Definition at line 49 of file GeneralHLTOffline.cc.

Constructor & Destructor Documentation

GeneralHLTOffline::GeneralHLTOffline ( const edm::ParameterSet & ps )

explicit

Definition at line 102 of file GeneralHLTOffline.cc.

References gather_cfg::cout, debugPrint, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hltTag, HLT_25ns14e33_v1_cff::InputTag, outputPrint, plotDirectoryName, AlCaHLTBitMon_QueryRunRegistry::string, triggerResultsToken, triggerSummaryTokenAOD, and triggerSummaryTokenRAW.

                                                              :streamA_found_(false),
                                                                   hlt_menu_(""),
                                                                   cppath_(0) {
   debugPrint  = false;
   outputPrint = false;
 
   plotDirectoryName = ps.getUntrackedParameter<std::string>("dirname",
                                                             "HLT/General");
 
   hltTag = ps.getParameter<std::string> ("HltProcessName");
 
   triggerSummaryTokenRAW = consumes <trigger::TriggerEventWithRefs> (edm::InputTag(std::string("hltTriggerSummaryRAW"), std::string(""), hltTag));
   triggerSummaryTokenAOD = consumes <trigger::TriggerEvent> (edm::InputTag(std::string("hltTriggerSummaryAOD"), std::string(""), hltTag));
   triggerResultsToken = consumes <edm::TriggerResults>   (edm::InputTag(std::string("TriggerResults"), std::string(""), hltTag));
 
   if (debugPrint) {
     std::cout << "Inside Constructor" << std::endl;
     std::cout << "Got plot dirname = " << plotDirectoryName << std::endl;
   }
 }

GeneralHLTOffline::~GeneralHLTOffline ( )

Definition at line 124 of file GeneralHLTOffline.cc.

124 {

125 }

Member Function Documentation

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

overrideprivatevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 129 of file GeneralHLTOffline.cc.

References accept(), gather_cfg::cout, cppath_, cppath_mini_, makeLayoutFileForGui::datasetNames, debugPrint, MonitorElement::Fill(), fillHltMatrix(), edm::Event::getByToken(), MonitorElement::getTH1F(), hlt_config_, hlt_menu_, edm::EventBase::id(), cmsHarvester::index, edm::HandleBase::isValid(), diffTwoXMLs::label, edm::EventID::luminosityBlock(), NULL, EgammaValidation_cff::pathName, PDsVectorPathsVector, HLTConfigProvider::removeVersion(), edm::EventID::run(), findQualityFiles::size, streamA_found_, HLTConfigProvider::streamContent(), AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerIndex(), triggerResults, triggerResultsToken, triggerSummaryTokenAOD, and triggerSummaryTokenRAW.

                                                         {
   if (debugPrint)
     std::cout << "Inside analyze - run, block, event "
               << iEvent.id().run() << " , " << iEvent.id().luminosityBlock()
               << " , " << iEvent.id() << " , " << std::endl;
 
   // Access Trigger Results
   edm::Handle<edm::TriggerResults> triggerResults;
   iEvent.getByToken(triggerResultsToken, triggerResults);
 
   if (!triggerResults.isValid()) {
     if (debugPrint)
       std::cout << "Trigger results not valid" << std::endl;
     return;
   }
 
   if (debugPrint)
     std::cout << "Found triggerResults" << std::endl;
 
   edm::Handle<trigger::TriggerEventWithRefs> rawTriggerEvent;
   iEvent.getByToken(triggerSummaryTokenRAW, rawTriggerEvent);
 
   edm::Handle<trigger::TriggerEvent> aodTriggerEvent;
   iEvent.getByToken(triggerSummaryTokenAOD, aodTriggerEvent);
 
   bool hasRawTriggerEvent = true;
   if( !rawTriggerEvent.isValid() ){
     hasRawTriggerEvent = false;
     if (debugPrint)
       std::cout << "No RAW trigger summary found! Returning...";
 
     if( !aodTriggerEvent.isValid() ){
       if (debugPrint)
     std::cout << "No AOD trigger summary found! Returning...";
       return;
     }
   }
 
   if (streamA_found_) {
     const std::vector<std::string> &datasetNames =  hlt_config_.streamContent("A");
     // Loop over PDs
     for (unsigned int iPD = 0; iPD < datasetNames.size(); iPD++) {
       // Loop over Paths in each PD
       for (unsigned int iPath = 0;
            iPath < PDsVectorPathsVector[iPD].size(); iPath++) {
         std::string &pathName = PDsVectorPathsVector[iPD][iPath];
         unsigned int index = hlt_config_.triggerIndex(pathName);
         if (debugPrint) {
           std::cout << "Looking at path " << pathName << std::endl;
           std::cout << "Index = " << index
                     << " triggerResults->size() = " << triggerResults->size()
                     << std::endl;
         }
 
         // fill the histos with empty weights......
         const std::string &label = datasetNames[iPD];
         std::string fullPathToCPP = "HLT/GeneralHLTOffline/"
             + label + "/cppath_" + label + hlt_menu_;
         MonitorElement * ME_mini_cppath = NULL;
         TH1F * hist_mini_cppath = NULL;
         if( cppath_mini_.find(fullPathToCPP)!=cppath_mini_.end() ){
       ME_mini_cppath = cppath_mini_[fullPathToCPP];
           hist_mini_cppath = ME_mini_cppath->getTH1F();
     }
 
         if (hist_mini_cppath) {
           TAxis * axis = hist_mini_cppath->GetXaxis();
           if (axis) {
         std::string pathNameNoVer = hlt_config_.removeVersion(PDsVectorPathsVector[iPD][iPath]);
             int bin_num = axis->FindBin(pathNameNoVer.c_str());
             int bn = bin_num - 1;
             hist_mini_cppath->Fill(bn, 0);
             hist_mini_cppath->SetEntries(hist_mini_cppath->Integral());
           }
         }
 
         if( index < triggerResults->size() ) {
       bool accept = triggerResults->accept(index);
       if( accept ) cppath_->Fill(index, 1);
 
       fillHltMatrix(datasetNames[iPD], pathName,
             accept,
             hasRawTriggerEvent,
             rawTriggerEvent,
             aodTriggerEvent);
         }  // end if (index < triggerResults->size())
       }  // end Loop over Paths in each PD
     }  // end Loop over PDs
   }
 }

void GeneralHLTOffline::beginLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 610 of file GeneralHLTOffline.cc.

611 {

612 }

void GeneralHLTOffline::bookHistograms	(	DQMStore::IBooker &	iBooker,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 412 of file GeneralHLTOffline.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::bookString(), cppath_, DataSetNames, hlt_config_, hlt_menu_, plotDirectoryName, DQMStore::IBooker::setCurrentFolder(), setupHltMatrix(), HLTConfigProvider::size(), and streamA_found_.

 {
   iBooker.setCurrentFolder(plotDirectoryName) ;
 
 
   iBooker.setCurrentFolder("HLT/GeneralHLTOffline/");
   iBooker.bookString("hltMenuName", hlt_menu_.c_str());
   cppath_ = iBooker.book1D("cppath" + hlt_menu_,
                "Counts/Path",
                hlt_config_.size(), 0, hlt_config_.size());
 
   if (streamA_found_) {
 
     for (unsigned int iPD = 0; iPD < DataSetNames.size(); iPD++)
       setupHltMatrix(iBooker, DataSetNames[iPD], iPD);
 
   }  // if stream A found
 }  // end of bookHistograms

void GeneralHLTOffline::dqmBeginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 225 of file GeneralHLTOffline.cc.

                                                 {
   if (debugPrint)
     std::cout << "Inside beginRun" << std::endl;
 
   // Reset "condition" variables that could have memory of previous
   // runs.
 
   PDsVectorPathsVector.clear();
   AddedDatasets.clear();
   DataSetNames.clear();
   PathModules.clear();
 
 
   bool changed = true;
   if (!hlt_config_.init(iRun, iSetup, hltTag, changed)) {
     if (debugPrint) {
       std::cout << "Warning, didn't find process HLT" << std::endl;
       return;
     }
   } else {
     if (debugPrint)
       std::cout << " HLTConfig processName " << hlt_config_.processName()
                 << " tableName " << hlt_config_.tableName()
                 << " size " << hlt_config_.size() << std::endl;
   }
   hlt_menu_ = hlt_config_.tableName();
   for (unsigned int n = 0, e = hlt_menu_.length(); n != e; ++n)
     if (hlt_menu_[n] == '/' || hlt_menu_[n] == '.')
       hlt_menu_[n] = '_';
 
 
   const std::vector<std::string> &nameStreams = hlt_config_.streamNames();
   std::vector<std::string>::const_iterator si = nameStreams.begin();
   std::vector<std::string>::const_iterator se = nameStreams.end();
   for ( ; si != se; ++si) {
     if ((*si) == "A") {
       streamA_found_ = true;
       break;
     }
   }
 
 
 
   if (streamA_found_) {
     const std::vector<std::string> &datasetNames =  hlt_config_.streamContent("A");
     DataSetNames = datasetNames;
 
     if (debugPrint)
       std::cout << "Number of Stream A datasets "
                 << datasetNames.size() << std::endl;
 
     for (unsigned int i = 0; i < datasetNames.size(); i++) {
       const std::vector<std::string> &datasetPaths = hlt_config_.datasetContent(datasetNames[i]);
       if (debugPrint) {
         std::cout << "This is dataset " << datasetNames[i]
                   << "datasetPaths.size() = " << datasetPaths.size() << std::endl;
         for (unsigned int iPath = 0;
              iPath < datasetPaths.size(); iPath++) {
           std::cout << "Before setupHltMatrix -  MET dataset "
                     << datasetPaths[iPath] << std::endl;
         }
       }
       // Check if dataset has been added - if not add it
       // need to loop through AddedDatasets and compare
       bool foundDataset = false;
       int datasetNum = -1;
       for (unsigned int d = 0; d < AddedDatasets.size(); d++) {
         if (AddedDatasets[d].compare(datasetNames[i]) == 0) {
           foundDataset = true;
           datasetNum = d;
           if (debugPrint)
             std::cout << "Dataset " << datasetNames[i]
                       << " found in AddedDatasets at position " << d << std::endl;
           break;
         }
       }
 
       if (!foundDataset) {
         if (debugPrint)
           std::cout << " Fill trigger paths for dataset "
                     << datasetNames[i] << std::endl;
         PDsVectorPathsVector.push_back(datasetPaths);
         // store dataset pathname
         AddedDatasets.push_back(datasetNames[i]);
       } else {
         // This trigger path has already been added - this implies that
         // this is a new run What we want to do is check if there is a
         // new trigger that was not in the original dataset For a given
         // dataset, loop over the stored list of triggers, and compare
         // to the current list of triggers If any of the triggers are
         // missing, add them to the end of the appropriate dataset
         if (debugPrint)
           std::cout << " Additional runs : Check for additional"
                     << "trigger paths per dataset " << std::endl;
         // Loop over correct path of PDsVectorPathsVector
         bool found = false;
 
         // Loop over triggers in the path
         for (unsigned int iTrig = 0; iTrig < datasetPaths.size(); iTrig++) {
           if (debugPrint)
             std::cout << "Looping over trigger list in dataset "
                       <<  iTrig <<  "  "
                       << datasetPaths[iTrig] << std::endl;
           found = false;
           // Loop over triggers already on the list
           for (unsigned int od = 0; od < PDsVectorPathsVector[datasetNum].size(); od++) {
             if (debugPrint)
               std::cout << "Looping over existing trigger list " << od
                         <<  "  " << PDsVectorPathsVector[datasetNum][od] << std::endl;
             // Compare, see if match is found
             if (hlt_config_.removeVersion(datasetPaths[iTrig]).compare(
                     hlt_config_.removeVersion(PDsVectorPathsVector[datasetNum][od])) == 0) {
               found = true;
               if (debugPrint)
                 std::cout << " FOUND " << datasetPaths[iTrig] << std::endl;
               break;
             }
           }
           // If match is not found, add trigger to correct path of PDsVectorPathsVector
           if (!found)
             PDsVectorPathsVector[datasetNum].push_back(datasetPaths[iTrig]);
           if (debugPrint)
             std::cout << datasetPaths[iTrig]
                       << "  NOT FOUND - so we added it to the correct dataset "
                       << datasetNames[i] << std::endl;
         }
       }
       // Let's check this whole big structure
       if (debugPrint) {
         for (unsigned int is = 0; is < PDsVectorPathsVector.size(); is++) {
           std::cout << "   PDsVectorPathsVector[" << is << "] is "
                     << PDsVectorPathsVector[is].size() << std::endl;
           for (unsigned int ip = 0; ip < PDsVectorPathsVector[is].size(); ip++) {
             std::cout << "    trigger " << ip << " path "
                       << PDsVectorPathsVector[is][ip] << std::endl;
           }
         }
       }
 
       if (debugPrint)
         std::cout <<"Found PD: " << datasetNames[i] << std::endl;
     }  // end of loop over dataset names
 
 
 
     std::vector<std::string> triggerNames = hlt_config_.triggerNames();
 
     for( unsigned int iPath=0; iPath<triggerNames.size(); iPath++ ){
       std::string pathName = triggerNames[iPath];
 
       const std::vector<std::string>& moduleLabels = hlt_config_.moduleLabels(pathName);
       int NumModules = int( moduleLabels.size() );
 
       if( !(pathName.find("HLT_") != std::string::npos) ) continue;
       if( (pathName.find("HLT_Physics")!=std::string::npos) ||
       (pathName.find("HLT_Random")!=std::string::npos) ) continue;
 
       std::string prefix("hltPre");
 
       std::vector<std::string> good_module_names;
       good_module_names.clear();
       for( int iMod=0; iMod<NumModules; iMod++ ){
     std::string moduleType = hlt_config_.moduleType(moduleLabels[iMod]);
     std::string moduleEDMType = hlt_config_.moduleEDMType(moduleLabels[iMod]);
     if( !(moduleEDMType == "EDFilter") ) continue;
     if( moduleType.find("Selector")!= std::string::npos ) continue;
     if( moduleType == "HLTTriggerTypeFilter" || 
         moduleType == "HLTBool" ||
         moduleType == "PrimaryVertexObjectFilter" ||
         moduleType == "JetVertexChecker" ||
         moduleType == "HLTRHemisphere" ||
         moduleType == "DetectorStateFilter" ) continue;
 
     if( moduleLabels[iMod].compare(0, prefix.length(), prefix) == 0 ) continue;
     good_module_names.push_back(moduleLabels[iMod]);
       }
       PathModules[pathName] = good_module_names;
     } // loop over paths
 
   }  // if stream A found
 
 
 }

void GeneralHLTOffline::endLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 615 of file GeneralHLTOffline.cc.

616 {

617 }

void GeneralHLTOffline::fillHltMatrix	(	const std::string &	label,
		const std::string &	path,
		bool	accept,
		bool	hasRawTriggerEvent,
		edm::Handle< trigger::TriggerEventWithRefs >	triggerEventRAW,
		edm::Handle< trigger::TriggerEvent >	triggerEventAOD
	)

privatevirtual

Definition at line 510 of file GeneralHLTOffline.cc.

References gather_cfg::cout, cpfilt_mini_, cppath_mini_, debugPrint, MonitorElement::getTH1F(), hlt_config_, hlt_menu_, hltTag, edm::HandleBase::isValid(), NULL, cmsHarvester::path, PathModules, HLTConfigProvider::removeVersion(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                       {
   if (debugPrint)
     std::cout << "Inside fillHltMatrix( " << label << " , "
               << path << " ) " << std::endl;
 
   std::string fullPathToCPP;
 
   fullPathToCPP = "HLT/GeneralHLTOffline/" + label + "/cppath_" + label + "_" + hlt_menu_;
   
   std::string dnamez = "cppath_" + label + "_" + hlt_menu_;
 
   TH1F * hist_mini_cppath = NULL;
   MonitorElement * ME_mini_cppath = NULL;
   if( cppath_mini_.find(dnamez)!=cppath_mini_.end() ){
     ME_mini_cppath = cppath_mini_[dnamez];
     hist_mini_cppath = ME_mini_cppath->getTH1F();
   }
 
   std::string pathNameNoVer = hlt_config_.removeVersion(path);
 
   if( (path.find("HLT_") != std::string::npos) && 
       !(path.find("HLT_Physics")!=std::string::npos) && 
       !(path.find("HLT_Random")!=std::string::npos) ){
 
     unsigned int triggerEventSize = 0;
     if( hasRawTriggerEvent && triggerEventRAW.isValid() ) triggerEventSize = triggerEventRAW->size();
     else if( triggerEventAOD.isValid() ) triggerEventSize = triggerEventAOD->sizeFilters();
 
     std::string pathName_dataset = "cpfilt_" + label + "_" + pathNameNoVer;
 
     TH1F * hist_cpfilt_mini = NULL;
     MonitorElement * ME_cpfilt_mini = NULL;
     if( cpfilt_mini_.find(pathName_dataset)!=cpfilt_mini_.end() ){
       ME_cpfilt_mini = cpfilt_mini_[pathName_dataset];
       hist_cpfilt_mini = ME_cpfilt_mini->getTH1F();
     }
 
 
     std::vector<std::string> moduleLabels = PathModules[path];
     int NumModules = int( moduleLabels.size() );
 
     for( int iMod=0; iMod<NumModules; iMod++ ){
       edm::InputTag moduleWhoseResultsWeWant(moduleLabels[iMod],
                          "",
                          hltTag);
 
       unsigned int idx_module_trg = 0;
       if( hasRawTriggerEvent && triggerEventRAW.isValid() ) idx_module_trg = triggerEventRAW->filterIndex(moduleWhoseResultsWeWant);
       else if( triggerEventAOD.isValid() ) idx_module_trg = triggerEventAOD->filterIndex(moduleWhoseResultsWeWant);
   
       if( !(idx_module_trg < triggerEventSize) ) continue;
       if( hist_cpfilt_mini ){
     TAxis * axis = hist_cpfilt_mini->GetXaxis();
     int bin_num = axis->FindBin(moduleLabels[iMod].c_str());
     int bn = bin_num - 1;
 
     if( bin_num!=1 && hasRawTriggerEvent ){
       bool passPreviousFilters = true;
       for( int ibin = bin_num-1; ibin>0; ibin-- ){ 
         std::string previousFilter(axis->GetBinLabel(ibin));
         edm::InputTag previousModuleWhoseResultsWeWant(previousFilter,
                                "",
                                hltTag);
         unsigned int idx_previous_module_trg = 0;
         if( hasRawTriggerEvent && triggerEventRAW.isValid() ) idx_previous_module_trg = triggerEventRAW->filterIndex(previousModuleWhoseResultsWeWant);
         else if( triggerEventAOD.isValid() ) idx_previous_module_trg = triggerEventAOD->filterIndex(previousModuleWhoseResultsWeWant);
 
         if( !(idx_previous_module_trg < triggerEventSize) ){
           passPreviousFilters = false;
           break;
         }
       }
       // Only fill if previous filters have been passed
       if( passPreviousFilters ) hist_cpfilt_mini->Fill(bn, 1);
     }
     else hist_cpfilt_mini->Fill(bn, 1);
 
       }
     }
   }
   else{
     if (debugPrint) std::cout << "No AOD trigger summary found! Returning..." << std::endl;
   }
 
   if( accept && hist_mini_cppath ){
     TAxis * axis = hist_mini_cppath->GetXaxis();
     int bin_num = axis->FindBin(pathNameNoVer.c_str());
     int bn = bin_num - 1;
     hist_mini_cppath->Fill(bn, 1);
   }
 
   if (debugPrint)
     std::cout << "hist->Fill" << std::endl;
 }  // End fillHltMatrix

void GeneralHLTOffline::setupHltMatrix	(	DQMStore::IBooker &	iBooker,
		const std::string &	label,
		int	iPD
	)

privatevirtual

Definition at line 435 of file GeneralHLTOffline.cc.

References DQMStore::IBooker::book1D(), gather_cfg::cout, cpfilt_mini_, cppath_mini_, debugPrint, hist_cpfilt_mini_, hlt_config_, hlt_menu_, NULL, PathModules, EgammaValidation_cff::pathName, PDsVectorPathsVector, HLTConfigProvider::removeVersion(), DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bookHistograms().

                                                                                                   {
   std::string h_name;
   std::string h_title;
   std::string pathName;
   std::string PD_Folder;
   std::string Path_Folder;
 
   PD_Folder = TString("HLT/GeneralHLTOffline/"+label);
 
   iBooker.setCurrentFolder(PD_Folder.c_str());
 
   // make it the top level directory, that is on the same dir level as
   // paths
   std::string folderz;
   folderz = TString("HLT/GeneralHLTOffline/"+label);
   iBooker.setCurrentFolder(folderz.c_str());
 
   std::string dnamez = "cppath_" + label + "_" + hlt_menu_;
   int sizez = PDsVectorPathsVector[iPD].size();
   TH1F * hist_mini_cppath = NULL;
   cppath_mini_[dnamez] = iBooker.book1D(dnamez.c_str(),
                     dnamez.c_str(),
                     sizez,
                     0,
                     sizez);
   if( cppath_mini_[dnamez] )
     hist_mini_cppath = cppath_mini_[dnamez]->getTH1F();
 
   unsigned int jPath;
   for (unsigned int iPath = 0; iPath < PDsVectorPathsVector[iPD].size(); iPath++) {
     pathName = hlt_config_.removeVersion(PDsVectorPathsVector[iPD][iPath]);
     jPath = iPath + 1;
 
     if (hist_mini_cppath) {
       TAxis * axis = hist_mini_cppath->GetXaxis();
       if (axis)
         axis->SetBinLabel(jPath, pathName.c_str());
     }
 
     std::string pathNameVer = PDsVectorPathsVector[iPD][iPath];
 
     std::vector<std::string> moduleLabels = PathModules[pathNameVer];
     int NumModules = int( moduleLabels.size() );
 
     if( NumModules==0 ) continue;
 
     std::string pathName_dataset = "cpfilt_" + label + "_" + pathName;
 
     cpfilt_mini_[pathName_dataset] = iBooker.book1D(pathName_dataset.c_str(),
                               pathName.c_str(),
                               NumModules,
                               0,
                               NumModules);
 
     if( cpfilt_mini_[pathName_dataset] )
       hist_cpfilt_mini_[pathName_dataset] = cpfilt_mini_[pathName_dataset]->getTH1F();
 
     for( int iMod=0; iMod<NumModules; iMod++ ){
       if( cpfilt_mini_[pathName_dataset] && hist_cpfilt_mini_[pathName_dataset] ){
     TAxis * axis = hist_cpfilt_mini_[pathName_dataset]->GetXaxis();
     if (axis)
       axis->SetBinLabel(iMod+1,moduleLabels[iMod].c_str());
       }
     }
 
     if (debugPrint)
       std::cout << "book1D for " << pathName << std::endl;
   }
 
   if (debugPrint)
     std::cout << "Success setupHltMatrix( " << label << " , "
               << iPD << " )" << std::endl;
 }  // End setupHltMatrix