#include <EgHLTOfflineSummaryClient.h>

Inheritance diagram for EgHLTOfflineSummaryClient:

Classes
struct	SumHistBinData

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

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

void	beginRun (const edm::Run &run, const edm::EventSetup &c) override

	EgHLTOfflineSummaryClient (const edm::ParameterSet &)

void	endJob () override

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

void	endRun (const edm::Run &run, const edm::EventSetup &c) override

	~EgHLTOfflineSummaryClient () override

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

	~EDAnalyzer () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
	EgHLTOfflineSummaryClient (const EgHLTOfflineSummaryClient &rhs)

void	getEgHLTFiltersToMon_ (std::vector< std::string > &filterNames) const

MonitorElement *	getEgHLTSumHist_ ()

int	getQTestBinData_ (const edm::ParameterSet &)

int	getQTestResults_ (const std::string &filterName, const std::vector< std::string > &pattern) const

EgHLTOfflineSummaryClient &	operator= (const EgHLTOfflineSummaryClient &rhs)

void	runClient_ ()

void	splitStringsToPairs_ (const std::vector< std::string > &stringsToSplit, std::vector< std::pair< std::string, std::string > > &splitStrings)

Static Private Member Functions
static void	fillQTestData_ (const edm::ParameterSet &iConfig, std::vector< SumHistBinData > &qTests, const std::string &label)

Private Attributes
DQMStore *	dbe_

std::string	dirName_

std::vector< std::string >	egHLTFiltersToMon_

std::vector< std::string >	egHLTFiltersToMonPaths_

std::string	egHLTSumHistName_

std::vector< SumHistBinData >	egHLTSumHistXBins_

std::vector< std::string >	eleHLTFilterNames_

std::vector< std::string >	eleHLTFilterNamesForSumBit_

std::vector< SumHistBinData >	eleQTestsForSumBit_

bool	filterInactiveTriggers_

std::string	hltTag_

bool	isSetup_

std::vector< std::string >	phoHLTFilterNames_

std::vector< std::string >	phoHLTFilterNamesForSumBit_

std::vector< SumHistBinData >	phoQTestsForSumBit_

bool	runClientEndJob_

bool	runClientEndLumiBlock_

bool	runClientEndRun_

bool	usePathNames_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 33 of file EgHLTOfflineSummaryClient.h.

Constructor & Destructor Documentation

EgHLTOfflineSummaryClient::EgHLTOfflineSummaryClient ( const EgHLTOfflineSummaryClient & rhs )

inlineprivate

Definition at line 72 of file EgHLTOfflineSummaryClient.h.

Referenced by operator=().

72 {}

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

explicit

Definition at line 18 of file EgHLTOfflineSummaryClient.cc.

References dbe_, dirName_, egHLTSumHistXBins_, eleHLTFilterNames_, eleHLTFilterNamesForSumBit_, eleQTestsForSumBit_, fillQTestData_(), filterInactiveTriggers_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hltTag_, Utilities::operator, phoHLTFilterNames_, phoHLTFilterNamesForSumBit_, phoQTestsForSumBit_, runClientEndJob_, runClientEndLumiBlock_, runClientEndRun_, AlCaHLTBitMon_QueryRunRegistry::string, usePathNames_, and ~EgHLTOfflineSummaryClient().

                                                                                   :
   egHLTSumHistName_("egHLTTrigSum"),isSetup_(false)
 {  
   dirName_=iConfig.getParameter<std::string>("DQMDirName"); //only one chance to get this, if we every have another shot, remember to check isSetup is okay
   dbe_ = edm::Service<DQMStore>().operator->();
   if (!dbe_) {
     edm::LogError("EgHLTOfflineSummaryClient") << "unable to get DQMStore service, no summary histograms will be produced";
   }else{
     if(iConfig.getUntrackedParameter<bool>("DQMStore", false)) {
       dbe_->setVerbose(0);
     } 
     dbe_->setCurrentFolder(dirName_);
   }
  
   eleHLTFilterNames_ = iConfig.getParameter<std::vector<std::string> >("eleHLTFilterNames"); 
   phoHLTFilterNames_ = iConfig.getParameter<std::vector<std::string> >("phoHLTFilterNames");
   eleHLTFilterNamesForSumBit_ = iConfig.getParameter<std::vector<std::string> >("eleHLTFilterNamesForSumBit"); 
   phoHLTFilterNamesForSumBit_ = iConfig.getParameter<std::vector<std::string> >("phoHLTFilterNamesForSumBit");
   
 
   filterInactiveTriggers_ =iConfig.getParameter<bool>("filterInactiveTriggers"); 
   hltTag_ = iConfig.getParameter<std::string>("hltTag");
  
   usePathNames_ = iConfig.getParameter<bool>("usePathNames");
  
   
   //std::vector<std::string> egHLTSumQTests = iConfig.getParameter<std::vector<std::string> >("egHLTSumQTests");
   // splitStringsToPairs_(egHLTSumQTests,egHLTSumHistXBins_);
 
   fillQTestData_(iConfig,egHLTSumHistXBins_,"egHLTSumQTests");
   fillQTestData_(iConfig,eleQTestsForSumBit_,"egHLTEleQTestsForSumBit");
   fillQTestData_(iConfig,phoQTestsForSumBit_,"egHLTPhoQTestsForSumBit");
 
  
 
   runClientEndLumiBlock_ = iConfig.getParameter<bool>("runClientEndLumiBlock");
   runClientEndRun_ = iConfig.getParameter<bool>("runClientEndRun");
   runClientEndJob_ = iConfig.getParameter<bool>("runClientEndJob");
 
 
   //egHLTSumHistXBins_.push_back(std::make_pair("Ele Rel Trig Eff",&EgHLTOfflineSummaryClient::eleTrigRelEffQTestResult_));
   //egHLTSumHistXBins_.push_back(std::make_pair("Pho Rel Trig Eff",&EgHLTOfflineSummaryClient::phoTrigRelEffQTestResult_));
   //egHLTSumHistXBins_.push_back(std::make_pair("Ele T&P Trig Eff",&EgHLTOfflineSummaryClient::eleTrigTPEffQTestResult_));
   //egHLTSumHistXBins_.push_back(std::make_pair("Triggered Ele",&EgHLTOfflineSummaryClient::trigEleQTestResult_));
   //egHLTSumHistXBins_.push_back(std::make_pair("Triggered Pho",&EgHLTOfflineSummaryClient::trigPhoQTestResult_)); 
 }

EgHLTOfflineSummaryClient::~EgHLTOfflineSummaryClient ( )

overridedefault

Referenced by EgHLTOfflineSummaryClient(), and operator=().

Member Function Documentation

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

override

Definition at line 114 of file EgHLTOfflineSummaryClient.cc.

Referenced by operator=().

 {
   
 }

void EgHLTOfflineSummaryClient::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 68 of file EgHLTOfflineSummaryClient.cc.

Referenced by operator=().

 {
  
 }

void EgHLTOfflineSummaryClient::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	context
	)

inlineoverride

Definition at line 87 of file EgHLTOfflineSummaryClient.h.

References endLuminosityBlock(), fillQTestData_(), diMuonOutputModule_cfi::filterName, getEgHLTFiltersToMon_(), getEgHLTSumHist_(), getQTestBinData_(), getQTestResults_(), diffTwoXMLs::label, listBenchmarks::pattern, runClient_(), splitStringsToPairs_(), and AlCaHLTBitMon_QueryRunRegistry::string.

87 {}

void EgHLTOfflineSummaryClient::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

override

Definition at line 79 of file EgHLTOfflineSummaryClient.cc.

References egHLTFiltersToMon_, egHLTFiltersToMonPaths_, eleHLTFilterNames_, eleHLTFilterNamesForSumBit_, egHLT::trigTools::filterInactiveTriggers(), filterInactiveTriggers_, egHLT::trigTools::getActiveFilters(), getEgHLTFiltersToMon_(), hltTag_, HLTConfigProvider::init(), isSetup_, phoHLTFilterNames_, phoHLTFilterNamesForSumBit_, egHLT::trigTools::translateFiltersToPathNames(), and usePathNames_.

Referenced by operator=().

 {
   if(!isSetup_){
     bool changed;
     HLTConfigProvider hltConfig;
     hltConfig.init(run,c,hltTag_,changed);
     if(filterInactiveTriggers_){
       std::vector<std::string> activeFilters;
       std::vector<std::string> activeEleFilters;
       std::vector<std::string> activeEle2LegFilters;
       std::vector<std::string> activePhoFilters;
       std::vector<std::string> activePho2LegFilters;
       
       egHLT::trigTools::getActiveFilters(hltConfig,activeFilters,activeEleFilters,activeEle2LegFilters,activePhoFilters,activePho2LegFilters);     
       
       egHLT::trigTools::filterInactiveTriggers(eleHLTFilterNames_,activeFilters);
       egHLT::trigTools::filterInactiveTriggers(phoHLTFilterNames_,activePhoFilters);
       egHLT::trigTools::filterInactiveTriggers(eleHLTFilterNamesForSumBit_,activeEleFilters);
       egHLT::trigTools::filterInactiveTriggers(phoHLTFilterNamesForSumBit_,activePhoFilters); 
       
     }
     getEgHLTFiltersToMon_(egHLTFiltersToMon_);
      
     if(usePathNames_) egHLT::trigTools::translateFiltersToPathNames(hltConfig,egHLTFiltersToMon_,egHLTFiltersToMonPaths_);
     isSetup_=true;
   }
 }

void EgHLTOfflineSummaryClient::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 74 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndJob_.

Referenced by operator=().

 {
   if(runClientEndJob_) runClient_();
 }

void EgHLTOfflineSummaryClient::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

override

Definition at line 119 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndLumiBlock_.

Referenced by beginLuminosityBlock().

 { 
  
   if(runClientEndLumiBlock_)  runClient_();
 }

void EgHLTOfflineSummaryClient::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

override

Definition at line 108 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndRun_.

Referenced by operator=().

 {
   if(runClientEndRun_) runClient_();
 }

void EgHLTOfflineSummaryClient::fillQTestData_	(	const edm::ParameterSet &	iConfig,
		std::vector< SumHistBinData > &	qTests,
		const std::string &	label
	)

staticprivate

Definition at line 254 of file EgHLTOfflineSummaryClient.cc.

References edm::ParameterSet::getParameter(), diffTwoXMLs::label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginLuminosityBlock(), and EgHLTOfflineSummaryClient().

 {
   std::vector<edm::ParameterSet> qTestPara = iConfig.getParameter<std::vector<edm::ParameterSet> >(label);
   qTests.resize(qTestPara.size());
   for(size_t testNr=0;testNr<qTestPara.size();testNr++){
     qTests[testNr].name = qTestPara[testNr].getParameter<std::string>("name");
     qTests[testNr].qTestPatterns = qTestPara[testNr].getParameter<std::vector<std::string> >("qTestsToCheck"); 
   }
 }

void EgHLTOfflineSummaryClient::getEgHLTFiltersToMon_ ( std::vector< std::string > & filterNames ) const

private

Definition at line 220 of file EgHLTOfflineSummaryClient.cc.

References eleHLTFilterNames_, phoHLTFilterNames_, and edm::swap().

Referenced by beginLuminosityBlock(), and beginRun().

 { 
   std::set<std::string> filterNameSet;
   for(auto const & eleHLTFilterName : eleHLTFilterNames_) filterNameSet.insert(eleHLTFilterName);
   for(auto const & phoHLTFilterName : phoHLTFilterNames_) filterNameSet.insert(phoHLTFilterName);
  
   //right all the triggers are inserted once and only once in the set, convert to vector
   //very lazy, create a new vector so can use the constructor and then use swap to transfer
   std::vector<std::string>(filterNameSet.begin(),filterNameSet.end()).swap(filterNames);
 }

MonitorElement * EgHLTOfflineSummaryClient::getEgHLTSumHist_ ( )

private

Definition at line 182 of file EgHLTOfflineSummaryClient.cc.

References DQMStore::book2D(), dbe_, dirName_, egHLTFiltersToMon_, egHLTFiltersToMonPaths_, egHLTSumHistName_, egHLTSumHistXBins_, DQMStore::get(), create_public_lumi_plots::hist, dataset::name, DQMStore::setCurrentFolder(), and usePathNames_.

Referenced by beginLuminosityBlock(), and runClient_().

 {
   MonitorElement* egHLTSumHist = dbe_->get(dirName_+"/"+egHLTSumHistName_);
   if(egHLTSumHist==nullptr){
     auto* hist = new TH2F(egHLTSumHistName_.c_str(),"E/g HLT Offline Summary",egHLTSumHistXBins_.size(),0.,1.,egHLTFiltersToMon_.size(),0.,1.);
     for(size_t xBinNr=0;xBinNr<egHLTSumHistXBins_.size();xBinNr++){
       hist->GetXaxis()->SetBinLabel(xBinNr+1,egHLTSumHistXBins_[xBinNr].name.c_str());
     }
     
     for(size_t yBinNr=0;yBinNr<egHLTFiltersToMon_.size();yBinNr++){
       if(usePathNames_ && egHLTFiltersToMonPaths_.size()==egHLTFiltersToMon_.size()){
         hist->GetYaxis()->SetBinLabel(yBinNr+1,egHLTFiltersToMonPaths_[yBinNr].c_str());
       }else{
     hist->GetYaxis()->SetBinLabel(yBinNr+1,egHLTFiltersToMon_[yBinNr].c_str());
       }
     }
     for(size_t xBinNr=0;xBinNr<egHLTSumHistXBins_.size();xBinNr++){
       for(size_t yBinNr=0;yBinNr<egHLTFiltersToMon_.size();yBinNr++){
     hist->SetBinContent(xBinNr+1,yBinNr+1,-2);
       }
     }
  
     dbe_->setCurrentFolder(dirName_);
     egHLTSumHist = dbe_->book2D(egHLTSumHistName_,hist);
   }
   return egHLTSumHist;
 
 }

int EgHLTOfflineSummaryClient::getQTestBinData_ ( const edm::ParameterSet & )

private

Referenced by beginLuminosityBlock().

int EgHLTOfflineSummaryClient::getQTestResults_	(	const std::string &	filterName,
		const std::vector< std::string > &	pattern
	)		const

private

Definition at line 233 of file EgHLTOfflineSummaryClient.cc.

References dbe_, dirName_, DQMStore::getMatchingContents(), and listBenchmarks::pattern.

Referenced by beginLuminosityBlock(), and runClient_().

 {
   int nrFail =0;
   int nrQTests=0;
   for(auto const & pattern : patterns){
     std::vector<MonitorElement*> monElems = dbe_->getMatchingContents(dirName_+"/"+filterName+pattern);
     // std::cout <<"mon elem "<<dirName_+"/"+filterName+patterns[patternNr]<<"nr monElems "<<monElems.size()<<std::endl;
     for(auto & monElem : monElems){
      
       std::vector<QReport*> qTests = monElem->getQReports();
       nrQTests+=qTests.size();
       //  std::cout <<monElems[monElemNr]->getName()<<" "<<monElems[monElemNr]->hasError()<<" nr test "<<qTests.size()<<std::endl;
       if(monElem->hasError()) nrFail++;
     }
   }
   if(nrQTests==0) return -1;
   else if(nrFail==0) return 1;
   else return 0;
 }

EgHLTOfflineSummaryClient& EgHLTOfflineSummaryClient::operator= ( const EgHLTOfflineSummaryClient & rhs )

inlineprivate

Definition at line 73 of file EgHLTOfflineSummaryClient.h.

References analyze(), beginJob(), beginRun(), EnergyCorrector::c, EgHLTOfflineSummaryClient(), endJob(), endRun(), findQualityFiles::run, and ~EgHLTOfflineSummaryClient().

73 {return *this;}

void EgHLTOfflineSummaryClient::runClient_ ( )

private

Definition at line 125 of file EgHLTOfflineSummaryClient.cc.

References DQMStore::bookFloat(), dbe_, egHLTFiltersToMon_, egHLTSumHistXBins_, eleHLTFilterNamesForSumBit_, eleQTestsForSumBit_, MonitorElement::Fill(), DQMStore::get(), getEgHLTSumHist_(), getQTestResults_(), phoHLTFilterNamesForSumBit_, phoQTestsForSumBit_, MonitorElement::setBinContent(), and DQMStore::setCurrentFolder().

Referenced by beginLuminosityBlock(), endJob(), endLuminosityBlock(), and endRun().

 {
  
   MonitorElement* egHLTSumME = getEgHLTSumHist_();
 
   for(size_t filterNr=0;filterNr<egHLTFiltersToMon_.size();filterNr++){
     for(size_t xBinNr=0;xBinNr<egHLTSumHistXBins_.size();xBinNr++){
       //egHLTSumHist->setBinContent(xBinNr+1,filterNr+1,(*egHLTSumHistXBins_[xBinNr].second)(egHLTFiltersToMon_[filterNr].c_str()));
       egHLTSumME->setBinContent(xBinNr+1,filterNr+1,
                 getQTestResults_(egHLTFiltersToMon_[filterNr],egHLTSumHistXBins_[xBinNr].qTestPatterns)); 
     }
   }
 
   MonitorElement* hltEleSumBit = dbe_->get("HLT/EventInfo/reportSummaryContents/HLT_Electron");
   MonitorElement* hltPhoSumBit = dbe_->get("HLT/EventInfo/reportSummaryContents/HLT_Photon");
   dbe_->setCurrentFolder("HLT/EventInfo/reportSummaryContents/");
   if(hltEleSumBit==nullptr) hltEleSumBit = dbe_->bookFloat("HLT_Electron");
   if(hltPhoSumBit==nullptr) hltPhoSumBit = dbe_->bookFloat("HLT_Photon");
 
   
   float eleSumBit=1.;
   for(size_t filterNr=0;filterNr<eleHLTFilterNamesForSumBit_.size() && eleSumBit==1;filterNr++){ //breaks as soon as a test fails
     for(size_t testNr=0;testNr<eleQTestsForSumBit_.size() && eleSumBit==1;testNr++){
       if(getQTestResults_(eleHLTFilterNamesForSumBit_[filterNr],eleQTestsForSumBit_[testNr].qTestPatterns)==0) eleSumBit=0;
       
     }
   }
   hltEleSumBit->Fill(eleSumBit);
   
   float phoSumBit=1.;
   for(size_t filterNr=0;filterNr<phoHLTFilterNamesForSumBit_.size() && phoSumBit==1;filterNr++){ //breaks as soon as a test fails
     for(size_t testNr=0;testNr<phoQTestsForSumBit_.size() && phoSumBit==1;testNr++){
       if(getQTestResults_(phoHLTFilterNamesForSumBit_[filterNr],phoQTestsForSumBit_[testNr].qTestPatterns)==0) phoSumBit=0;
     }
   }
   hltPhoSumBit->Fill(phoSumBit);
   
   
    
 }

void EgHLTOfflineSummaryClient::splitStringsToPairs_	(	const std::vector< std::string > &	stringsToSplit,
		std::vector< std::pair< std::string, std::string > > &	splitStrings
	)

private

Definition at line 165 of file EgHLTOfflineSummaryClient.cc.

References split, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginLuminosityBlock().

 {
   splitStrings.clear();
   splitStrings.reserve(stringsToSplit.size());
   for(auto const & stringNr : stringsToSplit){
     std::vector<std::string> tempSplitStrings;
     boost::split(tempSplitStrings,stringNr,boost::is_any_of(std::string(":")));
     if(tempSplitStrings.size()==2){
       splitStrings.push_back(std::make_pair(tempSplitStrings[0],tempSplitStrings[1]));
     }else{
       edm::LogWarning("EgHLTOfflineSummaryClient") <<" Error : entry "<<stringNr<<" is not of form A:B, ignoring (ie this quailty test isnt being included in the sumamry hist) ";
     }
   }
 }