#include <EgHLTOfflineSummaryClient.h>

Inheritance diagram for EgHLTOfflineSummaryClient:

Classes
struct	SumHistBinData

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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::one::EDAnalyzer< edm::one::SharedResources, edm::one::WatchRuns, edm::one::WatchLuminosityBlocks >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () 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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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
Static Public Member Functions inherited from edm::one::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)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 30 of file EgHLTOfflineSummaryClient.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore EgHLTOfflineSummaryClient::DQMStore

Definition at line 34 of file EgHLTOfflineSummaryClient.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement EgHLTOfflineSummaryClient::MonitorElement

Definition at line 33 of file EgHLTOfflineSummaryClient.h.

Constructor & Destructor Documentation

◆ EgHLTOfflineSummaryClient() [1/2]

EgHLTOfflineSummaryClient::EgHLTOfflineSummaryClient ( const EgHLTOfflineSummaryClient & rhs )

inlineprivate

Definition at line 70 of file EgHLTOfflineSummaryClient.h.

70 {}

◆ EgHLTOfflineSummaryClient() [2/2]

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

explicit

Definition at line 17 of file EgHLTOfflineSummaryClient.cc.

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

     : egHLTSumHistName_("egHLTTrigSum"), isSetup_(false) {
   usesResource("DQMStore");
   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 {
     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::~EgHLTOfflineSummaryClient ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 101 of file EgHLTOfflineSummaryClient.cc.

101 {}

◆ beginJob()

void EgHLTOfflineSummaryClient::beginJob ( void )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 60 of file EgHLTOfflineSummaryClient.cc.

60 {}

◆ beginLuminosityBlock()

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

inlineoverride

Definition at line 83 of file EgHLTOfflineSummaryClient.h.

83 {}

◆ beginRun()

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

override

Definition at line 67 of file EgHLTOfflineSummaryClient.cc.

References c, egHLTFiltersToMon_, egHLTFiltersToMonPaths_, eleHLTFilterNames_, eleHLTFilterNamesForSumBit_, egHLT::trigTools::filterInactiveTriggers(), filterInactiveTriggers_, egHLT::trigTools::getActiveFilters(), getEgHLTFiltersToMon_(), HltComparatorCreateWorkflow::hltConfig, hltTag_, isSetup_, phoHLTFilterNames_, phoHLTFilterNamesForSumBit_, writedatasetfile::run, egHLT::trigTools::translateFiltersToPathNames(), and usePathNames_.

                                                                                   {
   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;
   }
 }

◆ endJob()

void EgHLTOfflineSummaryClient::endJob ( void )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 62 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndJob_.

                                        {
   if (runClientEndJob_)
     runClient_();
 }

◆ endLuminosityBlock()

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

override

Definition at line 103 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndLumiBlock_.

                                                                                                             {
   if (runClientEndLumiBlock_)
     runClient_();
 }

◆ endRun()

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

override

Definition at line 95 of file EgHLTOfflineSummaryClient.cc.

References runClient_(), and runClientEndRun_.

                                                                                 {
   if (runClientEndRun_)
     runClient_();
 }

◆ fillQTestData_()

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

staticprivate

Definition at line 252 of file EgHLTOfflineSummaryClient.cc.

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

Referenced by 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");
   }
 }

◆ getEgHLTFiltersToMon_()

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

private

Definition at line 209 of file EgHLTOfflineSummaryClient.cc.

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

Referenced by 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);
 }

◆ getEgHLTSumHist_()

EgHLTOfflineSummaryClient::MonitorElement * EgHLTOfflineSummaryClient::getEgHLTSumHist_ ( )

private

Definition at line 166 of file EgHLTOfflineSummaryClient.cc.

References dqm::implementation::IBooker::book2D(), dbe_, dirName_, egHLTFiltersToMon_, egHLTFiltersToMonPaths_, egHLTSumHistName_, egHLTSumHistXBins_, dqm::implementation::IGetter::get(), gpuVertexFinder::hist, Skims_PA_cff::name, dqm::implementation::DQMStore::setCurrentFolder(), and usePathNames_.

Referenced by 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;
 }

◆ getQTestBinData_()

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

private

◆ getQTestResults_()

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

private

Definition at line 223 of file EgHLTOfflineSummaryClient.cc.

References dbe_, dirName_, pdwgDoubleElectron_cfi::filterName, dqm::implementation::IGetter::getAllContents(), match(), Skims_PA_cff::name, and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by runClient_().

                                                                                             {
   int nrFail = 0;
   int nrQTests = 0;
   for (auto const& pattern : patterns) {
     auto filterpattern = filterName + pattern;
     std::vector<MonitorElement*> monElems = dbe_->getAllContents(dirName_);
     // std::cout <<"mon elem "<<dirName_+"/"+filterName+patterns[patternNr]<<"nr monElems "<<monElems.size()<<std::endl;
     for (auto& monElem : monElems) {
       const auto& name = monElem->getName();
       int match = fnmatch(filterpattern.c_str(), name.c_str(), 0);
       if (match == FNM_NOMATCH)
         continue;
 
       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;
 }

◆ operator=()

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

inlineprivate

Definition at line 71 of file EgHLTOfflineSummaryClient.h.

71 { return *this; }

◆ runClient_()

void EgHLTOfflineSummaryClient::runClient_ ( )

private

Definition at line 108 of file EgHLTOfflineSummaryClient.cc.

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

Referenced by 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);
 }

◆ splitStringsToPairs_()

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

private

Definition at line 149 of file EgHLTOfflineSummaryClient.cc.

References submitPVValidationJobs::split(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                               {
   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) ";
     }
   }
 }