#include <HLTriggerOfflineHeavyFlavor/src/HeavyFlavorValidation.cc>

Inheritance diagram for HeavyFlavorValidation:

Public Member Functions
	HeavyFlavorValidation (const edm::ParameterSet &)

	~HeavyFlavorValidation () override

Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () 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

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

Protected Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

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

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)

Private Member Functions
int	getFilterLevel (const std::string &moduleName, const HLTConfigProvider &hltConfig)

int	getMotherId (const Candidate *p)

void	match (MonitorElement *me, vector< LeafCandidate > &from, vector< LeafCandidate > &to, double deltaRMatchingCut, vector< int > &map)

void	myBook1D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString label, TString title)

void	myBook1D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString label)

void	myBook2D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString xLabel, vector< double > &yBins, TString yLabel, TString title)

void	myBook2D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString xLabel, vector< double > &yBins, TString yLabel)

void	myBookProfile2D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString xLabel, vector< double > &yBins, TString yLabel, TString title)

void	myBookProfile2D (DQMStore::IBooker &ibooker, TString name, vector< double > &xBins, TString xLabel, vector< double > &yBins, TString yLabel)

Private Attributes
vector< double >	deltaEtaBins

vector< double >	deltaPhiBins

vector< double >	dimuonDRBins

vector< double >	dimuonEtaBins

vector< double >	dimuonPtBins

string	dqmFolder

DQMStore *	dqmStore

vector< pair< string, int > >	filterNamesLevels

double	genGlobDeltaRMatchingCut

InputTag	genParticlesTag

EDGetTokenT< GenParticleCollection >	genParticlesToken

double	globL1DeltaRMatchingCut

double	globL2DeltaRMatchingCut

double	globL3DeltaRMatchingCut

map< TString, MonitorElement * >	ME

vector< int >	motherIDs

vector< double >	muonEtaBins

const double	muonMass

vector< double >	muonPhiBins

vector< double >	muonPtBins

InputTag	recoMuonsTag

EDGetTokenT< MuonCollection >	recoMuonsToken

string	triggerPathName

string	triggerProcessName

InputTag	triggerResultsTag

EDGetTokenT< TriggerResults >	triggerResultsToken

EDGetTokenT< TriggerEvent >	triggerSummaryAODTag

EDGetTokenT< TriggerEventWithRefs >	triggerSummaryRAWTag

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Description: Analyzer to fill Monitoring Elements for muon, dimuon and trigger path efficiency studies (HLT/RECO, RECO/GEN)

Implementation: matching is based on closest in delta R, no duplicates allowed. Generated to Global based on momentum at IP; L1, L2, L2v to Global based on position in muon system, L3 to Global based on momentum at IP.

Definition at line 54 of file HeavyFlavorValidation.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 121 of file HeavyFlavorValidation.cc.

References genParticlesTag, genParticlesToken, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), recoMuonsTag, recoMuonsToken, triggerProcessName, triggerResultsTag, triggerResultsToken, triggerSummaryAODTag, and triggerSummaryRAWTag.

                                                                     :
 //get parameters
   dqmFolder(pset.getUntrackedParameter<string>("DQMFolder")),
   triggerProcessName(pset.getUntrackedParameter<string>("TriggerProcessName")),
   triggerPathName(pset.getUntrackedParameter<string>("TriggerPathName")),
   motherIDs(pset.getUntrackedParameter<vector<int> >("MotherIDs")),
   genGlobDeltaRMatchingCut(pset.getUntrackedParameter<double>("GenGlobDeltaRMatchingCut")),
   globL1DeltaRMatchingCut(pset.getUntrackedParameter<double>("GlobL1DeltaRMatchingCut")),
   globL2DeltaRMatchingCut(pset.getUntrackedParameter<double>("GlobL2DeltaRMatchingCut")),
   globL3DeltaRMatchingCut(pset.getUntrackedParameter<double>("GlobL3DeltaRMatchingCut")),
   deltaEtaBins(pset.getUntrackedParameter<vector<double> >("DeltaEtaBins")),
   deltaPhiBins(pset.getUntrackedParameter<vector<double> >("DeltaPhiBins")),
   muonPtBins(pset.getUntrackedParameter<vector<double> >("MuonPtBins")),
   muonEtaBins(pset.getUntrackedParameter<vector<double> >("MuonEtaBins")),
   muonPhiBins(pset.getUntrackedParameter<vector<double> >("MuonPhiBins")),
   dimuonPtBins(pset.getUntrackedParameter<vector<double> >("DimuonPtBins")),
   dimuonEtaBins(pset.getUntrackedParameter<vector<double> >("DimuonEtaBins")),
   dimuonDRBins(pset.getUntrackedParameter<vector<double> >("DimuonDRBins")),
   muonMass(0.106)
 {
   triggerSummaryRAWTag = consumes<TriggerEventWithRefs>(InputTag( pset.getUntrackedParameter<string>("TriggerSummaryRAW"), "", triggerProcessName));
   triggerSummaryAODTag = consumes<TriggerEvent>(InputTag( pset.getUntrackedParameter<string>("TriggerSummaryAOD"), "", triggerProcessName));
   triggerResultsTag = InputTag( pset.getUntrackedParameter<string>("TriggerResults"), "", triggerProcessName);
   triggerResultsToken = consumes<TriggerResults>(triggerResultsTag);
   recoMuonsTag = pset.getParameter<InputTag>("RecoMuons");
   recoMuonsToken = consumes<MuonCollection>(recoMuonsTag);
   genParticlesTag = pset.getParameter<InputTag>("GenParticles");
   genParticlesToken = consumes<GenParticleCollection>(genParticlesTag);
 }

HeavyFlavorValidation::~HeavyFlavorValidation ( )

override

Definition at line 714 of file HeavyFlavorValidation.cc.

References DEFINE_FWK_MODULE.

714 {

715 }

Member Function Documentation

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

overrideprotected

Definition at line 288 of file HeavyFlavorValidation.cc.

References funct::abs(), edm::HLTGlobalStatus::accept(), ALCARECOTkAlJpsiMuMu_cff::charge, PVValHelper::eta, f, trigger::TriggerEventWithRefs::filterIndex(), trigger::TriggerEvent::filterKeys(), filterNamesLevels, trigger::TriggerEvent::filterTag(), spr::find(), plotBeamSpotDB::first, genGlobDeltaRMatchingCut, runTauDisplay::genMuons, GenHFHadronMatcher_cfi::genParticles, genParticlesTag, genParticlesToken, edm::Event::getByToken(), getMotherId(), trigger::TriggerEvent::getObjects(), trigger::TriggerEventWithRefs::getObjects(), globL1DeltaRMatchingCut, globL2DeltaRMatchingCut, globL3DeltaRMatchingCut, mps_fire::i, diffTreeTool::index, edm::HandleBase::isValid(), relativeConstraints::keys, LogDebug, match(), motherIDs, muonMass, AlCaHLTBitMon_ParallelJobs::p, phi, EnergyCorrector::pt, recoMuonsTag, recoMuonsToken, edm::second(), edm::TriggerNames::size(), findQualityFiles::size, trigger::TriggerEvent::sizeFilters(), HiIsolationCommonParameters_cff::track, trigger::TriggerL1Mu, trigger::TriggerMuon, edm::TriggerNames::triggerName(), edm::Event::triggerNames(), triggerPathName, triggerProcessName, triggerResults, triggerResultsTag, triggerResultsToken, triggerSummaryAODTag, triggerSummaryRAWTag, x, y, and z.

                                                                                 {
   if(filterNamesLevels.empty()){
     return;
   }
 //access the containers and create LeafCandidate copies
   vector<LeafCandidate> genMuons;
   Handle<GenParticleCollection> genParticles;
   iEvent.getByToken(genParticlesToken, genParticles);
   if(genParticles.isValid()){
     for(GenParticleCollection::const_iterator p=genParticles->begin(); p!= genParticles->end(); ++p){
       if( p->status() == 1 && std::abs(p->pdgId())==13 &&
           ( find( motherIDs.begin(), motherIDs.end(), -1 )!=motherIDs.end() || find( motherIDs.begin(), motherIDs.end(), getMotherId(&(*p)) )!=motherIDs.end() ) ){
         genMuons.push_back( *p );
       }
     }
   }else{
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Could not access GenParticleCollection"<<endl;
   }
   sort(genMuons.begin(), genMuons.end(), GreaterByPt<LeafCandidate>());
   ME["genMuon_size"]->Fill(genMuons.size());
   LogDebug("HLTriggerOfflineHeavyFlavor")<<"GenParticleCollection from "<<genParticlesTag<<" has size: "<<genMuons.size()<<endl;
 
   vector<LeafCandidate> globMuons;
   vector<LeafCandidate> globMuons_position;
   Handle<MuonCollection> recoMuonsHandle;
   iEvent.getByToken(recoMuonsToken, recoMuonsHandle);
   if(recoMuonsHandle.isValid()){
     for(MuonCollection::const_iterator p=recoMuonsHandle->begin(); p!= recoMuonsHandle->end(); ++p){
       if(p->isGlobalMuon()){
         globMuons.push_back(*p);
         globMuons_position.push_back( LeafCandidate( p->charge(), math::XYZTLorentzVector(p->outerTrack()->innerPosition().x(), p->outerTrack()->innerPosition().y(), p->outerTrack()->innerPosition().z(), 0.) ) );
       }
     }
   }else{
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Could not access reco Muons"<<endl;
   }
   ME["globMuon_size"]->Fill(globMuons.size());
   LogDebug("HLTriggerOfflineHeavyFlavor")<<"Global Muons from "<<recoMuonsTag<<" has size: "<<globMuons.size()<<endl;
 
 // access RAW trigger event
   vector<vector<LeafCandidate> > muonsAtFilter;
   vector<vector<LeafCandidate> > muonPositionsAtFilter;
   for(size_t i=0; i<filterNamesLevels.size(); i++){
     muonsAtFilter.push_back(vector<LeafCandidate>());
     muonPositionsAtFilter.push_back(vector<LeafCandidate>());
   }
   Handle<TriggerEventWithRefs> rawTriggerEvent;
   iEvent.getByToken( triggerSummaryRAWTag, rawTriggerEvent );
   if( rawTriggerEvent.isValid() ){
     for(size_t i=0; i<filterNamesLevels.size(); i++){
       size_t index = rawTriggerEvent->filterIndex(InputTag( filterNamesLevels[i].first, "", triggerProcessName ));
       if ( index < rawTriggerEvent->size() ){
         if( filterNamesLevels[i].second==1 ){
           vector<L1MuonParticleRef> l1Cands;
           rawTriggerEvent->getObjects( index, TriggerL1Mu, l1Cands );
           for(size_t j=0; j<l1Cands.size(); j++){
             muonsAtFilter[i].push_back(*l1Cands[j]);
           }
         }else{
           vector<RecoChargedCandidateRef> hltCands;
           rawTriggerEvent->getObjects( index, TriggerMuon, hltCands );
           for(size_t j=0; j<hltCands.size(); j++){
             muonsAtFilter[i].push_back(*hltCands[j]);
             if( filterNamesLevels[i].second==2 ){
               muonPositionsAtFilter[i].push_back( LeafCandidate( hltCands[j]->charge(), math::XYZTLorentzVector(hltCands[j]->track()->innerPosition().x(), hltCands[j]->track()->innerPosition().y(), hltCands[j]->track()->innerPosition().z(), 0.) ) );
             }
           }
         }
       }
       ME[TString::Format("filt%dMuon_size",int(i+1))]->Fill(muonsAtFilter[i].size());
       LogDebug("HLTriggerOfflineHeavyFlavor")<<"Filter \""<<filterNamesLevels[i].first<<"\" has "<<muonsAtFilter[i].size()<<" muons"<<endl;
     }
   }else{
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Could not access RAWTriggerEvent"<<endl;
   }
 
 // access AOD trigger event
   vector<LeafCandidate> pathMuons;
   Handle<TriggerEvent> aodTriggerEvent;
   iEvent.getByToken(triggerSummaryAODTag,aodTriggerEvent);
   if(aodTriggerEvent.isValid()){
     TriggerObjectCollection allObjects = aodTriggerEvent->getObjects();
     for(int i=0; i<aodTriggerEvent->sizeFilters(); i++){
      if(aodTriggerEvent->filterTag(i)==InputTag((filterNamesLevels.end()-1)->first,"",triggerProcessName)){
         Keys keys = aodTriggerEvent->filterKeys(i);
         for(size_t j=0; j<keys.size(); j++){
           pathMuons.push_back( LeafCandidate( allObjects[keys[j]].id()>0 ? 1 : -1, math::PtEtaPhiMLorentzVector( allObjects[keys[j]].pt(), allObjects[keys[j]].eta(), allObjects[keys[j]].phi(), muonMass ) ) );
         }
       }
     }
     ME["pathMuon_size"]->Fill(pathMuons.size());
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Path \""<<triggerPathName<<"\" has "<<pathMuons.size()<<" muons at last filter \""<<(filterNamesLevels.end()-1)->first<<"\""<<endl;
   }else{
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Could not access AODTriggerEvent"<<endl;
   }
 
 // access Trigger Results
   bool triggerFired = false;
   Handle<TriggerResults> triggerResults;
   iEvent.getByToken(triggerResultsToken,triggerResults);
   if(triggerResults.isValid()){
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Successfully initialized "<<triggerResultsTag<<endl;
     const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
     bool hlt_exists = false;
     for ( unsigned int i=0; i!=triggerNames.size(); i++) {
       TString hlt_name = triggerNames.triggerName(i);
       if (hlt_name.Contains(triggerPathName)) {
         triggerFired = triggerResults->accept( i );
         hlt_exists = true;
         break;
       }
     }
     if (!hlt_exists) {
       LogDebug("HLTriggerOfflineHeavyFlavor")<<triggerResultsTag<<" has no trigger: "<<triggerPathName<<endl;
     }
   }else{
     LogDebug("HLTriggerOfflineHeavyFlavor")<<"Could not initialize "<<triggerResultsTag<<endl;
   }
 
 //create matching maps
   vector<int> glob_gen(genMuons.size(),-1);
   match( ME["globGen_deltaEtaDeltaPhi"], genMuons, globMuons, genGlobDeltaRMatchingCut, glob_gen );
   vector<vector<int> > filt_glob;
   for(size_t i=0; i<filterNamesLevels.size(); i++){
     filt_glob.push_back( vector<int>(globMuons.size(),-1) );
     if( filterNamesLevels[i].second == 1 ){
       match( ME[TString::Format("filt%dGlob_deltaEtaDeltaPhi",int(i+1))], globMuons_position, muonsAtFilter[i] ,globL1DeltaRMatchingCut, filt_glob[i] );
     }else if( filterNamesLevels[i].second == 2 ){
       match( ME[TString::Format("filt%dGlob_deltaEtaDeltaPhi",int(i+1))], globMuons_position, muonPositionsAtFilter[i] ,globL2DeltaRMatchingCut, filt_glob[i] );
     }else if( filterNamesLevels[i].second > 2){
       match( ME[TString::Format("filt%dGlob_deltaEtaDeltaPhi",int(i+1))], globMuons, muonsAtFilter[i] ,globL3DeltaRMatchingCut, filt_glob[i] );
     }
   }
   vector<int> path_glob(globMuons.size(),-1);
   if( (filterNamesLevels.end()-1)->second == 1 ){
     match( ME["pathGlob_deltaEtaDeltaPhi"], globMuons_position, pathMuons ,globL1DeltaRMatchingCut, path_glob );
   }else if( (filterNamesLevels.end()-1)->second == 2 ){
     match( ME["pathGlob_deltaEtaDeltaPhi"], globMuons, pathMuons ,globL2DeltaRMatchingCut, path_glob );
   }else if( (filterNamesLevels.end()-1)->second > 2){
     match( ME["pathGlob_deltaEtaDeltaPhi"], globMuons, pathMuons ,globL3DeltaRMatchingCut, path_glob );
   }
 
 //fill histos
   bool first = true;
   for(size_t i=0; i<genMuons.size(); i++){
     ME["genMuon_genEtaPt"]->Fill(genMuons[i].eta(), genMuons[i].pt());
     ME["genMuon_genEtaPhi"]->Fill(genMuons[i].eta(), genMuons[i].phi());
     if(glob_gen[i] != -1) {
       ME["resGlobGen_genEtaPt"]->Fill(genMuons[i].eta(), genMuons[i].pt(), (globMuons[glob_gen[i]].pt()-genMuons[i].pt())/genMuons[i].pt() );
       ME["globMuon_genEtaPt"]->Fill(genMuons[i].eta(), genMuons[i].pt());
       ME["globMuon_genEtaPhi"]->Fill(genMuons[i].eta(), genMuons[i].phi());
       ME["globMuon_recoEtaPt"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt());
       ME["globMuon_recoEtaPhi"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].phi());
       for(size_t f=0; f<filterNamesLevels.size(); f++) {
         if(filt_glob[f][glob_gen[i]] != -1) {
           ME[TString::Format("resFilt%dGlob_recoEtaPt",int(f+1))]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt(), (muonsAtFilter[f][filt_glob[f][glob_gen[i]]].pt()-globMuons[glob_gen[i]].pt())/globMuons[glob_gen[i]].pt() );
           ME[TString::Format("filt%dMuon_recoEtaPt",int(f+1))]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt());
           ME[TString::Format("filt%dMuon_recoEtaPhi",int(f+1))]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].phi());
         }else{
           break;
         }
       }
       if(path_glob[glob_gen[i]] != -1){
         ME["resPathGlob_recoEtaPt"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt(), (pathMuons[path_glob[glob_gen[i]]].pt()-globMuons[glob_gen[i]].pt())/globMuons[glob_gen[i]].pt() );
         ME["pathMuon_recoEtaPt"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt());
         ME["pathMuon_recoEtaPhi"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].phi());
       }
 //highest pt muon
       if( first ){
         first = false;
         if( triggerFired ){
           ME["resultMuon_recoEtaPt"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].pt());
           ME["resultMuon_recoEtaPhi"]->Fill(globMuons[glob_gen[i]].eta(), globMuons[glob_gen[i]].phi());
         }
       }
     }
   }
 
 //fill dimuon histograms (highest pT, opposite charge)
   int secondMuon = 0;
   for(size_t j=1; j<genMuons.size(); j++){
     if(genMuons[0].charge()*genMuons[j].charge()==-1){
       secondMuon = j;
       break;
     }
   }
   if(secondMuon > 0){
 //two generated
     double genDimuonPt = (genMuons[0].p4()+genMuons[secondMuon].p4()).pt();
     double genDimuonEta = (genMuons[0].p4()+genMuons[secondMuon].p4()).eta();
     double genDimuonRap = (genMuons[0].p4()+genMuons[secondMuon].p4()).Rapidity();
     double genDimuonDR = deltaR<LeafCandidate,LeafCandidate>( genMuons[0], genMuons[secondMuon] );
     bool highPt = genMuons[0].pt()>7. && genMuons[secondMuon].pt()>7;
     ME["genDimuon_genEtaPt"]->Fill( genDimuonEta, genDimuonPt );
     ME["genDimuon_genRapPt"]->Fill( genDimuonRap, genDimuonPt );
     if(highPt) ME["genDimuon_genPtDR"]->Fill( genDimuonPt, genDimuonDR );
 //two global
     if(glob_gen[0]!=-1 && glob_gen[secondMuon]!=-1){
       ME["globDimuon_genEtaPt"]->Fill( genDimuonEta, genDimuonPt );
       ME["globDimuon_genRapPt"]->Fill( genDimuonRap, genDimuonPt );
       if(highPt) ME["globDimuon_genPtDR"]->Fill( genDimuonPt, genDimuonDR );
       double globDimuonPt = (globMuons[glob_gen[0]].p4()+globMuons[glob_gen[secondMuon]].p4()).pt();
       double globDimuonEta = (globMuons[glob_gen[0]].p4()+globMuons[glob_gen[secondMuon]].p4()).eta();
       double globDimuonRap = (globMuons[glob_gen[0]].p4()+globMuons[glob_gen[secondMuon]].p4()).Rapidity();
       double globDimuonDR = deltaR<LeafCandidate,LeafCandidate>( globMuons[glob_gen[0]], globMuons[glob_gen[secondMuon]] );
       double globDimuonDRpos = deltaR<LeafCandidate,LeafCandidate>( globMuons_position[glob_gen[0]], globMuons_position[glob_gen[secondMuon]] );
       ME["globDimuon_recoEtaPt"]->Fill( globDimuonEta, globDimuonPt );
       ME["globDimuon_recoRapPt"]->Fill( globDimuonRap, globDimuonPt );
       if(highPt) ME["globDimuon_recoPtDR"]->Fill( globDimuonPt, globDimuonDR );
       if(highPt) ME["globDimuon_recoPtDRpos"]->Fill( globDimuonPt, globDimuonDRpos );
 //two filter objects
       for(size_t f=0; f<filterNamesLevels.size(); f++){
         if(filt_glob[f][glob_gen[0]] != -1 && filt_glob[f][glob_gen[secondMuon]] != -1){
           ME[TString::Format("diFilt%dDimuon_recoEtaPt",int(f+1))]->Fill( globDimuonEta, globDimuonPt );
           ME[TString::Format("diFilt%dDimuon_recoRapPt",int(f+1))]->Fill( globDimuonRap, globDimuonPt );
           if(highPt) ME[TString::Format("diFilt%dDimuon_recoPtDR",int(f+1))]->Fill( globDimuonPt, globDimuonDR );
           if(highPt) ME[TString::Format("diFilt%dDimuon_recoPtDRpos",int(f+1))]->Fill( globDimuonPt, globDimuonDRpos );
         }else{
           break;
         }
       }
 //one filter object
       for(size_t f=0; f<filterNamesLevels.size(); f++){
         if(filt_glob[f][glob_gen[0]] != -1 || filt_glob[f][glob_gen[secondMuon]] != -1){
           ME[TString::Format("filt%dDimuon_recoEtaPt",int(f+1))]->Fill( globDimuonEta, globDimuonPt );
           ME[TString::Format("filt%dDimuon_recoRapPt",int(f+1))]->Fill( globDimuonRap, globDimuonPt );
           if(highPt) ME[TString::Format("filt%dDimuon_recoPtDR",int(f+1))]->Fill( globDimuonPt, globDimuonDR );
           if(highPt) ME[TString::Format("filt%dDimuon_recoPtDRpos",int(f+1))]->Fill( globDimuonPt, globDimuonDRpos );
         }else{
           break;
         }
       }
 //two path objects
       if(path_glob[glob_gen[0]] != -1 && path_glob[glob_gen[secondMuon]] != -1){
         ME["diPathDimuon_recoEtaPt"]->Fill( globDimuonEta, globDimuonPt );
         ME["diPathDimuon_recoRapPt"]->Fill( globDimuonRap, globDimuonPt );
         if(highPt) ME["diPathDimuon_recoPtDR"]->Fill( globDimuonPt, globDimuonDR );
         if(highPt) ME["diPathDimuon_recoPtDRpos"]->Fill( globDimuonPt, globDimuonDRpos );
       }
 //one path object
       if(path_glob[glob_gen[0]] != -1 || path_glob[glob_gen[secondMuon]] != -1){
         ME["pathDimuon_recoEtaPt"]->Fill( globDimuonEta, globDimuonPt );
         ME["pathDimuon_recoRapPt"]->Fill( globDimuonRap, globDimuonPt );
         if(highPt) ME["pathDimuon_recoPtDR"]->Fill( globDimuonPt, globDimuonDR );
         if(highPt) ME["pathDimuon_recoPtDRpos"]->Fill( globDimuonPt, globDimuonDRpos );
       }
 //trigger result
       if( triggerFired ){
         ME["resultDimuon_recoEtaPt"]->Fill( globDimuonEta, globDimuonPt );
         ME["resultDimuon_recoRapPt"]->Fill( globDimuonRap, globDimuonPt );
         if(highPt) ME["resultDimuon_recoPtDR"]->Fill( globDimuonPt, globDimuonDR );
         if(highPt) ME["resultDimuon_recoPtDRpos"]->Fill( globDimuonPt, globDimuonDRpos );
       }
     }
   }
 }

void HeavyFlavorValidation::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 189 of file HeavyFlavorValidation.cc.

References DQMStore::IBooker::cd(), deltaEtaBins, deltaPhiBins, dimuonDRBins, dimuonEtaBins, dimuonPtBins, dqmFolder, filterNamesLevels, plotBeamSpotDB::first, mps_fire::i, muonEtaBins, muonPhiBins, muonPtBins, myBook1D(), myBook2D(), myBookProfile2D(), DQMStore::IBooker::setCurrentFolder(), triggerPathName, and triggerProcessName.

                                                               {
           ibooker.cd();
           ibooker.setCurrentFolder((dqmFolder+"/")+triggerProcessName+"/"+triggerPathName);
 
     // create Monitor Elements
     // Eta Pt Single
       myBook2D(ibooker, "genMuon_genEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)");
       myBook2D(ibooker, "globMuon_genEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)");
       myBook2D(ibooker, "globMuon_recoEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)");
 
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dMuon_recoEtaPt",int(i+1)), muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathMuon_recoEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)", triggerPathName);
       myBook2D(ibooker, "resultMuon_recoEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)");
     // Eta Pt Single Resolution
       myBookProfile2D(ibooker, "resGlobGen_genEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBookProfile2D(ibooker, TString::Format("resFilt%dGlob_recoEtaPt",int(i+1)), muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBookProfile2D(ibooker, "resPathGlob_recoEtaPt", muonEtaBins, "#mu eta", muonPtBins, " #mu pT (GeV)", triggerPathName);
     // Eta Pt Double
       myBook2D(ibooker, "genDimuon_genEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)");
       myBook2D(ibooker, "globDimuon_genEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)");
       myBook2D(ibooker, "globDimuon_recoEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dDimuon_recoEtaPt",int(i+1)), dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathDimuon_recoEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)", triggerPathName);
       myBook2D(ibooker, "resultDimuon_recoEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("diFilt%dDimuon_recoEtaPt",int(i+1)), dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "diPathDimuon_recoEtaPt", dimuonEtaBins, "#mu#mu eta", dimuonPtBins, " #mu#mu pT (GeV)", triggerPathName);
     // Eta Phi Single
       myBook2D(ibooker, "genMuon_genEtaPhi", muonEtaBins, "#mu eta", muonPhiBins, "#mu phi");
       myBook2D(ibooker, "globMuon_genEtaPhi", muonEtaBins, "#mu eta", muonPhiBins, "#mu phi");
       myBook2D(ibooker, "globMuon_recoEtaPhi", muonEtaBins, "#mu eta", muonPhiBins, "#mu phi");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dMuon_recoEtaPhi",int(i+1)), muonEtaBins, "#mu eta", muonPhiBins, "#mu phi", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathMuon_recoEtaPhi", muonEtaBins, "#mu eta", muonPhiBins, "#mu phi", triggerPathName);
       myBook2D(ibooker, "resultMuon_recoEtaPhi", muonEtaBins, "#mu eta", muonPhiBins, "#mu phi");
     // Rap Pt Double
       myBook2D(ibooker, "genDimuon_genRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)");
       myBook2D(ibooker, "globDimuon_genRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)");
       myBook2D(ibooker, "globDimuon_recoRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dDimuon_recoRapPt",int(i+1)), dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathDimuon_recoRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)", triggerPathName);
       myBook2D(ibooker, "resultDimuon_recoRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("diFilt%dDimuon_recoRapPt",int(i+1)), dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "diPathDimuon_recoRapPt", dimuonEtaBins, "#mu#mu rapidity", dimuonPtBins, " #mu#mu pT (GeV)", triggerPathName);
     // Pt DR Double
       myBook2D(ibooker, "genDimuon_genPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP");
       myBook2D(ibooker, "globDimuon_genPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP");
       myBook2D(ibooker, "globDimuon_recoPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dDimuon_recoPtDR",int(i+1)), dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathDimuon_recoPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP", triggerPathName);
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("diFilt%dDimuon_recoPtDR",int(i+1)), dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "diPathDimuon_recoPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP", triggerPathName);
       myBook2D(ibooker, "resultDimuon_recoPtDR", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R at IP");
     // Pt DRpos Double
       myBook2D(ibooker, "globDimuon_recoPtDRpos", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dDimuon_recoPtDRpos",int(i+1)), dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathDimuon_recoPtDRpos", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS", triggerPathName);
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("diFilt%dDimuon_recoPtDRpos",int(i+1)), dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "diPathDimuon_recoPtDRpos", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS", triggerPathName);
       myBook2D(ibooker, "resultDimuon_recoPtDRpos", dimuonPtBins, " #mu#mu pT (GeV)", dimuonDRBins, "#mu#mu #Delta R in MS");
 
     // Matching
       myBook2D(ibooker, "globGen_deltaEtaDeltaPhi", deltaEtaBins, "#Delta eta", deltaPhiBins, "#Delta phi");
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook2D(ibooker, TString::Format("filt%dGlob_deltaEtaDeltaPhi",int(i+1)), deltaEtaBins, "#Delta eta", deltaPhiBins, "#Delta phi", filterNamesLevels[i].first);
       }
       myBook2D(ibooker, "pathGlob_deltaEtaDeltaPhi", deltaEtaBins, "#Delta eta", deltaPhiBins, "#Delta phi", triggerPathName);
     // Size of containers
       vector<double> sizeBins; sizeBins.push_back(10); sizeBins.push_back(0); sizeBins.push_back(10);
       myBook1D(ibooker, "genMuon_size", sizeBins, "container size" );
       myBook1D(ibooker, "globMuon_size", sizeBins, "container size" );
       for(size_t i=0; i<filterNamesLevels.size(); i++){
         myBook1D(ibooker, TString::Format("filt%dMuon_size",int(i+1)), sizeBins, "container size", filterNamesLevels[i].first);
       }
       myBook1D(ibooker, "pathMuon_size", sizeBins, "container size", triggerPathName );
 }

void HeavyFlavorValidation::dqmBeginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 151 of file HeavyFlavorValidation.cc.

References filterNamesLevels, filters, getFilterLevel(), HLTConfigProvider::init(), hcalDigis_cfi::level, LogDebug, HLTConfigProvider::moduleLabels(), edm::moduleName(), harvestTrackValidationPlots::str, AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerNames(), triggerPathName, and triggerProcessName.

                                                                                          {
     //discover HLT configuration
     HLTConfigProvider hltConfig;
     bool isChanged;
     if(hltConfig.init(iRun, iSetup, triggerProcessName, isChanged)){
         LogDebug("HLTriggerOfflineHeavyFlavor") << "Successfully initialized HLTConfigProvider with process name: "<<triggerProcessName<<endl;
     }else{
         LogWarning("HLTriggerOfflineHeavyFlavor") << "Could not initialize HLTConfigProvider with process name: "<<triggerProcessName<<endl;
         return;
     }
     vector<string> triggerNames = hltConfig.triggerNames();
         for (const auto &trigName : triggerNames) {
                 // TString triggerName = trigName;
                 if (trigName.find(triggerPathName) != std::string::npos) {
                 vector<string> moduleNames = hltConfig.moduleLabels( trigName );
                         for (const auto &moduleName : moduleNames) {
                                 const int level = getFilterLevel(moduleName, hltConfig);
                                 if (level > 0) {
                                         filterNamesLevels.push_back( {moduleName, level} );
                                 }
                         }
                         break;
         }
     }
 
     if(filterNamesLevels.empty()){
         LogDebug("HLTriggerOfflineHeavyFlavor")<<"Bad Trigger Path: "<<triggerPathName<<endl;
         return;
     }else{
                 std::string str;
                 str.reserve(512); // avoid too many realloctions in the following loop (allows for filter names with roughly 100 chars each)
                 for (const auto &filters : filterNamesLevels) str = str + " " + filters.first;
         LogDebug("HLTriggerOfflineHeavyFlavor")<<"Trigger Path: "<<triggerPathName<<" has filters:"<<str;
     }
 }

int HeavyFlavorValidation::getFilterLevel	(	const std::string &	moduleName,
		const HLTConfigProvider &	hltConfig
	)

private

Get the filter "level" (as it is defined for the use of this module and its corresponding harvesting module).

level 1 - 3 -> more or less synonymously to the the trigger levels level 4 and 5 -> vertex, dz, track, etc.. filters

See the comments in the definition for some more details.

Definition at line 652 of file HeavyFlavorValidation.cc.

References edm::contains(), funct::m, HLTConfigProvider::moduleEDMType(), HLTConfigProvider::moduleType(), AnalysisDataFormats_SUSYBSMObjects::ms, alignCSCRings::s, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by dqmBeginRun().

 {
   // helper lambda to check if a string contains a substring
   const auto contains = [](const std::string &s, const std::string &sub) -> bool {
     return s.find(sub) != std::string::npos;
   };
 
   // helper lambda to check if a string contains any of a list of substrings
   const auto containsAny = [](const std::string &s, const std::vector<std::string> &subs) -> bool {
     for (const auto &sub : subs) {
       if (s.find(sub) != std::string::npos) return true;
     }
     return false;
   };
 
   // helper lambda to check if string s is any of the strings in vector ms
   const auto isAnyOf = [](const std::string &s, const std::vector<std::string>& ms) -> bool {
     for (const auto &m : ms) {
       if (s == m) return true;
     }
     return false;
   };
 
   // tmadlener, 20.08.2017:
   // define the valid module names for the different "levels", to add a little bit more stability
   // to the checking compared to just doing some name matching.
   // Note, that the name matching is not completely remved, since at level 4 and 5 some of the
   // valid modules are the same, so that the name matching is still needed.
   // With the current definition this yields the exact same levels as before, but weeds out some
   // of the "false" positives at level 3 (naming matches also to some HLTMuonL1TFilter modules due to
   // the 'forIterL3' in the name)
   const std::string l1Filter = "HLTMuonL1TFilter";
   const std::string l2Filter = "HLTMuonL2FromL1TPreFilter";
   const std::vector<std::string> l3Filters = {"HLTMuonDimuonL3Filter", "HLTMuonL3PreFilter"};
   const std::vector<std::string> l4Filters = {"HLTDisplacedmumuFilter", "HLTDiMuonGlbTrkFilter",
                               "HLTMuonTrackMassFilter"};
   const std::vector<std::string> l5Filters = {"HLTmumutkFilter", "HLT2MuonMuonDZ", "HLTDisplacedmumuFilter"};
 
   if (contains(moduleName, "Filter") && hltConfig.moduleEDMType(moduleName) == "EDFilter") {
     if (contains(moduleName, "L1") && !contains(moduleName, "ForIterL3") &&
         hltConfig.moduleType(moduleName) == l1Filter) {
       return 1;
     }
     if (contains(moduleName, "L2") && hltConfig.moduleType(moduleName) == l2Filter) {
       return 2;
     }
     if (contains(moduleName, "L3") && isAnyOf(hltConfig.moduleType(moduleName), l3Filters)) {
       return 3;
     }
     if (containsAny(moduleName, {"DisplacedmumuFilter", "DiMuon", "MuonL3Filtered", "TrackMassFiltered"}) &&
         isAnyOf(hltConfig.moduleType(moduleName), l4Filters)) {
       return 4;
     }
     if (containsAny(moduleName, {"Vertex", "Dz"}) &&
         isAnyOf(hltConfig.moduleType(moduleName), l5Filters)) {
       return 5;
     }
   }
 
   return -1;
 }

int HeavyFlavorValidation::getMotherId ( const Candidate * p )

private

Definition at line 545 of file HeavyFlavorValidation.cc.

References reco::Candidate::mother(), and reco::Candidate::pdgId().

Referenced by analyze().

                                                            {
   const Candidate* mother = p->mother();
   if( mother ){
     if( mother->pdgId() == p->pdgId() ){
       return getMotherId(mother);
     }else{
       return mother->pdgId();
     }
   }else{
     return 0;
   }
 }

void HeavyFlavorValidation::match	(	MonitorElement *	me,
		vector< LeafCandidate > &	from,
		vector< LeafCandidate > &	to,
		double	deltaRMatchingCut,
		vector< int > &	map
	)

private

Definition at line 558 of file HeavyFlavorValidation.cc.

References PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, PVValHelper::eta, MonitorElement::Fill(), mps_fire::i, gen::k, and phi.

Referenced by analyze().

                                                                                                                                                          {
   vector<double> dR(from.size());
   for(size_t i=0; i<from.size(); i++){
     map[i] = -1;
     dR[i] = 10.;
     //find closest
     for(size_t j=0; j<to.size(); j++){
       double dRtmp = deltaR<double>(from[i].eta(), from[i].phi(), to[j].eta(), to[j].phi());
       if( dRtmp < dR[i] ){
         dR[i] = dRtmp;
         map[i] = j;
       }
     }
     //fill matching histo
     if( map[i] != -1 ){
       me->Fill( to[map[i]].eta()-from[i].eta(), deltaPhi<double>(to[map[i]].phi(), from[i].phi()) );
     }
     //apply matching cut
     if( dR[i] > dRMatchingCut ){
       map[i] = -1;
     }
     //remove duplication
     if( map[i] != -1 ){
       for(size_t k=0; k<i; k++){
         if( map[k] != -1 && map[i] == map[k] ){
           if( dR[i] < dR[k] ){
             map[k] = -1;
           }else{
             map[i] = -1;
           }
           break;
         }
       }
     }
   }
 }

void HeavyFlavorValidation::myBook1D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	label,
		TString	title
	)

private

Definition at line 637 of file HeavyFlavorValidation.cc.

References DQMStore::IBooker::book1D(), h, mps_fire::i, createfilelist::int, and dataset::name.

Referenced by bookHistograms().

 {
 //   dqmStore->setCurrentFolder(dqmFolder+"/"+folder);
   int binsN = bins.size()==3 ? (int)bins[0]+1 : bins.size();
   Double_t *myBins = new Double_t[ binsN ];
   for(int i=0; i<binsN; i++){
     myBins[i] = bins.size()==3 ? bins[1] + i*(bins[2]-bins[1])/bins[0] : bins[i] ;
   }
   TH1F *h = new TH1F( name, name, binsN-1, myBins );
   h->SetXTitle(label);
   h->SetTitle(title);
   ME[name] = ibooker.book1D( name.Data(), h );
   delete h;
 }

void HeavyFlavorValidation::myBook1D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	label
	)

inlineprivate

Definition at line 74 of file HeavyFlavorValidation.cc.

References edm::moduleName(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                  {
       myBook1D(ibooker, name, xBins, label, name );
     }

void HeavyFlavorValidation::myBook2D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	xLabel,
		vector< double > &	yBins,
		TString	yLabel,
		TString	title
	)

private

Definition at line 595 of file HeavyFlavorValidation.cc.

References DQMStore::IBooker::book2D(), PVValHelper::eta, h, mps_fire::i, createfilelist::int, dataset::name, and EnergyCorrector::pt.

Referenced by bookHistograms().

 {
 //   dqmStore->setCurrentFolder(dqmFolder+"/"+folder);
   int ptN = ptBins.size()==3 ? (int)ptBins[0]+1 : ptBins.size();
   Double_t *pt = new Double_t[ ptN ];
   for(int i=0; i<ptN; i++){
     pt[i] = ptBins.size()==3 ? ptBins[1] + i*(ptBins[2]-ptBins[1])/ptBins[0] : ptBins[i] ;
   }
   int etaN = etaBins.size()==3 ? (int)etaBins[0]+1 : etaBins.size();
   Double_t *eta = new Double_t[ etaN ];
   for(int i=0; i<etaN; i++){
     eta[i] = etaBins.size()==3 ? etaBins[1] + i*(etaBins[2]-etaBins[1])/etaBins[0] : etaBins[i] ;
   }
   TH2F *h = new TH2F( name, name, ptN-1, pt, etaN-1, eta  );
   h->SetXTitle(ptLabel);
   h->SetYTitle(etaLabel);
   h->SetTitle(title);
   ME[name] = ibooker.book2D( name.Data(), h );
   delete h;
 }

void HeavyFlavorValidation::myBook2D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	xLabel,
		vector< double > &	yBins,
		TString	yLabel
	)

inlineprivate

Definition at line 66 of file HeavyFlavorValidation.cc.

                                                                                                                                         {
       myBook2D(ibooker, name, xBins, xLabel, yBins, yLabel, name);
     }

void HeavyFlavorValidation::myBookProfile2D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	xLabel,
		vector< double > &	yBins,
		TString	yLabel,
		TString	title
	)

private

Definition at line 616 of file HeavyFlavorValidation.cc.

References DQMStore::IBooker::bookProfile2D(), PVValHelper::eta, h, mps_fire::i, createfilelist::int, dataset::name, and EnergyCorrector::pt.

Referenced by bookHistograms().

 {
 //   dqmStore->setCurrentFolder(dqmFolder+"/"+folder);
   int ptN = ptBins.size()==3 ? (int)ptBins[0]+1 : ptBins.size();
   Double_t *pt = new Double_t[ ptN ];
   for(int i=0; i<ptN; i++){
     pt[i] = ptBins.size()==3 ? ptBins[1] + i*(ptBins[2]-ptBins[1])/ptBins[0] : ptBins[i] ;
   }
   int etaN = etaBins.size()==3 ? (int)etaBins[0]+1 : etaBins.size();
   Double_t *eta = new Double_t[ etaN ];
   for(int i=0; i<etaN; i++){
     eta[i] = etaBins.size()==3 ? etaBins[1] + i*(etaBins[2]-etaBins[1])/etaBins[0] : etaBins[i] ;
   }
   TProfile2D *h = new TProfile2D( name, name, ptN-1, pt, etaN-1, eta  );
   h->SetXTitle(ptLabel);
   h->SetYTitle(etaLabel);
   h->SetTitle(title);
   ME[name] = ibooker.bookProfile2D( name.Data(), h );
   delete h;
 }

void HeavyFlavorValidation::myBookProfile2D	(	DQMStore::IBooker &	ibooker,
		TString	name,
		vector< double > &	xBins,
		TString	xLabel,
		vector< double > &	yBins,
		TString	yLabel
	)

inlineprivate

Definition at line 70 of file HeavyFlavorValidation.cc.

References diffTwoXMLs::label.

                                                                                                                                                {
       myBookProfile2D(ibooker, name, xBins, xLabel, yBins, yLabel, name);
     }