Inheritance diagram for LumiCalculator:

Public Member Functions
	LumiCalculator (edm::ParameterSet const &pset)

	~LumiCalculator () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

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

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
void	analyze (edm::Event const &e, edm::EventSetup const &c) override

void	beginJob () override

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

void	endJob () override

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

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

std::vector< std::string >	splitpathstr (const std::string &strValue, const std::string separator)

Private Attributes
unsigned int	currentlumi_

HLTConfigProvider	hltConfig_

std::map< std::string, hltPerPathInfo >	hltmap_

std::map< std::string, l1PerBitInfo >	l1map_

edm::LogInfo *	log_

std::vector< MyPerLumiInfo >	perrunlumiinfo_

bool	showTrgInfo_

std::multimap< std::string, std::string >	trgpathMmap_

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	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

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)

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 () noexcept

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

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 34 of file LumiCalculator.cc.

Constructor & Destructor Documentation

LumiCalculator::LumiCalculator ( edm::ParameterSet const & pset )

explicit

Definition at line 61 of file LumiCalculator.cc.

References edm::ParameterSet::getUntrackedParameter(), HLT_FULL_cff::InputTag, and showTrgInfo_.

                                                           : log_(new edm::LogInfo("LumiReport")), currentlumi_(0) {
   showTrgInfo_ = pset.getUntrackedParameter<bool>("showTriggerInfo", false);
   consumes<LumiSummary, edm::InLumi>(edm::InputTag("lumiProducer", ""));
   consumes<LumiSummaryRunHeader, edm::InRun>(edm::InputTag("lumiProducer", ""));
 }

LumiCalculator::~LumiCalculator ( )

override

Definition at line 69 of file LumiCalculator.cc.

References log_.

                                 {
   delete log_;
   log_ = nullptr;
 }

Member Function Documentation

void LumiCalculator::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 76 of file LumiCalculator.cc.

76 {}

void LumiCalculator::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 80 of file LumiCalculator.cc.

80 {}

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

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 84 of file LumiCalculator.cc.

References Exception, edm::ParameterSet::getParameter(), ValidationMatrix::hlt, hltConfig_, hltmap_, mps_fire::i, HLTConfigProvider::init(), l1map_, log_, HLTConfigProvider::moduleLabels(), HLTConfigProvider::modulePSet(), HLTConfigProvider::moduleType(), perrunlumiinfo_, hltPerPathInfo::prescale, edm::RunBase::run(), DetachedQuadStep_cff::seeds, showTrgInfo_, HLTConfigProvider::size(), findQualityFiles::size, splitpathstr(), AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, HLTConfigProvider::tableName(), trgpathMmap_, and HLTConfigProvider::triggerName().

                                                                        {
   //std::cout<<"I'm in run number "<<run.run()<<std::endl;
   //if(!hltConfig_.init("HLT")){
   // throw cms::Exception("HLT process cannot be initialized");
   //}
   bool changed(true);
   const std::string processname("HLT");
   if (!hltConfig_.init(run, c, processname, changed)) {
     throw cms::Exception("HLT process cannot be initialized");
   }
   perrunlumiinfo_.clear();
   trgpathMmap_.clear();
   hltmap_.clear();
   l1map_.clear();
   //hltConfig_.dump("processName");
   //hltConfig_.dump("TableName");
   //hltConfig_.dump("Triggers");
   //hltConfig_.dump("Modules");
   if (showTrgInfo_) {
     *log_ << "======Trigger Configuration Overview======\n";
     *log_ << "Run " << run.run() << " Trigger Table : " << hltConfig_.tableName() << "\n";
   }
   unsigned int totaltrg = hltConfig_.size();
   for (unsigned int t = 0; t < totaltrg; ++t) {
     std::string hltname(hltConfig_.triggerName(t));
     std::vector<std::string> numpathmodules = hltConfig_.moduleLabels(hltname);
     if (showTrgInfo_) {
       *log_ << t << " HLT path\t" << hltname << "\n";
     }
     hltPerPathInfo hlt;
     hlt.prescale = 1;
     hltmap_.insert(std::make_pair(hltname, hlt));
     std::vector<std::string>::iterator hltpathBeg = numpathmodules.begin();
     std::vector<std::string>::iterator hltpathEnd = numpathmodules.end();
     unsigned int mycounter = 0;
     for (std::vector<std::string>::iterator numpathmodule = hltpathBeg; numpathmodule != hltpathEnd; ++numpathmodule) {
       if (hltConfig_.moduleType(*numpathmodule) != "HLTLevel1GTSeed") {
         continue;
       }
       ++mycounter;
 
       edm::ParameterSet l1GTPSet = hltConfig_.modulePSet(*numpathmodule);
       std::string l1pathname = l1GTPSet.getParameter<std::string>("L1SeedsLogicalExpression");
       //*log_<<"numpathmodule "<< *numpathmodule <<" : l1pathname "<<l1pathname<<"\n";
       if (mycounter > 1) {
         if (showTrgInfo_) {
           *log_ << "\tskip and erase previous seeds : multiple L1SeedsLogicalExpressions per hlt path\n";
         }
         //erase all previously calculated seeds for this path
         trgpathMmap_.erase(hltname);
         continue;
       }
       if (l1pathname.find('(') != std::string::npos) {
         if (showTrgInfo_) {
           *log_ << "  L1SeedsLogicalExpression(Complex)\t" << l1pathname << "\n";
           *log_ << "\tskip:contain complex logic\n";
         }
         continue;
       } else if (l1pathname.find("OR") != std::string::npos) {
         if (showTrgInfo_) {
           *log_ << "  L1SeedsLogicalExpression(ORed)\t" << l1pathname << "\n";
         }
         std::vector<std::string> seeds = splitpathstr(l1pathname, " OR ");
         if (seeds.size() > 2) {
           if (showTrgInfo_) {
             *log_ << "\tskip:contain >1 OR\n";
           }
           continue;
         } else {
           for (std::vector<std::string>::iterator i = seeds.begin(); i != seeds.end(); ++i) {
             if (!i->empty() && showTrgInfo_)
               *log_ << "\t\tseed: " << *i << "\n";
             if (i == seeds.begin()) {  //for now we take the first one from OR
               trgpathMmap_.insert(std::make_pair(hltname, *i));
             }
           }
         }
       } else if (l1pathname.find("AND") != std::string::npos) {
         if (showTrgInfo_) {
           *log_ << "  L1SeedsLogicalExpression(ANDed)\t" << l1pathname << "\n";
         }
         std::vector<std::string> seeds = splitpathstr(l1pathname, " AND ");
         if (seeds.size() > 2) {
           if (showTrgInfo_) {
             *log_ << "\tskip:contain >1 AND\n";
           }
           continue;
         } else {
           for (std::vector<std::string>::iterator i = seeds.begin(); i != seeds.end(); ++i) {
             if (!i->empty() && showTrgInfo_)
               *log_ << "\t\tseed: " << *i << "\n";
             if (i == seeds.begin()) {  //for now we take the first one
               trgpathMmap_.insert(std::make_pair(hltname, *i));
             }
           }
         }
       } else {
         if (showTrgInfo_) {
           *log_ << "  L1SeedsLogicalExpression(ONE)\t" << l1pathname << "\n";
         }
         if (splitpathstr(l1pathname, " NOT ").size() > 1) {
           if (showTrgInfo_) {
             *log_ << "\tskip:contain NOT\n";
           }
           continue;
         }
         trgpathMmap_.insert(std::make_pair(hltname, l1pathname));
       }
     }
   }
   if (showTrgInfo_) {
     *log_ << "================\n";
   }
 }

void LumiCalculator::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 348 of file LumiCalculator.cc.

348 {}

void LumiCalculator::endLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	c
	)

overrideprivatevirtual

Integrated Luminosity per Lumi Section instantaneousLumi*93.244(sec)

for(hltit=hltitBeg;hltit!=hltitEnd;++hltit){ }

Reimplemented from edm::EDAnalyzer.

Definition at line 200 of file LumiCalculator.cc.

References c, currentlumi_, MyPerLumiInfo::deadcount, edm::LuminosityBlock::getByLabel(), edm::Run::getByLabel(), edm::LuminosityBlock::getRun(), hltmap_, mps_fire::i, edm::LuminosityBlockBase::id(), MyPerLumiInfo::intglumi, cmsLHEtoEOSManager::l, l1map_, MyPerLumiInfo::livefraction, log_, MyPerLumiInfo::lsnum, edm::LuminosityBlockID::luminosityBlock(), dqmiodumpmetadata::n, perrunlumiinfo_, l1PerBitInfo::prescale, LumiSummary::L1::prescale, showTrgInfo_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, and trgpathMmap_.

                                                                                                    {
   //std::cout<<"I'm in lumi block "<<lumiBlock.id()<<std::endl;
 
   edm::Handle<LumiSummary> lumiSummary;
   lumiBlock.getByLabel("lumiProducer", lumiSummary);
 
   edm::Handle<LumiSummaryRunHeader> lumiSummaryRH;
   lumiBlock.getRun().getByLabel("lumiProducer", lumiSummaryRH);
 
   MyPerLumiInfo l;
   l.lsnum = lumiBlock.id().luminosityBlock();
 
   //
   //collect lumi.
   //
   l.deadcount = lumiSummary->deadcount();
   l.intglumi = lumiSummary->avgInsDelLumi() * 93.244;
   l.livefraction = lumiSummary->liveFrac();
 
   *log_ << "====== Lumi Section " << lumiBlock.id().luminosityBlock() << " ======\n";
   *log_ << "\t Luminosity " << l.intglumi << "\n";
   *log_ << "\t Dead count " << l.deadcount << "\n";
   *log_ << "\t Deadtime corrected Luminosity " << l.intglumi * l.livefraction << "\n";
 
   //
   //print correlated hlt-l1 info, only if you ask
   //
   if (showTrgInfo_) {
     std::map<std::string, hltPerPathInfo>::iterator hltit;
     std::map<std::string, hltPerPathInfo>::iterator hltitBeg = hltmap_.begin();
     std::map<std::string, hltPerPathInfo>::iterator hltitEnd = hltmap_.end();
 
     typedef std::pair<std::multimap<std::string, std::string>::iterator,
                       std::multimap<std::string, std::string>::iterator>
         TRGMAPIT;
     unsigned int c = 0;
     for (hltit = hltitBeg; hltit != hltitEnd; ++hltit) {
       std::string hltname = hltit->first;
       *log_ << c << " HLT path  " << hltname << " , prescale : " << hltit->second.prescale << "\n";
       TRGMAPIT ppp;
       ppp = trgpathMmap_.equal_range(hltname);
       if (ppp.first == ppp.second) {
         *log_ << "    no L1\n";
       }
       for (std::multimap<std::string, std::string>::iterator mit = ppp.first; mit != ppp.second; ++mit) {
         std::string l1name = mit->second;
         *log_ << "    L1 name : " << l1name;
         LumiSummary::L1 l1result = lumiSummary->l1info(lumiSummaryRH->getL1Index(l1name));
         *log_ << " prescale : " << l1result.prescale << "\n";
         *log_ << "\n";
       }
       ++c;
     }
   }
   //
   //accumulate hlt counts. Absent for now
   //
   //
   //accumulate l1 counts
   //
   size_t n = lumiSummary->nTriggerLine();
   for (size_t i = 0; i < n; ++i) {
     std::string l1bitname = lumiSummaryRH->getL1Name(lumiSummary->l1info(i).triggernameidx);
     l1PerBitInfo t;
     if (currentlumi_ == 0) {
       t.prescale = lumiSummary->l1info(i).prescale;
       l1map_.insert(std::make_pair(l1bitname, t));
     }
   }
 
   perrunlumiinfo_.push_back(l);
 
   ++currentlumi_;
 }

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

overrideprivatevirtual

Notes on calculation:

CMS recorded Luminosity per run : sum over HLX&&HF certified LS lumiSummary->avgInsDelLumi()*93.244*livefraction()
1. Effective Luminosity per run per trigger line: For the moment, we take only the first L1 seed in case of 'OR' or 'AND' relationship between HLT and L1 seeds
avgInsDelLumi()*93.244*livefraction()/(HLTprescale*L1prescale) for now HLTprescale=1
1. LHC delivered: there is no point in calculating delivered when data do not contain all LS

Reimplemented from edm::EDAnalyzer.

Definition at line 284 of file LumiCalculator.cc.

References gather_cfg::cout, hltmap_, l1map_, log_, perrunlumiinfo_, edm::RunBase::run(), and trgpathMmap_.

                                                                      {
   //std::cout<<"valid trigger lines "<<trgpathMmap_.size()<<std::endl;
   //std::cout<<"total lumi lines "<<perrunlumiinfo_.size()<<std::endl;
   std::vector<MyPerLumiInfo>::const_iterator lumiIt;
   std::vector<MyPerLumiInfo>::const_iterator lumiItBeg = perrunlumiinfo_.begin();
   std::vector<MyPerLumiInfo>::const_iterator lumiItEnd = perrunlumiinfo_.end();
   float recorded = 0.0;
 
   *log_ << "================ Run Summary " << run.run() << "================\n";
   for (lumiIt = lumiItBeg; lumiIt != lumiItEnd; ++lumiIt) {  //loop over LS
     recorded += lumiIt->intglumi * lumiIt->livefraction;
   }
   *log_ << "  CMS Recorded Lumi (e+27cm^-2) : " << recorded << "\n";
   *log_ << "  Effective Lumi (e+27cm^-2) per trigger path: "
         << "\n\n";
   std::multimap<std::string, std::string>::iterator it;
   std::multimap<std::string, std::string>::iterator itBeg = trgpathMmap_.begin();
   std::multimap<std::string, std::string>::iterator itEnd = trgpathMmap_.end();
   unsigned int cc = 0;
   for (it = itBeg; it != itEnd; ++it) {
     *log_ << "  " << cc << "  " << it->first << " - " << it->second << " : ";
     ++cc;
     std::map<std::string, hltPerPathInfo>::const_iterator hltIt = hltmap_.find(it->first);
     if (hltIt == hltmap_.end()) {
       std::cout << "HLT path " << it->first << " not found" << std::endl;
       *log_ << "\n";
       continue;
     }
     std::map<std::string, l1PerBitInfo>::const_iterator l1It = l1map_.find(it->second);
     if (l1It == l1map_.end()) {
       std::cout << "L1 bit " << it->second << " not found" << std::endl;
       *log_ << "\n";
       continue;
     }
     unsigned int hltprescale = hltIt->second.prescale;
     unsigned int l1prescale = l1It->second.prescale;
     if (hltprescale != 0 && l1prescale != 0) {
       float effectiveLumi = recorded / (hltprescale * l1prescale);
       *log_ << effectiveLumi << "\n";
     } else {
       *log_ << "0 prescale exception\n";
       continue;
     }
     *log_ << "\n";
   }
 }

std::vector< std::string > LumiCalculator::splitpathstr	(	const std::string &	strValue,
		const std::string	separator
	)

private

Definition at line 350 of file LumiCalculator.cc.

References dataset::end, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by beginRun().

                                                                                                       {
   std::vector<std::string> vecstrResult;
   boost::regex re(separator);
   boost::sregex_token_iterator p(strValue.begin(), strValue.end(), re, -1);
   boost::sregex_token_iterator end;
   while (p != end) {
     vecstrResult.push_back(*p++);
   }
   return vecstrResult;
 }