Inheritance diagram for LumiCalculator:

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

virtual	~LumiCalculator ()

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

virtual	~EDAnalyzer ()

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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &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 (edm::Event const &e, edm::EventSetup const &c) override

virtual void	beginJob () override

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

virtual void	endJob () override

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

virtual 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 &)

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

Constructor & Destructor Documentation

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

explicit

Definition at line 62 of file LumiCalculator.cc.

References edm::ParameterSet::getUntrackedParameter(), HLT_25ns10e33_v2_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 ( )

virtual

Definition at line 70 of file LumiCalculator.cc.

References log_.

                                {
   delete log_; log_=0; 
 }

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.

                                                                   {
   
 }

void LumiCalculator::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 82 of file LumiCalculator.cc.

                              {
   
 }

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

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 88 of file LumiCalculator.cc.

References Exception, edm::ParameterSet::getParameter(), runregparse::hlt, hltConfig_, hltmap_, lumiCalc2::hltname, i, HLTConfigProvider::init(), l1map_, log_, HLTConfigProvider::moduleLabels(), HLTConfigProvider::modulePSet(), HLTConfigProvider::moduleType(), perrunlumiinfo_, hltPerPathInfo::prescale, edm::RunBase::run(), showTrgInfo_, HLTConfigProvider::size(), findQualityFiles::size, splitpathstr(), AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::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->size()!=0 && 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->size()!=0 && 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 351 of file LumiCalculator.cc.

351 {

352 }

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

References EnergyCorrector::c, currentlumi_, MyPerLumiInfo::deadcount, edm::LuminosityBlock::getByLabel(), edm::Run::getByLabel(), edm::LuminosityBlock::getRun(), hltmap_, lumiCalc2::hltname, i, edm::LuminosityBlockBase::id(), MyPerLumiInfo::intglumi, cmsLHEtoEOSManager::l, l1map_, MyPerLumiInfo::livefraction, log_, MyPerLumiInfo::lsnum, edm::LuminosityBlockID::luminosityBlock(), runregparse::lumiSummary, gen::n, perrunlumiinfo_, l1PerBitInfo::prescale, LumiSummary::L1::prescale, showTrgInfo_, AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::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 287 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 355 of file LumiCalculator.cc.

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