#include <HLTBitAnalyzer.h>

Inheritance diagram for HLTBitAnalyzer:

Public Member Functions
virtual void	analyze (edm::Event const &e, edm::EventSetup const &iSetup)

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

virtual void	endJob ()

	HLTBitAnalyzer (edm::ParameterSet const &conf)

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

	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 &	itemsToGetFromEvent () 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

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

virtual	~EDConsumerBase () noexcept(false)

Public Attributes
TTree *	HltTree

Static Private Member Functions
static int	errMax ()

Private Attributes
double	_EtaMax

double	_EtaMin

std::string	_HistName

bool	_isData

bool	_UseTFileService

int	errCnt

EventHeader	evt_header_
	Default analyses. More...

edm::InputTag	genEventInfo_

edm::EDGetTokenT< GenEventInfoProduct >	genEventInfoToken_

HLTInfo	hlt_analysis_

edm::InputTag	hltresults_

edm::EDGetTokenT< edm::TriggerResults >	hltresultsToken_

edm::InputTag	l1results_

edm::EDGetTokenT< GlobalAlgBlkBxCollection >	l1resultsToken_

TFile *	m_file

HLTMCtruth	mct_analysis_

edm::InputTag	mctruth_

edm::EDGetTokenT< reco::CandidateView >	mctruthToken_

edm::InputTag	pileupInfo_

edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	pileupInfoToken_

double	ptHat

edm::InputTag	simhits_

edm::EDGetTokenT< std::vector< SimTrack > >	simtracksToken_

edm::EDGetTokenT< std::vector< SimVertex > >	simverticesToken_

edm::InputTag	VertexTagOffline0_

edm::EDGetTokenT< reco::VertexCollection >	VertexTagOffline0Token_

RECOVertex	vrt_analysisOffline0_

double	weight

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

$Date: November 2006 $Revision:

Author: P. Bargassa - Rice U.

$Date: April 2016 $Revision:

Author: G. Karapostoli - ULB

Definition at line 46 of file HLTBitAnalyzer.h.

Constructor & Destructor Documentation

HLTBitAnalyzer::HLTBitAnalyzer ( edm::ParameterSet const & conf )

explicit

Definition at line 30 of file HLTBitAnalyzer.cc.

References _HistName, _isData, _UseTFileService, edm::EDConsumerBase::consumesCollector(), gather_cfg::cout, errCnt, evt_header_, genEventInfo_, genEventInfoToken_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hlt_analysis_, hltresults_, hltresultsToken_, HltTree, l1results_, l1resultsToken_, m_file, TFileService::make(), mct_analysis_, mctruth_, mctruthToken_, pileupInfo_, pileupInfoToken_, EventHeader::setup(), RECOVertex::setup(), HLTMCtruth::setup(), HLTInfo::setup(), simhits_, simtracksToken_, simverticesToken_, AlCaHLTBitMon_QueryRunRegistry::string, VertexTagOffline0_, VertexTagOffline0Token_, and vrt_analysisOffline0_.

                                                            :
   hlt_analysis_(conf, consumesCollector(), *this) {
 
   // If your module takes parameters, here is where you would define
   // their names and types, and access them to initialize internal
   // variables. Example as follows:
   std::cout << " Beginning HLTBitAnalyzer Analysis " << std::endl;
 
   /*
   l1extramu_        = conf.getParameter<std::string>   ("l1extramu");
   m_l1extramu       = edm::InputTag(l1extramu_, "");
 
   // read the L1Extra collection name, and add the instance names as needed
   l1extramc_        = conf.getParameter<std::string>   ("l1extramc");
   m_l1extraemi      = edm::InputTag(l1extramc_, "Isolated");
   m_l1extraemn      = edm::InputTag(l1extramc_, "NonIsolated");
   m_l1extrajetc     = edm::InputTag(l1extramc_, "Central");
   m_l1extrajetf     = edm::InputTag(l1extramc_, "Forward");
   m_l1extrajet      = edm::InputTag("gctInternJetProducer","Internal","ANALYSIS");
   m_l1extrataujet   = edm::InputTag(l1extramc_, "Tau");
   m_l1extramet      = edm::InputTag(l1extramc_, "MET");
   m_l1extramht      = edm::InputTag(l1extramc_, "MHT");
   */
 
   mctruth_            = conf.getParameter<edm::InputTag> ("mctruth");
   genEventInfo_       = conf.getParameter<edm::InputTag> ("genEventInfo");
   VertexTagOffline0_  = conf.getParameter<edm::InputTag> ("OfflinePrimaryVertices0");
   simhits_            = conf.getParameter<edm::InputTag> ("simhits");
 
   hltresults_       = conf.getParameter<edm::InputTag> ("hltresults");
   l1results_        = conf.getParameter<edm::InputTag> ("l1results");  
   //  gtReadoutRecord_  = conf.getParameter<edm::InputTag> ("l1GtReadoutRecord");
   /*
   gtObjectMap_      = conf.getParameter<edm::InputTag> ("l1GtObjectMapRecord");
 
   gctBitCounts_        = edm::InputTag( conf.getParameter<edm::InputTag>("l1GctHFBitCounts").label(), "" );
   gctRingSums_         = edm::InputTag( conf.getParameter<edm::InputTag>("l1GctHFRingSums").label(), "" );
   */
   pileupInfo_         = edm::InputTag("addPileupInfo");
 
   hltresultsToken_ = consumes<edm::TriggerResults>(hltresults_);
   genEventInfoToken_ = consumes<GenEventInfoProduct>(genEventInfo_);
   /*
   l1extramuToken_ = consumes<l1extra::L1MuonParticleCollection>(m_l1extramu);
   l1extraemiToken_ = consumes<l1extra::L1EmParticleCollection>(m_l1extraemi);
   l1extraemnToken_ = consumes<l1extra::L1EmParticleCollection>(m_l1extraemn);
   
   l1extrajetcToken_ = consumes<l1extra::L1JetParticleCollection>(m_l1extrajetc);
   l1extrajetfToken_ = consumes<l1extra::L1JetParticleCollection>(m_l1extrajetf);
   l1extrajetToken_ = consumes<l1extra::L1JetParticleCollection>(m_l1extrajet);
   l1extrataujetToken_ = consumes<l1extra::L1JetParticleCollection>(m_l1extrataujet);
   l1extrametToken_ = consumes<l1extra::L1EtMissParticleCollection>(m_l1extramet);
   l1extramhtToken_ = consumes<l1extra::L1EtMissParticleCollection>(m_l1extramht);
   */
   
   l1resultsToken_ = consumes<GlobalAlgBlkBxCollection>(l1results_);
   //  gtReadoutRecordToken_ = consumes<L1GlobalTriggerReadoutRecord>(gtReadoutRecord_);
   /*
   gtObjectMapToken_ = consumes<L1GlobalTriggerObjectMapRecord>(gtObjectMap_);
   gctBitCountsToken_ = consumes<L1GctHFBitCountsCollection>(gctBitCounts_);
   gctRingSumsToken_ = consumes<L1GctHFRingEtSumsCollection>(gctRingSums_);
   */
 
   mctruthToken_ = consumes<reco::CandidateView>(mctruth_);
   VertexTagOffline0Token_ = consumes<reco::VertexCollection>(VertexTagOffline0_);
   simtracksToken_ = consumes<std::vector<SimTrack> >(simhits_);
   simverticesToken_ = consumes<std::vector<SimVertex> >(simhits_);
   pileupInfoToken_ = consumes<std::vector<PileupSummaryInfo> >(pileupInfo_);
   
   _UseTFileService = conf.getUntrackedParameter<bool>("UseTFileService",false);
     
   m_file = nullptr;   // set to null
   errCnt = 0;
 
   // read run parameters with a default value
   edm::ParameterSet runParameters = conf.getParameter<edm::ParameterSet>("RunParameters");
   _HistName = runParameters.getUntrackedParameter<std::string>("HistogramFile", "test.root");
   _isData = runParameters.getUntrackedParameter<bool>("isData",true);
 
   // open the tree file and initialize the tree
   if(_UseTFileService){
     edm::Service<TFileService> fs;
     HltTree = fs->make<TTree>("HltTree", "");
   }else{
     m_file = new TFile(_HistName.c_str(), "RECREATE");
     if (m_file)
       m_file->cd();
     HltTree = new TTree("HltTree", "");
   }
 
   // Setup the different analysis
   hlt_analysis_.setup(conf, HltTree);
   if (!_isData) { mct_analysis_.setup(conf, HltTree); }
   vrt_analysisOffline0_.setup(conf, HltTree, "Offline0");
   evt_header_.setup(consumesCollector(), HltTree);
 }

Member Function Documentation

void HLTBitAnalyzer::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	iSetup
	)

virtual

Implements edm::EDAnalyzer.

Definition at line 128 of file HLTBitAnalyzer.cc.

References _isData, EventHeader::analyze(), RECOVertex::analyze(), HLTMCtruth::analyze(), HLTInfo::analyze(), mps_splice::entry, errCnt, errMax(), evt_header_, genEventInfo_, genEventInfoToken_, getCollection(), hlt_analysis_, hltresults_, hltresultsToken_, HltTree, edm::HandleBase::isValid(), kGenEventInfo, kHltresults, kL1GtRR, kMctruth, kPileupInfo, kRecoVerticesOffline0, kSimhit, l1results_, l1resultsToken_, m_file, mct_analysis_, mctruth_, mctruthToken_, MillePedeFileConverter_cfg::out, pileupInfo_, pileupInfoToken_, ptHat, GenEventInfoProduct::qScale(), simhits_, tkConvValidator_cfi::simTracks, simtracksToken_, simverticesToken_, VertexTagOffline0_, VertexTagOffline0Token_, vrt_analysisOffline0_, and GenEventInfoProduct::weight().

                                                                                 {
 
   edm::Handle<edm::TriggerResults>                  hltresults;
   edm::Handle<GlobalAlgBlkBxCollection>             l1results;
   /*
   edm::Handle<l1extra::L1EmParticleCollection>      l1extemi, l1extemn;
   edm::Handle<l1extra::L1MuonParticleCollection>    l1extmu;
   edm::Handle<l1extra::L1JetParticleCollection>     l1extjetc, l1extjetf, l1extjet, l1exttaujet;
   edm::Handle<l1extra::L1EtMissParticleCollection>  l1extmet,l1extmht;
   edm::Handle<L1GlobalTriggerReadoutRecord>         l1GtRR;
   edm::Handle<L1GlobalTriggerObjectMapRecord>       l1GtOMRec;
   edm::Handle<L1GlobalTriggerObjectMap>             l1GtOM;
   edm::Handle< L1GctHFBitCountsCollection >         gctBitCounts ;
   edm::Handle< L1GctHFRingEtSumsCollection >        gctRingSums ;
   */
   edm::Handle<reco::CandidateView>                  mctruth;
   edm::Handle<GenEventInfoProduct>                  genEventInfo;
   edm::Handle<std::vector<SimTrack> >               simTracks;
   edm::Handle<std::vector<SimVertex> >              simVertices;
   edm::Handle<reco::VertexCollection>               recoVertexsOffline0; 
   edm::Handle<std::vector< PileupSummaryInfo > >    pupInfo; 
 
   // extract the collections from the event, check their validity and log which are missing
   std::vector<MissingCollectionInfo> missing;
 
   getCollection( iEvent, missing, hltresults,      hltresults_,        hltresultsToken_,      kHltresults );
   /*
   getCollection( iEvent, missing, l1extemi,        m_l1extraemi,       l1extraemiToken_,      kL1extemi );
   getCollection( iEvent, missing, l1extemn,        m_l1extraemn,       l1extraemnToken_,      kL1extemn );
   getCollection( iEvent, missing, l1extmu,         m_l1extramu,        l1extramuToken_,       kL1extmu );
   getCollection( iEvent, missing, l1extjetc,       m_l1extrajetc,      l1extrajetcToken_,     kL1extjetc );
   getCollection( iEvent, missing, l1extjetf,       m_l1extrajetf,      l1extrajetfToken_,     kL1extjetf );
   getCollection( iEvent, missing, l1extjet,        m_l1extrajet,       l1extrajetToken_,      kL1extjet );
   getCollection( iEvent, missing, l1exttaujet,     m_l1extrataujet,    l1extrataujetToken_,   kL1exttaujet );
   getCollection( iEvent, missing, l1extmet,        m_l1extramet,       l1extrametToken_,      kL1extmet );
   getCollection( iEvent, missing, l1extmht,        m_l1extramht,       l1extramhtToken_,      kL1extmht );
   */
   getCollection( iEvent, missing, l1results, l1results_, l1resultsToken_, kL1GtRR) ;
   //  getCollection( iEvent, missing, l1GtRR,          gtReadoutRecord_,   gtReadoutRecordToken_, kL1GtRR );
   /*
   getCollection( iEvent, missing, l1GtOMRec,       gtObjectMap_,       gtObjectMapToken_,     kL1GtOMRec );
   getCollection( iEvent, missing, gctBitCounts,    gctBitCounts_,      gctBitCountsToken_,    kL1GctBitCounts );
   getCollection( iEvent, missing, gctRingSums,     gctRingSums_,       gctRingSumsToken_,     kL1GctRingSums );
   */
   getCollection( iEvent, missing, mctruth,         mctruth_,   mctruthToken_,     kMctruth );
   getCollection( iEvent, missing, simTracks,       simhits_,  simtracksToken_,         kSimhit );
   getCollection( iEvent, missing, simVertices,     simhits_,    simverticesToken_,       kSimhit );
   getCollection( iEvent, missing, genEventInfo,    genEventInfo_,    genEventInfoToken_,    kGenEventInfo );
   getCollection( iEvent, missing, pupInfo,         pileupInfo_,   pileupInfoToken_,      kPileupInfo );
 
   getCollection( iEvent, missing, recoVertexsOffline0,      VertexTagOffline0_,         VertexTagOffline0Token_,     kRecoVerticesOffline0 );
 
   if (!_isData) {
     ptHat=-1.;
     if (genEventInfo.isValid()) {ptHat=genEventInfo->qScale();}
     
     weight = genEventInfo->weight();
   }
   // print missing collections
   if (not missing.empty() and (errCnt < errMax())) {
     errCnt++;
     std::stringstream out;       
     out <<  "OpenHLT analyser - missing collections:";
     BOOST_FOREACH(const MissingCollectionInfo & entry, missing)
       out << "\n\t" << entry.first << ": " << entry.second->encode();
     edm::LogPrint("OpenHLT") << out.str() << std::endl; 
     if (errCnt == errMax())
       edm::LogWarning("OpenHLT") << "Maximum error count reached -- No more messages will be printed.";
   }
 
   // run the analysis, passing required event fragments
   hlt_analysis_.analyze(
     hltresults,
     /*
     l1extemi,
     l1extemn,
     l1extmu,
     l1extjetc,
     l1extjetf,
     l1extjet,
     l1exttaujet,
     l1extmet,
     l1extmht,
     */
     l1results,
     //    l1GtRR,
     /*
     gctBitCounts,
     gctRingSums,
     */
     iSetup,
     iEvent,
     HltTree);
 
   evt_header_.analyze(iEvent, HltTree);
 
   if (!_isData) {
     mct_analysis_.analyze(
               mctruth,
               ptHat,
               weight,
               simTracks,
               simVertices,
               pupInfo,
               HltTree);
   }
   vrt_analysisOffline0_.analyze(
                 recoVertexsOffline0,
                 HltTree);
 
   // std::cout << " Ending Event Analysis" << std::endl;
   // After analysis, fill the variables tree
   if (m_file)  { m_file->cd(); }
 
   HltTree->Fill();
 }

void HLTBitAnalyzer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	es
	)

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 247 of file HLTBitAnalyzer.cc.

References HLTInfo::beginRun(), and hlt_analysis_.

 {
    hlt_analysis_.beginRun(run, es);
 }

void HLTBitAnalyzer::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 253 of file HLTBitAnalyzer.cc.

References _UseTFileService, HltTree, and m_file.

                             {
     
     if(!_UseTFileService){
         if (m_file)
             m_file->cd();
         
         HltTree->Write();
         delete HltTree;
         HltTree = nullptr;
         
         if (m_file) {         // if there was a tree file...
             m_file->Write();    // write out the branches
             delete m_file;      // close and delete the file
             m_file = nullptr;         // set to zero to clean up
         }
     }
 }