#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 noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept 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 noexcept

bool	wantsStreamRuns () const noexcept

	~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

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

std::vector< ESResolverIndex > 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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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 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 DummyCfis::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(), compareTotals::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) ";
     }
   }
 }